public static ILookup<IPackageInfo, AssemblyName> InGac(IEnumerable<IPackageInfo> packages, ExecutionEnvironment environment)
{
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);
}
}
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(DependencyResolutionResult resolveResult, ExecutionEnvironment exec, bool includeContentOnly)
{
var packages = resolveResult.Dependencies
.Where(x=> includeContentOnly || !IsInContentBranch(x))
.Select(x => x.Package);
return GetAssemblyReferencesFromPackages(packages, exec);
}
public IExport ProcessExports(IEnumerable<IExport> exports, ExecutionEnvironment environment)
{
var parsedExports = (from export in exports
let exportSegments =
export.Name.Split(new[] {"-"}, StringSplitOptions.RemoveEmptyEntries)
let platform = exportSegments.Length == 3 ? exportSegments[1] : ANYCPU
let target = exportSegments.Length == 3 ? exportSegments[2] : exportSegments[1]
where PlatformMatches(platform, environment.Platform)
&& ProfileMatches(target, environment.Profile)
from file in export.Items
select new EnvironmentDependentFile()
{
Platform = platform,
Profile = target,
Item = file
})
.ToLookup(x => Path.GetFileName(x.Item.FullPath));
// now for each assembly, find the most compatible
var compatibleAssembly = parsedExports.Select(x =>
{
var ordered = x.ToList();
ordered.Sort();
var item =
ordered.Select(i => i.Item).FirstOrDefault();
return item;
});
return new AssemblyReferenceExport(compatibleAssembly);
}
static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferencesFromPackages(IEnumerable<IPackageInfo> packages, ExecutionEnvironment exec)
{
return packages
.GroupBy(x=>x.Name)
.Select(x=>x.OrderByDescending(y=>y.Version).First())
.NotNull()
.SelectMany(x => x.Load().GetExport("bin", exec).Items)
.Cast<IAssemblyReferenceExportItem>();
}
public ResharperProjectUpdater(IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, ExecutionEnvironment environment)
{
_descriptorPath = descriptorPath;
_packageRepository = packageRepository;
_projectFilePath = projectFilePath;
Environment = environment;
WrapServices.GetService<IWrapDescriptorMonitoringService>()
.ProcessWrapDescriptor(_descriptorPath, _packageRepository, this);
}
public ResharperProjectUpdater(IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, ExecutionEnvironment environment, IEnumerable<string> ignoredAssemblies)
{
_descriptorPath = descriptorPath;
_packageRepository = packageRepository;
_projectFilePath = projectFilePath;
_ignoredAssemblies = ignoredAssemblies.ToList();
Environment = environment;
Services.Services.GetService<IWrapDescriptorMonitoringService>()
.ProcessWrapDescriptor(_descriptorPath, _packageRepository, this);
}
public void TryAddNotifier(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository repository, string projectFilePath, IEnumerable<string> ignoredAssemblies)
{
lock (_projectFiles)
{
if (_projectFiles.ContainsKey(projectFilePath))
{
Services.Services.GetService<IWrapDescriptorMonitoringService>().ProcessWrapDescriptor(descriptorPath, repository, _projectFiles[projectFilePath]);
return;
}
_projectFiles[projectFilePath] = new ResharperProjectUpdater(descriptorPath, repository, projectFilePath, environment, ignoredAssemblies);
}
}
public ResharperProjectUpdater(IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, ExecutionEnvironment environment, IEnumerable<string> ignoredAssemblies)
{
_descriptorPath = descriptorPath;
_packageRepository = packageRepository;
_projectFilePath = projectFilePath;
_ignoredAssemblies = ignoredAssemblies.ToList();
Environment = environment;
object result = null;
if (Shell.HasInstance)
result = Shell.Instance.TryGetComponent<MessageBoxStuff>();
Services.Services.GetService<IWrapDescriptorMonitoringService>()
.ProcessWrapDescriptor(_descriptorPath, _packageRepository, this);
}
// TODO: Make sure assemblies already loaded are loaded from normal reflection context
public IExport ProcessExports(IEnumerable<IExport> exports, ExecutionEnvironment environment)
{
var commandTypes = from folder in exports
from file in folder.Items
where file.FullPath.EndsWith(".dll")
let assembly = TryReflectionOnlyLoad(file)
where assembly != null
from type in TryGetExportedTypes(assembly)
where type.GetInterface("ICommand") != null
let loadedAssembly = Assembly.LoadFrom(file.FullPath)
select loadedAssembly.GetType(type.FullName);
return new CommandExport(commandTypes);
}
// TODO: Make sure assemblies already loaded are loaded from normal reflection context
public IExport ProcessExports(IEnumerable<IExport> exports, ExecutionEnvironment environment)
{
var loadedAssemblyPaths = AppDomain.CurrentDomain.GetAssemblies().Select(x => Path.GetFullPath(x.Location)).ToList();
var commandTypes = from folder in exports
from file in folder.Items
where file.FullPath.EndsWith(".dll")
where !loadedAssemblyPaths.Contains(file.FullPath)
let assembly = TryReflectionOnlyLoad(file)
where assembly != null
from type in TryGetExportedTypes(assembly)
where type.GetInterface("ICommand") != null
let loadedAssembly = Assembly.LoadFrom(file.FullPath)
select loadedAssembly.GetType(type.FullName);
return new CommandExport(commandTypes);
}
public IExport GetExport(string exportName, ExecutionEnvironment environment)
{
// get the list of exports in the
var exporter =
_exporters.SingleOrDefault(x => x.ExportName.Equals(exportName, StringComparison.OrdinalIgnoreCase));
if (exporter == null)
return null;
var exports = from directory in BaseDirectory.GetDirectories()
where exporter.CanProcessExport(directory.Name)
let directoryPath = directory.FullName
select (IExport)new FolderExport(directory)
{
Items = directory.GetFiles()
.Select(x => (IExportItem)new FileExportItem(x))
.ToList()
};
return exporter.ProcessExports(exports, environment);
}
// TODO: Make sure assemblies already loaded are loaded from normal reflection context
public IExport ProcessExports(IEnumerable<IExport> exports, ExecutionEnvironment environment)
{
var loadedAssemblyPaths = AppDomain.CurrentDomain.GetAssemblies()
.Select(x=>new { loc = TryGetAssemblyLocation(x), asm=x })
.Where(x=>x.loc != null)
.ToLookup(x=>x.loc,x=>x.asm, StringComparer.OrdinalIgnoreCase);
var commandTypes = from folder in exports
from file in folder.Items
where file.FullPath.EndsWith(".dll")
let assembly = loadedAssemblyPaths.Contains(file.FullPath)
? loadedAssemblyPaths[file.FullPath].First()
: TryReflectionOnlyLoad(file)
where assembly != null
from type in TryGetExportedTypes(assembly)
where type.IsAbstract == false &&
type.IsGenericTypeDefinition == false &&
type.GetInterface("ICommand") != null
let loadedAssembly = Assembly.LoadFrom(file.FullPath)
select loadedAssembly.GetType(type.FullName);
return new CommandExport(commandTypes);
}
static void ExecyteTryAddNotifierMethod(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
_instance.GetType().GetMethod("TryAddNotifier").Invoke(_instance, new object[] { environment, descriptorPath, packageRepository, projectFilePath, excludedAssemblies });
}
public static void TryRegisterResharper(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
TryCreateIntegrationService();
TryRegisterProjectToResharper(environment, descriptorPath, packageRepository, projectFilePath, excludedAssemblies);
}
public NotificationRegistration(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
Environment = environment;
DescriptorPath = descriptorPath;
PackageRepository = packageRepository;
ProjectFilePath = projectFilePath;
ExcludedAssemblies = excludedAssemblies;
}
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageManager manager, ExecutionEnvironment environment, params IPackageRepository[] repositories)
{
return manager.GetExports<IExport>("bin", environment, repositories.NotNull()).SelectMany(x => x.Items).OfType<IAssemblyReferenceExportItem>().ToList();
}
public ResharperIntegrationService(ExecutionEnvironment environment)
{
this.Environment = environment;
}
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageManager manager, bool includeContentOnly, ExecutionEnvironment exec, PackageDescriptor descriptor, params IPackageRepository[] repositories)
{
return GetAssemblyReferences(manager.TryResolveDependencies(descriptor, repositories), exec, includeContentOnly);
}
public IExport GetExport(string exportName, ExecutionEnvironment environment)
{
return null;
}
public static IEnumerable<ICommandOutput> GacConflicts(this DependencyResolutionResult result, ExecutionEnvironment env)
{
return from package in GacResolver.InGac(result.ResolvedPackages.Select(x => x.Package), env)
from assembly in package
select new GacConflict(package.Key, assembly) as ICommandOutput;
}
static void ExecuteTryAddNotifierMethod(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
ResharperLogger.Debug("ExecuteTryAddNotifierMethod: executing TryAdd for {0}.", projectFilePath);
_instance.GetType().GetMethod("TryAddNotifier").Invoke(_instance, new object[] { environment, descriptorPath, packageRepository, projectFilePath, excludedAssemblies });
}
static void Queue(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
ResharperLogger.Debug("Queue: queued '{0}'.", projectFilePath);
_registrationQueue.Enqueue(new NotificationRegistration(environment,descriptorPath,packageRepository,projectFilePath, excludedAssemblies));
}
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(InstallationPaths.UserRepositoryPath))
{
Name = "System repository"
};
ConfigurationDirectory = FileSystem.GetDirectory(InstallationPaths.ConfigurationDirectory);
RemoteRepositories = Services.Services.GetService<IConfigurationManager>().LoadRemoteRepositories()
.OrderBy(x => x.Value.Priority)
.Select(x => CreateRemoteRepository(x.Key, x.Value.Href))
.Where(x => x != null)
.Cast<IPackageRepository>()
.ToList();
ExecutionEnvironment = new ExecutionEnvironment
{
Platform = IntPtr.Size == 4 ? "x86" : "x64",
Profile = "net35"
};
}
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);
}
static void Queue(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
_registrationQueue.Enqueue(new NotificationRegistration(environment,descriptorPath,packageRepository,projectFilePath, excludedAssemblies));
}
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.Take(1);
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();
}
static void TryRegisterProjectToResharper(ExecutionEnvironment environment, IFile descriptorPath, IPackageRepository packageRepository, string projectFilePath, IEnumerable<string> excludedAssemblies)
{
lock (_registrationQueue)
{
if (_instance == null)
Queue(environment, descriptorPath, packageRepository, projectFilePath, excludedAssemblies);
else
ExecyteTryAddNotifierMethod(environment,descriptorPath,packageRepository,projectFilePath,excludedAssemblies);
}
}
public IExport GetExport(string exportName, ExecutionEnvironment environment)
{
VerifyLoaded();
return _loadedPackage.GetExport(exportName, environment);
}
public void Initialize()
{
FileSystem = LocalFileSystem.Instance;
Descriptor = CurrentDirectory
.AncestorsAndSelf()
.SelectMany(x => x.Files("*.wrapdesc"))
.Select(x=>new WrapDescriptorParser().ParseFile(x))
.FirstOrDefault();
var projectRepositoryDirectory = Descriptor == null
? null
: Descriptor.File.Parent
.AncestorsAndSelf()
.SelectMany(x => x.Directories("wraps"))
.Where(x => x != null)
.FirstOrDefault();
if (projectRepositoryDirectory != null)
ProjectRepository = new FolderRepository(projectRepositoryDirectory, true)
{
Name = "Project repository"
};
CurrentDirectoryRepository = new CurrentDirectoryRepository();
SystemRepository = new FolderRepository(FileSystem.GetDirectory(InstallationPaths.UserRepositoryPath), false)
{
Name="System repository"
};
ConfigurationDirectory = FileSystem.GetDirectory(InstallationPaths.ConfigurationDirectory);
RemoteRepositories = WrapServices.GetService<IConfigurationManager>().LoadRemoteRepositories()
.Select(x => new HttpRepository(FileSystem, new HttpRepositoryNavigator(x.Value.Href)))
.Cast<IPackageRepository>()
.ToList();
ExecutionEnvironment = new ExecutionEnvironment
{
Platform = IntPtr.Size == 4 ? "x86" : "x64",
Profile = "net35"
};
}
public static IEnumerable<IAssemblyReferenceExportItem> GetAssemblyReferences(this IPackageManager manager, ExecutionEnvironment exec, params IPackageRepository[] repositories)
{
return GetAssemblyReferencesFromPackages(repositories.SelectMany(x => x.PackagesByName.SelectMany(y => y)), exec);
}
