Example #1
0
        public static IPackage Latest(this IEnumerable<IPackage> values, IVersionSpec spec)
        {
            var candidates = values.ToArray();
            var candidate = candidates.FirstOrDefault(x => x.IsAbsoluteLatestVersion)
                            ?? candidates.FirstOrDefault(x => x.IsLatestVersion);

            if (candidate == null)
            {
                // If both absolute and latest are false, then we order in descending order (by version) and take the top
                var ordered = candidates
                    .OrderByDescending(x => x.Version)
                    .ToArray();

                if (spec == null)
                {
                    candidate = ordered.FirstOrDefault();
                }
                else
                {
                    Func<IPackage, bool> predicate;
                    if (spec.IsMaxInclusive)
                    {
                        predicate = x => x.Version <= spec.MaxVersion;
                    }
                    else
                    {
                        predicate = x => x.Version < spec.MaxVersion;
                    }

                    candidate = ordered.FirstOrDefault(predicate);
                }
            }

            return candidate;
        }
        public void GetPackage(string packageId, IVersionSpec version)
        {
            /*
            if (repositoryRemote == null)
            {
                //var repositoryRemote = PackageRepositoryFactory.Default.CreateRepository("https://nuget.org/api/v2");
                repositoryRemote = PackageRepositoryFactory.Default.CreateRepository(@"C:\Dev\Tools\NuGetFeed");
            }
            if (repositoryLocal == null)
            {
                repositoryLocal = GetLocalRepository();
            }
            */
            var packageInfo = FindPackage(packageId, version, false, false);

            if (packageInfo == null)
                throw new NotImplementedException();

            var localRepository = _repositories[0];
            if (localRepository != packageInfo.Item1)
            {
                localRepository.AddPackage(packageInfo.Item2);
            }

            foreach (var deps in packageInfo.Item2.DependencySets)
            {
                foreach (var dep in deps.Dependencies)
                {
                    GetPackage(dep.Id, dep.VersionSpec);
                }
            }
        }
        public static bool Matches(IVersionSpec versionSpec, SemanticVersion version)
        {
            if (versionSpec == null)
                return true; // I CAN'T DEAL WITH THIS

            bool minVersion;
            if (versionSpec.MinVersion == null) {
                minVersion = true; // no preconditon? LET'S DO IT
            } else if (versionSpec.IsMinInclusive) {
                minVersion = version >= versionSpec.MinVersion;
            } else {
                minVersion = version > versionSpec.MinVersion;
            }

            bool maxVersion;
            if (versionSpec.MaxVersion == null) {
                maxVersion = true; // no preconditon? LET'S DO IT
            } else if (versionSpec.IsMaxInclusive) {
                maxVersion = version <= versionSpec.MaxVersion;
            } else {
                maxVersion = version < versionSpec.MaxVersion;
            }

            return maxVersion && minVersion;
        }
Example #4
0
        public DependencyInfo(FullPackageName fullName, IVersionSpec versionSpec)
        {
            FullName = fullName;

            // Default to the simple version (which means min-version)
            VersionSpec = versionSpec ?? VersionUtility.ParseVersionSpec(FullName.Version.ToString());
        }
Example #5
0
 public PackageDependency(string id, IVersionSpec versionSpec)
 {
     if (String.IsNullOrEmpty(id)) {
         throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "id");
     }
     Id = id;
     VersionSpec = versionSpec;
 }
Example #6
0
 public PackageDependency(string id, IVersionSpec versionSpec)
 {
     if (String.IsNullOrEmpty(id)) {
         throw new ArgumentNullException("id");
     }
     Id = id;
     VersionSpec = versionSpec;
 }
Example #7
0
 internal static VersionRange SafeToVerRange(IVersionSpec spec)
 {
     if(spec == null) {
         return null;
     }
     return new VersionRange(
         SafeToNuGetVer(spec.MinVersion),
         spec.IsMinInclusive,
         SafeToNuGetVer(spec.MaxVersion),
         spec.IsMaxInclusive);
 }
Example #8
0
        // The version string is either a simple version or an arithmetic range
        // e.g.
        //      1.0         --> 1.0 ≤ x
        //      (,1.0]      --> x ≤ 1.0
        //      (,1.0)      --> x &lt; 1.0
        //      [1.0]       --> x == 1.0
        //      (1.0,)      --> 1.0 &lt; x
        //      (1.0, 2.0)   --> 1.0 &lt; x &lt; 2.0
        //      [1.0, 2.0]   --> 1.0 ≤ x ≤ 2.0
        public Package(string packageId, string versionSpec = null, bool allowPrereleaseVersions = false, bool allowUnlisted = false)
        {
            if (packageId == null)
            {
                throw new ArgumentNullException("packageId");
            }
            if (string.IsNullOrWhiteSpace(packageId))
            {
                throw new ArgumentException("packageId");
            }

            _packageId = packageId;
            _versionSpec = string.IsNullOrWhiteSpace(versionSpec) ? null : VersionUtility.ParseVersionSpec(versionSpec);
            _allowPrereleaseVersions = allowPrereleaseVersions;
            _allowUnlisted = allowUnlisted;
        }
Example #9
0
        public Dependency(string name, IVersionSpec versionSpec)
            : this(name)
        {
            if (versionSpec.MinVersion != null && versionSpec.MaxVersion != null &&
                versionSpec.MinVersion == versionSpec.MaxVersion)
            {
                Mode = UpdateMode.Fixed;
                Version = versionSpec.MinVersion.Version.ToString();
            }
            else
            {
                Mode = UpdateMode.Float;
            }

            _versionSpec = versionSpec;
        }
        public AzureVersionSpec(IVersionSpec version)
        {

            this.IsMaxInclusive = version.IsMaxInclusive;
            this.IsMinInclusive = version.IsMinInclusive;

            if (version.MaxVersion != null)
            {
                this.MaxVersionSpecial = version.MaxVersion.SpecialVersion;
                this.MaxVersionVersion = version.MaxVersion.Version.ToString();
            }

            if (version.MinVersion != null)
            {
                this.MinVersionSpecial = version.MinVersion.SpecialVersion;
                this.MinVersionVersion = version.MinVersion.Version.ToString();
            }
        }
        /// <summary>
        /// Enumerates the required package requests.
        /// </summary>
        /// <param name="packageId">
        /// The package id.
        /// </param>
        /// <param name="version">
        /// The version.
        /// </param>
        /// <returns>
        /// An enumeration of package requests.
        /// </returns>
        public IEnumerable<SolutionPackageRequest> EnumPackageRequests(string packageId, IVersionSpec version)
        {
            if (packageId.EndsWith(Constants.SolutionPackagePostFix, StringComparison.CurrentCultureIgnoreCase))
            {
                var packageRequest = SolutionPackageRequestFactory.CreatePackageRequest(packageId, version);
                if (packageRequest != null)
                {
                    yield return packageRequest;

                    foreach (var dependencySet in packageRequest.Package.DependencySets)
                    {
                        foreach (var dependency in dependencySet.Dependencies)
                        {
                            foreach (var request in this.EnumPackageRequests(dependency.Id, dependency.VersionSpec))
                            {
                                yield return request;
                            }
                        }
                    }
                }
            }
        }
