public bool InstallPackage(IPackageReference packageId, bool allowPreRelease = false, Action<string> packageInstalled = null)
{
var useVersion = packageId.Version.CompareTo(new Version()) != 0;
try
{
if (useVersion)
{
_manager.InstallPackage(packageId.PackageId,
new SemanticVersion(packageId.Version, packageId.SpecialVersion), false,
allowPreRelease);
}
else
{
_manager.InstallPackage(packageId.PackageId);
}
if (packageInstalled != null)
packageInstalled("Installed: " + packageId.PackageId + " " + (useVersion ? packageId.Version.ToString() : ""));
return true;
}
catch (Exception e)
{
if (packageInstalled != null)
{
packageInstalled("Installation failed: " + packageId.PackageId + " " + (useVersion ? packageId.Version.ToString() : ""));
packageInstalled(e.Message);
}
return false;
}
}
public bool InstallPackage(IPackageReference packageId, bool allowPreRelease = false, Action <string> packageInstalled = null)
{
Guard.AgainstNullArgument("packageId", packageId);
var version = GetVersion(packageId);
var packageName = packageId.PackageId + " " + (version == null ? string.Empty : packageId.Version.ToString());
try
{
_manager.InstallPackage(packageId.PackageId, version, allowPrereleaseVersions: allowPreRelease, ignoreDependencies: false);
if (packageInstalled != null)
{
packageInstalled("Installed: " + packageName);
}
return(true);
}
catch (Exception e)
{
if (packageInstalled != null)
{
packageInstalled("Installation failed: " + packageName);
packageInstalled(e.Message);
}
return(false);
}
}
public bool IsInstalled(IPackageReference packageReference, bool allowPreRelease = false)
{
Guard.AgainstNullArgument("packageReference", packageReference);
var version = GetVersion(packageReference);
return _manager.LocalRepository.FindPackage(packageReference.PackageId, version, allowPreRelease, allowUnlisted: false) != null;
}
private ValidationResult ValidateAssets(IPackageReference reference, AssetsProperty property, IProject project)
{
var inProject = Array.Empty <string>();
switch (property)
{
case AssetsProperty.Include:
inProject = reference.IncludeAssets;
break;
case AssetsProperty.Exclude:
inProject = reference.ExcludeAssets;
break;
case AssetsProperty.Private:
inProject = reference.PrivateAssets;
break;
}
var inConfig = Array.Empty <string>();
switch (property)
{
case AssetsProperty.Include:
inConfig = _data.IncludeAssets;
break;
case AssetsProperty.Exclude:
inConfig = _data.ExcludeAssets;
break;
case AssetsProperty.Private:
inConfig = _data.PrivateAssets;
break;
}
if (inProject.Any(x => x == "none") && inConfig.Length == 0 ||
inProject.Length == 0 && inConfig.Any(x => x == "none"))
{
return(ValidationResult.Success());
}
var missingInProject = inConfig.Except(inProject).ToList();
if (missingInProject.Any())
{
return(ValidationResult.Error(project,
$"Missing {property}Asset entry in project: {string.Join(",", missingInProject)}"));
}
var extraInProject = inProject.Except(inConfig).ToList();
if (extraInProject.Any())
{
return(ValidationResult.Error(project,
$"Extra {property}Asset entry in project: {string.Join(",", extraInProject)}"));
}
return(ValidationResult.Success());
}
public void InstallPackage(IPackageReference packageId, bool allowPreRelease = false)
{
var version = GetVersion(packageId);
var packageName = packageId.PackageId + " " + (version == null ? string.Empty : packageId.Version.ToString());
_manager.InstallPackage(packageId.PackageId, version, allowPrereleaseVersions: allowPreRelease, ignoreDependencies: false);
_logger.Info("Installed: " + packageName);
}
public bool InstallPackage(IPackageReference packageId, bool allowPreRelease = false, Action <string> packageInstalled = null)
{
var useVersion = packageId.Version.CompareTo(new Version()) != 0;
try
{
if (useVersion)
{
_manager.InstallPackage(packageId.PackageId,
new SemanticVersion(packageId.Version, packageId.SpecialVersion), false,
allowPreRelease);
}
else
{
_manager.InstallPackage(packageId.PackageId);
}
if (packageInstalled != null)
{
packageInstalled("Installed: " + packageId.PackageId + " " + (useVersion ? packageId.Version.ToString() : ""));
}
return(true);
}
catch (Exception e)
{
if (packageInstalled != null)
{
packageInstalled("Installation failed: " + packageId.PackageId + " " + (useVersion ? packageId.Version.ToString() : ""));
packageInstalled(e.Message);
}
return(false);
}
}
public bool InstallPackage(IPackageReference packageId, bool allowPreRelease = false, Action<string> packageInstalled = null)
{
Guard.AgainstNullArgument("packageId", packageId);
var version = GetVersion(packageId);
var packageName = packageId.PackageId + " " + (version == null ? string.Empty : packageId.Version.ToString());
try
{
_manager.InstallPackage(packageId.PackageId, version, allowPrereleaseVersions: allowPreRelease, ignoreDependencies: false);
if(packageInstalled != null)
{
packageInstalled("Installed: " + packageName);
}
return true;
}
catch (Exception e)
{
if (packageInstalled != null)
{
packageInstalled("Installation failed: " + packageName);
packageInstalled(e.Message);
}
return false;
}
}
public bool IsInstalled(IPackageReference packageReference, bool allowPreRelease = false)
{
Guard.AgainstNullArgument("packageReference", packageReference);
var version = GetVersion(packageReference);
return(_manager.LocalRepository.FindPackage(packageReference.PackageId, version, allowPreRelease, allowUnlisted: false) != null);
}
public bool HasPackageReference(string name, string versionString, out IPackageReference packageReference)
{
packageReference = this.PackageReferences.Where(x => x.Name == name && x.VersionString == versionString).SingleOrDefault();
var hasPackageReference = packageReference == default;
return(hasPackageReference);
}
/// <summary>
/// Determines whether the manager contains the package that is referenced by <paramref name="package"/>.
/// </summary>
/// <param name="package">The package.</param>
/// <returns>
/// <c>true</c> if the manager contains the package that is referenced by <paramref name="package"/>; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="package"/> is null.</exception>
public bool Contains(IPackageReference package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
return(m_packages.ContainsKey(package.ID));
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return(package == null ? null : new PackageObject(package, packageRef.FrameworkName));
}
public void InstallPackage(IPackageReference packageId, bool allowPreRelease = false)
{
Guard.AgainstNullArgument("packageId", packageId);
var version = GetVersion(packageId);
var packageName = packageId.PackageId + " " + (version == null ? string.Empty : packageId.Version.ToString());
_manager.InstallPackage(packageId.PackageId, version, allowPrereleaseVersions: allowPreRelease, ignoreDependencies: false);
_logger.Info("Installed: " + packageName);
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return package == null ? null : new PackageObject(package, packageRef.FrameworkName);
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
Guard.AgainstNullArgument("packageRef", packageRef);
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null && !(packageRef.Version.Major == 0 && packageRef.Version.Minor == 0)
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return package == null ? null : new PackageObject(package, packageRef.FrameworkName);
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
Guard.AgainstNullArgument("packageRef", packageRef);
var repository = new LocalPackageRepository(path);
var package = packageRef.Version != null && !(packageRef.Version.Major == 0 && packageRef.Version.Minor == 0)
? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
: repository.FindPackage(packageRef.PackageId);
return(package == null ? null : new PackageObject(package, packageRef.FrameworkName));
}
public bool RemovePackageReference(IPackageReference packageReference)
{
var hasAnyPackageReferences = this.ProjectXElement.HasPackageReferencesItemGroupElement(out var packageReferencesItemGroupXElement);
if (!hasAnyPackageReferences)
{
return(false);
}
var success = packageReferencesItemGroupXElement.RemovePackageReference(packageReference);
return(success);
}
public IPackage GetPackage(IPackageReference package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
if (m_packages.ContainsKey(package.ID))
{
return(m_packages[package.ID]);
}
return(null);
}
public IPackageObject FindPackage(string path, IPackageReference packageRef)
{
if (packageRef == null)
{
throw new ArgumentNullException(nameof(packageRef));
}
return(null);
//todo
////var repository = new LocalPackageRepository(path);
//var folderReader = new PackageFolderReader(path);
//var nupkgFiles = folderReader.GetFiles().Where(x => Path.GetExtension(x).ToLowerInvariant() == ".nupkg");
//var result = new List<string>();
//foreach (var nupkg in nupkgFiles)
//{
// var stream = folderReader.GetStream(nupkg);
// folderReader.GetPackageDependencies()
// var packageReader = new PackageReader(stream);
// var identity = packageReader.GetIdentity();
// if (identity.Id == packageRef.PackageId && identity.Version.Version == packageRef.Version)
// {
// return new PackageObject(identity, );
// }
// var package = packageRef.Version != null && !(packageRef.Version.Major == 0 && packageRef.Version.Minor == 0)
// ? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
// : repository.FindPackage(packageRef.PackageId);
// //var packagesConfigReference = contents.FirstOrDefault(x => x.PackageIdentity.Id == identity.Id && x.PackageIdentity.Version == identity.Version);
// //if (packagesConfigReference == null)
// //{
// // break;
// //}
// //var packageContents = packageReader.GetLibItems().Where(x => compatibilityProvider.IsCompatible(x.TargetFramework, packagesConfigReference.TargetFramework)).
// // SelectMany(x => x.Items.Where(i => Path.GetExtension(i).ToLowerInvariant() == ".dll"));
// //result.AddRange(packageContents);
//}
//var package = packageRef.Version != null && !(packageRef.Version.Major == 0 && packageRef.Version.Minor == 0)
// ? repository.FindPackage(packageRef.PackageId, new SemanticVersion(packageRef.Version, packageRef.SpecialVersion), true, true)
// : repository.FindPackage(packageRef.PackageId);
//return package == null ? null : new PackageObject(package, packageRef.FrameworkName);
}
public bool HasPackageReference(string name, out IPackageReference packageReference)
{
var hasAnyPackageReferences = this.ProjectXElement.HasPackageReferencesItemGroupElement(out var packageReferencesItemGroupXElement);
if (!hasAnyPackageReferences)
{
packageReference = PackageReferenceHelper.None;
return(false);
}
var hasPackageReference = packageReferencesItemGroupXElement.HasPackageReference(name, out packageReference);
return(hasPackageReference);
}
protected internal virtual void ProcessPackage(
string packagesPath,
IPackageReference reference,
StringBuilder builder,
List <string> references,
List <string> namespaces)
{
Guard.AgainstNullArgument("reference", reference);
Guard.AgainstNullArgument("builder", builder);
Guard.AgainstNullArgument("references", references);
Guard.AgainstNullArgument("namespaces", namespaces);
_logger.DebugFormat("Finding package:{0}", reference.PackageId);
var package = _packageContainer.FindPackage(packagesPath, reference);
if (package == null)
{
_logger.WarnFormat("Package missing: {0}", reference.PackageId);
return;
}
_logger.Debug("Package found");
var script = GetMainScript(package);
if (script != null)
{
script = Path.Combine(packagesPath, string.Format("{0}.{1}", package.Id, package.TextVersion), script);
_logger.Debug("Pre-processing script");
var result = _preProcessor.ProcessFile(script);
var fileWithoutExtension = Path.GetFileNameWithoutExtension(script);
var classname = fileWithoutExtension.Substring(0, fileWithoutExtension.Length - 4);
_logger.DebugFormat("Created Script Libary class: {0}", classname);
var classBuilder = new StringBuilder();
classBuilder.AppendFormat("public class {0} : ScriptCs.ScriptLibraryWrapper {{{1}", classname, Environment.NewLine);
classBuilder.AppendLine(result.Code);
classBuilder.AppendLine("}");
var classDefinition = classBuilder.ToString();
_logger.TraceFormat("Class definition:{0}{0}{1}", Environment.NewLine, classDefinition);
builder.Append(classDefinition);
references.AddRange(result.References);
namespaces.AddRange(result.Namespaces);
}
}
public bool InstallPackage(IPackageReference packageId, bool allowPreRelease = false)
{
if (packageId == null) throw new ArgumentNullException("packageId");
var version = GetVersion(packageId);
var packageName = packageId.PackageId + " " + (version == null ? string.Empty : packageId.Version.ToString());
try
{
_manager.InstallPackage(packageId.PackageId, version, allowPrereleaseVersions: allowPreRelease, ignoreDependencies: false);
_logger.Info("Installed: " + packageName);
return true;
}
catch (Exception e)
{
_logger.Error("Installation failed: " + packageName);
_logger.Error(e.Message);
return false;
}
}
private ValidationResult ValidateVersion(IPackageReference reference, IProject project)
{
if (string.IsNullOrEmpty(_data.Version))
{
return(ValidationResult.Success());
}
if (!VersionRange.TryParse(_data.Version, out var range))
{
return(ValidationResult.Error(project, $"Invalid semantic version range given: {_data.Version}"));
}
if (!range !.SatisfiedBy(SemanticVersion.Parse(reference.Version)))
{
return(ValidationResult.Error(project,
$"Version of {_data.Name} ({reference.Version}) das not match required version ({_data.Version})"));
}
return(ValidationResult.Success());
}
private ValidationResult ValidateAssets(IPackageReference reference, IProject project)
{
var validation = ValidateAssets(reference, AssetsProperty.Include, project);
if (validation.IsError)
{
return(validation);
}
validation = ValidateAssets(reference, AssetsProperty.Exclude, project);
if (validation.IsError)
{
return(validation);
}
validation = ValidateAssets(reference, AssetsProperty.Private, project);
if (validation.IsError)
{
return(validation);
}
return(ValidationResult.Success());
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public override void ReadXml(System.Xml.XmlReader reader)
{
string fileId = reader.GetAttribute("FileID");
if (fileId == null)
{
base.ReadXml(reader);
}
else
{
var sourceSerializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(PackageSystem.PackageReference), null);
m_packageFile = fileId;
System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument(reader);
var nav = doc.CreateNavigator();
var iter = nav.SelectSingleNode("/FilePath/PackageReference");
if (iter == null)
{
throw new XmlSchemaException();
}
m_packageSource = (IPackageReference)sourceSerializer.Deserialize(iter.ReadSubtree());
}
}
public static bool IsNone(IPackageReference packageReference)
{
var isNone = packageReference == PackageReferenceHelper.None;
return(isNone);
}
/// <summary>
/// Inits the TraceLabFilePath with the specified file from the given package.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="id">The id.</param>
public void Init(IPackageReference source, string id)
{
PackageSource = source;
PackageFile = id;
}
public IPackageObject FindPackage(string path, IPackageReference packageReference)
{
return _packageContainer.FindPackage(path, packageReference);
}
public static bool HasPackageReference(this IVisualStudioProjectFile visualStudioProjectFile, string name, string versionString, out IPackageReference packageReference)
{
var hasPackageReferenceByName = visualStudioProjectFile.HasPackageReference(name, out packageReference);
if (!hasPackageReferenceByName)
{
return(false);
}
var versionStringMatches = packageReference.VersionString == versionString;
if (versionStringMatches)
{
return(true);
}
else
{
packageReference = PackageReferenceHelper.None;
return(false);
}
}
/// <summary>
/// Inits the TraceLabDirectoryPath with the specified directory from the given package.
/// </summary>
/// <param name="source">The package source.</param>
/// <param name="dir">The directory.</param>
public void Init(IPackageReference source, string dir)
{
PackageSource = source;
PackageDirectory = dir;
}
public static bool WasFound(IPackageReference packageReference)
{
var wasFound = packageReference != PackageReferenceHelper.None;
return(wasFound);
}
/// <summary>
/// Initializes a new <see cref="SerializablePackageReference"/>.
/// </summary>
/// <param name="packageReference">The <see cref="IPackageReference"/>.</param>
/// <exception cref="ArgumentNullException">
/// - <paramref name="packageReference"/>
/// </exception>
public SerializablePackageReference(IPackageReference packageReference)
: base(packageReference)
{
Version = packageReference.Version;
RawVersion = packageReference.RawVersion;
}
public void InstallPackage(IPackageReference packageId, bool allowPreRelease = false)
{
throw new NotImplementedException();
}
/// <summary>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public override void ReadXml(System.Xml.XmlReader reader)
{
string fileId = reader.GetAttribute("FileID");
if (fileId == null)
{
base.ReadXml(reader);
}
else
{
var sourceSerializer = TraceLab.Core.Serialization.XmlSerializerFactory.GetSerializer(typeof(PackageSystem.PackageReference), null);
m_packageFile = fileId;
System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument(reader);
var nav = doc.CreateNavigator();
var iter = nav.SelectSingleNode("/FilePath/PackageReference");
if(iter == null)
throw new XmlSchemaException();
m_packageSource = (IPackageReference)sourceSerializer.Deserialize(iter.ReadSubtree());
}
}
public bool RemovePackageReference(IPackageReference packageReference)
{
var removed = this.PackageReferences.Remove(packageReference);
return(removed);
}
/// <summary>
/// Inits the TraceLabDirectoryPath with the specified directory from the given package.
/// </summary>
/// <param name="source">The package source.</param>
/// <param name="dir">The directory.</param>
public void Init(IPackageReference source, string dir)
{
PackageSource = source;
PackageDirectory = dir;
}
protected internal virtual void ProcessPackage(
string packagesPath,
IPackageReference reference,
StringBuilder builder,
List<string> references,
List<string> namespaces)
{
_logger.DebugFormat("Finding package:{0}", reference.PackageId);
var package = _packageContainer.FindPackage(packagesPath, reference);
if (package == null)
{
_logger.WarnFormat("Package missing: {0}", reference.PackageId);
return;
}
_logger.Debug("Package found");
var script = GetMainScript(package);
if (script != null)
{
script = Path.Combine(packagesPath, string.Format("{0}.{1}", package.Id, package.TextVersion), script);
_logger.Debug("Pre-processing script");
var result = _preProcessor.ProcessFile(script);
var fileWithoutExtension = Path.GetFileNameWithoutExtension(script);
var classname = fileWithoutExtension.Substring(0, fileWithoutExtension.Length - 4);
_logger.DebugFormat("Created Script Libary class: {0}", classname);
var classBuilder = new StringBuilder();
classBuilder.AppendFormat("public class {0} : ScriptCs.ScriptLibraryWrapper {{{1}", classname, Environment.NewLine);
classBuilder.AppendLine(result.Code);
classBuilder.AppendLine("}");
var classDefinition = classBuilder.ToString();
_logger.TraceFormat("Class definition:{0}{0}{1}", Environment.NewLine, classDefinition);
builder.Append(classDefinition);
references.AddRange(result.References);
namespaces.AddRange(result.Namespaces);
}
}
/// <summary>
/// Inits the TraceLabFilePath with the specified file from the given package.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="id">The id.</param>
public void Init(IPackageReference source, string id)
{
PackageSource = source;
PackageFile = id;
}
private static SemanticVersion GetVersion(IPackageReference packageReference)
{
return(packageReference.Version == EmptyVersion ? null : new SemanticVersion(packageReference.Version, packageReference.SpecialVersion));
}
public void RemoveReference(IPackageReference reference)
{
m_references.Remove(reference);
}
/// <summary>
/// Method name indicates that we clone the package reference, instead of adding the actual instance.
/// </summary>
public static void AddNewPackageReferenceFrom(this IVisualStudioProjectFile visualStudioProjectFile, IPackageReference packageReference)
{
visualStudioProjectFile.AddPackageReference(packageReference.Name, packageReference.VersionString);
}
/// <summary>
/// Note, no need for package version string since you can't have mulitple versions of the same package.
/// </summary>
public static bool HasPackageReference(this PackageReferencesItemGroupXElement packageReferencesItemGroupXElement, string name, out IPackageReference packageReference)
{
packageReference = packageReferencesItemGroupXElement.GetPackageReferenceXElementsWhereName(name)
.Select(xElement => PackageReferenceXElement.From(xElement))
.SingleOrDefault();
var hasPackageReference = PackageReferenceHelper.WasFound(packageReference);
return(hasPackageReference);
}
public static bool RemovePackageReference(this PackageReferencesItemGroupXElement packageReferencesItemGroupXElement, IPackageReference packageReference)
{
var xPackageReference = packageReferencesItemGroupXElement.GetPackageReferenceXElementsWhereName(packageReference.Name)
.SingleOrDefault();
var wasFound = XElementHelper.WasFound(xPackageReference);
if (wasFound)
{
xPackageReference.Remove();
}
return(wasFound);
}
public bool IsInstalled(IPackageReference packageReference, bool allowPreRelease = false)
{
if (packageReference == null) throw new ArgumentNullException("packageReference");
var version = GetVersion(packageReference);
return _manager.LocalRepository.FindPackage(packageReference.PackageId, version, allowPreRelease, allowUnlisted: false) != null;
}
private static SemanticVersion GetVersion(IPackageReference packageReference)
{
return packageReference.Version == EmptyVersion ? null : new SemanticVersion(packageReference.Version, packageReference.SpecialVersion);
}
public void RemoveReference(IPackageReference reference)
{
m_references.Remove(reference);
}
