Esempio n. 1
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PackageVersionRange" /> class.
 /// </summary>
 /// <param name="minVersion">The minimum version.</param>
 /// <param name="minVersionInclusive">if set to <c>true</c> the minimum version is inclusive</param>
 /// <param name="maxVersion">The maximum version.</param>
 /// <param name="maxVersionInclusive">if set to <c>true</c> the maximum version is inclusive</param>
 public PackageVersionRange(PackageVersion minVersion, bool minVersionInclusive, PackageVersion maxVersion, bool maxVersionInclusive)
 {
     IsMinInclusive = minVersionInclusive;
     IsMaxInclusive = maxVersionInclusive;
     MinVersion     = minVersion;
     MaxVersion     = maxVersion;
 }
Esempio n. 2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PackageVersionRange"/> class with only one possible version.
 /// </summary>
 /// <param name="version">The exact version.</param>
 public PackageVersionRange(PackageVersion version) : this(version, true, version, true)
 {
 }
Esempio n. 3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PackageVersionRange" /> class with just a lower bound
 /// <paramref name="minVersion"/> that can be inclusive or not depending on <paramref name="minVersionInclusive"/>.
 /// </summary>
 /// <param name="minVersion">The minimum version.</param>
 /// <param name="minVersionInclusive">if set to <c>true</c> the minimum version is inclusive</param>
 public PackageVersionRange(PackageVersion minVersion, bool minVersionInclusive)
 {
     IsMinInclusive = minVersionInclusive;
     MinVersion     = minVersion;
 }
Esempio n. 4
0
        /// <summary>
        /// Tries to parse a version dependency.
        /// </summary>
        /// <param name="value">The version dependency as a string.</param>
        /// <param name="result">The parsed result.</param>
        /// <returns><c>true</c> if successfuly parsed, <c>false</c> otherwise.</returns>
        /// <exception cref="System.ArgumentNullException">value</exception>
        public static bool TryParse(string value, out PackageVersionRange result)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }

            var versionSpec = new PackageVersionRange();

            value = value.Trim();

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

            if (PackageVersion.TryParse(value, out version))
            {
                // A plain version is treated as an inclusive minimum range
                result = new PackageVersionRange
                {
                    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 (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 (!PackageVersion.TryParse(minVersionString, out version))
                {
                    return(false);
                }
                versionSpec.MinVersion = version;
            }

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

            // Successful parse!
            result = versionSpec;
            return(true);
        }