Example #12
0
        internal IEnumerable <PackageItem> GetPackageByIdAndVersionSpec(string name, IVersionSpec versionSpec, bool allowUnlisted = false)
        {
            if (String.IsNullOrEmpty(name))
            {
                return(Enumerable.Empty <PackageItem>());
            }

            return(SelectedSources.AsParallel().WithMergeOptions(ParallelMergeOptions.NotBuffered).SelectMany(source => {
                var pkgs = source.Repository.FindPackages(name, versionSpec, AllowPrereleaseVersions, allowUnlisted);

                /*
                 * // necessary?
                 * pkgs = from p in pkgs where p.IsLatestVersion select p;
                 */

                var pkgs2 = pkgs.ToArray();

                return pkgs2.Select(pkg => new PackageItem {
                    Package = pkg,
                    PackageSource = source,
                    FastPath = MakeFastPath(source, pkg.Id, pkg.Version.ToString())
                });
            }).OrderByDescending(each => each.Package.Version));
        }
Example #13
0
        private static void SetMaxVersion(VersionSpec target, IVersionSpec source)
        {
            if (source == null || source.MaxVersion == null)
            {
                return;
            }

            if (target.MaxVersion == null)
            {
                target.MaxVersion     = source.MaxVersion;
                target.IsMaxInclusive = source.IsMaxInclusive;
            }

            if (target.MaxVersion > source.MaxVersion)
            {
                target.MaxVersion     = source.MaxVersion;
                target.IsMaxInclusive = source.IsMaxInclusive;
            }

            if (target.MaxVersion == source.MaxVersion)
            {
                target.IsMaxInclusive = target.IsMaxInclusive && source.IsMaxInclusive;
            }
        }
Example #14
0
 public static Func <T, bool> ToDelegate <T>(this IVersionSpec versionInfo, Func <T, SemanticVersion> extractor)
 {
     if (versionInfo == null)
     {
         throw new ArgumentNullException("versionInfo");
     }
     if (extractor == null)
     {
         throw new ArgumentNullException("extractor");
     }
     return(delegate(T p) {
         SemanticVersion version = extractor(p);
         bool flag = true;
         if (versionInfo.MinVersion != null)
         {
             flag = !versionInfo.IsMinInclusive ? (flag && (version > versionInfo.MinVersion)) : (flag && (version >= versionInfo.MinVersion));
         }
         if (versionInfo.MaxVersion != null)
         {
             flag = !versionInfo.IsMaxInclusive ? (flag && (version < versionInfo.MaxVersion)) : (flag && (version <= versionInfo.MaxVersion));
         }
         return flag;
     });
 }
Example #15
0
        public static bool TryParseVersionSpec(string value, out IVersionSpec result)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            var versionSpec = new VersionSpec();

            value = value.Trim();

            // First, try to parse it as a plain version string
            SemanticVersion version;

            if (SemanticVersion.TryParse(value, out version))
            {
                // A plain version is treated as an inclusive minimum range
                result = new VersionSpec
                {
                    MinVersion     = version,
                    IsMinInclusive = true
                };

                return(true);
            }

            // It's not a plain version, so it must be using the bracket arithmetic range syntax

            result = null;

            // Fail early if the string is too short to be valid
            if (value.Length < 3)
            {
                return(false);
            }

            // The first character must be [ ot (
            switch (value.First())
            {
            case '[':
                versionSpec.IsMinInclusive = true;
                break;

            case '(':
                versionSpec.IsMinInclusive = false;
                break;

            default:
                return(false);
            }

            // The last character must be ] ot )
            switch (value.Last())
            {
            case ']':
                versionSpec.IsMaxInclusive = true;
                break;

            case ')':
                versionSpec.IsMaxInclusive = false;
                break;

            default:
                return(false);
            }

            // Get rid of the two brackets
            value = value.Substring(1, value.Length - 2);

            // Split by comma, and make sure we don't get more than two pieces
            string[] parts = value.Split(',');
            if (parts.Length > 2)
            {
                return(false);
            }
            else if (parts.All(String.IsNullOrEmpty))
            {
                // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,]
                return(false);
            }

            // If there is only one piece, we use it for both min and max
            string minVersionString = parts[0];
            string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0];

            // Only parse the min version if it's non-empty
            if (!String.IsNullOrWhiteSpace(minVersionString))
            {
                if (!TryParseVersion(minVersionString, out version))
                {
                    return(false);
                }
                versionSpec.MinVersion = version;
            }

            // Same deal for max
            if (!String.IsNullOrWhiteSpace(maxVersionString))
            {
                if (!TryParseVersion(maxVersionString, out version))
                {
                    return(false);
                }
                versionSpec.MaxVersion = version;
            }

            // Successful parse!
            result = versionSpec;
            return(true);
        }
 /// <summary>
 /// Stolen from NuGet codebase.
 /// </summary>
 /// <param name="versionInfo"></param>
 /// <returns></returns>
 public static Func <IPackage, bool> ToDelegate(this IVersionSpec versionInfo)
 {
     return(versionInfo.ToDelegate <IPackage>(p => p.Version));
 }
