public AuditProject(IProject roslynProject, FrameworkName targetFramework, Options options)
{
// Shared
RoslynProject = roslynProject;
MsBuildProject = RoslynProject.GetMsBuildProject();
LocalRepository = RoslynProject.Solution.GetLocalPackageRepository();
ConfigReferences = PackageReferenceFile.CreateFromProject(RoslynProject.FilePath).GetPackageReferences(false).ToList();
CsprojReferences = MsBuildProject.GetDirectPackageAssemblies().Select(g => g.Key).Where(r => r != null).Distinct().ToList();
References = ConfigReferences.Union(CsprojReferences).ToList();
Packages = options.Unused || options.Snapshot || options.Missing || options.Project
? References.Select(r => r.GetPackage(LocalRepository)).Where(p => p != null).ToList()
: Enumerable.Empty <IPackage>();
// Unused Packages
UnusedPackages = options.Unused
? GetUnusedPackages(targetFramework, options.UnusedUsings)
: Enumerable.Empty <UnusedPackage>();
// Snapshot References
SnapshotPackages = options.Snapshot
? Packages.GetSnapshotPackages()
: Enumerable.Empty <SnapshotPackage>();
// Missing Packages
MissingPackages = options.Missing
? GetMissingPackages(targetFramework)
: Enumerable.Empty <MissingPackageDependency>();
// Project Packages
ProjectPackages = options.Project
? GetProjectPackages()
: Enumerable.Empty <ProjectPackage>();
// File Diff References
MissingPackageReferences = options.FileDiff
? GetMissingPackageReferences()
: Enumerable.Empty <InconsistentFiles>();
// Duplicate Package References
DuplicatePackageReferences = options.FileDiff
? GetDuplicatePackageReferences()
: Enumerable.Empty <DuplicatePackageReference>();
// Orphan Binding Redirects
BindingRedirectOnlyReferences = options.FileDiff
? GetBindingRedirectOnlyReferences()
: Enumerable.Empty <OrphanAssemblyBinding>();
// Mismatched Binding Redirects
BindingRedirectMismatchReferences = options.RedirectMismatch
? GetBindingRedirectMismatchReferences()
: Enumerable.Empty <MismatchAssemblyBinding>();
BadProjectRefGuids = options.FileDiff
? GetBadProjectRefGuids()
: Enumerable.Empty <MismatchedGuid>();
IllegalNugetTargets = options.NugetTargets
? GetIllegalNugetTargets()
: Enumerable.Empty <IllegalProjectFileElement>();
}
private void AddDependencies(Dictionary <String, Tuple <IPackage, PackageDependency> > packagesAndDependencies)
{
var file = PackageReferenceFile.CreateFromProject(_project.FullPath);
if (!File.Exists(file.FullPath))
{
return;
}
Logger.Log(MessageLevel.Info, LocalizedResourceManager.GetString("UsingPackagesConfigForDependencies"));
// Get the solution repository
IPackageRepository repository = GetPackagesRepository();
// Collect all packages
IDictionary <PackageName, PackageReference> packageReferences =
file.GetPackageReferences()
.Where(r => !r.IsDevelopmentDependency)
.ToDictionary(r => new PackageName(r.Id, r.Version));
// add all packages and create an associated dependency to the dictionary
foreach (PackageReference reference in packageReferences.Values)
{
if (repository != null)
{
IPackage package = repository.FindPackage(reference.Id, reference.Version);
if (package != null && !packagesAndDependencies.ContainsKey(package.Id))
{
IVersionSpec spec = GetVersionConstraint(packageReferences, package);
var dependency = new PackageDependency(package.Id, spec);
packagesAndDependencies.Add(package.Id, new Tuple <IPackage, PackageDependency>(package, dependency));
}
}
}
}
public override bool Execute()
{
var packageReferenceFile = PackageReferenceFile.CreateFromProject(ProjectPath);
PackageReferences = packageReferenceFile.GetPackageReferences().Select(ConvertPackageElement).ToArray();
return(true);
}
public override bool Execute()
{
var packageReferences = from project in Projects
let packageReferenceFile = PackageReferenceFile.CreateFromProject(project.GetMetadata("FullPath"))
from packageReference in packageReferenceFile.GetPackageReferences()
select ConvertPackageElement(project, packageReference);
PackageReferences = packageReferences.ToArray();
return(true);
}
private void AddFiles(PackageBuilder builder, string itemType, string targetFolder)
{
// Skip files that are added by dependency packages
var references = PackageReferenceFile.CreateFromProject(_project.FullPath).GetPackageReferences();
IPackageRepository repository = GetPackagesRepository();
string projectName = Path.GetFileNameWithoutExtension(_project.FullPath);
var contentFilesInDependencies = new List <IPackageFile>();
if (references.Any() && repository != null)
{
contentFilesInDependencies = references.Select(reference => repository.FindPackage(reference.Id, reference.Version))
.Where(a => a != null)
.SelectMany(a => a.GetContentFiles())
.ToList();
}
// Get the content files from the project
foreach (var item in _project.GetItems(itemType))
{
string fullPath = item.GetMetadataValue("FullPath");
if (_excludeFiles.Contains(Path.GetFileName(fullPath)))
{
continue;
}
string targetFilePath = GetTargetPath(item);
if (!File.Exists(fullPath))
{
Logger.Log(MessageLevel.Warning, LocalizedResourceManager.GetString("Warning_FileDoesNotExist"), targetFilePath);
continue;
}
// Skip target file paths containing msbuild variables since we do not offer a way to install files with variable paths.
// These are show up in shared files found in universal apps.
if (targetFilePath.IndexOf("$(MSBuild", StringComparison.OrdinalIgnoreCase) > -1)
{
Logger.Log(MessageLevel.Warning, LocalizedResourceManager.GetString("Warning_UnresolvedFilePath"), targetFilePath);
continue;
}
// if IncludeReferencedProjects is true and we are adding source files,
// add projectName as part of the target to avoid file conflicts.
string targetPath = IncludeReferencedProjects && itemType == SourcesItemType?
Path.Combine(targetFolder, projectName, targetFilePath) :
Path.Combine(targetFolder, targetFilePath);
// Check that file is added by dependency
IPackageFile targetFile = contentFilesInDependencies.Find(a => a.Path.Equals(targetPath, StringComparison.OrdinalIgnoreCase));
if (targetFile != null)
{
// Compare contents as well
var isEqual = ContentEquals(targetFile, fullPath);
if (isEqual)
{
Logger.Log(MessageLevel.Info, LocalizedResourceManager.GetString("PackageCommandFileFromDependencyIsNotChanged"), targetFilePath);
continue;
}
Logger.Log(MessageLevel.Info, LocalizedResourceManager.GetString("PackageCommandFileFromDependencyIsChanged"), targetFilePath);
}
var packageFile = new PhysicalPackageFile
{
SourcePath = fullPath,
TargetPath = targetPath
};
AddFileToBuilder(builder, packageFile);
}
}