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)));
}
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));
}
public void PushPackage(string packageFileName, Stream packageStream)
{
packageFileName = PackageNameUtility.NormalizeFileName(packageFileName);
var packageFile = _directory.GetFile(packageFileName);
using (var destinationStream = packageFile.OpenWrite())
StreamExtensions.CopyTo(packageStream, destinationStream);
var zipPackage = new CachedZipPackage(null, packageFile, null);
IndexDocument.Document.Root.Add(
new XElement("wrap",
new XAttribute("name", zipPackage.Name),
new XAttribute("version", zipPackage.Version),
new XElement("link",
new XAttribute("rel", "package"),
new XAttribute("href", packageFile.Name)),
zipPackage.Dependencies.Select(x => new XElement("depends", x.ToString()))
));
SaveIndex(IndexDocument);
return;
}
public IPackageInfo Publish(IPackageRepository repository, string packageFileName, Stream packageStream)
{
packageFileName = PackageNameUtility.NormalizeFileName(packageFileName);
var newPackage = _packageLoader.Publish(repository, packageFileName, packageStream);
return(newPackage.Package);
}
ICommandOutput SetupEnvironmentForAdd()
{
var directory = HostEnvironment.CurrentDirectory;
var fromDirectory = string.IsNullOrEmpty(From) ? null : FileSystem.GetDirectory(From);
if (fromDirectory != null && fromDirectory.Exists)
{
if (SysPath.GetExtension(Name).EqualsNoCase(".wrap") &&
SysPath.IsPathRooted(Name) &&
FileSystem.GetDirectory(SysPath.GetDirectoryName(Name)) != fromDirectory)
{
return(new Error("You provided both -From and -Name, but -Name is a path. Try removing the -From parameter."));
}
directory = fromDirectory;
_userSpecifiedRepository = new FolderRepository(directory, FolderRepositoryOptions.Default);
}
if (SysPath.GetExtension(Name).EqualsNoCase(".wrap") && directory.GetFile(SysPath.GetFileName(Name)).Exists)
{
var originalName = Name;
Name = PackageNameUtility.GetName(SysPath.GetFileNameWithoutExtension(Name));
Version = PackageNameUtility.GetVersion(SysPath.GetFileNameWithoutExtension(originalName)).ToString();
return(new Warning("The requested package contained '.wrap' in the name. Assuming you pointed to a file name and meant a package named '{0}' with version qualifier '{1}'.",
Name,
Version));
}
return(null);
}
IPackageInfo Publish(string packageFileName, Stream packageStream)
{
var fileWithoutExtension = packageFileName.Trim().ToLowerInvariant().EndsWith(".wrap")
? Path.GetFileNameWithoutExtension(packageFileName)
: packageFileName;
if (Packages.Any(x => x.FullName.EqualsNoCase(fileWithoutExtension)))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = FileExtensions.OpenWrite(inMemoryFile))
packageStream.CopyTo(stream);
var tempFolder = new CachedZipPackage(null, inMemoryFile, null);
var package = new InMemoryPackage
{
Name = PackageNameUtility.GetName(fileWithoutExtension),
Version = PackageNameUtility.GetVersion(fileWithoutExtension),
Source = this,
Dependencies = tempFolder.Dependencies.ToList(),
Anchored = tempFolder.Anchored
};
Packages.Add(package);
return(package);
}
public void PushPackage(string packageFileName, Stream packageStream)
{
packageFileName = PackageNameUtility.NormalizeFileName(packageFileName);
var packageFile = _directory.GetFile(packageFileName);
using (var destinationStream = packageFile.OpenWrite())
packageStream.CopyTo(destinationStream);
#pragma warning disable 612,618
var zipPackage = new ZipFilePackage(packageFile);
IndexDocument.Document.Root.Add(
new XElement("wrap",
new XAttribute("name", zipPackage.Name),
new XAttribute("version", zipPackage.Version),
new XAttribute("semantic-version", zipPackage.SemanticVersion),
new XElement("link",
new XAttribute("rel", "package"),
new XAttribute("href", packageFile.Name)),
zipPackage.Dependencies.Select(x => new XElement("depends", x.ToString()))
));
#pragma warning restore 612,618
SaveIndex(IndexDocument);
return;
}
// TODO: Read-retry should be part of an extension method that can be reused for reading the index in indexed folder repositories.
public IPackageDescriptor Read(IFile filePath)
{
if (!filePath.Exists)
{
return(null);
}
IOException ioException = null;
int tries = 0;
while (tries < FILE_READ_RETRIES)
{
try
{
using (var fileStream = filePath.OpenRead())
{
var descriptor = new PackageDescriptorReader().Read(fileStream);
if (descriptor.Name == null)
{
descriptor.Name = PackageNameUtility.GetName(filePath.NameWithoutExtension);
}
return(descriptor);
}
}
catch (IOException ex)
{
ioException = ex;
tries++;
Thread.Sleep(FILE_READ_RETRIES_WAIT);
continue;
}
}
throw ioException;
}
protected void given_project_package(string name, string version, params string[] descriptorLines)
{
Packager.NewWithDescriptor(
project_directory.GetDirectory("wraps").GetFile(PackageNameUtility.PackageFileName(name, version)),
name,
version,
descriptorLines);
}
IPackageInfo Publish(string packageFileName, Stream packageStream)
{
if (!Navigator.CanPublish)
{
throw new InvalidOperationException(string.Format("The repository {0} is read-only.", Navigator));
}
Navigator.PushPackage(packageFileName, packageStream);
_packagesByName = null;
EnsureDataLoaded();
return(PackagesByName[PackageNameUtility.GetName(packageFileName)].FirstOrDefault(x => x.Version == PackageNameUtility.GetVersion(packageFileName)));
}
public void RefreshPackages()
{
Packages = (from wrapFile in BasePath.Files("*.wrap")
let packageFullName = wrapFile.NameWithoutExtension
let packageVersion = PackageNameUtility.GetVersion(packageFullName)
where packageVersion != null
let packageCacheDirectory = _rootCacheDirectory.GetDirectory(packageFullName)
select new PackageLocation(
packageCacheDirectory,
CreatePackageInstance(packageCacheDirectory, wrapFile)
)).ToList();
}
void Add(InMemoryRepository repository, string name, string[] dependencies)
{
var package = new InMemoryPackage
{
Name = PackageNameUtility.GetName(name),
SemanticVersion = PackageNameUtility.GetVersion(name),
Source = repository,
Dependencies = dependencies.Select(DependsParser.ParseDependsLine).ToList()
};
repository.Packages.Add(package);
}
protected void given_currentdirectory_package(string packageName, Version version, params string[] dependencies)
{
if (Environment.CurrentDirectoryRepository is InMemoryRepository)
{
AddPackage(Environment.CurrentDirectoryRepository, packageName, version.ToString(), dependencies);
}
else
{
var localFile = Environment.CurrentDirectory.GetFile(PackageNameUtility.PackageFileName(packageName, version.ToString())).MustExist();
Packager.NewWithDescriptor(localFile, packageName, version.ToString(), dependencies);
}
}
void Add(InMemoryRepository repository, string name, string[] dependencies)
{
var packageNamespace = name.Contains("/") ? name.Substring(0, name.IndexOf("/")) : "global";
name = name.Contains("/") ? name.Substring(name.IndexOf("/") + 1) : name;
var package = new InMemoryPackage
{
Name = PackageNameUtility.GetName(name),
Version = PackageNameUtility.GetVersion(name),
Namespace = packageNamespace,
Source = repository,
Dependencies = dependencies.SelectMany(x => DependsParser.ParseDependsInstruction(x).Dependencies)
.ToList()
};
repository.Packages.Add(package);
}
public IPackageInfo Publish(string packageFileName, Stream packageStream)
{
packageFileName = PackageNameUtility.NormalizeFileName(packageFileName);
var wrapFile = BasePath.GetFile(packageFileName);
if (wrapFile.Exists)
{
return(null);
}
using (var file = wrapFile.OpenWrite())
StreamExtensions.CopyTo(packageStream, file);
var newPackageCacheDir = _rootCacheDirectory.GetDirectory(wrapFile.NameWithoutExtension);
var newPackage = new CachedZipPackage(this, wrapFile, newPackageCacheDir);
Packages.Add(new PackageLocation(newPackageCacheDir, newPackage));
return(newPackage);
}
void Publish(IPackageRepository source, string packageFileName, Stream packageStream)
{
var name = PackageNameUtility.GetName(packageFileName);
var version = PackageNameUtility.GetVersion(packageFileName);
if (Packages.Any(x => x.Name.EqualsNoCase(name) && x.SemanticVersion == version))
{
throw new InvalidOperationException("Package already exists in repository.");
}
var inMemoryFile = new InMemoryFile("c:\\" + Guid.NewGuid());
using (var stream = inMemoryFile.OpenWrite())
IO.StreamExtensions.CopyTo(packageStream, stream);
var tempFolder = new ZipFilePackage(inMemoryFile);
var package = new InMemoryPackage(tempFolder)
{
Source = this
};
Packages.Add(package);
}
protected void given_package_file(string name, string version)
{
Packager.NewWithDescriptor(repository_directory.GetFile(PackageNameUtility.PackageFileName(name, version)), name, version);
}
public void Publish(IPackageRepository repository, string packageFileName, Stream packageStream)
{
packageFileName = PackageNameUtility.NormalizeFileName(packageFileName);
_packageLoader.Publish(repository, packageFileName, packageStream);
}
public void version_is_parsed()
{
PackageNameUtility.GetVersion("openrasta-2.0.0").ShouldBe("2.0.0");
PackageNameUtility.GetName("openrasta-2.0.0").ShouldBe("openrasta");
}
public void invalid_version_is_ignored()
{
PackageNameUtility.GetVersion("openrasta-xxx").ShouldBeNull();
PackageNameUtility.GetName("openrasta-xxx").ShouldBe("openrasta-xxx");
}
protected void given_file_package(string directory, string name, string version, params string[] lines)
{
Packager.NewWithDescriptor(FileSystem.GetDirectory(directory).GetFile(PackageNameUtility.PackageFileName(name, version)), name, version, lines);
}
