C# Project.GetSourceSet方法代码示例

        public void GetSourceSetReturnsTheSameInstanceIfCalledTwice()
        {
            var project = new Project("test", new Module("testmod", new Suite(new TestFileSystemDirectory("module"))));
            var set1 = project.GetSourceSet("cs");
            var set2 = project.GetSourceSet("cs");

            set1.Should().BeSameAs(set2);
        }

        public void CreatedSourceSetAddedToSourceSetsProperty()
        {
            var project = new Project("test", new Module("testmod", new Suite(new TestFileSystemDirectory("module"))));
            var set1 = project.GetSourceSet("cs");
            var set2 = project.GetSourceSet("cs");

            project.SourceSets.Should().HaveCount(1);
            project.SourceSets.Should().HaveElementAt(0, set1);
        }

        public void GetSourceSetCreatesSetIfMissing()
        {
            var project = new Project("test", new Module("testmod", new Suite(new TestFileSystemDirectory("module"))));
            var set1 = project.GetSourceSet("cs");

            set1.Should().NotBeNull();
            set1.Type.Should().Be(new SourceSetType("cs"));
        }

 /// <summary>
 /// Goes through all the subdirectories of a project and interprets them as source sets
 /// </summary>
 /// <param name="project">The project to be extended with source sets</param>
 /// <param name="projectDir">The project's directory</param>
 private void DiscoverProjectSources(Project project, IFileSystemDirectory projectDir)
 {
     foreach (var sourceSetName in projectDir.ChildDirectories)
     {
         var sourceSet = project.GetSourceSet(sourceSetName);
         AddAllFiles(sourceSet, projectDir.GetChildDirectory(sourceSetName));
     }
 }

        public void HasNonEmptySourceSetMethodWorks()
        {
            var project = new Project("test", new Module("testmod", new Suite(new TestFileSystemDirectory("module"))));
            var set1 = project.GetSourceSet("cs");

            project.HasNonEmptySourceSet("cs").Should().BeFalse();
            project.HasNonEmptySourceSet("vb").Should().BeFalse();

            set1.Add(new SuiteRelativePath("testfile"));

            project.HasNonEmptySourceSet("cs").Should().BeTrue();
            project.HasNonEmptySourceSet("vb").Should().BeFalse();
        }

        /// <summary>
        /// Executes the given build script on the given project, returning the set of
        /// target files the script generated.
        /// 
        /// <para>
        /// The script's global scope has the following predefined variables set:
        /// - <c>project</c> refers to the project being built
        /// - <c>sourceSet</c> is the project's source set associated with the build script
        /// - <c>targetRoot</c> is the root target directory where all the files are generated
        /// - <c>targetDir</c> is where the project's output should be built
        /// </para>
        /// <para>
        /// A special global function <c>get_tool</c> is available which accepts a reference URI and
        /// a file name. 
        /// The same protocols are supported as for references in the suite definition. The 
        /// function's return value is the absolute path of the given file, where the tool
        /// has been deployed.
        /// </para>
        /// </summary>
        /// <param name="project">The input project to build</param>
        /// <param name="buildScript">The build script to execute</param>
        /// <returns>Returns the set of files generated by the script. They have to be
        /// indicated in the script's <c>results</c> variable, relative to <c>targetDir</c>.</returns>
        public ISet<TargetRelativePath> Run(Project project, IBuildScript buildScript)
        {
            var engine = CreateEngine();
            
            var runtime = engine.Runtime;
            try
            {
                var scope = runtime.CreateScope();

                scope.SetVariable("project", project);
                scope.SetVariable("sourceSet",
                                  project.GetSourceSet(buildScript.SourceSetName)
                                         .Files.Select(srp => (string) srp)
                                         .ToList());
                AddGetToolToScope(scope, project);

                var targetDir = TargetRoot.GetChildDirectory(project.Module.Name, createIfMissing: true);
                var localTargetDir = targetDir as LocalFileSystemDirectory;
                var localTargetRoot = TargetRoot as LocalFileSystemDirectory;
                if (localTargetDir != null && localTargetRoot != null)
                {
                    scope.SetVariable("targetRoot", localTargetRoot.AbsolutePath);
                    scope.SetVariable("targetDir", localTargetDir.AbsolutePath);

                    var pco = (PythonCompilerOptions)engine.GetCompilerOptions();
                    pco.Module |= ModuleOptions.Optimized;
                    
                    var script = engine.CreateScriptSourceFromString(buildScript.Source, SourceCodeKind.File);
                    script.Compile(pco);
                    script.Execute(scope);

                    return new HashSet<TargetRelativePath>(
                        scope.GetVariable<IList<object>>("results")
                             .Cast<string>()
                             .Select(t => GetTargetRelativePath(targetDir, t)));
                }
                else
                {
                    throw new NotSupportedException("Only local file system is supported for python scripts!");
                }
            }
            finally
            {
                runtime.Shutdown();
            }
        }

 /// <summary>
 /// Gets the source sets to include 
 /// </summary>
 /// <param name="project">The project to get its source sets</param>
 /// <returns>Returns an enumeration of source sets, all belonging to the given project</returns>
 protected override IEnumerable<ISourceSet> GetSourceSets(Project project)
 {
     return new[] {project.GetSourceSet("resources")};
 }

        private void WriteAppConfig(XmlWriter writer, Project project)
        {
            // Must be called within an open PropertyGroup

            if (project.HasNonEmptySourceSet("appconfig"))
            {
                var sourceSet = project.GetSourceSet("appconfig");
                var configs = sourceSet.Files.ToList();

                if (configs.Count > 1)
                    throw new TooManyAppConfigsException(project);

                var appConfigPath = configs.FirstOrDefault();
                if (appConfigPath != null)
                {
                    writer.WriteElementString("AppConfig", ToProjectRelativePath(project, appConfigPath, "cs"));
                }
            }
        }

        private void WriteManifest(XmlWriter writer, Project project)
        {
            // Must be called within an open PropertyGroup

            if (project.HasNonEmptySourceSet("manifest"))
            {
                var sourceSet = project.GetSourceSet("manifest");
                var manifests = sourceSet.Files.ToList();

                if (manifests.Count > 1)
                    throw new TooManyManifestsException(project);

                var manifestPath = manifests.FirstOrDefault();
                if (manifestPath != null)
                {
                    writer.WriteElementString("ApplicationManifest", ToProjectRelativePath(project, manifestPath, "cs"));
                }
            }
        }

        /// <summary>
        /// Executes the given build script on the given project, returning the set of
        /// target files the script generated.
        /// 
        /// <para>
        /// The script's global scope has the following predefined variables set:
        /// - <c>project</c> refers to the project being built
        /// - <c>sourceSet</c> is the project's source set associated with the build script
        /// - <c>targetRoot</c> is the root target directory where all the files are generated
        /// - <c>targetDir</c> is where the project's output should be built
        /// </para>
        /// <para>
        /// A special global function <c>get_tool</c> is available which accepts a reference URI and
        /// a file name. 
        /// The same protocols are supported as for references in the suite definition. The 
        /// function's return value is the absolute path of the given file, where the tool
        /// has been deployed.
        /// </para>
        /// </summary>
        /// <param name="project">The input project to build</param>
        /// <param name="buildScript">The build script to execute</param>
        /// <returns>Returns the set of files generated by the script. They have to be
        /// indicated in the script's <c>results</c> variable, relative to <c>targetDir</c>.</returns>
        public ISet<TargetRelativePath> Run(Project project, IBuildScript buildScript)
        {
            var engine = CreateEngine();

            var runtime = engine.Runtime;
            try
            {
                var scope = runtime.CreateScope();

                scope.SetVariable("is_mono", parameters.UseMono);
                scope.SetVariable("project", project);
                scope.SetVariable("sourceSet",
                                  project.GetSourceSet(buildScript.SourceSetName)
                                         .Files.Select(srp => (string) srp)
                                         .ToList());
                AddGetToolToScope(scope, project);

                var targetDir = TargetRoot.GetChildDirectory(project.Module.Name, createIfMissing: true);
                var localTargetDir = targetDir as LocalFileSystemDirectory;
                var localTargetRoot = TargetRoot as LocalFileSystemDirectory;
                if (localTargetDir != null && localTargetRoot != null)
                {
                    scope.SetVariable("targetRoot", localTargetRoot.AbsolutePath);
                    scope.SetVariable("targetDir", localTargetDir.AbsolutePath);

                    var pco = (PythonCompilerOptions)engine.GetCompilerOptions();
                    pco.Module |= ModuleOptions.Optimized;

                    try
                    {
                        var script = engine.CreateScriptSourceFromString(buildScript.Source, SourceCodeKind.File);
                        script.Compile(pco);
                        script.Execute(scope);

                        return new HashSet<TargetRelativePath>(
                            scope.GetVariable<IList<object>>("results")
                                .Cast<string>()
                                .Select(t => GetTargetRelativePath(targetDir, t)));
                    }
                    catch (Exception ex)
                    {
                        var eo = engine.GetService<ExceptionOperations>();

                        string msg, typeName;
                        eo.GetExceptionMessage(ex, out msg, out typeName);

                        foreach (var line in msg.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries))
                        {
                            output.Error(line);
                        }

                        output.Error("Call stack:");
                        foreach (var frame in eo.GetStackFrames(ex))
                        {
                            var line = frame.GetFileLineNumber();
                            var method = frame.GetMethodName();

                            output.Error(String.Format("Line {0} in {1}", line, method));
                        }

                        throw new ScriptException(buildScript);
                    }
                }
                else
                {
                    throw new NotSupportedException("Only local file system is supported for python scripts!");
                }
            }
            finally
            {
                runtime.Shutdown();
            }
        }

        private void WriteCompilerParameters(XmlWriter writer, Project project)
        {
            VCppProjectCompilerParameters compilerParameters = project.HasParameters("cpp-compiler")
                                                                   ? project.GetParameters<VCppProjectCompilerParameters>("cpp-compiler")
                                                                   : new VCppProjectCompilerParameters(Suite);

            compilerParameters.FillProjectSpecificMissingInfo(project, GetCLIMode(project), targetDir as LocalFileSystemDirectory);

            writer.WriteStartElement("ClCompile");
            compilerParameters.ToVcxprojProperties(writer);

            if (project.GetSourceSet("cpp").Files.Any(file => Path.GetFileName(file) == "stdafx.cpp"))
                writer.WriteElementString("PrecompiledHeader", "Use");

            writer.WriteEndElement();
        }

        public void FillProjectSpecificMissingInfo(Project project)
        {
            if (RootNamespace == null)
                RootNamespace = project.Name;

            if (project.HasNonEmptySourceSet("resources"))
            {
                var resources = project.GetSourceSet("resources");
                var icons = resources.Files.Where(p => Path.GetExtension(p) == ".ico").ToList();

                if (icons.Count == 1 && ApplicationIcon == null)
                {
                    ApplicationIcon = project.Module.Suite.SuiteRoot.GetRelativePathFrom(project.RootDirectory.GetChildDirectory("resources"), icons[0]);
                }
            }
        }

 /// <summary>
 /// Gets the source sets to include 
 /// </summary>
 /// <param name="project">The project to get its source sets</param>
 /// <returns>Returns an enumeration of source sets, all belonging to the given project</returns>
 protected override IEnumerable<ISourceSet> GetSourceSets(Project project)
 {
     return new[] { project.GetSourceSet("cpp").FilterCppSourceSet(project.RootDirectory.GetChildDirectory("cpp"), suiteRoot) };
 }

 /// <summary>
 /// Goes through all the subdirectories of a project and interprets them as source sets
 /// </summary>
 /// <param name="project">The project to be extended with source sets</param>
 /// <param name="projectDir">The project's directory</param>
 /// <param name="ignoreLists">The suite's source set ignore lists</param>
 private void DiscoverProjectSources(Project project, IFileSystemDirectory projectDir, SourceSetIgnoreLists ignoreLists)
 {
     foreach (var sourceSetName in projectDir.ChildDirectories)
     {
         var sourceSet = project.GetSourceSet(sourceSetName);
         AddAllFiles(sourceSet, projectDir.GetChildDirectory(sourceSetName), ignoreLists.Get(new SourceSetType(sourceSetName)));
     }
 }