semantic_range 2.3.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccde626c1a653687b8994fa8f79db2862c424e785e5f9947081481eadce45a21
-  data.tar.gz: d73b3387a5955017d9133f41a9ab844fb647805d206f1b5221e82ace813c68fb
+  metadata.gz: 67ae11bb60e5aa3341d7d83eae4e7f100262878f2ef6612391b4e18ce3ee5801
+  data.tar.gz: d25d1b605ddf68eed7979808d0ce1bebbaac5e7025e47ac9d81564dbabb21ca6
 SHA512:
-  metadata.gz: df892019675f0bd4c9b0d9e38dbc373201de7b7ee1a5e40f0aa0f6339d7915021476b01569aaa6e2ab4a903fa45c5fc6fa31449877a221be90bf155b6b2e7527
-  data.tar.gz: ca56913a665bc5b9adca0f5497331c11c190149ca1f6349fdc370f4fe4405cced341a19c95b991ded906fc6edd123022dbfd88aabbfef94f2637bde85c49410b
+  metadata.gz: 873719a7f9a4af750cd6deda9a59a7953566d87558f3c7b9825cb3001f188d6453dfca58ce429fb013ffe664ea1806ebefbd081c4c2eadfee734e87dc1d167cf
+  data.tar.gz: dff74a1adac2232a3425e6e6d9b7de0412dadd574a3dee8a114d008b9a003c9070db6a69444142980e16e7c7586f7d50f409769e616b18c298b47fb8ce25877d

data/README.md