Example #17
0
        public virtual async Task <IHttpActionResult> GetUpdates(
            ODataQueryOptions <ODataPackage> options,
            [FromODataUri] string packageIds,
            [FromODataUri] string versions,
            [FromODataUri] bool includePrerelease,
            [FromODataUri] bool includeAllVersions,
            [FromODataUri] string targetFrameworks   = "",
            [FromODataUri] string versionConstraints = "",
            [FromUri] string semVerLevel             = "",
            CancellationToken token = default(CancellationToken))
        {
            if (string.IsNullOrEmpty(packageIds) || string.IsNullOrEmpty(versions))
            {
                return(Ok(Enumerable.Empty <ODataPackage>().AsQueryable()));
            }

            // Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client.
            // Can probably eventually be retired (when nobody uses 2.1 anymore...)
            // Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because
            // space characters are never acepted as valid by VersionUtility.ParseFrameworkName.
            if (!string.IsNullOrEmpty(targetFrameworks))
            {
                targetFrameworks = targetFrameworks.Replace(' ', '+');
            }

            var idValues              = packageIds.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var versionValues         = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks)
                                        ? null
                                        : targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList();
            var versionConstraintValues = (String.IsNullOrEmpty(versionConstraints)
                                            ? new string[idValues.Length]
                                            : versionConstraints.Split('|')).ToList();

            if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Count)
            {
                // Exit early if the request looks invalid
                return(Ok(Enumerable.Empty <ODataPackage>().AsQueryable()));
            }

            var packagesToUpdate = new List <IPackageMetadata>();

            for (var i = 0; i < idValues.Length; i++)
            {
                if (SemanticVersion.TryParse(versionValues[i], out var semVersion))
                {
                    packagesToUpdate.Add(new PackageBuilder {
                        Id = idValues[i], Version = semVersion
                    });
                }
                else
                {
                    versionConstraintValues.RemoveAt(i);
                }
            }

            var versionConstraintsList = new IVersionSpec[versionConstraintValues.Count];

            for (var i = 0; i < versionConstraintsList.Length; i++)
            {
                if (!String.IsNullOrEmpty(versionConstraintValues[i]))
                {
                    VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraintsList[i]);
                }
            }

            var clientCompatibility = ClientCompatibilityFactory.FromProperties(semVerLevel);

            var sourceQuery = await _serverRepository.GetUpdatesAsync(
                packagesToUpdate,
                includePrerelease,
                includeAllVersions,
                targetFrameworkValues,
                versionConstraintsList,
                clientCompatibility,
                token);

            return(TransformToQueryResult(options, sourceQuery, clientCompatibility));
        }
Example #18
0
        public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool allowUnlisted)
        {
            IEnumerable <IPackage> packages = repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted);

            if (constraintProvider != null)
            {
                packages = DependencyResolveUtility.FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions);
            }
            return(packages.FirstOrDefault <IPackage>());
        }
        /// <summary>
        /// Attempts to parse a string with a version spec in NuGet format.
        /// See http://docs.nuget.org/docs/reference/versioning
        /// </summary>
        /// <param name="s">
        /// String to parse.
        /// </param>
        /// <param name="result">
        /// The version spec, or null if the input string does not contain a valid NuGet version spec.
        /// </param>
        /// <returns>
        /// True if the input string contains a valid version spec. False otherwise.
        /// </returns>
        public static bool TryParseNuGet(string s, out IVersionSpec result)
        {
            if (s == null)
            {
                throw new ArgumentNullException("value");
            }

            var versionSpec = new VersionSpec();
            s = s.Trim();

            // First, try to parse it as a plain version string
            SemanticVersion version;
            if (SemanticVersion.TryParseNuGet(s, out version))
            {
                // A plain version is treated as an inclusive minimum range
                result = new VersionSpec
                {
                    MinVersion = version,
                    IsMinInclusive = true
                };

                return true;
            }

            // It's not a plain version, so it must be using the bracket arithmetic range syntax

            result = null;

            // Fail early if the string is too short to be valid
            if (s.Length < 3)
            {
                return false;
            }

            // The first character must be [ ot (
            if (s.StartsWith("["))
            {
                versionSpec.IsMinInclusive = true;
            }
            else if (s.StartsWith("("))
            {
                versionSpec.IsMinInclusive = false;
            }
            else
            {
                return false;
            }

            // The last character must be ] ot )
            if (s.EndsWith("]"))
            {
                    versionSpec.IsMaxInclusive = true;
            } 
            else if (s.EndsWith(")"))
            {
                    versionSpec.IsMaxInclusive = false;
            }
            else
            {
                    return false;
            }

            // Get rid of the two brackets
            s = s.Substring(1, s.Length - 2);

            // Split by comma, and make sure we don't get more than two pieces
            string[] parts = s.Split(',');
            if (parts.Length > 2)
            {
                return false;
            }
            else if (parts.All(p=>String.IsNullOrEmpty(p)))
            {
                // If all parts are empty, then neither of upper or lower bounds were specified. Version spec is of the format (,]
                return false;
            }

            // If there is only one piece, we use it for both min and max
            string minVersionString = parts[0];
            string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0];

            // Only parse the min version if it's non-empty
            if (!String.IsNullOrWhiteSpace(minVersionString))
            {
                if (!SemanticVersion.TryParseNuGet(minVersionString, out version))
                {
                    return false;
                }
                versionSpec.MinVersion = version;
            }

            // Same deal for max
            if (!String.IsNullOrWhiteSpace(maxVersionString))
            {
                if (!SemanticVersion.TryParseNuGet(maxVersionString, out version))
                {
                    return false;
                }
                versionSpec.MaxVersion = version;
            }

            // Successful parse!
            result = versionSpec;
            return true;
        }
