public void Parse(string line, PackageDescriptor descriptor) { var match = _regex.Match(line); if (!match.Success) return; ParseContent(match.Groups["content"].Value, descriptor); }
IEnumerable<ICommandOutput> Build() { var packageName = Name ?? Environment.Descriptor.Name; var destinationPath = _destinationPath ?? Environment.CurrentDirectory; var packageDescriptorForEmbedding = new PackageDescriptor(GetCurrentPackageDescriptor()); var generatedVersion = GetPackageVersion(_buildResults, packageDescriptorForEmbedding); if (generatedVersion == null) yield return new Error("Could not build package, no version found."); packageDescriptorForEmbedding.Version = generatedVersion; packageDescriptorForEmbedding.Name = packageName; foreach (var file in _buildResults) yield return new GenericMessage(string.Format("Copying: {0} - {1}", file.ExportName, file.Path)); var packageFilePath = destinationPath.GetFile( PackageNameUtility.PacakgeFileName(packageName, generatedVersion.ToString())); var packageContent = GeneratePackageContent(_buildResults).Concat( GenerateVersionFile(generatedVersion), GenerateDescriptorFile(packageDescriptorForEmbedding) ); PackageBuilder.NewFromFiles(packageFilePath, packageContent); yield return new GenericMessage(string.Format("Package built at '{0}'.", packageFilePath)); }
public IEnumerable<ICommandOutput> Execute() { var currentDirectory = Environment.CurrentDirectory; var packagePath = Target; var projectDirectory = currentDirectory.GetDirectory(packagePath); var packageName = Target == "." ? Environment.CurrentDirectory.Name : Target; var packageDescriptorFile = projectDirectory.GetFile(packageName + ".wrapdesc"); var items = new List<IFileSystemItem> { packageDescriptorFile }; var packageDescriptor = new PackageDescriptor(); if (Meta) { packageDescriptor.BuildCommand = "$meta"; } else { AddOpenWrapDependency(packageDescriptor); AddPackageFolders(projectDirectory, items); foreach(var m in CopyOpenWrap(projectDirectory)) yield return m; } WriteVersionFile(projectDirectory); WriteDescriptor(packageDescriptorFile, packageDescriptor); yield return new GenericMessage("Package '{0}' initialized. Start adding packages by using the 'add-wrap' command.", packageName); }
public DependencyResolutionResult TryResolveDependencies( PackageDescriptor packageDescriptor, IEnumerable<IPackageRepository> repositoriesToQuery) { var packageSelection = new PackageSelectionContext(); for (int i = 0; i < MAX_RETRIES; i++) { var exclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); var visitor = new DependencyVisitor(repositoriesToQuery, packageSelection, packageDescriptor.Dependencies, packageDescriptor.Overrides); var resolutionSucceeded = visitor .VisitDependencies(packageDescriptor.Dependencies); if (resolutionSucceeded == false) { var newExclusionList = packageSelection.IncompatiblePackageVersions.Select(x => x.Key); if (newExclusionList.Except(exclusionList).Any()) { packageSelection = new PackageSelectionContext(packageSelection.IncompatiblePackageVersions); continue; } } return Result(packageSelection, repositoriesToQuery, visitor.NotFound); } throw new InvalidOperationException(string.Format("OpenWrap tried {0} times to resolve the tree of dependencies and gave up.", MAX_RETRIES)); }
public void Parsing_whitespace_description_sets_Description_to_empty_string() { var parser = new DescriptionParser(); var wrapDescriptor = new PackageDescriptor(); parser.Parse("description : ", wrapDescriptor); wrapDescriptor.Description.ShouldBe(""); }
public void Parsing_description_trims_whitespace() { var parser = new DescriptionParser(); var wrapDescriptor = new PackageDescriptor(); parser.Parse("description : \t test message \t", wrapDescriptor); wrapDescriptor.Description.ShouldBe("test message"); }
public void Parsing_description_sets_Description_property() { var parser = new DescriptionParser(); var wrapDescriptor = new PackageDescriptor(); parser.Parse("description: test message", wrapDescriptor); wrapDescriptor.Description.ShouldBe("test message"); }
public DefaultPackageInfo(string packageFileName, Version versionFileContent, PackageDescriptor descriptor) { _descriptor = descriptor; _packageVersion = versionFileContent ?? descriptor.Version ?? PackageNameUtility.GetVersion(packageFileName); _packageName = PackageNameUtility.GetName(packageFileName); }
public IEnumerable<PackageOperationResult> CleanProjectPackages(PackageDescriptor packages, IPackageRepository projectRepository, string name) { if (packages == null) throw new ArgumentNullException("packages"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); var repoForClean = projectRepository as ISupportCleaning; if (repoForClean == null) throw new ArgumentException("projectRepository must implement ISupportCleaning"); return CleanProjectPackagesCore(packages, repoForClean, x => name.EqualsNoCase(x)); }
public IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(PackageDescriptor descriptor, IPackageRepository repository, IWrapAssemblyClient client) { return (from dependency in descriptor.Dependencies where dependency.ContentOnly == false let package = repository.Find(dependency) where package != null let items = package.Load().GetExport("bin", client.Environment).Items.OfType<IAssemblyReferenceExportItem>() select items).SelectMany(x => x); }
public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory) { CurrentDirectory = currentDirectory; SystemRepository = new InMemoryRepository("System repository"); RemoteRepository = new InMemoryRepository("Remote repository"); CurrentDirectoryRepository = new InMemoryRepository("Current directory repository"); RemoteRepositories = new List<InMemoryRepository> { RemoteRepository }; DescriptorFile = CurrentDirectory.GetFile("descriptor.wrapdesc"); Descriptor = new PackageDescriptor(); ConfigurationDirectory = configDirectory; }
public PackageDescriptor(PackageDescriptor copy) { Dependencies = copy.Dependencies.Select(x => new PackageDependency(x)).ToList(); Overrides = new List<PackageNameOverride>(copy.Overrides); Description = copy.Description; UseProjectRepository = copy.UseProjectRepository; Name = copy.Name; Version = copy.Version; Anchored = copy.Anchored; BuildCommand = copy.BuildCommand; CreationTime = copy.CreationTime; }
public IEnumerable<PackageOperationResult> AddProjectPackage(PackageRequest packageToAdd, IEnumerable<IPackageRepository> sourceRepositories, PackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageAddOptions options = PackageAddOptions.Default) { Check.NotNull(packageToAdd, "packageToAdd"); Check.NoNullElements(sourceRepositories, "sourceRepositories"); Check.NotNull(projectDescriptor, "projectDescriptor"); Check.NotNull(projectRepository, "projectRepository"); return AddProjectPackageCore(packageToAdd, sourceRepositories, projectDescriptor, projectRepository, options); }
protected abstract void ParseContent(string content, PackageDescriptor descriptor);
protected abstract IEnumerable<string> WriteContent(PackageDescriptor descriptor);
public IEnumerable<PackageOperationResult> RemoveProjectPackage(PackageRequest packageToRemove, PackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options = PackageRemoveOptions.Default) { if (packageToRemove == null) throw new ArgumentNullException("packageToRemove"); if (packageDescriptor == null) throw new ArgumentNullException("packageDescriptor"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); return (packageToRemove.ExactVersion == null && !packageToRemove.LastVersion) ? RemoveFromDescriptor(packageToRemove, packageDescriptor, projectRepository, options) : RemovePackageFilesFromProjectRepo(packageToRemove, projectRepository); }
public IEnumerable<string> Write(PackageDescriptor descriptor) { var content = WriteContent(descriptor).ToList(); if (content.Count == 0) return content; return content.Select(x => Header + ": " + x); }
Version GetPackageVersion(IList<FileBuildResult> buildFiles, PackageDescriptor packageDescriptorForEmbedding) { // gets the package version from (in this order): // 1. 'version' file generated by the build // 2. 'version' file living alongside the .wrapdesc file // 3. 'version:' header in wrap descriptor return new DefaultPackageInfo(string.Empty, GetVersionFromVersionFiles(buildFiles), packageDescriptorForEmbedding).Version; }
public IEnumerable<PackageOperationResult> UpdateProjectPackages(IEnumerable<IPackageRepository> sourceRepositories, IPackageRepository projectRepository, PackageDescriptor projectDescriptor, string packageName) { if (sourceRepositories == null) throw new ArgumentNullException("sourceRepositories"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); if (projectDescriptor == null) throw new ArgumentNullException("projectDescriptor"); if (sourceRepositories.Any(x => x == null)) throw new ArgumentException("Some repositories are null.", "sourceRepositories"); return CopyPackageCore(sourceRepositories, new[] { projectRepository }, projectDescriptor, x => x.EqualsNoCase(packageName)); }
IEnumerable<ICommandOutput> VerifyPackageCache(PackageDescriptor packageDescriptor) { return PackageResolver.VerifyPackageCache(Environment, packageDescriptor); }
PackageContent GenerateDescriptorFile(PackageDescriptor descriptor) { var descriptorStream = new MemoryStream(); new PackageDescriptorReaderWriter().Write(descriptor, descriptorStream); return new PackageContent { FileName = descriptor.Name + ".wrapdesc", RelativePath = ".", Stream = descriptorStream.ResetOnRead(), Size = descriptorStream.Length }; }
static PackageContent ConvertSpecification(ZipFile file, ZipEntry entry) { var nuspec = new XmlDocument(); var ns = new XmlNamespaceManager(nuspec.NameTable); ns.AddNamespace("nuspec", NuSpecSchema); nuspec.Load(file.GetInputStream(entry)); var descriptor = new PackageDescriptor { Name = nuspec.Element(XPaths.PackageName, ns), Version = nuspec.Element(XPaths.PackageVersion, ns).ToVersion(), Description = nuspec.Element(XPaths.PacakgeDescrition, ns), Dependencies = nuspec.Elements(XPaths.PackageDependencies, ns).Select(x=>CreateDependency(x)).ToList() }; var memoryStream = new MemoryStream(); new PackageDescriptorReaderWriter().Write(descriptor, memoryStream); memoryStream.Position = 0; return new PackageContent { FileName = Path.GetFileNameWithoutExtension(entry.Name) + ".wrapdesc", RelativePath = ".", Size = memoryStream.Length, Stream = () => { memoryStream.Position = 0; return memoryStream; } }; }
IEnumerable<ICommandOutput> UpdateProjectPackages() { if (!Project) yield break; var sourceRepos = Environment.RemoteRepositories .Concat(Environment.SystemRepository, Environment.CurrentDirectoryRepository); var updateDescriptor = new PackageDescriptor(Environment.Descriptor); if (!string.IsNullOrEmpty(Name)) updateDescriptor.Dependencies = updateDescriptor.Dependencies.Where(x => x.Name.Equals(Name, StringComparison.OrdinalIgnoreCase)).ToList(); var resolvedPackages = PackageResolver.TryResolveDependencies( updateDescriptor, sourceRepos); if (!resolvedPackages.IsSuccess) { foreach (var m in FailedUpdate(resolvedPackages, sourceRepos)) yield return m; yield break; } foreach (var m in resolvedPackages.GacConflicts(Environment.ExecutionEnvironment)) yield return m; var copyResult = PackageResolver.CopyPackagesToRepositories( resolvedPackages, Environment.ProjectRepository ); foreach (var m in copyResult) yield return m; foreach (var m in PackageResolver.VerifyPackageCache(Environment, updateDescriptor)) yield return m; }
IEnumerable<PackageOperationResult> AddProjectPackageCore(PackageRequest packageToAdd, IEnumerable<IPackageRepository> sourceRepositories, PackageDescriptor projectDescriptor, IPackageRepository projectRepository, PackageAddOptions options) { var finalDescriptor = (options & PackageAddOptions.UpdateDescriptor) == PackageAddOptions.UpdateDescriptor ? projectDescriptor : new PackageDescriptor(projectDescriptor); var existingEntries = finalDescriptor.Dependencies.Where(x => x.Name.EqualsNoCase(packageToAdd.Name)).ToList(); if (existingEntries.Count > 0) { finalDescriptor.Dependencies.RemoveRange(existingEntries); yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Updated); } else { yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.Added); } finalDescriptor.Dependencies.Add(ToDependency(packageToAdd, options)); foreach (var m in CopyPackageCore(sourceRepositories, new[] { projectRepository }, finalDescriptor, x => true)) yield return m; }
public PackageCleanCannotDo(PackageDescriptor projectDescriptor) { }
IEnumerable<PackageOperationResult> CleanProjectPackagesCore(PackageDescriptor projectDescriptor, ISupportCleaning projectRepository, Func<string, bool> packageName) { var resolvedPackages = _resolver.TryResolveDependencies(projectDescriptor, new[] { projectRepository }); if(resolvedPackages.SuccessfulPackages.Any() == false) { yield return new PackageCleanCannotDo(projectDescriptor); yield break; } var projectPackagesInUse = from successfulPackageStack in resolvedPackages.SuccessfulPackages from package in successfulPackageStack.Packages where packageName(package.Identifier.Name) select package; var otherPackages = from packagesByName in projectRepository.PackagesByName where !packageName(packagesByName.Key) from package in packagesByName select package; var packagesInUse = projectPackagesInUse.Concat(otherPackages).ToList(); foreach (var cleanedPackage in projectRepository.Clean(packagesInUse)) yield return cleanedPackage; foreach (var anchored in AnchorPackages(resolvedPackages, new[] { projectRepository })) yield return anchored; }
protected override void ParseContent(string content, PackageDescriptor descriptor) { descriptor.Version = new Version(content); }
IEnumerable<PackageOperationResult> CopyPackageCore(IEnumerable<IPackageRepository> sourceRepositories, IEnumerable<IPackageRepository> destinationRepositories, PackageDescriptor descriptor, Func<string, bool> nameSelector) { var updateDescriptor = new PackageDescriptor(descriptor); updateDescriptor.Dependencies.Clear(); updateDescriptor.Dependencies.AddRange(descriptor.Dependencies.Where(x => nameSelector(x.Name))); var resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, sourceRepositories); if (!resolvedPackages.IsSuccess) { foreach (var packageResolution in ReturnError(resolvedPackages)) yield return packageResolution; yield break; } var packagesForGacDetection = resolvedPackages.SuccessfulPackages.Select(x => x.Packages.First()).ToList(); foreach (var conflict in from errors in GacResolver.InGac(packagesForGacDetection) select new PackageGacConflictResult(errors.Key, errors)) yield return conflict; foreach (var m in CopyPackagesToRepositories(sourceRepositories, resolvedPackages, destinationRepositories)) yield return m; foreach (var repo in destinationRepositories) repo.RefreshPackages(); // need to refresh the resolve with the newly copied packages resolvedPackages = _resolver.TryResolveDependencies( updateDescriptor, destinationRepositories); foreach(var anchor in AnchorPackages(resolvedPackages, destinationRepositories)) yield return anchor; }
protected override IEnumerable<string> WriteContent(PackageDescriptor descriptor) { if (descriptor.Version != null) yield return descriptor.Version.ToString(); }
IEnumerable<PackageOperationResult> RemoveFromDescriptor(PackageRequest packageToRemove, PackageDescriptor packageDescriptor, IPackageRepository projectRepository, PackageRemoveOptions options) { var dependency = packageDescriptor.Dependencies.FirstOrDefault(x => x.Name.EqualsNoCase(packageToRemove.Name)); if (dependency == null) { yield return new PackageDescriptorUpdateResult(PackageDescriptorDependencyUpdate.DependencyNotFound); yield break; } packageDescriptor.Dependencies.Remove(dependency); if ((options & PackageRemoveOptions.Clean) == PackageRemoveOptions.Clean) foreach (var cleaned in CleanProjectPackages(packageDescriptor, projectRepository, packageToRemove.Name)) yield return cleaned; }