@@ -2,6 +2,11 @@
 
 [node-semver](https://github.com/npm/node-semver) written in Ruby for comparison and inclusion of semantic versions and ranges.
 
+**NOTE: current `master` and releases `>= 3` use keyword arguments instead of positional arguments to pass options.
+If you used `SemanticRange.compare(a, b, true)` in SemanticRange 2, in SemanticRange 3 use `SemanticRange.compare(a, b, loose: true)`**
+
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -30,6 +35,14 @@ SemanticRange.gt?('1.2.3', '9.8.7') # false
 SemanticRange.lt?('1.2.3', '9.8.7') # true
 ```
 
+### Options
+All functions support optional keyword arguments that modify default behavior. The options supported are:
+* `loose` Be more forgiving about not-quite-valid semver strings. Any resulting output will always be 100% strict compliant. `false` by default.
+
+Some functions support `platform` option:
+* `platform` Changes behavior for `'Rubygems'` and `'Packagist'`. `nil` by default. See https://github.com/librariesio/semantic_range/issues/59
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -38,7 +51,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/librariesio/semantic_range. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/librariesio/semantic_range. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://www.contributor-covenant.org/) code of conduct.
 
 
 ## License

data/lib/semantic_range.rb

@@ -50,15 +50,15 @@ module SemanticRange
   class InvalidComparator < StandardError; end
   class InvalidRange < StandardError; end
 
-  def self.ltr?(version, range, loose = false, platform = nil)
-    outside?(version, range, '<', loose, platform)
+  def self.ltr?(version, range, loose: false, platform: nil)
+    outside?(version, range, '<', loose: loose, platform: platform)
   end
 
-  def self.gtr?(version, range, loose = false, platform = nil)
-    outside?(version, range, '>', loose, platform)
+  def self.gtr?(version, range, loose: false, platform: nil)
+    outside?(version, range, '>', loose: loose, platform: platform)
   end
 
-  def self.cmp(a, op, b, loose = false)
+  def self.cmp(a, op, b, loose: false)
     case op
     when '==='
       a = a.version if !a.is_a?(String)
@@ -69,27 +69,27 @@ module SemanticRange
       b = b.version if !b.is_a?(String)
       a != b
     when '', '=', '=='
-      eq?(a, b, loose)
+      eq?(a, b, loose: loose)
     when '!='
-      neq?(a, b, loose)
+      neq?(a, b, loose: loose)
     when '>'
-      gt?(a, b, loose)
+      gt?(a, b, loose: loose)
     when '>='
-      gte?(a, b, loose)
+      gte?(a, b, loose: loose)
     when '<'
-      lt?(a, b, loose)
+      lt?(a, b, loose: loose)
     when '<='
-      lte?(a, b, loose)
+      lte?(a, b, loose: loose)
     else
       raise 'Invalid operator: ' + op
     end
   end
 
-  def self.outside?(version, range, hilo, loose = false, platform = nil)
-    version = Version.new(version, loose)
-    range = Range.new(range, loose, platform)
+  def self.outside?(version, range, hilo, loose: false, platform: nil)
+    version = Version.new(version, loose: loose)
+    range = Range.new(range, loose: loose, platform: platform)
 
-    return false if satisfies?(version, range, loose, platform)
+    return false if satisfies?(version, range, loose: loose, platform: platform)
 
     case hilo
     when '>'
@@ -114,15 +114,15 @@ module SemanticRange
 
         case hilo
         when '>'
-          if gt?(comparator.semver, high.semver, loose)
+          if gt?(comparator.semver, high.semver, loose: loose)
             high = comparator
-          elsif lt?(comparator.semver, low.semver, loose)
+          elsif lt?(comparator.semver, low.semver, loose: loose)
             low = comparator
           end
         when '<'
-          if lt?(comparator.semver, high.semver, loose)
+          if lt?(comparator.semver, high.semver, loose: loose)
             high = comparator
-          elsif gt?(comparator.semver, low.semver, loose)
+          elsif gt?(comparator.semver, low.semver, loose: loose)
             low = comparator
           end
         end
@@ -132,15 +132,15 @@ module SemanticRange
 
       case hilo
       when '>'
-        if (low.operator.empty? || low.operator == comp) && lte?(version, low.semver, loose)
+        if (low.operator.empty? || low.operator == comp) && lte?(version, low.semver, loose: loose)
           return false;
-        elsif (low.operator == ecomp && lt?(version, low.semver, loose))
+        elsif (low.operator == ecomp && lt?(version, low.semver, loose: loose))
           return false;
         end
       when '<'
-        if (low.operator.empty? || low.operator == comp) && gte?(version, low.semver, loose)
+        if (low.operator.empty? || low.operator == comp) && gte?(version, low.semver, loose: loose)
           return false;
-        elsif low.operator == ecomp && gt?(version, low.semver, loose)
+        elsif low.operator == ecomp && gt?(version, low.semver, loose: loose)
           return false;
         end
       end
@@ -148,28 +148,28 @@ module SemanticRange
     true
   end
 
-  def self.satisfies?(version, range, loose = false, platform = nil)
-    return false if !valid_range(range, loose, platform)
-    Range.new(range, loose, platform).test(version)
+  def self.satisfies?(version, range, loose: false, platform: nil)
+    return false if !valid_range(range, loose: loose, platform: platform)
+    Range.new(range, loose: loose, platform: platform).test(version)
   end
 
-  def self.filter(versions, range, loose = false, platform = nil)
-    return [] if !valid_range(range, loose, platform)
+  def self.filter(versions, range, loose: false, platform: nil)
+    return [] if !valid_range(range, loose: loose, platform: platform)
 
-    versions.filter { |v| SemanticRange.satisfies?(v, range, loose, platform) }
+    versions.filter { |v| SemanticRange.satisfies?(v, range, loose: loose, platform: platform) }
   end
 
-  def self.max_satisfying(versions, range, loose = false, platform = nil)
+  def self.max_satisfying(versions, range, loose: false, platform: nil)
     versions.select { |version|
-      satisfies?(version, range, loose, platform)
+      satisfies?(version, range, loose: loose, platform: platform)
     }.sort { |a, b|
-      rcompare(a, b, loose)
+      rcompare(a, b, loose: loose)
     }[0] || nil
   end
 
-  def self.valid_range(range, loose = false, platform = nil)
+  def self.valid_range(range, loose: false, platform: nil)
     begin
-      r = Range.new(range, loose, platform).range
+      r = Range.new(range, loose: loose, platform: platform).range
       r = '*' if r.nil? || r.empty?
       r
     rescue
@@ -177,61 +177,61 @@ module SemanticRange
     end
   end
 
-  def self.compare(a, b, loose = false)
-    Version.new(a, loose).compare(b)
+  def self.compare(a, b, loose: false)
+    Version.new(a, loose: loose).compare(b)
   end
 
   def self.compare_loose(a, b)
-    compare(a, b, true)
+    compare(a, b, loose: true)
   end
 
-  def self.rcompare(a, b, loose = false)
-    compare(b, a, true)
+  def self.rcompare(a, b, loose: false)
+    compare(b, a, loose: true)
   end
 
-  def self.sort(list, loose = false)
+  def self.sort(list, loose: false)
     # TODO
   end
 
-  def self.rsort(list, loose = false)
+  def self.rsort(list, loose: false)
     # TODO
   end
 
-  def self.lt?(a, b, loose = false)
-    compare(a, b, loose) < 0
+  def self.lt?(a, b, loose: false)
+    compare(a, b, loose: loose) < 0
   end
 
-  def self.gt?(a, b, loose = false)
-    compare(a, b, loose) > 0
+  def self.gt?(a, b, loose: false)
+    compare(a, b, loose: loose) > 0
   end
 
-  def self.eq?(a, b, loose = false)
-    compare(a, b, loose) == 0
+  def self.eq?(a, b, loose: false)
+    compare(a, b, loose: loose) == 0
   end
 
-  def self.neq?(a, b, loose = false)
-    compare(a, b, loose) != 0
+  def self.neq?(a, b, loose: false)
+    compare(a, b, loose: loose) != 0
   end
 
-  def self.gte?(a, b, loose = false)
-    compare(a, b, loose) >= 0
+  def self.gte?(a, b, loose: false)
+    compare(a, b, loose: loose) >= 0
   end
 
-  def self.lte?(a, b, loose = false)
-    compare(a, b, loose) <= 0
+  def self.lte?(a, b, loose: false)
+    compare(a, b, loose: loose) <= 0
   end
 
-  def self.valid(version, loose = false)
-    v = parse(version, loose)
+  def self.valid(version, loose: false)
+    v = parse(version, loose: loose)
     return v ? v.version : nil
   end
 
-  def self.clean(version, loose = false)
-    s = parse(version.strip.gsub(/^[=v]+/, ''), loose)
+  def self.clean(version, loose: false)
+    s = parse(version.strip.gsub(/^[=v]+/, ''), loose: loose)
     return s ? s.version : nil
   end
 
-  def self.parse(version, loose = false)
+  def self.parse(version, loose: false)
     return version if version.is_a?(Version)
 
     return nil unless version.is_a?(String)
@@ -243,23 +243,18 @@ module SemanticRange
     rxp = loose ? LOOSE : FULL
     return nil if !rxp.match(stripped_version)
 
-    Version.new(stripped_version, loose)
+    Version.new(stripped_version, loose: loose)
   end
 
-  def self.increment!(version, release, loose, identifier)
-    if loose.is_a? String
-      identifier = loose
-      loose = false
-    end
-
-    Version.new(version, loose).increment!(release, identifier).version
+  def self.increment!(version, release, identifier, loose: false)
+    Version.new(version, loose: loose).increment!(release, identifier).version
   rescue InvalidIncrement, InvalidVersion
     nil
   end
 
   def self.diff(a, b)
-    a = Version.new(a, false) unless a.kind_of?(Version)
-    b = Version.new(b, false) unless b.kind_of?(Version)
+    a = Version.new(a, loose: false) unless a.kind_of?(Version)
+    b = Version.new(b, loose: false) unless b.kind_of?(Version)
     pre_diff = a.prerelease.to_s != b.prerelease.to_s
     pre = pre_diff ? 'pre' : ''
     return "#{pre}major" if a.major != b.major
@@ -268,8 +263,8 @@ module SemanticRange
     return "prerelease"  if pre_diff
   end
 
-  def self.to_comparators(range, loose = false, platform = nil)
-    Range.new(range, loose, platform).set.map do |comp|
+  def self.to_comparators(range, loose: false, platform: nil)
+    Range.new(range, loose: loose, platform: platform).set.map do |comp|
       comp.map(&:to_s)
     end
   end

data/lib/semantic_range/comparator.rb

@@ -17,7 +17,7 @@ module SemanticRange
     def test(version)
       return true if @semver == ANY
       version = Version.new(version, @loose) if version.is_a?(String)
-      SemanticRange.cmp(version, @operator, @semver, @loose)
+      SemanticRange.cmp(version, @operator, @semver, loose: @loose)
     end
 
     def parse(comp)
@@ -27,26 +27,26 @@ module SemanticRange
       @operator = m[1]
       @operator = '' if @operator == '='
 
-      @semver = !m[2] ? ANY : Version.new(m[2], @loose)
+      @semver = !m[2] ? ANY : Version.new(m[2], loose: @loose)
     end
 
-    def intersects?(comp, loose = false, platform = nil)
+    def intersects?(comp, loose: false, platform: nil)
       comp = Comparator.new(comp, loose)
 
       if @operator == ''
-        range_b = Range.new(comp.value, loose, platform)
-        SemanticRange.satisfies?(@value, range_b, loose, platform)
+        range_b = Range.new(comp.value, loose: loose, platform: platform)
+        SemanticRange.satisfies?(@value, range_b, loose: loose, platform: platform)
       elsif comp.operator == ''
-        range_a = Range.new(@value, loose, platform)
-        SemanticRange.satisfies?(comp.semver, range_a, loose, platform)
+        range_a = Range.new(@value, loose: loose, platform: platform)
+        SemanticRange.satisfies?(comp.semver, range_a, loose: loose, platform: platform)
       else
         same_direction_increasing      = (@operator == '>=' || @operator == '>') && (comp.operator == '>=' || comp.operator == '>')
         same_direction_decreasing      = (@operator == '<=' || @operator == '<') && (comp.operator == '<=' || comp.operator == '<')
         same_version                   = @semver.raw == comp.semver.raw
         different_directions_inclusive = (@operator == '>=' || @operator == '<=') && (comp.operator == '>=' || comp.operator == '<=')
-        opposite_directions_lte        = SemanticRange.cmp(@semver, '<', comp.semver, loose) &&
+        opposite_directions_lte        = SemanticRange.cmp(@semver, '<', comp.semver, loose: loose) &&
             ((@operator == '>=' || @operator == '>') && (comp.operator == '<=' || comp.operator == '<'))
-        opposite_directions_gte        = SemanticRange.cmp(@semver, '>', comp.semver, loose) &&
+        opposite_directions_gte        = SemanticRange.cmp(@semver, '>', comp.semver, loose: loose) &&
             ((@operator == '<=' || @operator == '<') && (comp.operator == '>=' || comp.operator == '>'))
 
         same_direction_increasing || same_direction_decreasing || (same_version && different_directions_inclusive) ||
@@ -54,12 +54,12 @@ module SemanticRange
       end
     end
 
-    def satisfies_range?(range, loose = false, platform = nil)
-      range = Range.new(range, loose, platform)
+    def satisfies_range?(range, loose: false, platform: nil)
+      range = Range.new(range, loose: loose, platform: platform)
 
       range.set.any? do |comparators|
         comparators.all? do |comparator|
-          intersects?(comparator, loose, platform)
+          intersects?(comparator, loose: loose, platform: platform)
         end
       end
     end

data/lib/semantic_range/range.rb

@@ -2,7 +2,7 @@ module SemanticRange
   class Range
     attr_reader :loose, :raw, :range, :set, :platform
 
-    def initialize(range, loose = false, platform = nil)
+    def initialize(range, loose: false, platform: nil)
       range = range.raw if range.is_a?(Range)
       @platform = platform
       @raw = range
@@ -31,7 +31,7 @@ module SemanticRange
 
     def test(version)
       return false if !version
-      version = Version.new(version, @loose) if version.is_a?(String)
+      version = Version.new(version, loose: @loose) if version.is_a?(String)
       @set.any?{|s| test_set(s, version) }
     end
 
@@ -283,12 +283,12 @@ module SemanticRange
       "#{from} #{to}".strip
     end
 
-    def intersects(range, loose = false, platform = nil)
-      range = Range.new(range, loose, platform)
+    def intersects(range, loose: false, platform: nil)
+      range = Range.new(range, loose: loose, platform: platform)
 
       @set.any? do |comparators|
         comparators.all? do |comparator|
-          comparator.satisfies_range(range, loose, platform)
+          comparator.satisfies_range(range, loose: loose, platform: platform)
         end
       end
     end

data/lib/semantic_range/version.rb

@@ -1,10 +1,10 @@
 module SemanticRange
-  VERSION = "2.3.1"
+  VERSION = "3.0.0"
 
   class Version
     attr_reader :major, :minor, :patch, :prerelease
 
-    def initialize(version, loose = false)
+    def initialize(version, loose: false)
       @raw = version
       @loose = loose
 
@@ -45,13 +45,13 @@ module SemanticRange
     end
 
     def compare(other)
-      other = Version.new(other, @loose) unless other.is_a?(Version)
+      other = Version.new(other, loose: @loose) unless other.is_a?(Version)
       res = truthy(compare_main(other)) || truthy(compare_pre(other))
       res.is_a?(FalseClass) ? 0 : res
     end
 
     def compare_main(other)
-      other = Version.new(other, @loose) unless other.is_a?(Version)
+      other = Version.new(other, loose: @loose) unless other.is_a?(Version)
       truthy(self.class.compare_identifiers(@major, other.major)) ||
       truthy(self.class.compare_identifiers(@minor, other.minor)) ||
       truthy(self.class.compare_identifiers(@patch, other.patch))

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: semantic_range
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Andrew Nesbitt
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.11'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description:
+description: 
 email:
 - andrewnez@gmail.com
 executables: []
@@ -70,7 +42,7 @@ homepage: https://libraries.io/github/librariesio/semantic_range
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -85,8 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: node-semver rewritten in ruby, for comparison and inclusion of semantic versions
   and ranges