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");
}