Example #20
0
        public IQueryable <V2FeedPackage> GetUpdates(
            string packageIds,
            string versions,
            bool includePrerelease,
            bool includeAllVersions,
            string targetFrameworks,
            string versionConstraints)
        {
            if (String.IsNullOrEmpty(packageIds) || String.IsNullOrEmpty(versions))
            {
                return(Enumerable.Empty <V2FeedPackage>().AsQueryable());
            }

            // Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client. Can probably eventually be retired (when nobody uses 2.1 anymore...)
            // Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because
            // space characters are never acepted as valid by VersionUtility.ParseFrameworkName.
            if (!string.IsNullOrEmpty(targetFrameworks))
            {
                targetFrameworks = targetFrameworks.Replace(' ', '+');
            }

            var idValues              = packageIds.Trim().ToLowerInvariant().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var versionValues         = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks)
                                            ? null
                                            : targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList();
            var versionConstraintValues = String.IsNullOrEmpty(versionConstraints)
                                            ? new string[idValues.Length]
                                            : versionConstraints.Split('|');

            if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length)
            {
                // Exit early if the request looks invalid
                return(Enumerable.Empty <V2FeedPackage>().AsQueryable());
            }

            var versionLookup = idValues.Select((id, i) =>
            {
                SemanticVersion currentVersion = null;
                if (SemanticVersion.TryParse(versionValues[i], out currentVersion))
                {
                    IVersionSpec versionConstraint = null;
                    if (versionConstraintValues[i] != null)
                    {
                        if (!VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraint))
                        {
                            versionConstraint = null;
                        }
                    }
                    return(Tuple.Create(id, Tuple.Create(currentVersion, versionConstraint)));
                }
                return(null);
            })
                                .Where(t => t != null)
                                .ToLookup(t => t.Item1, t => t.Item2, StringComparer.OrdinalIgnoreCase);

            var packages = PackageRepository.GetAll()
                           .Include(p => p.PackageRegistration)
                           .Include(p => p.SupportedFrameworks)
                           .Where(p =>
                                  p.Listed && (includePrerelease || !p.IsPrerelease) &&
                                  idValues.Contains(p.PackageRegistration.Id.ToLower()))
                           .OrderBy(p => p.PackageRegistration.Id);

            return(GetUpdates(packages, versionLookup, targetFrameworkValues, includeAllVersions).AsQueryable()
                   .ToV2FeedPackageQuery(GetSiteRoot(), Configuration.Features.FriendlyLicenses));
        }
 IPackage matchPackage(IPackageRepository packageRepository, string id, IVersionSpec version)
 {
     return packageRepository.FindPackagesById(id).FirstOrDefault(x => VersionComparer.Matches(version, x.Version));
 }
