Esempio n. 1
0
        static Configuration()
        {
            var configPath = AssemblyDirectory + fileName;

            if (File.Exists(configPath))
            {
                var content = File.ReadAllText(configPath);
                Properties = JsonPacker.ExtractDataAs <ParsedConfiguration>(content);
            }
            else
            {
                Properties = new ParsedConfiguration
                {
                    InputRootPath = AssemblyDirectory
                };
            }
        }
Esempio n. 2
0
 void Awake()
 {
     Current = JsonConvert.DeserializeObject <ParsedConfiguration>(ConfigurationFile.text);
 }
Esempio n. 3
0
        /// <summary>
        ///     Parses the configuration.
        /// </summary>
        /// <param name="profiles">The profiles.</param>
        /// <param name="startupProjects">The startup projects.</param>
        /// <param name="currentStartupProjects">The current startup projects.</param>
        /// <returns>The parsed configuration.</returns>
        private ParsedConfiguration ParseConfiguration(IEnumerable <Profile> profiles, IEnumerable <string> startupProjects, ICollection <string> currentStartupProjects)
        {
            var parsedConfiguration = new ParsedConfiguration();

            // List all projects
            foreach (var startupProject in startupProjects)
            {
                var profile = new Profile();
                profile.DisplayName = startupProject;

                var projectItem = new Project();
                projectItem.Name = startupProject;

                profile.Projects.Add(projectItem);
                parsedConfiguration.Profiles.Add(profile);
            }

            var currentProfile = new Profile();

            foreach (var startupProject in currentStartupProjects)
            {
                var projectName = Path.GetFileNameWithoutExtension(startupProject);
                if (!_projectCache.TryGetProjectByName(projectName, out var projectProxy))
                {
                    continue;
                }

                var projectItem = new Project();
                projectItem.Name = projectProxy.Name;

                foreach (EnvDTE.Configuration configuration in projectProxy.Source.ConfigurationManager)
                {
                    if (configuration?.Properties == null)
                    {
                        continue;
                    }

                    foreach (var property in configuration.Properties.Cast <Property>())
                    {
                        if (property == null)
                        {
                            continue;
                        }

                        switch (property.Name)
                        {
                        case "StartArguments":
                            projectItem.CommandLineArgs = Convert.ToString(property.Value);
                            break;

                        case "StartWorkingDirectory":
                            projectItem.WorkingDirectory = Convert.ToString(property.Value);
                            break;

                        case "StartProgram":
                            projectItem.StartExternalProgram = Convert.ToString(property.Value);
                            break;

                        case "StartURL":
                            projectItem.StartBrowserUrl = Convert.ToString(property.Value);
                            break;

                        case "RemoteDebugEnabled":
                            projectItem.IsRemoteDebuggingEnabled = Convert.ToBoolean(property.Value);
                            break;

                        case "RemoteDebugMachine":
                            projectItem.RemoteDebuggingMachine = Convert.ToString(property.Value);
                            break;
                        }
                    }
                }

                currentProfile.Projects.Add(projectItem);
            }

            // List custom configuration
            foreach (var profile in profiles)
            {
                parsedConfiguration.Profiles.Add(profile);
            }

            // Identify current configuration
            var profileScores = ProfileScore.Generate(parsedConfiguration.Profiles, currentProfile);
            var bestMatch     = profileScores.OrderByDescending(s => s.Score).FirstOrDefault();

            parsedConfiguration.CurrentProfile = bestMatch?.Configuration;
            return(parsedConfiguration);
        }