private List <FileInfo> FindAllProjectFiles(SlnGenerationOptions options) { if (options.ProjectTypes.Length > 0) { Finder.SetProjectTypes(options.ProjectTypes); } List <FileInfo> files = new List <FileInfo>(); if (options.RootFolderSearchPaths.Count == 0) { files.AddRange(Finder.FindAllProjectFiles(options.ProjectsRootDirectory)); } else { foreach (string path in options.RootFolderSearchPaths) { files.AddRange(Finder.FindAllProjectFiles(path)); } } foreach (string path in options.AdditionalSearchPaths) { files.AddRange(Finder.FindAllProjectFiles(path)); } return(files); }
public string GenerateSolutionFile(SlnGenerationOptions options) { LogSummary(options); List <CsProj> projects = ProjectRepository.LookupCsProjsFromDirectory(options); Sln solution = SlnBuilder.GetSlnBuilder(projects).BuildSln(options); if (options.FixHintPaths) { new HintPathConverter().ConvertHintPaths(solution, options); } if (options.ConvertReferences) { new ReferenceConverter().ConvertToProjectReferences(solution); } else if (options.RestoreReferences) { new ReferenceConverter().RestoreAssemblyReferences(solution); } if (options.RestoreHintPaths) { new HintPathConverter().RestoreHintPaths(solution, options); } WarnOnMissingNuGetTargets(projects, options); return(SlnWriter.WriteSlnFile(solution, options.SlnOutputPath).FullName); }
public void SpecifiedMultipleTargetProjects() { options = ArgsOptionsBuilder.BuildOptions(new[] { "--target", "MyProject", "--target", "YourProject" }, WorkingDirectory); CollectionAssert.AreEqual(new[] { "MyProject", "YourProject" }, options.TargetProjectNames); Assert.AreEqual("MyProject_YourProject", options.SolutionName); }
public void RelativeProjectsRootDirIsRootedAtWorkingDir() { options = new SlnGenerationOptions(WorkingDirectory); options.ProjectsRootDirectory = Path.Combine("Proj", "Root"); Assert.That(options.SlnOutputPath, Is.EqualTo(Path.Combine(WorkingDirectory, "Proj", "Root"))); }
public void IgnoresFolderNames() { _options = ArgsOptionsBuilder.BuildOptions(new[] { "--ignore", "Folder1", "--ignore", "Folder2" }, WorkingDirectory); Assert.That(_options.IgnoreDirectoryPatterns, Is.EqualTo(new[] { "Folder1", "Folder2" })); }
public void SpecifiedTargetProject() { options = ArgsOptionsBuilder.BuildOptions(new[] { "--target", "MyProject" }, WorkingDirectory); Assert.That(options.TargetProjectNames, Is.EqualTo(new[] { "MyProject" })); Assert.That(options.SolutionName, Is.EqualTo("MyProject")); }
public void RelativeProjectsRootDirIsRootedAtWorkingDir() { options = new SlnGenerationOptions(@"C:\WorkingDir"); options.ProjectsRootDirectory = @"Proj\Root"; Assert.That(options.SlnOutputPath, Is.EqualTo(@"C:\WorkingDir\Proj\Root")); }
public void RelativeSlnOutputPathRootedAtProjectsRoot() { options = new SlnGenerationOptions(@"C:\Proj\Root"); options.SlnOutputPath = "Solutions"; Assert.That(options.SlnOutputPath, Is.EqualTo(@"C:\Proj\Root\Solutions")); }
public void AdditionalSearchPathsRootedAtProjectRoot() { options = new SlnGenerationOptions(@"C:\Proj\Root"); options.AddAdditionalSearchPaths(@"..\SearchPath", @"..\..\OtherPath\Pork"); Assert.That(options.AdditionalSearchPaths, Is.EqualTo(new[] { @"C:\Proj\Root\..\SearchPath", @"C:\Proj\Root\..\..\OtherPath\Pork" })); }
public void SpecifiedMultipleTargetProjects() { options = ArgsOptionsBuilder.BuildOptions(new[] { "--target", "MyProject", "--target", "YourProject" }, WorkingDirectory); Assert.That(options.TargetProjectNames, Is.EqualTo(new[] { "MyProject", "YourProject" })); Assert.That(options.SolutionName, Is.StringMatching("MyProject_YourProject")); }
public void RelativeProjectsRootDirIsRootedAtWorkingDir() { options = new SlnGenerationOptions(WorkingDirectory); options.ProjectsRootDirectory = Path.Combine("Proj", "Root"); StringAssert.Equals(Path.Combine(WorkingDirectory, "Proj", "Root"), options.SlnOutputPath); }
private void IgnoreConfiguredDirectoryPatterns(SlnGenerationOptions options) { if (options.IgnoreDirectoryPatterns.Count > 0) { Finder.IgnorePatterns(options.IgnoreDirectoryPatterns.ToArray()); } }
public void SpecifiedSlnOuputPath() { var slnDir = GetSamplePath(WorkingDirectory, "Sln"); options = ArgsOptionsBuilder.BuildOptions(new[] { "--out", slnDir }, WorkingDirectory); Assert.That(options.SlnOutputPath, Is.EqualTo(slnDir)); }
public SlnGenerationOptions Build(string[] args, string workingDirectory) { _options = new SlnGenerationOptions(workingDirectory); ProcessArguments(args); return(_options); }
public void RestoreHintPaths(Sln solution, SlnGenerationOptions options) { var packagesDir = Path.Combine(options.SlnOutputPath, "packages"); foreach (var project in solution.Projects) { ConvertProjectHintPaths(project, packagesDir, Mode.Restore); } }
public void RelativeSlnOutputPathRootedAtProjectsRoot() { var root = GetSamplePath("Proj", "Root"); options = new SlnGenerationOptions(root); options.SlnOutputPath = "Solutions"; StringAssert.Equals(Path.Combine(root, "Solutions"), options.SlnOutputPath); }
public virtual List <CsProj> LookupCsProjsFromDirectory(SlnGenerationOptions options) { IgnoreConfiguredDirectoryPatterns(options); List <FileInfo> files = FindAllProjectFiles(options); List <CsProj> projects = ReadProjectFilesIntoCsProjObjects(files); return(projects); }
public void RelativeSlnOutputPathRootedAtProjectsRoot() { var root = GetSamplePath("Proj", "Root"); options = new SlnGenerationOptions(root); options.SlnOutputPath = "Solutions"; Assert.That(options.SlnOutputPath, Is.EqualTo(Path.Combine(root, "Solutions"))); }
public void SpecifiedAdditionalSearchPaths() { var otherDir = GetSamplePath("OtherProjects"); var moreProjects = GetSamplePath("MoreProjects"); options = ArgsOptionsBuilder.BuildOptions(new[] { "--search", otherDir, "--search", moreProjects }, WorkingDirectory); Assert.That(options.AdditionalSearchPaths, Is.EqualTo(new[] { otherDir, moreProjects })); }
public void SpecifiedRootFolderSearchPaths() { var otherDir = GetSamplePath("OtherProjects"); var moreProjects = GetSamplePath("MoreProjects"); options = ArgsOptionsBuilder.BuildOptions(new[] { "--narrow", otherDir, "--narrow", moreProjects }, WorkingDirectory); CollectionAssert.AreEqual(new[] { otherDir, moreProjects }, options.RootFolderSearchPaths); }
public void SolutionOutputPathUsesGivenValueIfSet() { string slnOutputPath = @"C:\Projects\Solutions"; options = new SlnGenerationOptions(@"C:\Projects") { SlnOutputPath = slnOutputPath }; Assert.That(options.SlnOutputPath, Is.EqualTo(slnOutputPath)); }
public void BeforeEach() { options = new SlnGenerationOptions(StartPath); finder = MockRepository.GenerateStrictMock <ProjectFileFinder>(); reader = MockRepository.GenerateStrictMock <CsProjReader>(); repository = new CsProjRepository { Finder = finder, Reader = reader }; }
private List <FileInfo> FindAllProjectFiles(SlnGenerationOptions options) { List <FileInfo> files = Finder.FindAllProjectFiles(options.ProjectsRootDirectory); foreach (string path in options.AdditionalSearchPaths) { files.AddRange(Finder.FindAllProjectFiles(path)); } return(files); }
public void BeforeEach() { _options = new SlnGenerationOptions(WorkingDirectory); _finder = MockRepository.GenerateStrictMock <ProjectFileFinder>(); _reader = MockRepository.GenerateStrictMock <CsProjReader>(); _repository = new CsProjRepository { Finder = _finder, Reader = _reader }; }
public void SolutionOutputPathUsesGivenValueIfSet() { string slnOutputPath = GetSamplePath("Projects", "Solutions"); options = new SlnGenerationOptions(GetSamplePath("Projects")) { SlnOutputPath = slnOutputPath }; Assert.That(options.SlnOutputPath, Is.EqualTo(slnOutputPath)); }
public virtual List <CsProj> LookupCsProjsFromDirectory(SlnGenerationOptions options) { IgnoreConfiguredDirectoryPatterns(options); var files = FindAllProjectFiles(options); var projects = PopulateTopLevelProjectGuids(files); projects = PopulateProjectReferenceGuids(projects); projects = PopulateRemainingProjectGuids(projects); return(projects); }
public void AdditionalSearchPathsRootedAtProjectRoot() { var root = GetSamplePath("Proj", "Root"); options = new SlnGenerationOptions(root); var path1 = Path.Combine("..", "SearchPath"); var path2 = Path.Combine("..", "..", "OtherPath", "Pork"); options.AddAdditionalSearchPaths(path1, path2); Assert.That(options.AdditionalSearchPaths, Is.EqualTo(new[] { Path.Combine(root, path1), Path.Combine(root, path2) })); }
private void LogSummary(SlnGenerationOptions options) { Log.InfoFormat("SlimJim solution file generator."); Log.InfoFormat(""); Log.InfoFormat("----------------------------------------"); Log.InfoFormat("Target projects: {0}", SummarizeTargetProjects(options)); Log.InfoFormat("Destination: {0}", Path.Combine(options.SlnOutputPath, options.SolutionName + ".sln")); Log.InfoFormat("Visual Studio Version: {0}", options.VisualStudioVersion); Log.InfoFormat("Dinosaur: {0}", GetDinosaur()); Log.InfoFormat("----------------------------------------"); Log.InfoFormat(""); }
private void WarnOnMissingNuGetTargets(List <Proj> projects, SlnGenerationOptions options) { var nugetTargetsPath = Path.Combine(options.SlnOutputPath, ".nuget", "nuget.targets"); if (projects.Any(p => p.UsesMSBuildPackageRestore) && !File.Exists(nugetTargetsPath)) { Log.WarnFormat( "One or more of the projects included use MSBuild-based NuGet package restore. " + "To ensure these projects build correctly from the generated solution, copy nuget.targets " + "from the solution to {0}.", nugetTargetsPath); } }
public void TestDefaults() { options = ArgsOptionsBuilder.BuildOptions(new string[0], WorkingDirectory); Assert.That(options.ProjectsRootDirectory, Is.EqualTo(WorkingDirectory), "ProjectsRootDirectory"); Assert.That(options.TargetProjectNames, Is.Empty, "TargetProjectNames"); Assert.That(options.Mode, Is.EqualTo(SlnGenerationMode.FullGraph), "Mode"); Assert.That(options.AdditionalSearchPaths, Is.Empty, "AdditionalSearchPaths"); Assert.That(options.SkipReferences, Is.False, "IncludeEfferentAssemblyReferences"); Assert.That(options.ShowHelp, Is.False, "ShowHelp"); Assert.That(options.OpenInVisualStudio, Is.False, "OpenInVisualStudio"); }