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); }