Example #22
0
 private void UpdatePackageReference(IProjectManager projectManager, string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 {
     RunProjectAction(projectManager, () => projectManager.UpdatePackageReference(packageId, versionSpec, updateDependencies, allowPrereleaseVersions));
 }
Example #23
0
        private List <NuGetPackageInfo> ResolveDependencies(string packageId, IVersionSpec packageVersionSpec, IEnumerable <IPackageRepository> packageRepositories)
        {
            Log.Debug("Resolving dependencies for package '{0}'", packageId);

            var      packagesToRetrieve = new List <NuGetPackageInfo>();
            IPackage packageToInstall   = null;

            foreach (var packageRepository in packageRepositories)
            {
                try
                {
                    var query = packageRepository.GetPackages().Where(x => x.Id.Equals(packageId, StringComparison.CurrentCultureIgnoreCase));

                    // TODO: optimize performance here
                    //if (packageVersionSpec.MinVersion != null)
                    //{
                    //    foreach (var version in x.Version.Get)

                    //    query = query.Where(x => x.Version.GetComparableVersionStrings() >= packageVersionSpec.MinVersion.V);
                    //}

                    //if (packageVersionSpec.MaxVersion != null)
                    //{
                    //    query = query.Where(x => x.Version <= packageVersionSpec.MaxVersion);
                    //}

                    // Note: FirstOrDefault not supported on GetPackages()
                    var possiblePackages = query.ToList().OrderBy(x => x.Version);

                    packageToInstall = (from possiblePackage in possiblePackages
                                        where (packageVersionSpec.MinVersion == null || possiblePackage.Version >= packageVersionSpec.MinVersion) &&
                                        (packageVersionSpec.MaxVersion == null || possiblePackage.Version <= packageVersionSpec.MaxVersion)
                                        select possiblePackage).FirstOrDefault();

                    if (packageToInstall != null)
                    {
                        packagesToRetrieve.Add(new NuGetPackageInfo(packageToInstall, packageRepository));
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Log.Warning(ex, "Failed to check if package '{0}' is available on package repository '{1}'", packageId, packageRepository.Source);
                }
            }

            if (packageToInstall == null)
            {
                Log.ErrorAndThrowException <NotSupportedException>("Package '{0}' is not found in any of the sources, cannot install package", packageId);
                return(packagesToRetrieve);
            }

            if (IgnoreDependencies)
            {
                Log.Debug("Dependencies are ignored, only returning list of requested packages");
                return(packagesToRetrieve);
            }

            foreach (var dependencySet in packageToInstall.DependencySets)
            {
                // TODO: check framework name
                //if (dependencySet.TargetFramework == new FrameworkName() )

                foreach (var dependency in dependencySet.Dependencies)
                {
                    var resolvedDependencies = ResolveDependencies(dependency.Id, dependency.VersionSpec, packageRepositories);
                    for (var i = resolvedDependencies.Count - 1; i >= 0; i--)
                    {
                        var resolvedDependency = resolvedDependencies[i];
                        if (!packagesToRetrieve.Any(x => x.Package.Id.Equals(resolvedDependency.Package.Id, StringComparison.CurrentCultureIgnoreCase)))
                        {
                            packagesToRetrieve.Insert(0, resolvedDependency);
                        }
                    }
                }
            }

            return(packagesToRetrieve);
        }
		public void AddConstraint (string packageId, IVersionSpec versionSpec)
		{
			constraintProvider.AddConstraint (packageId, versionSpec);
		}
 public void AddConstraint(string packageId, IVersionSpec versionSpec)
 {
     _constraints[packageId] = versionSpec;
 }
Example #26
0
 public void AddConstraint(string packageId, IVersionSpec versionSpec)
 {
     this._constraints[packageId] = versionSpec;
 }
        public static async Task <IEnumerable <IServerPackage> > GetUpdatesAsync(
            this IServerPackageRepository repository,
            IEnumerable <IPackageName> packages,
            bool includePrerelease,
            bool includeAllVersions,
            IEnumerable <FrameworkName> targetFramework,
            IEnumerable <IVersionSpec> versionConstraints,
            ClientCompatibility compatibility,
            CancellationToken token)
        {
            List <IPackageName> packageList = packages.ToList();

            if (!packageList.Any())
            {
                return(Enumerable.Empty <IServerPackage>());
            }

            IList <IVersionSpec> versionConstraintList;

            if (versionConstraints == null)
            {
                versionConstraintList = new IVersionSpec[packageList.Count];
            }
            else
            {
                versionConstraintList = versionConstraints.ToList();
            }

            if (packageList.Count != versionConstraintList.Count)
            {
                throw new ArgumentException(Strings.GetUpdatesParameterMismatch);
            }

            // These are the packages that we need to look at for potential updates.
            var candidates = await GetUpdateCandidatesAsync(
                repository,
                packageList,
                includePrerelease,
                compatibility,
                token);

            ILookup <string, IServerPackage> sourcePackages = candidates
                                                              .ToList()
                                                              .ToLookup(package => package.Id, StringComparer.OrdinalIgnoreCase);

            var results = new List <IServerPackage>();

            for (int i = 0; i < packageList.Count; i++)
            {
                var package    = packageList[i];
                var constraint = versionConstraintList[i];

                var updates = from candidate in sourcePackages[package.Id]
                              where (candidate.Version > package.Version) &&
                              SupportsTargetFrameworks(targetFramework, candidate) &&
                              (constraint == null || constraint.Satisfies(candidate.Version))
                              select candidate;

                results.AddRange(updates);
            }

            if (!includeAllVersions)
            {
                return(CollapseById(results));
            }
            return(results);
        }
Example #28
0
        private static bool IsPrereleaseDependency(PackageDependency dependency)
        {
            IVersionSpec versionSpec = dependency.VersionSpec;

            return((versionSpec != null) && (((versionSpec.MinVersion == null) || string.IsNullOrEmpty(dependency.VersionSpec.MinVersion.SpecialVersion)) ? ((versionSpec.MaxVersion != null) && !string.IsNullOrEmpty(dependency.VersionSpec.MaxVersion.SpecialVersion)) : true));
        }
Example #29
0
 public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies)
 {
     throw new NotImplementedException();
 }
        private List<NuGetPackageInfo> ResolveDependencies(string packageId, IVersionSpec packageVersionSpec, IEnumerable<IPackageRepository> packageRepositories)
        {
            Log.Debug("Resolving dependencies for package '{0}'", packageId);

            var packagesToRetrieve = new List<NuGetPackageInfo>();
            IPackage packageToInstall = null;

            foreach (var packageRepository in packageRepositories)
            {
                try
                {
					var query = packageRepository.GetPackages().Where(x => x.Id.Equals(packageId, StringComparison.CurrentCultureIgnoreCase));

                    // TODO: optimize performance here
                    //if (packageVersionSpec.MinVersion != null)
                    //{
                    //    foreach (var version in x.Version.Get)

                    //    query = query.Where(x => x.Version.GetComparableVersionStrings() >= packageVersionSpec.MinVersion.V);
                    //}

                    //if (packageVersionSpec.MaxVersion != null)
                    //{
                    //    query = query.Where(x => x.Version <= packageVersionSpec.MaxVersion);
                    //}

                    // Note: FirstOrDefault not supported on GetPackages()
                    var possiblePackages = query.ToList().OrderBy(x => x.Version);

                    packageToInstall = (from possiblePackage in possiblePackages
                                        where (packageVersionSpec.MinVersion == null || possiblePackage.Version >= packageVersionSpec.MinVersion) &&
                                              (packageVersionSpec.MaxVersion == null || possiblePackage.Version <= packageVersionSpec.MaxVersion)
                                        select possiblePackage).FirstOrDefault();

                    if (packageToInstall != null)
                    {
                        packagesToRetrieve.Add(new NuGetPackageInfo(packageToInstall, packageRepository));
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Log.Warning(ex, "Failed to check if package '{0}' is available on package repository '{1}'", packageId, packageRepository.Source);
                }
            }

            if (packageToInstall == null)
            {
                throw Log.ErrorAndCreateException<NotSupportedException>("Package '{0}' is not found in any of the sources, cannot install package", packageId);
            }

            if (IgnoreDependencies)
            {
                Log.Debug("Dependencies are ignored, only returning list of requested packages");
                return packagesToRetrieve;
            }

            foreach (var dependencySet in packageToInstall.DependencySets)
            {
                // TODO: check framework name
                //if (dependencySet.TargetFramework == new FrameworkName() )

                foreach (var dependency in dependencySet.Dependencies)
                {
                    var resolvedDependencies = ResolveDependencies(dependency.Id, dependency.VersionSpec, packageRepositories);
                    for (var i = resolvedDependencies.Count - 1; i >= 0; i--)
                    {
                        var resolvedDependency = resolvedDependencies[i];
                        if (!packagesToRetrieve.Any(x => x.Package.Id.Equals(resolvedDependency.Package.Id, StringComparison.CurrentCultureIgnoreCase)))
                        {
                            packagesToRetrieve.Insert(0, resolvedDependency);
                        }
                    }
                }
            }

            return packagesToRetrieve;
        }
Example #31
0
 public NuspecDependency(string name, IVersionSpec spec)
 {
     Name = name;
     VersionSpec = spec;
 }
        /// <summary>
        /// Adds a package that has been resolved as the latest within a constraint.  Saves doing the math and resolution again.
        /// </summary>
        /// <param name="package"></param>
        /// <param name="constraint"></param>
        /// <returns></returns>
        public bool AddCacheEntryByConstraint(IPackage package, IVersionSpec constraint)
        {
            if (!_latestPackageConstraintCache.ContainsKey(package.Id))
                _latestPackageConstraintCache.Add(package.Id, new Dictionary<IVersionSpec, IPackage>());

            if (!_latestPackageConstraintCache[package.Id].ContainsKey(constraint))
            {
                _latestPackageConstraintCache[package.Id].Add(constraint, package);
                return true;
            }
            return false;

        }
Example #33
0
        IPackage findPackageFromName(string id, IVersionSpec versionSpec, string packagesRootDir = null, IQueryable<IPackage> machineCache = null)
        {
            machineCache = machineCache ?? Enumerable.Empty<IPackage>().AsQueryable();

            if (packagesRootDir != null && localPackageCache == null) {
                localPackageCache = Utility.GetAllFilePathsRecursively(packagesRootDir)
                    .Where(PackageHelper.IsPackageFile)
                    .Select(x => new ZipPackage(x))
                    .ToArray();
            }

            return findPackageFromNameInList(id, versionSpec, localPackageCache ?? Enumerable.Empty<IPackage>()) ??
                findPackageFromNameInList(id, versionSpec, machineCache);
        }
Example #34
0
 public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 {
     UpdatePackage(packageId, () => SourceRepository.FindPackage(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted: false),
         updateDependencies, allowPrereleaseVersions);
 }
    private static IVersionSpec StripPatchLevel(IVersionSpec dependencyVersionSpec)
    {
      // Given a curatedFeedVersion of 8.0, make [8.0.1] work. Semver says the patch
      // level should be backwards compatible, so this should be safe
      var spec = new VersionSpec
      {
        IsMinInclusive = true,
        MinVersion =
          new SemanticVersion(dependencyVersionSpec.MinVersion.Version.Major,
            dependencyVersionSpec.MinVersion.Version.Minor, 0, 0),
        IsMaxInclusive = dependencyVersionSpec.IsMaxInclusive,
        MaxVersion = dependencyVersionSpec.MaxVersion
      };

      return spec;
    }
Example #36
0
        public IQueryable <ODataPackage> GetUpdates(
            string packageIds,
            string versions,
            bool includePrerelease,
            bool includeAllVersions,
            string targetFrameworks,
            string versionConstraints,
            string semVerLevel)
        {
            if (String.IsNullOrEmpty(packageIds) || String.IsNullOrEmpty(versions))
            {
                return(Enumerable.Empty <ODataPackage>().AsQueryable());
            }

            var idValues              = packageIds.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var versionValues         = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks) ? null :
                                        targetFrameworks.Split('|').Select(VersionUtility.ParseFrameworkName).ToList();
            var versionConstraintValues = String.IsNullOrEmpty(versionConstraints)
                                            ? new string[idValues.Length]
                                            : versionConstraints.Split('|');

            if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length)
            {
                // Exit early if the request looks invalid
                return(Enumerable.Empty <ODataPackage>().AsQueryable());
            }

            var packagesToUpdate = new List <IPackageMetadata>();

            for (var i = 0; i < idValues.Length; i++)
            {
                packagesToUpdate.Add(new PackageBuilder {
                    Id = idValues[i], Version = new SemanticVersion(versionValues[i])
                });
            }

            var versionConstraintsList = new IVersionSpec[versionConstraintValues.Length];

            for (var i = 0; i < versionConstraintsList.Length; i++)
            {
                if (!String.IsNullOrEmpty(versionConstraintValues[i]))
                {
                    VersionUtility.TryParseVersionSpec(versionConstraintValues[i], out versionConstraintsList[i]);
                }
            }

            var clientCompatibility = ClientCompatibilityFactory.FromProperties(semVerLevel);

            return(Repository
                   .GetUpdatesCore(
                       packagesToUpdate,
                       includePrerelease,
                       includeAllVersions,
                       targetFrameworkValues,
                       versionConstraintsList,
                       clientCompatibility)
                   .Select(package => package.AsODataPackage(clientCompatibility))
                   .AsQueryable()
                   .InterceptWith(new NormalizeVersionInterceptor()));
        }
