private IEnumerable<string> GetPackageAssemblyNames(string path)
        {
            var compatibilityProvider = new DefaultCompatibilityProvider();
            var folderReader = new PackageFolderReader(Path.Combine(path, _fileSystem.PackagesFolder));
            var nupkgFiles = folderReader.GetFiles().Where(x => Path.GetExtension(x).ToLowerInvariant() == ".nupkg");

            var packagesConfig = XDocument.Parse(File.ReadAllText(Path.Combine(path, _fileSystem.PackagesFile)));

            var reader = new PackagesConfigReader(packagesConfig);
            var contents = reader.GetPackages();

            var result = new List<string>();

            foreach (var nupkg in nupkgFiles)
            {
                var stream = folderReader.GetStream(nupkg);
                var packageReader = new PackageReader(stream);

                var identity = packageReader.GetIdentity();
                var packagesConfigReference = contents.FirstOrDefault(x => x.PackageIdentity.Id == identity.Id && x.PackageIdentity.Version == identity.Version);

                if (packagesConfigReference == null)
                {
                    break;
                }

                var packageContents = packageReader.GetLibItems().Where(x => compatibilityProvider.IsCompatible(x.TargetFramework, packagesConfigReference.TargetFramework)).
                    SelectMany(x => x.Items.Where(i => Path.GetExtension(i).ToLowerInvariant() == ".dll"));

                result.AddRange(packageContents);
            }

            return result;
        }
        /// <summary>
        /// Adds refresh files to the specified project for all assemblies references belonging to the packages specified by packageNames.
        /// </summary>
        /// <param name="project">The project.</param>
        /// <param name="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param>
        /// <param name="packageNames">The package names.</param>
        private void AddRefreshFilesForReferences(Project project, string repositoryPath, IEnumerable<PackageIdentity> packageNames)
        {
            if (project == null)
            {
                throw new ArgumentNullException("project");
            }

            if (repositoryPath == null)
            {
                throw new ArgumentNullException("repositoryPath");
            }

            if (!packageNames.Any())
            {
                return;
            }

            VSAPIProjectContext context = new VSAPIProjectContext();
            WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context);

            var root = EnvDTEProjectUtility.GetFullPath(project);

            foreach (var packageName in packageNames)
            {
                string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);

                DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));

                PackageFolderReader reader = new PackageFolderReader(packageFolder);

                var frameworkGroups = reader.GetReferenceItems();

                var groups = reader.GetReferenceItems();

                var fwComparer = new NuGetFrameworkFullComparer();
                FrameworkReducer reducer = new FrameworkReducer();
                NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));

                if (targetGroupFramework != null)
                {
                    var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();

                    foreach (string refItem in refGroup.Items)
                    {
                        string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));

                        // create one refresh file for each assembly reference, as per required by Website projects
                        // projectSystem.CreateRefreshFile(assemblyPath);
                        RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath, context);
                    }
                }
            }
        }
Exemple #3
0
        private static CommandSpec ConfigureCommandFromPackage(string commandName, IEnumerable<string> args, string packageDir)
        {
            var commandPackage = new PackageFolderReader(packageDir);

            var files = commandPackage.GetFiles();

            return ConfigureCommandFromPackage(commandName, args, files, packageDir);
        }
        /// <summary>
        /// Возвращает наименьшую поддерживаемую версию фреймворка для указанного пакета.
        /// </summary>
        /// <param name="packageIdentity">Идентификатор пакета.</param>
        private NuGetFramework GetPackageLowestSupportedFramework(PackageIdentity packageIdentity)
        {
            var packagePath = GetPackagePath(packageIdentity);

            using (var reader = new PackageFolderReader(packagePath))
            {
                // Выбираются только поддерживаемые TargetFramework, содержащие файлы в каталоге 'lib'

                return reader.GetLibItems()
                             .OrderBy(i => i.TargetFramework, NuGetFrameworkComparer)
                             .FirstOrDefault(i => NuGetFrameworkComparer.Compare(i.TargetFramework, NuGetFramework.AnyFramework) != 0
                                                  && !i.TargetFramework.IsUnsupported
                                                  && i.Items != null
                                                  && i.Items.Any())?.TargetFramework;
            }
        }
        /// <summary>
        /// Добавляет в содержимое пакета совместимые версии файлов из указанного пакета.
        /// </summary>
        /// <param name="packageContent">Содержимое пакета.</param>
        /// <param name="packageIdentity">Идентификатор пакета.</param>
        /// <param name="targetFramework">Версия совместимого фреймворка.</param>
        /// <param name="compatibilityProvider">Провайдер для проверки совместимости фреймворков.</param>
        private void FillPackageContent(PackageContent packageContent,
                                        PackageIdentity packageIdentity,
                                        NuGetFramework targetFramework,
                                        IFrameworkCompatibilityProvider compatibilityProvider)
        {
            var packagePath = GetPackagePath(packageIdentity);

            using (var reader = new PackageFolderReader(packagePath))
            {
                var libItems = GetCompatibleItems(reader, reader.GetLibItems().ToList(), targetFramework, compatibilityProvider);

                if (libItems?.Items != null)
                {
                    foreach (var item in libItems.Items)
                    {
                        var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Lib, libItems.TargetFramework);
                        packageContent.Lib.Add(installItem);
                    }
                }

                var contentItems = GetCompatibleItems(reader, reader.GetContentItems().ToList(), targetFramework, compatibilityProvider);

                if (contentItems?.Items != null)
                {
                    foreach (var item in contentItems.Items)
                    {
                        var installItem = GetPackageItem(packagePath, item, PackagingConstants.Folders.Content, contentItems.TargetFramework);
                        packageContent.Content.Add(installItem);
                    }
                }

                var pluginItems = GetCompatibleItems(reader, reader.GetPluginItems().ToList(), targetFramework, compatibilityProvider);

                if (pluginItems?.Items != null)
                {
                    foreach (var item in pluginItems.Items)
                    {
                        var installItem = GetPackageItem(packagePath, item, PluginFolderName, pluginItems.TargetFramework);
                        packageContent.Plugin.Add(installItem);
                    }
                }
            }
        }