protected override IEnumerable <string> WriteContent(PackageDescriptor descriptor)
{
foreach (var dependency in descriptor.Dependencies)
{
yield return(dependency.ToString());
}
}
public IEnumerable <KeyValuePair <string, bool?> > ExecuteAllTests(ExecutionEnvironment environment, IPackage package)
{
var descriptor = new PackageDescriptor();
descriptor.Dependencies.Add(new PackageDependencyBuilder(Guid.NewGuid().ToString()).Name(package.Name).VersionVertex(new EqualVersionVertex(package.Version)));
var allAssemblyReferences = _manager.GetProjectAssemblyReferences(descriptor, package.Source, environment, false);
var runners = _factories.SelectMany(x => x.GetTestRunners(allAssemblyReferences)).NotNull();
var tests = new DefaultAssemblyExporter("tests").Items <Exports.IAssembly>(package, environment);
if (tests == null)
{
return(Enumerable.Empty <KeyValuePair <string, bool?> >());
}
var testAssemblies = from item in tests.SelectMany(x => x)
where item.File.Extension.Equals(".dll")
select item.File.Path.FullPath;
return(from runner in runners
from asm in testAssemblies
from result in runner.ExecuteTests(allAssemblyReferences.Select(x => x.File.Path.FullPath).ToList(), testAssemblies)
select result);
}
public void Parse(string line, PackageDescriptor descriptor)
{
var match = _regex.Match(line);
if (!match.Success)
return;
ParseContent(match.Groups["content"].Value, descriptor);
}
IEnumerable <ICommandOutput> Package()
{
var packageName = Name ?? _environment.Descriptor.Name;
var currentPackageDescriptor = GetCurrentPackageDescriptor();
var packageDescriptorForEmbedding = new PackageDescriptor(currentPackageDescriptor);
packageDescriptorForEmbedding.SemanticVersion = _generatedVersion;
packageDescriptorForEmbedding.Name = packageName;
#pragma warning disable 612,618
if (currentPackageDescriptor.IncludeLegacyVersion)
{
packageDescriptorForEmbedding.Version = _generatedVersion.ToVersion();
}
#pragma warning restore 612,618
var packageFilePath = _destinationPath.GetFile(
PackageNameUtility.PackageFileName(packageName, _generatedVersion.ToString()));
var packageContent = GeneratePackageContent(_buildResults)
.Concat(
GenerateVersionFile(_generatedVersion),
GenerateDescriptorFile(packageDescriptorForEmbedding)
).ToList();
foreach (var item in packageContent)
{
yield return(new Info(string.Format("Copying: {0}/{1}{2}", item.RelativePath, item.FileName, FormatBytes(item.Size))));
}
Packager.NewFromFiles(packageFilePath, packageContent);
yield return(new PackageBuilt(packageFilePath, _generatedVersion));
}
/// <summary>
/// Extracts the Package Descriptor values from the provided string (contents of the physical file).
/// </summary>
/// <param name="content">
/// The content of the physical Package Descriptor file.
/// </param>
/// <returns>
/// A populated PackageDescriptor object.
/// </returns>
public PackageDescriptor ExtractPackageDescriptor(string content)
{
MatchCollection packageCategoryMatches = this.ExecuteExpression(Expressions.PackageCategory, content);
MatchCollection packageDescriptionMatches = this.ExecuteExpression(Expressions.PackageDescription, content);
MatchCollection packageForumUrlMatches = this.ExecuteExpression(Expressions.PackageForumUrl, content);
MatchCollection packageHomepageUrlMatches = this.ExecuteExpression(Expressions.PackageHomepageUrl, content);
MatchCollection packageIdMatches = this.ExecuteExpression(Expressions.PackageId, content);
MatchCollection packageNameMatches = this.ExecuteExpression(Expressions.PackageName, content);
MatchCollection packageNotesMatches = this.ExecuteExpression(Expressions.PackageNotes, content);
MatchCollection packageVersionMatches = this.ExecuteExpression(Expressions.PackageVersion, content);
var packageDescriptor = new PackageDescriptor
{
Category = this.GetMatch(packageCategoryMatches, "category"),
Description = this.GetMatch(packageDescriptionMatches, "description"),
ForumUrl = this.GetMatch(packageForumUrlMatches, "forumurl"),
HomePageUrl = this.GetMatch(packageHomepageUrlMatches, "homepageurl"),
Id = this.GetMatch(packageIdMatches, "id"),
Name = this.GetMatch(packageNameMatches, "name"),
Notes = this.GetMatch(packageNotesMatches, "notes"),
Version = this.GetMatch(packageVersionMatches, "version"),
};
return(packageDescriptor);
}
protected void when_finding_packages(string dependency)
{
var dep = new PackageDescriptor();
new DependsParser().Parse(dependency, dep);
FoundPackage = Repository.FindAll(dep.Dependencies.First()).FirstOrDefault();
}
/// <summary>
/// GetDescriptorResourceTextFile
/// </summary>
/// <param name="bundleDllPath"></param>
/// <returns></returns>
public static PackageDescriptor LoadPackageDescriptorFromDll(string bundleDllPath)
{
try
{
var assemblyName = Path.GetFileNameWithoutExtension(bundleDllPath);
var routePath = string.Format("{0}.property.descriptor.xml", assemblyName);
var assembly = Assembly.LoadFile(bundleDllPath);
using (var stream = assembly.GetManifestResourceStream(routePath))
{
if (stream == null)
{
return(null);
}
using (var sr = new StreamReader(stream))
{
var data = sr.ReadToEnd();
var obj = new PackageDescriptor(data);
Console.WriteLine(" version: [{0}], friendly-name: [{1}]", obj.ModelVersion, obj.Name);
return(obj);
}
}
}
catch (Exception exception)
{
throw new SynapseException(string.Format("[LoadPackageDescriptorFromDll_Error] - {0}", bundleDllPath), exception);
}
}
IEnumerable <ICommandOutput> CopyOpenWrap(PackageDescriptor projectDescriptor, IDirectory projectDirectory)
{
var packageManager = ServiceLocator.GetService <IPackageManager>();
var repositoryOptions = FolderRepositoryOptions.AnchoringEnabled;
if (projectDescriptor.UseSymLinks)
{
repositoryOptions |= FolderRepositoryOptions.UseSymLinks;
}
if (projectDescriptor.StorePackages)
{
repositoryOptions |= FolderRepositoryOptions.PersistPackages;
}
var projectRepository = new FolderRepository(projectDirectory.GetDirectory("wraps"), repositoryOptions)
{
Name = "Project repository"
};
packageManager.AddProjectPackage(PackageRequest.Any("openwrap"),
new[] { Environment.SystemRepository },
projectDescriptor,
projectRepository,
PackageAddOptions.Default | PackageAddOptions.Anchor | PackageAddOptions.Content).ToList();
yield return(new Info("Project repository initialized."));
}
private bool ValidatePackageDescriptor(PackageDescriptor packageDescriptor)
{
string newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.PackageVersion, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.PackageVersion = newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.MinCompositeVersionSupported, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.MinCompositeVersionSupported = newVersion;
if (!VersionStringHelper.ValidateVersion(packageDescriptor.MaxCompositeVersionSupported, out newVersion))
{
Log.LogWarning("PackageServerFacade",
$"The package '{packageDescriptor.Name}' ({packageDescriptor.Id}) did not validate and is skipped");
return(false);
}
packageDescriptor.MaxCompositeVersionSupported = newVersion;
return(true);
}
public void PackAllBinaries(PackageDescriptor desc)
{
using (var p = new Package(desc.Path, this.f.ParentPath)) {
p.Add(q.files("^/dlls/release/*.(dll|pdb)$"), "/", "dlls/release");
p.Add(q.files("^/[^/]+.txt$"));
}
}
public Package GetPackage()
{
var packageId = PackageId.Create(GetStringId());
IPackageDescriptor iPackageDescriptor = new PackageDescriptor();
return(Package.Create(packageId, GetAbsolutePath(), iPackageDescriptor));
}
public void given_dependency(string dependencyLine)
{
var target = new PackageDescriptor();
((IPackageDescriptor)target).Dependencies.Add(DependsParser.ParseDependsLine(dependencyLine));
Declaration = target.Dependencies.First();
}
static PackageContent ConvertSpecification(ZipFile file, ZipEntry entry)
{
var inputStream = file.GetInputStream(entry);
var nuspec = new XmlDocument();
nuspec.Load(inputStream);
PackageDescriptor descriptor = NuConverter.ConvertSpecificationToDescriptor(nuspec);
var memoryStream = new MemoryStream();
new PackageDescriptorWriter().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;
}
});
}
void WriteDescriptor(IFile descriptor, PackageDescriptor packageDescriptor)
{
using (Stream descriptorStream = descriptor.OpenWrite())
{
new PackageDescriptorReaderWriter().Write(packageDescriptor, descriptorStream);
}
}
private Task <IPackage> GetPackage2 <T>(PackageDescriptor descriptor)
where T : class, IPackage
{
return(_packages2.GetOrAdd(descriptor, async descriptor2 =>
{
foreach (var packageFinder in _packageFinders)
{
var package = await packageFinder.Find <IPackage>(descriptor);
if (package != null)
{
if (package is Package2 package2)
{
var packageAsset = package2.Assets.OfType <T>().FirstOrDefault();
if (packageAsset != null)
{
return packageAsset;
}
}
}
if (package is T pkg)
{
return pkg;
}
}
return default;
}));
}
IEnumerable <ICommandOutput> Build()
{
var packageName = Name ?? _environment.Descriptor.Name;
var destinationPath = _destinationPath ?? _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;
var packageFilePath = destinationPath.GetFile(
PackageNameUtility.PackageFileName(packageName, generatedVersion.ToString()));
var packageContent = GeneratePackageContent(_buildResults).Concat(
GenerateVersionFile(generatedVersion),
GenerateDescriptorFile(packageDescriptorForEmbedding)
).ToList();
foreach (var item in packageContent)
{
yield return(new GenericMessage(string.Format("Copying: {0}/{1}{2}", item.RelativePath, item.FileName, FormatBytes(item.Size))));
}
Packager.NewFromFiles(packageFilePath, packageContent);
yield return(new GenericMessage(string.Format("Package built at '{0}'.", packageFilePath)));
}
public static PackageDescriptor ParseDependsInstruction(string line)
{
var descriptor = new PackageDescriptor();
new DependsParser().Parse(line, descriptor);
return(descriptor);
}
public void given_dependency(string dependencyLine)
{
var target = new PackageDescriptor();
new DependsParser().Parse(dependencyLine, target);
Declaration = target.Dependencies.First();
}
protected void when_finding_packages(string dependency)
{
var dep = new PackageDescriptor();
((IPackageDescriptor)dep).Dependencies.Add(DependsParser.ParseDependsLine(dependency));
FoundPackage = Repository.PackagesByName.FindAll(dep.Dependencies.First()).FirstOrDefault();
}
protected void when_finding_packages(string dependency)
{
var dep = new PackageDescriptor();
new DependsParser().Parse(dependency, dep);
FoundPackage = Repository.FindAll(dep.Dependencies.First()).FirstOrDefault();
}
protected void when_finding_packages(string dependency)
{
var dep = new PackageDescriptor();
((IPackageDescriptor)dep).Dependencies.Add(DependsParser.ParseDependsLine(dependency));
FoundPackage = Repository.PackagesByName.FindAll(dep.Dependencies.First()).FirstOrDefault();
}
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageResolver resolver,
bool includeContentOnly,
ExecutionEnvironment exec,
PackageDescriptor descriptor,
params IPackageRepository[] repositories)
{
return GetAssemblyReferences(resolver.TryResolveDependencies(descriptor, repositories), exec, includeContentOnly);
}
private Package CreatePackage(string version)
{
AbsolutePath path = AbsolutePath.Create(m_context.PathTable, TemporaryDirectory + $"\\random.package.name\\{version}\\nu.spec");
var pathStr = path.ToString(m_context.PathTable);
var id = PackageId.Create(StringId.Create(m_context.StringTable, pathStr));
var desc = new PackageDescriptor();
return(Package.Create(id, path, desc));
}
public DefaultPackageInfo(string packageFileName, Version versionFileContent, PackageDescriptor descriptor)
{
_descriptor = descriptor;
_packageVersion = versionFileContent
?? descriptor.Version
?? PackageNameUtility.GetVersion(packageFileName);
_packageName = PackageNameUtility.GetName(packageFileName);
Identifier = new PackageIdentifier(Name, Version);
}
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 IPackageCleanResult CleanProjectPackages(PackageDescriptor packages, IPackageRepository projectRepository, string name, PackageCleanOptions options = PackageCleanOptions.Default)
{
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 new PackageCleanResultIterator(CleanProjectPackagesCore(packages, repoForClean, x => name.EqualsNoCase(x)));
}
public IEnumerable <string> Write(PackageDescriptor descriptor)
{
var content = WriteContent(descriptor).ToList();
if (content.Count == 0)
{
return(content);
}
return(content.Select(x => Header + ": " + x));
}
public static IPackageDescriptor Lock(this IPackageDescriptor descriptor, IPackageRepository repository, string scope = null)
{
scope = scope ?? string.Empty;
var lockedRepo = repository.Feature<ISupportLocking>();
if (lockedRepo == null)
return descriptor;
var lockedDescriptor = new PackageDescriptor(descriptor);
var lockedPackages = lockedRepo.LockedPackages[scope];
return Lock(lockedDescriptor, lockedPackages);
}
protected static Package ReadPackage(BuildXLReader reader, PathTable pathTable)
{
var id = ReadPackageId(reader);
var path = reader.ReadAbsolutePath();
var descriptor = new PackageDescriptor()
{
Name = id.Name.ToString(pathTable.StringTable),
};
return(Package.Create(id, path, descriptor));
}
public void Write(PackageDescriptor descriptor, Stream descriptorStream)
{
var streamWriter = new StreamWriter(descriptorStream, Encoding.UTF8);
var lines = from parser in _lineParsers
from parserLine in parser.Write(descriptor)
select parserLine;
var content = lines.Join("\r\n");
streamWriter.Write(content);
streamWriter.Flush();
}
public void PackMin(PackageDescriptor desc)
{
// 'min' - /dlls/release/ImageResizer.* - /
// /*.txt
using (var p = new Package(desc.Path, this.f.ParentPath)) {
p.Add(q.files("^/dlls/release/ImageResizer.(Mvc.)?(dll|pdb|xml)$"), "/", "dlls/release");
p.Add(q.files("^/readme.txt$"));
p.Add(q.files("^/Core/license.txt$"), "");
p.Add(q.files("^/Web.config$"));
}
}
public PackageInfo(PackageDescriptor descriptor, string packagePath,
IEnumerable <string> filePaths)
{
Descriptor = descriptor;
PackagePath = packagePath;
FilePaths = filePaths;
if (PackageVersion.TryParseVersion(descriptor.PackageVersion, out PackageVersion version))
{
Version = version;
}
}
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 Read(Stream content)
{
var stringReader = new StreamReader(content, true);
var lines = stringReader.ReadToEnd().GetUnfoldedLines();
var descriptor = new PackageDescriptor();
foreach (var line in lines)
foreach (var parser in _lineParsers)
parser.Parse(line, descriptor);
return descriptor;
}
static 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
};
}
public dependency_resolver_context()
{
DependencyDescriptor = new PackageDescriptor
{
Name = "test",
SemanticVersion = "1.0".ToSemVer()
};
ProjectRepository = new InMemoryRepository("Local repository");
SystemRepository = new InMemoryRepository("System repository");
RemoteRepository = new InMemoryRepository("Remote repository");
CurrentDirectoryRepository = new InMemoryRepository("Current repository");
}
public dependency_resolver_context()
{
DependencyDescriptor = new PackageDescriptor
{
Name = "test",
SemanticVersion = "1.0".ToSemVer()
};
ProjectRepository = new InMemoryRepository("Local repository");
SystemRepository = new InMemoryRepository("System repository");
RemoteRepository = new InMemoryRepository("Remote repository");
CurrentDirectoryRepository = new InMemoryRepository("Current repository");
}
private async Task <IPackage> GetPackage2 <T>(PackageDescriptor descriptor)
where T : class, IPackage
{
foreach (var packgeFinder in _packageFinders)
{
if (await packgeFinder.Find <T>(descriptor) is T pkg)
{
return(pkg);
}
}
return(default);
IEnumerable <PackageOperationResult> CopyPackageCore(IEnumerable <IPackageRepository> sourceRepositories,
IEnumerable <IPackageRepository> destinationRepositories,
IPackageDescriptor 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 = GetSelectedPackages(resolvedPackages);
foreach (var conflict in from errors in _exporter.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);
}
}
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").MustExist();
Descriptor = new PackageDescriptor();
ConfigurationDirectory = configDirectory;
ScopedDescriptors = new Dictionary<string, FileBased<IPackageDescriptor>>(StringComparer.OrdinalIgnoreCase);
ScopedDescriptors[string.Empty] = FileBased.New(DescriptorFile, Descriptor);
}
public IPackageAddResult 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 new PackageAddResultIterator(AddProjectPackageCore(packageToAdd, sourceRepositories, projectDescriptor, projectRepository, options));
}
static PackageContent GenerateDescriptorFile(PackageDescriptor descriptor)
{
var descriptorStream = new MemoryStream();
new PackageDescriptorWriter().Write(descriptor.GetPersistableEntries(), descriptorStream);
return(new PackageContent
{
FileName = descriptor.Name + ".wrapdesc",
RelativePath = ".",
Stream = descriptorStream.ResetOnRead(),
Size = descriptorStream.Length
});
}
/// <nodoc/>
protected Package CreateDummyPackageFromPath(AbsolutePath path)
{
Contract.Requires(path.IsValid);
var pathStr = path.ToString(Context.PathTable);
var id = PackageId.Create(StringId.Create(Context.StringTable, pathStr));
var desc = new PackageDescriptor
{
Name = path.ToString(Context.PathTable),
};
return(Package.Create(id, path, desc));
}
public InMemoryEnvironment(IDirectory currentDirectory, IDirectory configDirectory = null)
{
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").MustExist();
Descriptor = new PackageDescriptor();
ConfigurationDirectory = configDirectory;
ScopedDescriptors = new Dictionary <string, FileBased <IPackageDescriptor> >(StringComparer.OrdinalIgnoreCase);
ScopedDescriptors[string.Empty] = FileBased.New(DescriptorFile, Descriptor);
ExecutionEnvironment = new ExecutionEnvironment("AnyCPU", "net35");
}
/// <summary>
/// Retrieves a suitable package to put a certain type into.
/// </summary>
/// <param name="type">type for which a suitable package is desired</param>
/// <returns>suitable package</returns>
public PackageDescriptor GetPackage(Type type)
{
string pkgName = type.Namespace;
if (pkgName == null)
pkgName = "DefaultPackage";
PackageDescriptor pd;
if (!_pkgMap.TryGetValue(pkgName, out pd))
{
pd = new PackageDescriptor(pkgName);
}
_pkgMap[pkgName] = pd;
_design.AddChild(pd, pd.Name);
return pd;
}
public IEnumerable<KeyValuePair<string, bool?>> ExecuteAllTests(ExecutionEnvironment environment, IPackage package)
{
var descriptor = new PackageDescriptor();
descriptor.Dependencies.Add(new PackageDependencyBuilder(Guid.NewGuid().ToString()).Name(package.Name).VersionVertex(new EqualVersionVertex(package.Version)));
var allAssemblyReferences = _manager.GetProjectAssemblyReferences(descriptor, package.Source, environment, false);
var runners = _factories.SelectMany(x => x.GetTestRunners(allAssemblyReferences)).NotNull();
var tests = new DefaultAssemblyExporter("tests").Items<Exports.IAssembly>(package, environment);
if (tests == null) return Enumerable.Empty<KeyValuePair<string, bool?>>();
var testAssemblies = from item in tests.SelectMany(x=>x)
where item.File.Extension.Equals(".dll")
select item.File.Path.FullPath;
return from runner in runners
from asm in testAssemblies
from result in runner.ExecuteTests(allAssemblyReferences.Select(x => x.File.Path.FullPath).ToList(), testAssemblies)
select result;
}
public IEnumerable<KeyValuePair<string, bool?>> ExecuteAllTests(ExecutionEnvironment environment, IPackage package)
{
var descriptor = new PackageDescriptor();
descriptor.Dependencies.Add(new PackageDependencyBuilder(Guid.NewGuid().ToString()).Name(package.Name).VersionVertex(new EqualVersionVertex(package.Version)));
var allAssemblyReferences = _resolver.GetAssemblyReferences(false, environment, descriptor, package.Source, _environment.ProjectRepository, _environment.SystemRepository);
var runners = _factories.SelectMany(x=>x.GetTestRunners(allAssemblyReferences)).NotNull();
var export = package.GetExport("tests", environment);
if (export == null) return Enumerable.Empty<KeyValuePair<string, bool?>>();
var testAssemblies = from item in export.Items
where item.FullPath.EndsWithNoCase(".dll")
select item.FullPath;
return from runner in runners
from asm in testAssemblies
from result in runner.ExecuteTests(allAssemblyReferences.Select(x => x.FullPath).ToList(), testAssemblies)
select result;
}
public UncompressedPackage(IPackageRepository source,
IFile originalPackageFile,
IDirectory wrapCacheDirectory,
IEnumerable<IExportBuilder> exporters)
{
_originalPackageFile = originalPackageFile;
_exporters = exporters;
BaseDirectory = wrapCacheDirectory;
// get the descriptor file inside the package
var descriptorName = originalPackageFile.NameWithoutExtension;
Source = source;
var wrapDescriptor = wrapCacheDirectory.Files("*.wrapdesc").SingleOrDefault();
if (wrapDescriptor == null)
throw new InvalidOperationException("Could not find descriptor in wrap cache directory, or there are multiple .wrapdesc files in the package.");
var versionFile = wrapCacheDirectory.GetFile("version");
_descriptor = new PackageDescriptorReaderWriter().Read(wrapDescriptor);
PackageInfo = new DefaultPackageInfo(originalPackageFile.Name,
versionFile.Exists ? versionFile.Read(x => x.ReadString().ToVersion()) : null,
_descriptor);
Identifier = new PackageIdentifier(Name, Version);
}
protected override IEnumerable<ICommandOutput> ExecuteCore()
{
_targetDescriptor = HostEnvironment.GetOrCreateScopedDescriptor(Scope ?? string.Empty);
yield return VerifyDescriptor(_targetDescriptor);
yield return VerifyProjectRepository();
yield return SetupEnvironmentForAdd();
var sourceRepositories = GetSourceRepositories().ToList();
var descriptor = new PackageDescriptor(_targetDescriptor.Value);
if (Project && System)
{
var sysToAdd = new List<PackageIdentifier>();
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
ParseSuccess(m, sysToAdd.Add);
}
foreach (var identifier in sysToAdd)
foreach (var m in PackageManager.AddSystemPackage(PackageRequest.Exact(identifier.Name, identifier.Version), sourceRepositories, HostEnvironment.SystemRepository))
yield return ToOutput(m);
}
}
else if (Project)
{
using (SaveDescriptorOnSuccess(_targetDescriptor))
{
foreach (var m in AddProjectPackage(descriptor, sourceRepositories))
{
yield return ToOutput(m);
}
}
}
else if (System)
{
foreach (var m in PackageManager.AddSystemPackage(PackageRequest, sourceRepositories, HostEnvironment.SystemRepository, AddOptions))
{
yield return ToOutput(m);
}
}
if (_packageNotFound)
{
var hit = false;
foreach (var m in PackageManager.ListPackages(sourceRepositories, Name))
{
if (!hit)
{
yield return new Info("Did you mean one of the following packages?", Name);
hit = true;
}
yield return ToOutput(m);
}
}
}
void WriteDescriptor(IFile descriptor, PackageDescriptor packageDescriptor)
{
using (Stream descriptorStream = descriptor.OpenWrite())
{
new PackageDescriptorReaderWriter().Write(packageDescriptor, descriptorStream);
}
}
IEnumerable<ICommandOutput> Package()
{
var packageName = Name ?? _environment.Descriptor.Name;
var currentPackageDescriptor = GetCurrentPackageDescriptor();
var packageDescriptorForEmbedding = new PackageDescriptor(currentPackageDescriptor);
packageDescriptorForEmbedding.SemanticVersion = _generatedVersion;
packageDescriptorForEmbedding.Name = packageName;
#pragma warning disable 612,618
if (currentPackageDescriptor.IncludeLegacyVersion)
packageDescriptorForEmbedding.Version = _generatedVersion.ToVersion();
#pragma warning restore 612,618
var packageFilePath = _destinationPath.GetFile(
PackageNameUtility.PackageFileName(packageName, _generatedVersion.ToString()));
var packageContent = GeneratePackageContent(_buildResults)
.Concat(
GenerateVersionFile(_generatedVersion),
GenerateDescriptorFile(packageDescriptorForEmbedding)
).ToList();
foreach (var item in packageContent)
yield return new Info(string.Format("Copying: {0}/{1}{2}", item.RelativePath, item.FileName, FormatBytes(item.Size)));
Packager.NewFromFiles(packageFilePath, packageContent);
yield return new PackageBuilt(packageFilePath, _generatedVersion);
}
internal void Nest(PackageDescriptor owner)
{
owner.AddChild(this);
Owner = owner;
}
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;
}
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;
var packageFilePath = destinationPath.GetFile(
PackageNameUtility.PackageFileName(packageName, generatedVersion.ToString()));
var packageContent = GeneratePackageContent(_buildResults).Concat(
GenerateVersionFile(generatedVersion),
GenerateDescriptorFile(packageDescriptorForEmbedding)
).ToList();
foreach (var item in packageContent)
yield return new GenericMessage(string.Format("Copying: {0}/{1}{2}", item.RelativePath, item.FileName, FormatBytes(item.Size)));
Packager.NewFromFiles(packageFilePath, packageContent);
yield return new GenericMessage(string.Format("Package built at '{0}'.", packageFilePath));
}
public InMemoryPackage()
{
Created = DateTime.Now;
Dependencies = new List<PackageDependency>();
Descriptor = new PackageDescriptor();
}
protected void given_descriptor(params string[] lines)
{
Descriptor = new PackageDescriptorReaderWriter().Read(new MemoryStream(Encoding.UTF8.GetBytes(string.Join("\r\n", lines))));
}
public dependency_manager_context()
{
DependencyDescriptor = new PackageDescriptor
{
Name = "test",
Version = new Version("1.0")
};
ProjectRepository = new InMemoryRepository("Local repository");
SystemRepository = new InMemoryRepository("System repository");
RemoteRepository = new InMemoryRepository("Remote repository");
}
public IEnumerable<string> Write(PackageDescriptor descriptor)
{
var content = WriteContent(descriptor).ToList();
if (content.Count == 0) return content;
return content.Select(x => Header + ": " + x);
}
protected abstract void ParseContent(string content, PackageDescriptor descriptor);
protected abstract IEnumerable<string> WriteContent(PackageDescriptor descriptor);