Example #37
0
 public static IRemoteNuget LatestNuget(this IEnumerable<IPackage> candidates, IVersionSpec spec = null)
 {
     var candidate = candidates.Latest(spec);
     return candidate == null ? null : new RemoteNuget(candidate);
 }
Example #38
0
        public void PopulateDependencies(PackageBuilder packageBuilder)
        {
            var dependencies = new List <PackageDependency>();
            var project      = _libraryManager.GetLibraryDescription(_project.Name);

            foreach (var dependency in project.Dependencies)
            {
                if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency))
                {
                    continue;
                }

                var dependencyDescription = _libraryManager.GetLibraryDescription(dependency.Name);

                // REVIEW: Can we get this far with unresolved dependencies
                if (dependencyDescription == null || !dependencyDescription.Resolved)
                {
                    continue;
                }

                if (dependencyDescription.Type == LibraryTypes.Project &&
                    ((ProjectDescription)dependencyDescription).Project.EmbedInteropTypes)
                {
                    continue;
                }

                if (dependency.LibraryRange.IsGacOrFrameworkReference)
                {
                    packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.LibraryRange.GetReferenceAssemblyName(), new[] { _targetFramework }));
                }
                else
                {
                    IVersionSpec dependencyVersion = null;

                    if (dependency.LibraryRange.VersionRange == null ||
                        dependency.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None)
                    {
                        dependencyVersion = new VersionSpec
                        {
                            IsMinInclusive = true,
                            MinVersion     = dependencyDescription.Identity.Version
                        };
                    }
                    else
                    {
                        var versionRange = dependency.LibraryRange.VersionRange;

                        dependencyVersion = new VersionSpec
                        {
                            IsMinInclusive = true,
                            MinVersion     = versionRange.MinVersion,
                            MaxVersion     = versionRange.MaxVersion,
                            IsMaxInclusive = versionRange.IsMaxInclusive
                        };
                    }

                    dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion));
                }
            }

            packageBuilder.DependencySets.Add(new PackageDependencySet(_targetFramework, dependencies));
        }
Example #39
0
 public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec, bool allowPrereleaseVersions, bool allowUnlisted) =>
 repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted).FirstOrDefault <IPackage>();
        /// <summary>
        /// Copyright 2010 Outercurve Foundation 
        /// Licensed under the Apache License, Version 2.0 (the "License"); 
        /// you may not use this file except in compliance with the License. 
        /// You may obtain a copy of the License at 
        ///  http://www.apache.org/licenses/LICENSE-2.0 
        /// Unless required by applicable law or agreed to in writing, software 
        /// distributed under the License is distributed on an "AS IS" BASIS, 
        /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
        /// See the License for the specific language governing permissions and 
        /// limitations under the License.
        /// </summary>
        /// <param name="value"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public static bool TryParseVersionSpec(string value, out IVersionSpec result)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            var versionSpec = new VersionSpec();
            value = value.Trim();

            // First, try to parse it as a plain version string
            Version version;
            if (Version.TryParse(value, out version))
            {
                // A plain version is treated as an inclusive minimum range
                result = new VersionSpec
                {
                    MinVersion = version,
                    IsMinInclusive = true
                };

                return true;
            }

            // It's not a plain version, so it must be using the bracket arithmetic range syntax

            result = null;

            // Fail early if the string is too short to be valid
            if (value.Length < 3)
            {
                return false;
            }

            // The first character must be [ ot (
            switch (value.First())
            {
                case '[':
                    versionSpec.IsMinInclusive = true;
                    break;
                case '(':
                    versionSpec.IsMinInclusive = false;
                    break;
                default:
                    return false;
            }

            // The last character must be ] ot )
            switch (value.Last())
            {
                case ']':
                    versionSpec.IsMaxInclusive = true;
                    break;
                case ')':
                    versionSpec.IsMaxInclusive = false;
                    break;
                default:
                    return false;
            }

            // Get rid of the two brackets
            value = value.Substring(1, value.Length - 2);

            // Split by comma, and make sure we don't get more than two pieces
            string[] parts = value.Split(',');
            if (parts.Length > 2)
            {
                return false;
            }

            // If there is only one piece, we use it for both min and max
            string minVersionString = parts[0];
            string maxVersionString = (parts.Length == 2) ? parts[1] : parts[0];

            // Only parse the min version if it's non-empty
            if (!String.IsNullOrWhiteSpace(minVersionString))
            {
                if (!Version.TryParse(minVersionString, out version))
                {
                    return false;
                }
                versionSpec.MinVersion = version;
            }

            // Same deal for max
            if (!String.IsNullOrWhiteSpace(maxVersionString))
            {
                if (!Version.TryParse(maxVersionString, out version))
                {
                    return false;
                }
                versionSpec.MaxVersion = version;
            }

            // Successful parse!
            result = versionSpec;
            return true;
        }
        public static IPackage FindPackage(this IPackageRepository repository, string packageId, IVersionSpec versionSpec,
                                           IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool allowUnlisted)
        {
            var packages = repository.FindPackages(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted);

            if (constraintProvider != null)
            {
                packages = FilterPackagesByConstraints(constraintProvider, packages, packageId, allowPrereleaseVersions);
            }

            return(packages.FirstOrDefault());
        }
