semantic_version 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f66dedf8397b08654d2916450edd305292885da
+  data.tar.gz: 533285d4dc57aac800fcbd44192c449e3ba300bb
+SHA512:
+  metadata.gz: bc6fb8ebca00aaf4e9668d9d2f31278a946e41ebe86d82261a1578977514931b2f6994e9084b94a36a36f19de0d05c14eef7fe09126b017f450dd31c5b885736
+  data.tar.gz: 9b6c19356538f190ff03ede3466aa311c039af9d52a03c07d0ee641cd98db03cd4f46ffe19a2deff091f06a9ab16627a6b8718db6ebe4c381779bd4710051223

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Jared Wyatt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+semantic_version
+================
+
+A utility for comparing semantic version numbers (see: http://semver.org).
+
+### Usage
+
+Initialize a new SemanticVersion object with `SemanticVersion.new()` or `SemanticVersion[]`.
+
+SemanticVersion objects have an `is` method for comparing against strings or other SemanticVersion objects.
+
+__Available operators for use with the `is` method:__
+
+* `eq` or `equal_to` returns true if versions are equivalent; false otherwise
+* `lt` or `less_than` returns true if SemanticVersion is less than comparison version; false otherwise
+* `lte` or `less_than_or_equal_to` returns true if SemanticVersion is less than or equal to comparison version; false otherwise
+* `gt` or `greater_than` returns true if SemanticVersion is greater than comparison version; false otherwise
+* `gte` or `greater_than_or_equal_to` returns true if SemanticVersion is greater than or equal to comparison version; false otherwise
+* `between` returns true if SemanticVersion falls between two comparison versions; false otherwise
+* `within` returns true if SemanticVersion falls within the range of two comparison versions (inclusive); false otherwise
+* `any_of` returns true if SemanticVersion is equivalent to any of the versions in a list; false otherwise
+
+__Examples:__
+
+```ruby
+version_a = SemanticVersion.new("1.0")
+version_b = SemanticVersion.new("2.0")
+version_a.is less_than: version_b                                  #=> true
+
+SemanticVersion["2.5.0"].is eq: "2.5"                              #=> true
+
+SemanticVersion["2.5.0"].is gt: "2.5.0-beta"                       #=> true
+
+SemanticVersion["3.2.0-beta"].is gt: "3.2.0-alpha", lt: "3.2.0-rc" #=> true
+
+SemanticVersion["5.6.2"].is between: ["5.6.0", "5.6.4"]            #=> true
+
+SemanticVersion["2.2.48"].is any_of: ["2.2.2", "2.2.48", "3.8.0"]  #=> true
+
+SemanticVersion["1.0.0-rc+1234"].is eq: "1.0.0-rc+6789"            #=> true
+```

data/lib/semantic_version.rb

@@ -0,0 +1,177 @@
+class SemanticVersion
+
+  SINGLE_OPERATORS = {
+    eq:  [0],
+    lt:  [-1],
+    lte: [-1, 0],
+    gt:  [1],
+    gte: [1, 0],
+    equal_to:                 [0],
+    less_than:                [-1],
+    less_than_or_equal_to:    [-1, 0],
+    greater_than:             [1],
+    greater_than_or_equal_to: [1, 0]
+  }.freeze
+
+  RANGE_OPERATORS = {
+    between: [],
+    within:  [],
+    any_of:  []
+  }.freeze
+
+  OPERATORS = SINGLE_OPERATORS.merge(RANGE_OPERATORS).freeze
+
+
+  attr_reader :number_components, :prerelease_components, :build_metadata
+
+
+  # Instantiates a new SemanticVersion.
+  #
+  # @param [String] version: A semantic version (see http://semver.org).
+  #
+  def self.[](version)
+    self.new(version)
+  end
+
+
+  # Parses the given value into version components.
+  #
+  # @param [String or SemanticVersion] version: A semantic version (see http://semver.org).
+  #
+  # @return An array [version_number, prerelease, build_metadata], where `version_number` is an array of the
+  #         number components [MAJOR, MINOR, PATCH], `prerelease` is an array of the prerelease components,
+  #         and `build_metadata` is, like, you know, the build metadata.
+  #
+  def self.parse_components(version)
+    return version.components if version.is_a? SemanticVersion
+
+    version_number, extensions = version.to_s.split('-', 2)
+    prerelease, build_metadata = extensions.to_s.split('+', 2)
+
+    version_number = version_number.to_s.split('.').map(&:to_i)
+    prerelease = prerelease.to_s.split('.').map {|c| c == c.to_i.to_s ? c.to_i : c }
+
+    return [version_number, prerelease, build_metadata]
+  end
+
+
+  # Instantiates a new SemanticVersion.
+  #
+  # @param [String] version: A semantic version (see http://semver.org).
+  #
+  def initialize(version)
+    @number_components, @prerelease_components, @build_metadata = self.class.parse_components(version)
+  end
+
+
+  # Compares this SemanticVersion with one or more other version numbers.
+  #
+  # @param [Hash] assertions: A hash where keys are OPERATORS and values are operands in the form of semantic versions.
+  #
+  # @return True if all assertions are true, false otherwise.
+  #
+  def is(comparison)
+    comparison.each_pair do |operator, version|
+      unless OPERATORS.keys.include? operator
+        raise ArgumentError.new("unrecognized operator `#{operator}'")
+      end
+
+      if RANGE_OPERATORS.keys.include? operator
+        unless version.is_a?(Array) && version.length >= 2
+          raise ArgumentError.new("range operand must be an array containing at least two elements")
+        end
+
+        result = if operator == :between
+          is gt: version[0], lt: version[1]
+        elsif operator == :within
+          is gte: version[0], lte: version[1]
+        elsif operator == :any_of
+          version.map {|v| is eq: v }.any?
+        else
+          false
+        end
+
+        return false unless result == true
+
+      else
+        number_components, prerelease_components, _ = self.class.parse_components(version)
+
+        result = 0
+
+        # Compare version number components.
+
+        (0..[@number_components.count, number_components.count].max-1).each do |i|
+          a = @number_components[i]
+          b = number_components[i]
+
+          result = if !a.nil? && b.nil?
+            a == 0 ? 0 : 1
+          elsif a.nil? && !b.nil?
+            b == 0 ? 0 : -1
+          else
+            a <=> b
+          end
+
+          break unless result == 0
+        end
+
+        if result == 0
+          if @prerelease_components.empty? && !prerelease_components.empty?
+            result = 1
+          elsif !@prerelease_components.empty? && prerelease_components.empty?
+            result = -1
+          end
+        end
+
+        # Compare pre-release components.
+
+        if result == 0
+          (0..[@prerelease_components.count, prerelease_components.count].max-1).each do |i|
+            break unless result == 0
+
+            a = @prerelease_components[i]
+            b = prerelease_components[i]
+
+            result = if !a.nil? && b.nil?
+              1
+            elsif a.nil? && !b.nil?
+              -1
+            elsif a.class == b.class
+              a <=> b
+            else
+              a.to_s <=> b.to_s
+            end
+          end
+        end
+
+        return false unless OPERATORS[operator].include? result
+      end
+    end
+
+    return true
+  end
+
+
+  # Returns the string representation of the "MAJOR.MINOR.PATCH" version part.
+  #
+  def number
+    @number_components.join('.')
+  end
+
+
+  # Returns the string representation of the pre-release version part.
+  #
+  def prerelease
+    @prerelease_components.join('.')
+  end
+
+
+  # Returns the string representation of the version.
+  #
+  def to_s
+    number +
+    (@prerelease_components.empty? ? "" : "-#{prerelease}") +
+    (@build_metadata.nil? ? "" : "+#{@build_metadata}")
+  end
+
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: semantic_version
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Jared Wyatt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-02 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: j@wyatt.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/semantic_version.rb
+homepage: http://github.com/wyattisimo/semantic_version
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: 'A utility for comparing semantic version numbers (see: http://semver.org).'
+test_files: []