nuget_versions 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f98426e0ba617b4850dd393413fc3903512065fd50eda4b4c8f8113f521eaf61
+  data.tar.gz: 34443a387d83d688af43749bee5567daeb66a3f23101fab06661ac2fd3bf1a31
+SHA512:
+  metadata.gz: 34ea17015d284886b274c9d89e56f13019050715dea6500dfeb4cfc414955c75abd66dd57d41913d26874de56876ddd0391ae8ee7a02a5e5a44e16c76f1afc86
+  data.tar.gz: 84146c7f6c2021c59c6b1d4e0aa91a50a66b4632533724a3caa0711f7debbb65cf695efc7259908f5097b2b99fd72bcb5203821aec02a3e9815c85a58699f44c

data/README.md

@@ -0,0 +1,191 @@
+# NuGetVersions
+
+This Gem contains components for parsing & working with version numbers, as NuGet assigns them to packages. The NuGet versioning scheme is a superset of Semantic Versioning (http://semver.org). The components in this library are loosely based on the version number classes in the NuGet client source code.
+
+## Class: `SemanticVersion`
+
+This class is a basic implementation of Semantic Versions with no extensions. This allows version numbers of the form `x.y.z-prerelease+metadata`, where `-prerelease` and `+metadata` are each optional.
+
+### Creating
+
+There are three main ways to create an instance of `SemanticVersion`:
+
+#### Constructor: `SemanticVersion.new`
+
+The `SemanticVersion` constructor has arguments for all 5 parts of the version. The prerelease ("release label") and metadata parts are optional, and default to `nil`.
+
+```
+  version = SemanticVersion.new(1, 2, 3)                    # "1.2.3"
+  version = SemanticVersion.new(1, 2, 3, "alpha")           # "1.2.3-alpha"
+  version = SemanticVersion.new(1, 2, 3, "alpha.4")         # "1.2.3-alpha.4"
+  version = SemanticVersion.new(1, 2, 3, ["alpha", "4"])    # "1.2.3-alpha.4"
+  version = SemanticVersion.new(1, 2, 3, "alpha", "bugfix") # "1.2.3-alpha+bugfix"
+  version = SemanticVersion.new(1, 2, 3, nil, "bugfix")     # "1.2.3+bugfix"
+```
+  
+#### Copy: `SemanticVersion.copy_of`
+
+If you have an existing instance of `SemanticVersion`, you can make another instance with equivalent values by calling the `copy_of` method on the class.
+
+```
+  version = ...
+  
+  version2 = SemanticVersion.copy_of(version)
+```
+
+This can be used to convert a `NuGetVersion` (below) to a `SemanticVersion`, as a `NuGetVersion` is a `kind_of? SemanticVersion`.
+
+#### Parse: `SemanticVersion.parse`, `SemanticVersion.try_parse`
+
+If you have a version number in string form, you can convert it to a `SemanticVersion` object using one of the parse methods on the class. The method `SemanticVersion.parse` raises an exception if the string is not in a valid format, while `SemanticVersion.try_parse` returns `nil`.
+
+```
+  version = SemanticVersion.parse("1.2.3")          # "1.2.3"
+  version = SemanticVersion.parse("1.2.3-alpha.4")  # "1.2.3-alpha.4"
+  version = SemanticVersion.parse("1.2.3+bugfix")   # "1.2.3+bugfix"
+  version = SemanticVersion.parse("1.2.3.4")        # EXCEPTION
+  version = SemanticVersion.try_parse("1.2.3.4")    # nil
+```
+
+### Using
+
+The `SemanticVersion` class exposes its component values as read-only property accessors.
+
+| Property Name    | Description                                                                                                |
+| ---------------- | ---------------------------------------------------------------------------------------------------------- |
+| `major`          | The major part of the version number - `X.y.z`.                                                            |
+| `minor`          | The minor part of the version number - `x.Y.z`.                                                            |
+| `patch`          | The patch part of the version number - `x.y.Z`.                                                            |
+| `release`        | The release label of the version number, as in `alpha.4` for `1.2.3-alpha.4`. Can be `nil`.                |
+| `release_labels` | The release label of the version number as an array of components, as in `[ 'alpha', '4' ]` for `alpha.4`. |
+| `metadata`       | The metadata part of the version number, as in `bugfix` for `1.2.3+bugfix`. Can be `nil`.                  |
+
+An instance of `SemanticVersion` can be converted to its string representation using the standard `to_s` method.
+
+```
+  SemanticVersion.parse("1.2.3-alpha.4+bugfix").to_s # "1.2.3-alpha.4-bugfix"
+```
+
+Instances of `SemanticVersion` are comparable & orderable.
+
+```
+  a = SemanticVersion.parse("1.2.3")
+  b = SemanticVersion.parse("1.2.4")
+  
+  a < b   # true
+  a <= b  # true
+  a > b   # false
+  a >= b  # false
+  a < a   # false
+  a <= a  # false
+  a == a  # true
+  a != a  # false
+  a == b  # false
+  a != b  # true
+  a <=> b # -1
+```
+
+Instances of `SemanticVersion` can also be compared directly with instances of `NuGetVersion`.
+
+## Class: `NuGetVersion`
+
+This class extends `SemanticVersion` to support NuGet's "legacy" 4-part version number scheme. This is essentially the same scheme as Semantic Version, except with four version components instead of three. Thus, version numbers such as `1.2.3.4`, `1.2.3.4-alpha` and `1.2.3.4+bugfix` are permissible, in addition to any version `SemanticVersion` accepts. Note that if the 4th component is `0`, then it is omitted.
+
+```
+  NuGetVersion.parse("1.2.3.0").to_s # "1.2.3"
+```
+
+### Creating
+
+As with `SemanticVersion`, there are three main ways to create an instance of `NuGetVersion`:
+
+#### Constructor: `NuGetVersion.new`
+
+The `NuGetVersion` constructor has arguments for all 6 parts of the version. The prerelease ("release label") and metadata parts are optional, and default to `nil`. The fourth version component is also optional, and defaults to `0`.
+
+```
+  version = NuGetVersion.new(1, 2, 3)                       # "1.2.3"
+  version = NuGetVersion.new(1, 2, 3, 0)                    # "1.2.3"
+  version = NuGetVersion.new(1, 2, 3, 4)                    # "1.2.3.4"
+  version = NuGetVersion.new(1, 2, 3, 0, "alpha")           # "1.2.3-alpha"
+  version = NuGetVersion.new(1, 2, 3, 4, "alpha")           # "1.2.3.4-alpha"
+  version = NuGetVersion.new(1, 2, 3, 4, "alpha.5")         # "1.2.3.4-alpha.5"
+  version = NuGetVersion.new(1, 2, 3, 4, ["alpha", "5"])    # "1.2.3.4-alpha.5"
+  version = NuGetVersion.new(1, 2, 3, 4, "alpha", "bugfix") # "1.2.3.4-alpha+bugfix"
+  version = NuGetVersion.new(1, 2, 3, 4, nil, "bugfix")     # "1.2.3.4+bugfix"
+```
+  
+#### Copy: `NuGetVersion.copy_of`
+
+If you have an existing instance of `NuGetVersion`, you can make another instance with equivalent values by calling the `copy_of` method on the class.
+
+```
+  version = ...
+  
+  version2 = NuGetVersion.copy_of(version)
+```
+
+This can be used to convert a `SemanticVersion` (above) to a `NuGetVersion`. In this case, the `revision` component of the `NuGetVersion` will be `0`.
+
+#### Parse: `NuGetVersion.parse`, `NuGetVersion.try_parse`
+
+If you have a version number in string form, you can convert it to a `NuGetVersion` object using one of the parse methods on the class. The method `NuGetVersion.parse` raises an exception if the string is not in a valid format, while `NuGetVersion.try_parse` returns `nil`.
+
+```
+  version = NuGetVersion.parse("1.2.3")          # "1.2.3"
+  version = NuGetVersion.parse("1.2.3-alpha.4")  # "1.2.3-alpha.4"
+  version = NuGetVersion.parse("1.2.3+bugfix")   # "1.2.3+bugfix"
+  version = NuGetVersion.parse("1.2.3.4")        # "1.2.3.4"
+  version = NuGetVersion.try_parse("1.2.3.4")    # "1.2.3.4"
+  version = NuGetVersion.parse("1.2.3.4.5")      # EXCEPTION
+  version = NuGetVersion.try_parse("1.2.3.4.5")  # nil
+```
+
+### Using
+
+The `NuGetVersion` class exposes its component values as read-only property accessors.
+
+| Property Name    | Description                                                                                                |
+| ---------------- | ---------------------------------------------------------------------------------------------------------- |
+| `major`          | The major part of the version number - `W.x.y.z`.                                                          |
+| `minor`          | The minor part of the version number - `w.X.y.z`.                                                          |
+| `patch`          | The patch part of the version number - `w.x.Y.z`.                                                          |
+| `revision`       | The revision part of the version number - `w.x.y.Z`.                                                       |
+| `release`        | The release label of the version number, as in `alpha.5` for `1.2.3.4-alpha.5`. Can be `nil`.              |
+| `release_labels` | The release label of the version number as an array of components, as in `[ 'alpha', '5' ]` for `alpha.5`. |
+| `metadata`       | The metadata part of the version number, as in `bugfix` for `1.2.3.4+bugfix`. Can be `nil`.                |
+
+An instance of `NuGetVersion` can be converted to its string representation using the standard `to_s` method.
+
+```
+  NuGetVersion.parse("1.2.3-alpha.5+bugfix").to_s # "1.2.3-alpha.5-bugfix"
+  NuGetVersion.parse("1.2.3.0-alpha.5+bugfix").to_s # "1.2.3-alpha.5-bugfix"
+  NuGetVersion.parse("1.2.3.4-alpha.5+bugfix").to_s # "1.2.3.4-alpha.5-bugfix"
+```
+
+Instances of `NuGetVersion` are comparable & orderable.
+
+```
+  a = NuGetVersion.parse("1.2.3.4")
+  b = NuGetVersion.parse("1.2.3.5")
+  
+  a < b   # true
+  a <= b  # true
+  a > b   # false
+  a >= b  # false
+  a < a   # false
+  a <= a  # false
+  a == a  # true
+  a != a  # false
+  a == b  # false
+  a != b  # true
+  a <=> b # -1
+```
+
+Instances of `NuGetVersion` can also be compared directly with instances of `SemanticVersion`.
+
+## Class: `VersionComparer`
+
+This class exists to provide the underlying implementation for the comparison operators on `SemanticVersion` and `NuGetVersion`. All of these operators are driven by a single method `VersionComparer.compare`, which returns the same type of value as the rocket ship operator `<=>`. Logically, its first argument is "subtracted" from its second argument, and if the result is negative, then `compare` returns -1. If the result is positive, `compare` returns +1. If the result is zero (i.e., the arguments have identical values), then `compare` returns 0.
+
+This method can be called directly, and is documented as part of the interface, but in most cases it should be possible to compare instances of `SemanticVersion` and `NuGetVersion` directly, and this usage is preferred.

data/lib/nuget_versions/nuget_version.rb

@@ -0,0 +1,81 @@
+module NuGetVersions
+  class NuGetVersion < SemanticVersion
+    # Creates a NuGetVersion from an existing NuGetVersion
+    # Parameters:
+    # - version: Version to clone.
+    def self.copy_of(version)
+      revision = 0
+      revision = version.revision if version.respond_to? :revision
+
+      return NuGetVersion.new(version.major, version.minor, version.patch, revision, version.release_labels, version.metadata)
+    end
+
+    # Creates a NuGetVersion X.Y.Z, X.Y.Z-alpha, X.Y.Z-alpha+metadata, W.X.Y.Z, W.X.Y.Z-alpha, W.X.Y.Z-alpha+metadata.
+    # Parameters:
+    # - major: W.x.y.z
+    # - minor: w.X.y.z
+    # - patch: w.x.Y.z
+    # - revision: w.x.y.Z
+    # - release_labels: Prerelease label
+    # - metadata: Build metadata
+    def initialize(major, minor, patch, revision = 0, release_labels = nil, metadata = nil)
+      super(major, minor, patch, release_labels, metadata)
+
+      @revision = revision
+    end
+
+    attr_reader :revision
+
+    attr_accessor :original_version
+
+    def to_s
+      return @original_version if !@original_version.nil? && !@original_version.empty?
+
+      version = "#{@major}.#{@minor}.#{@patch}"
+      version += ".#{@revision}" if revision != 0
+      version += "-#{release}" if is_prerelease?
+      version += "+#{metadata}" if has_metadata?
+
+      version
+    end
+
+    def self.parse(value)
+      ver = self.try_parse(value)
+      raise "Invalid NuGet version value" if ver.nil?
+
+      ver
+    end
+
+    def self.try_parse(value)
+      return nil if value.nil?
+
+      value = original_value = value.to_s if !value.is_a? String
+
+      value = value.split("+", 2)
+
+      metadata = (value.length == 2) ? value.last : nil
+
+      value = value.first.split("-", 2)
+
+      release_labels = (value.length == 2) ? value.last : nil
+
+      parts = value.first.split(".")
+
+      return nil if value.length > 4
+
+      begin
+        major = Integer(parts[0])
+        minor = (parts.length >= 2) ? Integer(parts[1]) : 0
+        patch = (parts.length >= 3) ? Integer(parts[2]) : 0
+        revision = (parts.length >= 4) ? Integer(parts[3]) : 0
+      rescue
+        return nil
+      end
+
+      ver = NuGetVersion.new(major, minor, patch, revision, release_labels, metadata)
+      ver.original_version = original_value
+
+      ver
+    end
+  end
+end

data/lib/nuget_versions/semantic_version.rb

@@ -0,0 +1,122 @@
+module NuGetVersions
+  # A strict SemVer implementation
+  # Based on: NuGet.Client/NuGet.Core/NuGet.Versioning/SemanticVersion.cs from the NuGet source code.
+  class SemanticVersion
+    # Creates a SemanticVersion from an existing SemanticVersion
+    # Parameters:
+    # - version: Version to clone.
+    def self.copy_of(version)
+      return SemanticVersion.new(version.major, version.minor, version.patch, version.release_labels, version.metadata)
+    end
+
+    # Creates a SemanticVersion X.Y.Z, X.Y.Z-alpha, X.Y.Z-alpha+metadata.
+    # Parameters:
+    # - major: X.y.z
+    # - minor: x.Y.z
+    # - patch: x.y.Z
+    # - release_labels: Prerelease label
+    # - metadata: Build metadata
+    def initialize(major, minor, patch, release_labels = nil, metadata = nil)
+      @major = major
+      @minor = minor
+      @patch = patch
+
+      if !release_labels.nil?
+        release_labels = release_labels.to_s.split('.') if !release_labels.kind_of? Array
+        @release_labels = release_labels
+      end
+
+      @metadata = metadata
+    end
+
+    attr_reader :major
+    attr_reader :minor
+    attr_reader :patch
+    attr_reader :release_labels
+    attr_reader :metadata
+
+    def release
+      return "" if @release_labels.nil?
+      @release_labels.join('.')
+    end
+
+    def is_prerelease?
+      !@release_labels.nil? && !@release_labels.all?(&:empty?)
+    end
+
+    def has_metadata?
+      !@metadata.nil? && !@metadata.empty?
+    end
+
+    def to_s
+      version = "#{@major}.#{@minor}.#{@patch}"
+      version += "-#{release}" if is_prerelease?
+      version += "+#{metadata}" if has_metadata?
+
+      version
+    end
+
+    def ==(other)
+      VersionComparer.compare(self, other) == 0
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+
+    def <(other)
+      VersionComparer.compare(self, other) == -1
+    end
+
+    def >(other)
+      other < self
+    end
+
+    def <=(other)
+      !(other < self)
+    end
+
+    def >=(other)
+      !(self < other)
+    end
+
+    def <=>(other)
+      VersionComparer.compare(self, other)
+    end
+
+    def self.parse(value)
+      ver = self.try_parse(value)
+      raise "Invalid semantic version value" if ver.nil?
+
+      ver
+    end
+
+    def self.try_parse(value)
+      return nil if value.nil?
+
+      value = value.to_s if !value.is_a? String
+
+      value = value.split("+", 2)
+
+      metadata = (value.length == 2) ? value.last : nil
+
+      value = value.first.split("-", 2)
+
+      release_labels = (value.length == 2) ? value.last : nil
+
+      parts = value.first.split(".")
+
+      return nil if value.length > 3
+
+      begin
+        major = Integer(parts[0])
+        minor = (parts.length >= 2) ? Integer(parts[1]) : 0
+        patch = (parts.length >= 3) ? Integer(parts[2]) : 0
+      rescue
+        return nil
+      end
+
+      return SemanticVersion.new(major, minor, patch, release_labels, metadata)
+    end
+  end
+end

data/lib/nuget_versions/version_comparer.rb

@@ -0,0 +1,48 @@
+module NuGetVersions
+  class VersionComparer
+    class << self
+      def compare(a, b)
+        return 0 if a.equal? b
+        return 1 if b.nil?
+        return -1 if a.nil?
+
+        result = 0
+        return result if (result = a.major <=> b.major) != 0
+        return result if (result = a.minor <=> b.minor) != 0
+        return result if (result = a.patch <=> b.patch) != 0
+
+        if a.kind_of?(NuGetVersion) && b.kind_of?(NuGetVersion)
+          return result if (result = a.revision <=> b.revision) != 0
+        else
+          return +1 if a.kind_of?(NuGetVersion) && (a.revision > 0)
+          return -1 if b.kind_of?(NuGetVersion) && (b.revision > 0)
+        end
+
+        a_labels = a.release_labels
+        b_labels = b.release_labels
+
+        count = [a_labels.length, b_labels.length].min
+
+        for i in 0..(count - 1)
+          return -1 if i >= a_labels.length
+          return +1 if i >= b_labels.length
+
+          a_release = a_labels[i].to_s
+          b_release = b_labels[i].to_s
+
+          a_release_int = Integer(a_labels[i]) rescue nil
+          b_release_int = Integer(b_labels[i]) rescue nil
+
+          return a_release_int <=> b_release_int if !(a_release_int.nil? || b_release_int.nil?)
+
+          return +1 if !a_release_int.nil?
+          return -1 if !b_release_int.nil?
+
+          return result if (result = a_release.casecmp(b_release)) != 0
+        end
+
+        return (a.metadata || "").casecmp(b.metadata || "")
+      end
+    end
+  end
+end

data/lib/nuget_versions.rb

@@ -0,0 +1,3 @@
+require 'nuget_versions/semantic_version.rb'
+require 'nuget_versions/nuget_version.rb'
+require 'nuget_versions/version_comparer.rb'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: nuget_versions
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Jonathan Gilbert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Provides facilities for parsing & working with NuGet Versions, which
+  are a superset of Semantic Versions 2.0.
+email:
+- JonathanG@iQmetrix.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/nuget_versions.rb
+- lib/nuget_versions/nuget_version.rb
+- lib/nuget_versions/semantic_version.rb
+- lib/nuget_versions/version_comparer.rb
+homepage: https://github.com/logiclrd/NuGetVersions
+licenses:
+- LGPL-3.0+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: NuGet Version Library
+test_files: []