Example #42
0
        IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IQueryable<IPackage> packageList)
        {
            // Apply a VersionSpec to a specific Version (this code is nicked
            // from NuGet)
            return packageList.Where(x => x.Id == id).ToArray().FirstOrDefault(x => {
                if (((versionSpec != null) && (versionSpec.MinVersion != null)) && (versionSpec.MaxVersion != null)) {
                    if ((!versionSpec.IsMaxInclusive || !versionSpec.IsMinInclusive) && (versionSpec.MaxVersion == versionSpec.MinVersion)) {
                        return false;
                    }

                    if (versionSpec.MaxVersion < versionSpec.MinVersion) {
                        return false;
                    }
                }

                return true;
            });
        }
Example #43
0
 public void UpdatePackage(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 {
     UpdatePackage(packageId, () => SourceRepository.FindPackage(packageId, versionSpec, allowPrereleaseVersions, allowUnlisted: false),
                   updateDependencies, allowPrereleaseVersions);
 }
Example #44
0
 public NuspecDependency(string name, IVersionSpec spec)
 {
     Name        = name;
     VersionSpec = spec;
 }
		public void UpdatePackageReference (string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
		{
			throw new NotImplementedException ();
		}
Example #46
0
 private static bool SpecifiedMinVersion(IVersionSpec requestVersionsRange)
 {
     return(requestVersionsRange.MinVersion != null && !requestVersionsRange.MinVersion.Equals(new SemanticVersion("0.0")));
 }
Example #47
0
 IPackage matchPackage(IPackageRepository packageRepository, string id, IVersionSpec version)
 {
     return(packageRepository.FindPackagesById(id).FirstOrDefault(x => VersionComparer.Matches(version, x.Version)));
 }
Example #48
0
        public void PopulateDependencies(PackageBuilder packageBuilder)
        {
            var dependencies           = new List <PackageDependency>();
            var projectReferenceByName = _applicationHostContext.ProjectDepencyProvider
                                         .Dependencies
                                         .ToDictionary(r => r.Identity.Name);

            LibraryDescription description;

            if (!projectReferenceByName.TryGetValue(_project.Name, out description))
            {
                return;
            }

            foreach (var dependency in description.Dependencies)
            {
                if (!dependency.HasFlag(LibraryDependencyTypeFlag.BecomesNupkgDependency))
                {
                    continue;
                }

                Runtime.Project dependencyProject;
                if (projectReferenceByName.ContainsKey(dependency.Name) &&
                    _applicationHostContext.ProjectResolver.TryResolveProject(dependency.Name, out dependencyProject) &&
                    dependencyProject.EmbedInteropTypes)
                {
                    continue;
                }

                if (dependency.LibraryRange.IsGacOrFrameworkReference)
                {
                    packageBuilder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new[] { _targetFramework }));
                }
                else
                {
                    IVersionSpec dependencyVersion = null;

                    if (dependency.LibraryRange.VersionRange == null ||
                        dependency.LibraryRange.VersionRange.VersionFloatBehavior != SemanticVersionFloatBehavior.None)
                    {
                        var actual = _applicationHostContext.DependencyWalker.Libraries
                                     .Where(pkg => string.Equals(pkg.Identity.Name, _project.Name, StringComparison.OrdinalIgnoreCase))
                                     .SelectMany(pkg => pkg.Dependencies)
                                     .SingleOrDefault(dep => string.Equals(dep.Name, dependency.Name, StringComparison.OrdinalIgnoreCase));


                        if (actual != null)
                        {
                            dependencyVersion = new VersionSpec
                            {
                                IsMinInclusive = true,
                                MinVersion     = actual.Library.Version
                            };
                        }
                    }
                    else
                    {
                        var versionRange = dependency.LibraryRange.VersionRange;

                        dependencyVersion = new VersionSpec
                        {
                            IsMinInclusive = true,
                            MinVersion     = versionRange.MinVersion,
                            MaxVersion     = versionRange.MaxVersion,
                            IsMaxInclusive = versionRange.IsMaxInclusive
                        };
                    }

                    dependencies.Add(new PackageDependency(dependency.Name, dependencyVersion));
                }
            }

            if (dependencies.Count > 0)
            {
                packageBuilder.DependencySets.Add(new PackageDependencySet(_targetFramework, dependencies));
            }
        }
 public void UpdatePackageReference(string packageId, IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 {
     throw new NotImplementedException();
 }
Example #50
0
        public static IEnumerable<IPackage> FindByVersion(this IEnumerable<IPackage> source, IVersionSpec versionSpec)
        {
            if (versionSpec == null)
            {
                throw new ArgumentNullException("versionSpec");
            }

            return source.Where(versionSpec.ToDelegate());
        }
Example #51
0
 static IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IEnumerable<IPackage> packageList)
 {
     return packageList.Where(x => x.Id == id).ToArray()
         .FirstOrDefault(x => VersionComparer.Matches(versionSpec, x.Version));
 }
