private List <ProjectDetails> GetProjects(string pathToSolution)
{
var solution = SolutionFile.Parse(pathToSolution);
var projects = solution.ProjectsInOrder.Select(p =>
{
if (p.ProjectType != SolutionProjectType.KnownToBeMSBuildFormat && p.ProjectType != SolutionProjectType.WebProject)
{
return(null);
}
var projectParser = new ProjectFileParser(p.AbsolutePath);
return(new ProjectDetails
{
ProjectName = p.ProjectName,
ProjectFilePath = p.AbsolutePath,
ProjectGuid = p.ProjectGuid,
TargetFrameworks = projectParser.GetTargetFrameworks().ConvertAll(tfm =>
{
var framework = NuGetFramework.Parse(tfm);
return string.Format("{0} {1}", framework.Framework, NuGetVersion.Parse(framework.Version.ToString()).ToNormalizedString());
}),
PackageReferences = projectParser.GetPackageReferences()
});
}).Where(p => p != null).ToList();
return(projects);
}
public static PackagesConfigValidation Create()
{
var solutionReader = SolutionReaderFactory.Create();
var projectFileParser = new ProjectFileParser();
return(new PackagesConfigValidation(solutionReader, projectFileParser));
}
public VersionCliTest()
{
_vcsTool = A.Fake <IVcs>(opts => opts.Strict());
A.CallTo(() => _vcsTool.ToolName()).Returns("_FAKE_");
_fileDetector = A.Fake <ProjectFileDetector>();
_fileParser = A.Fake <ProjectFileParser>();
_filePatcher = A.Fake <ProjectFileVersionPatcher>();
A.CallTo(() => _fileDetector.FindAndLoadCsProj(A <string> ._)).Returns("<Project/>");
const string csProjFilePath = "/unit-test/test.csproj";
A.CallTo(() => _fileDetector.ResolvedCsProjFile).Returns(csProjFilePath);
A.CallTo(() => _fileParser.Load(A <string> ._)).DoesNothing();
A.CallTo(() => _fileParser.Version).Returns("1.2.1");
_cli = new VersionCli(
_vcsTool,
_fileDetector,
_fileParser,
_filePatcher,
new SemVerBumper()
);
}
public void GetAssemblyNameFromFullNameTest()
{
using (Stream s = GetStreamForFile("MSBuild.Community.Tasks.csproj"))
{
Assert.AreEqual("Ionic.Zip.Reduced", ProjectFileParser.GetAssemblyNameFromFullName("Ionic.Zip.Reduced, Version=1.9.1.8, Culture=neutral, PublicKeyToken=edbe51ad942a3f5c, processorArchitecture=MSIL"));
}
}
public void ParsePackageReferencesMustThrowArgumentNullReferenceExceptionWhenProjectIsNull()
{
var parser = new ProjectFileParser();
var exception = Assert.Throws <ArgumentNullException>(() => ParsePackageReferences(null));
Assert.That(exception.Message, Does.Contain("project"));
}
public void ParseProjectWithCorruptContentThrowsException()
{
var corruptProjectFileParser = new ProjectFileParser(Path.Combine(TestContext.CurrentContext.TestDirectory,
"TestXml", "SolutionWithFailedContent", "test", "ProjectWithCorruptContent.csproj"));
Assert.AreEqual(0, corruptProjectFileParser.GetPackageReferences().Count);
}
private bool IsDefaultNode(string path)
{
var setAsDefault = false;
if (path.EndsWith(".shproj"))
{
setAsDefault = File.ReadAllLines(path.Substring(0, path.Length - "shproj".Length) + "projitems")
.Any(l => l.Contains(Info.DefaultProjectWithFile + "\""));
}
else
{
var parser = new ProjectFileParser(File.ReadAllLines(path));
if (parser.ItemGroups.TryGetValue(ProjectFileParser.ItemGroupTypes.Compile, out var compileItems))
{
setAsDefault = ContainsDefaultProjectFile(compileItems);
}
if (!setAsDefault && parser.ItemGroups.TryGetValue(ProjectFileParser.ItemGroupTypes.None, out var noneItems))
{
setAsDefault = ContainsDefaultProjectFile(noneItems);
}
if (!setAsDefault && parser.ItemGroups.TryGetValue(ProjectFileParser.ItemGroupTypes.Content, out var contentItems))
{
setAsDefault = ContainsDefaultProjectFile(contentItems);
}
}
return(setAsDefault);
}
public void TestParseReferences()
{
const string Xml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project>
<ItemGroup>
<Reference Include=""System.Data"" />
<Reference Include=""System.Reactive.Core, Version=2.2.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"">
<HintPath>..\packages\Rx-Core.2.2.5\lib\net45\System.Reactive.Core.dll</HintPath>
<Private>True</Private>
</Reference>
</ItemGroup>
</Project>";
using (var textReader = new StringReader(Xml))
{
using (var projectStructureItemSubject = new Subject <ProjectStructureItem>())
{
var projectStructureItems = new List <ProjectStructureItem>();
projectStructureItemSubject.Subscribe(projectStructureItems.Add);
var sut = new ProjectFileParser();
sut.Parse(textReader, projectStructureItemSubject);
var items = projectStructureItems
.OfType <ReferenceBase>()
.ToList();
Assert.AreEqual(2, items.Count);
}
}
}
public void TestParsePackagesConfig()
{
const string Xml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<Project>
<ItemGroup>
<None Include=""packages.config"">
<SubType>Designer</SubType>
</None>
</ItemGroup>
</Project>";
using (var textReader = new StringReader(Xml))
{
using (var projectStructureItemSubject = new Subject <ProjectStructureItem>())
{
var projectStructureItems = new List <ProjectStructureItem>();
projectStructureItemSubject.Subscribe(projectStructureItems.Add);
var sut = new ProjectFileParser();
sut.Parse(textReader, projectStructureItemSubject);
var items = projectStructureItems
.OfType <PackagesConfigItem>()
.ToList();
Assert.AreEqual(1, items.Count);
}
}
}
public void GetAssemblyNameVS2013ProjectTest()
{
using (Stream s = GetStreamForFile("MSBuild.Community.Tasks.csproj"))
{
ProjectFileParser p = new ProjectFileParser(s);
Assert.AreEqual("MSBuild.Community.Tasks", p.GetAssemblyName());
}
}
public void TestProjectTargetName()
{
var sut = new ProjectFileParser();
var parsedReferences = sut.Parse(_fullPath);
Assert.AreEqual("NugetUnicorn.Ui.exe", parsedReferences.TargetName);
}
public void TestParseReferencesCount()
{
var sut = new ProjectFileParser();
var parsedReferences = sut.Parse(_fullPath);
Assert.AreEqual(32, parsedReferences.References.Count);
}
public void GetAssemblyNameVS2008ProjectTest()
{
using (Stream s = GetStreamForFile("DBInfo.CodeGen.csproj"))
{
ProjectFileParser p = new ProjectFileParser(s);
Assert.AreEqual("DBInfo.CodeGen", p.GetAssemblyName());
}
}
private void FindCommonTestProject(List <ProjectFileParser> projects)
{
Logger.AddDetail("Searching For the Shared Test Project, which is a project containing the 'UnitTestSettings.config' file.");
var project = projects.FirstOrDefault(p =>
p.ItemGroups.TryGetValue(ProjectFileParser.ItemGroupTypes.None, out var noneItemGroup) &&
noneItemGroup.Any(l => l.Contains("<None Include=\"UnitTestSettings.config\">")));
SharedTestProject = project ?? throw new Exception("Unable to find the Shared Test Project!");
}
public void TestParseTargetFrameworkVersion()
{
var sut = new ProjectFileParser();
var projectPoco = sut.Parse(_fullPath);
Assert.NotNull(projectPoco);
Assert.AreEqual("net461", projectPoco.TargetFramework.ShortFolderName);
}
public void GetReferencesVS2008Test()
{
using (Stream s = GetStreamForFile("DBInfo.CodeGen.csproj"))
{
ProjectFileParser p = new ProjectFileParser(s);
Assert.AreEqual("System", p.GetAssemblyReferences().ToList()[0].Include);
Assert.AreEqual("System.Core", p.GetAssemblyReferences().ToList()[1].Include);
}
}
public void GetReferencesVS2013Test()
{
using (Stream s = GetStreamForFile("MSBuild.Community.Tasks.csproj"))
{
ProjectFileParser p = new ProjectFileParser(s);
Assert.AreEqual("Ionic.Zip.Reduced, Version=1.9.1.8, Culture=neutral, PublicKeyToken=edbe51ad942a3f5c, processorArchitecture=MSIL", p.GetAssemblyReferences().ToList()[0].Include);
Assert.AreEqual(@"..\packages\DotNetZip.Reduced.1.9.1.8\lib\net20\Ionic.Zip.Reduced.dll", p.GetAssemblyReferences().ToList()[0].HintPath);
Assert.AreEqual("Microsoft.Build.Framework", p.GetAssemblyReferences().ToList()[1].Include);
}
}
public void TestHintPath()
{
var sut = new ProjectFileParser();
var parsedReferences = sut.Parse(_fullPath);
var first = parsedReferences.References.OfType <Reference>().First();
Assert.NotNull(first);
Assert.AreEqual(@"..\packages\GraphX.2.3.3.0\lib\net40-client\GraphX.Controls.dll", first.HintPath);
}
public void ParseProjectWithProjectReferencesSucceeds()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory,
"TestXml", "ProjectWithReference", "ProjectWithReference.csproj");
var handler = new ProjectFileParser(path);
Assert.AreEqual(4, handler.GetPackageReferences().Count);
Assert.AreEqual(1, handler.GetProjectReferences().Count);
Assert.AreEqual(1, handler.GetTargetFrameworks().Count);
Assert.AreEqual("netcoreapp3.1", handler.GetTargetFrameworks().First());
}
public void ParseProjectInWrongDirectoryThrowsException()
{
var path = Path.Combine(TestContext.CurrentContext.TestDirectory,
"TestXml", "SolutionWithFailedContent", "ProjectInWrongDirectory.csproj");
Assert.Throws <PortingAssistantClientException>(() =>
{
var projectFileParser = new ProjectFileParser(path);
projectFileParser.GetPackageReferences();
});
}
public VersionCli(
IVcs vcsClient,
ProjectFileDetector fileDetector,
ProjectFileParser fileParser,
ProjectFileVersionPatcher fileVersionPatcher
)
{
_vcsTool = vcsClient;
_fileDetector = fileDetector;
_fileParser = fileParser;
_fileVersionPatcher = fileVersionPatcher;
}
public async Task ParseSingleProjectFile()
{
var projectFileParser = new ProjectFileParser(_prjConfig);
_prjConfig.ProjectFiles = "project1.csproj";
await File.WriteAllTextAsync($"{_prjConfig.RootPath}/project1.csproj", project1);
var packages = projectFileParser.GetNugetPackages();
Assert.Equal(1, packages.Count);
Assert.Equal("xunit", packages[0].Name);
Assert.Equal("2.4.0", packages[0].Version);
}
public override void Run(BuildContext context)
{
var projectFileParser = new ProjectFileParser(context);
if (context.SolutionFile != null)
{
GatherPackagesFromSolution(context, projectFileParser);
}
if (context.CheckForPackagesConfig)
{
GatherPackagesFromPackagesConfig(context);
}
}
public void TestProjectReferencePath()
{
var sut = new ProjectFileParser();
var parsedReferences = sut.Parse(_fullPath);
var references = parsedReferences.References;
var projectReferences = references.OfType <ProjectReference>()
.ToArray();
var first = projectReferences.First();
Assert.NotNull(first);
Assert.AreEqual(1, projectReferences.Length);
Assert.AreEqual(@"..\NugetUnicorn.Business\NugetUnicorn.Business.csproj", first.Include);
Assert.AreEqual(@"NugetUnicorn.Business", first.Name);
Assert.AreEqual(@"{79721f58-a1bd-4b03-8958-2560eb16d1ad}", first.Guid);
}
public void Parse()
{
var project = GetExampleProject();
var parser = new ProjectFileParser(project);
Assert.AreEqual(3, parser.PrePropertyGroups.Count);
Assert.AreEqual(5, parser.PropertyGroups.Count);
Assert.AreEqual("Xyz.Xrm.PluginAssembly", parser.AssemblyName);
Assert.AreEqual("Xyz.Xrm.Plugin", parser.Namespace);
Assert.AreEqual(new Guid("2B294DBF-8730-436E-B401-8745FEA632FE"), parser.Id);
Assert.AreEqual(3, parser.ItemGroups.Count);
Assert.AreEqual(4, parser.ItemGroups[ProjectFileParser.ItemGroupTypes.Reference].Count);
Assert.AreEqual(1, parser.ItemGroups[ProjectFileParser.ItemGroupTypes.Compile].Count);
Assert.AreEqual(1, parser.ItemGroups[ProjectFileParser.ItemGroupTypes.None].Count);
Assert.AreEqual(3, parser.Imports.Count);
Assert.AreEqual(11, parser.PostImports.Count);
Assert.That.LinesAreEqual(project, parser.GetProject());
}
public async Task ParseMultipleProjectFiles()
{
var projectFileParser = new ProjectFileParser(_prjConfig);
_prjConfig.ProjectFiles = "project1.csproj project2.csproj";
await File.WriteAllTextAsync($"{_prjConfig.RootPath}/project1.csproj", project1);
await File.WriteAllTextAsync($"{_prjConfig.RootPath}/project2.csproj", project2);
var packages = projectFileParser.GetNugetPackages();
Assert.Equal(2, packages.Count);
Assert.Equal("xunit", packages[0].Name);
Assert.Equal("2.4.0", packages[0].Version);
Assert.Equal("xunit.runner.visualstudio", packages[1].Name);
Assert.Equal("2.4.1", packages[1].Version);
}
static void Main(string[] args)
{
var parser = new Parser(settings =>
{
settings.HelpWriter = Console.Error;
settings.CaseInsensitiveEnumValues = true;
});
var result = parser.ParseArguments <Options>(args)
.WithParsed <Options>(o =>
{
if (DirectoryExplorer.DoesCsProjExistInFolder(o.Path, out var csProjPath))
{
ProjectFileParser.ReadFileAndUpdateVersion(csProjPath, o.VersionType);
}
else
{
Console.WriteLine("No csproj found in directory.");
Main(new string[] {});
}
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
try
{
var projFileParser = new ProjectFileParser(
Configuration[ReferencePrefixesEnvVarKey]?.Split(',').Select(s => s.Trim()),
bool.Parse(Configuration[AreReferencePrefixesIncludeEnvVarKey] ?? "true"));
var scanners = new List <IOrganizationScanner>();
var ghOrgKey = Configuration[GitHubOrganizationEnvVarKey];
if (!string.IsNullOrWhiteSpace(ghOrgKey))
{
scanners.Add(
new GitHubScanner(
projFileParser,
ghOrgKey,
Configuration[GitHubApiEnvVarKey],
Configuration[GitHubReposEnvVarKey]));
}
var bbAccountKey = Configuration[BitBucketAccountEnvVarKey];
if (!string.IsNullOrWhiteSpace(bbAccountKey))
{
scanners.Add(
new BitBucketScanner(
projFileParser,
bbAccountKey,
Configuration[BitBucketEnvVarKey],
Configuration[BitBucketSecretEnvVarKey]));
}
services.AddSingleton <IReferencesScanner>(new GitScanner(scanners));
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private static void GatherPackagesFromSolution(BuildContext context, ProjectFileParser projectFileParser)
{
context.Log.Information("Parsing {0}", context.SolutionFile);
var parsedSolution = context.ParseSolution(context.SolutionFile);
foreach (var project in parsedSolution.Projects)
{
context.Log.Information(
@"Solution project file:
Name: {0}
Path: {1}
Id : {2}
Type: {3}",
project.Name,
project.Path,
project.Id,
project.Type
);
if (project.Type == "{2150E333-8FDC-42A3-9474-1A3956D46DE8}")
{
// Solution Folder
continue;
}
try
{
var parseProject = projectFileParser.ParseProjectFile(project.Path);
context.AllPackageReferences.AddRange(parseProject.Select(x => x.Include));
}
catch (Exception e)
{
context.Log.Error("Failed to parse a project file, feel free to submit an issue.");
context.Log.Error(e.ToString());
}
}
}
private List <ProjectDetails> GetProjects(string pathToSolution)
{
var solution = SolutionFile.Parse(pathToSolution);
var projects = solution.ProjectsInOrder.Select(p =>
{
if (p.ProjectType != SolutionProjectType.KnownToBeMSBuildFormat && p.ProjectType != SolutionProjectType.WebProject)
{
return(null);
}
var projectParser = new ProjectFileParser(p.AbsolutePath);
return(new ProjectDetails
{
ProjectName = p.ProjectName,
ProjectFilePath = p.AbsolutePath,
ProjectGuid = p.ProjectGuid,
ProjectType = p.ProjectType.ToString(),
});
}).Where(p => p != null).ToList();
return(projects);
}
