public IWrapExport ProcessExports(IEnumerable<IWrapExport> exports, WrapRuntimeEnvironment 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);
        }
 public ResharperProjectUpdater(string descriptorPath, IWrapRepository wrapRepository, string projectFilePath, WrapRuntimeEnvironment environment)
 {
     _descriptorPath = descriptorPath;
     _wrapRepository = wrapRepository;
     _projectFilePath = projectFilePath;
     Environment = environment;
     WrapServices.GetService<IWrapDescriptorMonitoringService>()
         .ProcessWrapDescriptor(_descriptorPath, _wrapRepository, this);
 }
        public IWrapExport GetExport(string exportName, WrapRuntimeEnvironment 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 (IWrapExport)new FolderExport(directory)
                          {
                              Items = directory.GetFiles()
                                  .Select(x => (IWrapExportItem)new FileExportItem(x))
                                  .ToList()
                          };

            return exporter.ProcessExports(exports, environment);
        }
 public IWrapExport GetExport(string exportName, WrapRuntimeEnvironment environment)
 {
     VerifyLoaded();
     return _loadedPackage.GetExport(exportName, environment);
 }
 public ResharperIntegrationService(WrapRuntimeEnvironment environment)
 {
     this.Environment = environment;
 }