Example #52
0
        private void ProcessDependencies(PackageBuilder builder)
        {
            string packagesConfig = GetPackagesConfig();

            // No packages config then bail out
            if (String.IsNullOrEmpty(packagesConfig))
            {
                return;
            }

            Logger.Log(MessageLevel.Info, NuGetResources.UsingPackagesConfigForDependencies);

            var file = new PackageReferenceFile(packagesConfig);

            // Get the solution repository
            IPackageRepository repository = GetPackagesRepository();

            // Collect all packages
            var packages = new List <IPackage>();

            IDictionary <Tuple <string, SemanticVersion>, PackageReference> packageReferences = file.GetPackageReferences()
                                                                                                .ToDictionary(r => Tuple.Create(r.Id, r.Version));

            foreach (PackageReference reference in packageReferences.Values)
            {
                if (repository != null)
                {
                    IPackage package = repository.FindPackage(reference.Id, reference.Version);
                    if (package != null)
                    {
                        packages.Add(package);
                    }
                }
            }

            // Add the transform file to the package builder
            ProcessTransformFiles(builder, packages.SelectMany(GetTransformFiles));

            var dependencies = builder.GetCompatiblePackageDependencies(targetFramework: null)
                               .ToDictionary(d => d.Id, StringComparer.OrdinalIgnoreCase);

            // Reduce the set of packages we want to include as dependencies to the minimal set.
            // Normally, packages.config has the full closure included, we only add top level
            // packages, i.e. packages with in-degree 0
            foreach (var package in GetMinimumSet(packages))
            {
                // Don't add duplicate dependencies
                if (dependencies.ContainsKey(package.Id))
                {
                    continue;
                }

                IVersionSpec spec       = GetVersionConstraint(packageReferences, package);
                var          dependency = new PackageDependency(package.Id, spec);
                dependencies[dependency.Id] = dependency;
            }

            // TO FIX: when we persist the target framework into packages.config file,
            // we need to pull that info into building the PackageDependencySet object
            builder.DependencySets.Clear();
            builder.DependencySets.Add(new PackageDependencySet(null, dependencies.Values));
        }
Example #53
0
        public static bool TryParseVersionSpec(string value, out IVersionSpec result)
        {
            SemanticVersion version;

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }
            VersionSpec spec = new VersionSpec();

            value = value.Trim();
            if (SemanticVersion.TryParse(value, out version))
            {
                VersionSpec spec1 = new VersionSpec();
                spec1.MinVersion     = version;
                spec1.IsMinInclusive = true;
                result = spec1;
                return(true);
            }
            result = null;
            if (value.Length < 3)
            {
                return(false);
            }
            char ch = value.First <char>();

            if (ch == '(')
            {
                spec.IsMinInclusive = false;
            }
            else
            {
                if (ch != '[')
                {
                    return(false);
                }
                spec.IsMinInclusive = true;
            }
            ch = value.Last <char>();
            if (ch == ')')
            {
                spec.IsMaxInclusive = false;
            }
            else
            {
                if (ch != ']')
                {
                    return(false);
                }
                spec.IsMaxInclusive = true;
            }
            value = value.Substring(1, value.Length - 2);
            char[]   separator = new char[] { ',' };
            string[] strArray  = value.Split(separator);
            if (strArray.Length > 2)
            {
                return(false);
            }
            if (Enumerable.All <string>(strArray, new Func <string, bool>(string.IsNullOrEmpty)))
            {
                return(false);
            }
            string str  = strArray[0];
            string str2 = (strArray.Length == 2) ? strArray[1] : strArray[0];

            if (!string.IsNullOrWhiteSpace(str))
            {
                if (!TryParseVersion(str, out version))
                {
                    return(false);
                }
                spec.MinVersion = version;
            }
            if (!string.IsNullOrWhiteSpace(str2))
            {
                if (!TryParseVersion(str2, out version))
                {
                    return(false);
                }
                spec.MaxVersion = version;
            }
            result = spec;
            return(true);
        }
Example #54
0
        public static IRemoteNuget LatestNuget(this IEnumerable <IPackage> candidates, IVersionSpec spec = null)
        {
            var candidate = candidates.Latest(spec);

            return(candidate == null ? null : new RemoteNuget(candidate));
        }
Example #55
0
		public void UpdatePackage (string packageId, IVersionSpec versionSpec, bool updateDependencies)
		{
			throw new NotImplementedException ();
		}
Example #56
0
 static IPackage findPackageFromNameInList(string id, IVersionSpec versionSpec, IEnumerable<IPackage> packageList)
 {
     return packageList.Where(x => String.Equals(x.Id, id, StringComparison.OrdinalIgnoreCase)).ToArray()
         .FirstOrDefault(x => VersionComparer.Matches(versionSpec, x.Version));
 }
Example #57
0
        IPackage findPackageFromName(string id, IVersionSpec versionSpec, string packagesRootDir = null, IQueryable<IPackage> machineCache = null)
        {
            var localPackages = Enumerable.Empty<IPackage>().AsQueryable();
            machineCache = machineCache ?? Enumerable.Empty<IPackage>().AsQueryable();

            if (packagesRootDir != null) {
                localPackages = new DirectoryInfo(packagesRootDir).GetAllFilesRecursively()
                    .Where(x => x.Name.ToLowerInvariant().EndsWith("nupkg"))
                    .Select(x => new ZipPackage(x.FullName))
                    .ToArray().AsQueryable();
            }

            return findPackageFromNameInList(id, versionSpec, localPackages) ?? findPackageFromNameInList(id, versionSpec, machineCache);
        }
Example #58
0
        public async Task <PackageBase> Resolve(ObservableCollection <PackageBase> packages, string packageId, int depth,
                                                CancellationToken token, FrameworkName targetFramework = null, IVersionSpec versionSpec = null)
        {
            var result = await DoResolve(packages, packageId, depth, token, targetFramework, versionSpec);

            TryToFixMissingPackages(packages, depth + 1);

            return(result);
        }
Example #59
0
 private void AssertSafeVersion(IVersionSpec versionSpec, SemanticVersion minVer, SemanticVersion maxVer)
 {
     Assert.True(versionSpec.IsMinInclusive);
     Assert.False(versionSpec.IsMaxInclusive);
     Assert.Equal(versionSpec.MinVersion, minVer);
     Assert.Equal(versionSpec.MaxVersion, maxVer);
 }
Example #60
0
 protected abstract Task <PackageBase> DoResolve(ObservableCollection <PackageBase> packages, string packageId, int depth, CancellationToken token, FrameworkName targetFramework, IVersionSpec versionSpec);