public static ILookup<IPackageInfo, AssemblyName> InGac(IEnumerable<IPackageInfo> packages, ExecutionEnvironment environment = null)
{
var domain = TempDomain();
try
{
var loader = ((Loader)domain.CreateInstanceFromAndUnwrap(
typeof(Loader).Assembly.Location,
typeof(Loader).FullName));
return (from package in packages.NotNull().Select(x => x.Load()).NotNull()
let export = package.GetExport("bin", environment)
where export != null
from assembly in export.Items.OfType<IAssemblyReferenceExportItem>()
let inGac = loader.InGAC(assembly.AssemblyName)
where inGac
select new { package, assembly.AssemblyName })
.ToLookup(x => (IPackageInfo)x.package, x => x.AssemblyName);
}
catch
{
return (new AssemblyName[0]).ToLookup(x => (IPackageInfo)null);
}
finally
{
AppDomain.Unload(domain);
}
}
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);
}
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferencesFromPackages(IEnumerable<IPackageInfo> packages, ExecutionEnvironment exec)
{
return from package in packages.NotNull()
.GroupBy(x => x.Name)
.Select(x => x.OrderByDescending(y => y.Version).Select(y=>y.Load()).NotNull().First())
from assembly in package.Load().GetExport("bin", exec).Items.Cast<IAssemblyReferenceExportItem>()
where MatchesReferenceSection(package, assembly)
select assembly;
}
public IEnumerable<ITestRunner> GetTestRunners(ExecutionEnvironment environment, IEnumerable<IAssemblyReferenceExportItem> allReferencedAssemblies)
{
var referencedAssemblies = allReferencedAssemblies;
return from assembly in referencedAssemblies
let tdnet = _fileSystem.GetFile(assembly.FullPath + ".tdnet")
where tdnet.Exists
let runner = LoadRunner(tdnet)
where runner != null
select runner;
}
public static void TryRegisterResharper(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository)
{
lock (_lock)
{
if (_called)
return;
TryCreateIntegrationService();
TryRegisterProjectToResharper(() => environment, descriptorPath, packageRepository);
}
}
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");
}
public static IEnumerable<Exports.IAssembly> GetProjectAssemblyReferences(this IPackageManager manager,
IPackageDescriptor descriptor,
IPackageRepository repository,
ExecutionEnvironment environment,
bool includeContentOnly)
{
var sourcePackages = manager.ListProjectPackages(descriptor, repository);
var assemblies = manager.GetProjectExports<Exports.IAssembly>(descriptor, repository, environment)
.SelectMany(x => x);
if (includeContentOnly) return assemblies;
var packagesToInclude = sourcePackages.NotInContentBranch(descriptor.Dependencies).Select(x=>x.Identifier).ToList();
return assemblies.Where(x => packagesToInclude.Contains(x.Package.Identifier)).ToList();
}
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 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 IExport GetExport(string exportName, ExecutionEnvironment environment)
{
return null;
}
public IExport GetExport(string exportName, ExecutionEnvironment environment)
{
var exporter =
_exporters.FirstOrDefault(x => x.ExportName.EqualsNoCase(exportName));
var directories = BaseDirectory.Directories();
if (exporter != null)
directories = directories.Where(x => exporter.CanProcessExport(x.Name));
else
directories = directories.Where(x => x.Name.EqualsNoCase(exportName));
var exports = from directory in directories
select (IExport)new FolderExport(directory.Name)
{
Items = directory.Files()
.Select(x => (IExportItem)new FileExportItem(x))
.ToList()
};
return exporter != null ? exporter.ProcessExports(exports, environment) : exports.FirstOrDefault();
}
public void Initialize()
{
FileSystem = LocalFileSystem.Instance;
var descriptors = new PackageDescriptorReader().ReadAll(CurrentDirectory);
if (descriptors.ContainsKey(string.Empty))
{
DescriptorFile = descriptors[string.Empty].File;
Descriptor = descriptors[string.Empty].Value;
}
ScopedDescriptors = descriptors;
TryInitializeProjectRepository();
CurrentDirectoryRepository = new CurrentDirectoryRepository();
SystemRepository = new FolderRepository(FileSystem.GetDirectory(DefaultInstallationPaths.SystemRepositoryDirectory))
{
Name = "System repository"
};
ConfigurationDirectory = FileSystem.GetDirectory(DefaultInstallationPaths.ConfigurationDirectory);
RemoteRepositories = new RemoteRepositoryBuilder(FileSystem, Services.Services.GetService<IConfigurationManager>()).GetConfiguredPackageRepositories().ToList();
ExecutionEnvironment = new ExecutionEnvironment
{
Platform = IntPtr.Size == 4 ? "x86" : "x64",
Profile = Environment.Version.Major >= 4 ? "net40" : "net35"
};
}
public static IEnumerable<Exports.IAssembly> Assemblies(this IPackageExporter exporter, IPackage package, ExecutionEnvironment environment)
{
return exporter.Exports<Exports.IAssembly>(package, environment).SelectMany(x => x);
}
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(DependencyResolutionResult resolveResult, ExecutionEnvironment exec, bool includeContentOnly)
{
var packages = resolveResult.SuccessfulPackages.Where(resolvedPackage => includeContentOnly || !resolvedPackage.IsInContentBranch).SelectMany(x => x.Packages);
return GetAssemblyReferencesFromPackages(packages, exec);
}
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(ExecutionEnvironment exec, params IPackageRepository[] repositories)
{
return GetAssemblyReferencesFromPackages(repositories.SelectMany(x => x.PackagesByName.SelectMany(y => y)), exec);
}
public void Initialize()
{
FileSystem = LocalFileSystem.Instance;
SystemRepositoryDirectory = SystemRepositoryDirectory ?? FileSystem.GetDirectory(DefaultInstallationPaths.SystemRepositoryDirectory);
TryInitializeProject();
CurrentDirectoryRepository = new CurrentDirectoryRepository();
SystemRepository = new FolderRepository(SystemRepositoryDirectory)
{
Name = "System repository"
};
ConfigurationDirectory = FileSystem.GetDirectory(DefaultInstallationPaths.ConfigurationDirectory);
ExecutionEnvironment = new ExecutionEnvironment
{
Platform = IntPtr.Size == 4 ? "x86" : "x64",
Profile = Environment.Version.Major >= 4 ? "net40" : "net35"
};
}
public void Initialize()
{
FileSystem = LocalFileSystem.Instance;
DescriptorFile = CurrentDirectory
.AncestorsAndSelf()
.SelectMany(x => x.Files("*.wrapdesc"))
.FirstOrDefault();
if (DescriptorFile != null)
Descriptor = new PackageDescriptorReaderWriter().Read(DescriptorFile);
TryInitializeProjectRepository();
CurrentDirectoryRepository = new CurrentDirectoryRepository();
SystemRepository = new FolderRepository(FileSystem.GetDirectory(DefaultInstallationPaths.SystemRepositoryDirectory))
{
Name = "System repository"
};
ConfigurationDirectory = FileSystem.GetDirectory(DefaultInstallationPaths.ConfigurationDirectory);
RemoteRepositories = new RemoteRepositoryBuilder(FileSystem, Services.Services.GetService<IConfigurationManager>()).GetConfiguredPackageRepositories().ToList();
ExecutionEnvironment = new ExecutionEnvironment
{
Platform = IntPtr.Size == 4 ? "x86" : "x64",
Profile = Environment.Version.Major >= 4 ? "net40" : "net35"
};
}
