Module: SemanticRange

Defined in:
lib/semantic_range.rb,
lib/semantic_range/range.rb,
lib/semantic_range/version.rb,
lib/semantic_range/comparator.rb,
lib/semantic_range/pre_release.rb

Defined Under Namespace

Classes: Comparator, InvalidComparator, InvalidIncrement, InvalidRange, InvalidVersion, PreRelease, Range, Version

Constant Summary collapse

BUILDIDENTIFIER = 
/[0-9A-Za-z-]+/
BUILD = 
/(?:\+(#{BUILDIDENTIFIER.source}(?:\.#{BUILDIDENTIFIER.source})*))/
NUMERICIDENTIFIER = 
/0|[1-9]\d*/
NUMERICIDENTIFIERLOOSE = 
/[0-9]+/
NONNUMERICIDENTIFIER = 
/\d*[a-zA-Z-][a-zA-Z0-9-]*/
XRANGEIDENTIFIERLOOSE = 
/#{NUMERICIDENTIFIERLOOSE.source}|x|X|\*/
PRERELEASEIDENTIFIERLOOSE = 
/(?:#{NUMERICIDENTIFIERLOOSE.source}|#{NONNUMERICIDENTIFIER.source})/
PRERELEASELOOSE = 
/(?:-?(#{PRERELEASEIDENTIFIERLOOSE.source}(?:\.#{PRERELEASEIDENTIFIERLOOSE.source})*))/
XRANGEPLAINLOOSE = 
/[v=\s]*(#{XRANGEIDENTIFIERLOOSE.source})(?:\.(#{XRANGEIDENTIFIERLOOSE.source})(?:\.(#{XRANGEIDENTIFIERLOOSE.source})(?:#{PRERELEASELOOSE.source})?#{BUILD.source}?)?)?/
HYPHENRANGELOOSE = 
/^\s*(#{XRANGEPLAINLOOSE.source})\s+-\s+(#{XRANGEPLAINLOOSE.source})\s*$/
PRERELEASEIDENTIFIER = 
/(?:#{NUMERICIDENTIFIER.source}|#{NONNUMERICIDENTIFIER.source})/
PRERELEASE = 
/(?:-(#{PRERELEASEIDENTIFIER.source}(?:\.#{PRERELEASEIDENTIFIER.source})*))/
XRANGEIDENTIFIER = 
/#{NUMERICIDENTIFIER.source}|x|X|\*/
XRANGEPLAIN = 
/[v=\s]*(#{XRANGEIDENTIFIER.source})(?:\.(#{XRANGEIDENTIFIER.source})(?:\.(#{XRANGEIDENTIFIER.source})(?:#{PRERELEASE.source})?#{BUILD.source}?)?)?/
HYPHENRANGE = 
/^\s*(#{XRANGEPLAIN.source})\s+-\s+(#{XRANGEPLAIN.source})\s*$/
MAINVERSIONLOOSE = 
/(#{NUMERICIDENTIFIERLOOSE.source})\.(#{NUMERICIDENTIFIERLOOSE.source})\.(#{NUMERICIDENTIFIERLOOSE.source})/
LOOSEPLAIN = 
/[v=\s]*#{MAINVERSIONLOOSE.source}#{PRERELEASELOOSE.source}?#{BUILD.source}?/
GTLT = 
/((?:<|>)?=?)/
COMPARATORTRIM = 
/(\s*)#{GTLT.source}\s*(#{LOOSEPLAIN.source}|#{XRANGEPLAIN.source})/
LONETILDE = 
/(?:~>?)/
TILDETRIM = 
/(\s*)#{LONETILDE.source}\s+/
LONECARET = 
/(?:\^)/
CARETTRIM = 
/(\s*)#{LONECARET.source}\s+/
STAR = 
/(<|>)?=?\s*\*/
CARET = 
/^#{LONECARET.source}#{XRANGEPLAIN.source}$/
CARETLOOSE = 
/^#{LONECARET.source}#{XRANGEPLAINLOOSE.source}$/
MAINVERSION = 
/(#{NUMERICIDENTIFIER.source})\.(#{NUMERICIDENTIFIER.source})\.(#{NUMERICIDENTIFIER.source})/
FULLPLAIN = 
/v?#{MAINVERSION.source}#{PRERELEASE.source}?#{BUILD.source}?/
FULL = 
/^#{FULLPLAIN.source}$/
LOOSE = 
/^#{LOOSEPLAIN.source}$/
TILDE = 
/^#{LONETILDE.source}#{XRANGEPLAIN.source}$/
TILDELOOSE = 
/^#{LONETILDE.source}#{XRANGEPLAINLOOSE.source}$/
XRANGE = 
/^#{GTLT.source}\s*#{XRANGEPLAIN.source}$/
XRANGELOOSE = 
/^#{GTLT.source}\s*#{XRANGEPLAINLOOSE.source}$/
COMPARATOR = 
/^#{GTLT.source}\s*(#{FULLPLAIN.source})$|^$/
COMPARATORLOOSE = 
/^#{GTLT.source}\s*(#{LOOSEPLAIN.source})$|^$/
ANY = 
{}
MAX_LENGTH = 
256
VERSION = 
"3.0.0"

Class Method Summary collapse

Class Method Details

.clean(version, loose: false) ⇒ Object 



229
230
231
232
 
# File 'lib/semantic_range.rb', line 229

def self.clean(version, loose: false)
  s = parse(version.strip.gsub(/^[=v]+/, ''), loose: loose)
  return s ? s.version : nil
end

.cmp(a, op, b, loose: false) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/semantic_range.rb', line 61

def self.cmp(a, op, b, loose: false)
  case op
  when '==='
    a = a.version if !a.is_a?(String)
    b = b.version if !b.is_a?(String)
    a == b
  when '!=='
    a = a.version if !a.is_a?(String)
    b = b.version if !b.is_a?(String)
    a != b
  when '', '=', '=='
    eq?(a, b, loose: loose)
  when '!='
    neq?(a, b, loose: loose)
  when '>'
    gt?(a, b, loose: loose)
  when '>='
    gte?(a, b, loose: loose)
  when '<'
    lt?(a, b, loose: loose)
  when '<='
    lte?(a, b, loose: loose)
  else
    raise 'Invalid operator: ' + op
  end
end

.compare(a, b, loose: false) ⇒ Object 



180
181
182
 
# File 'lib/semantic_range.rb', line 180

def self.compare(a, b, loose: false)
  Version.new(a, loose: loose).compare(b)
end

.compare_loose(a, b) ⇒ Object 



184
185
186
 
# File 'lib/semantic_range.rb', line 184

def self.compare_loose(a, b)
  compare(a, b, loose: true)
end

.diff(a, b) ⇒ Object 



255
256
257
258
259
260
261
262
263
264
 
# File 'lib/semantic_range.rb', line 255

def self.diff(a, b)
  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
  return "#{pre}minor" if a.minor != b.minor
  return "#{pre}patch" if a.patch != b.patch
  return "prerelease"  if pre_diff
end

.eq?(a, b, loose: false) ⇒ Boolean Also known as: eq

Returns:

  • (Boolean) 


208
209
210
 
# File 'lib/semantic_range.rb', line 208

def self.eq?(a, b, loose: false)
  compare(a, b, loose: loose) == 0
end

.filter(versions, range, loose: false, platform: nil) ⇒ Object 



156
157
158
159
160
 
# File 'lib/semantic_range.rb', line 156

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: loose, platform: platform) }
end

.gt?(a, b, loose: false) ⇒ Boolean Also known as: gt

Returns:

  • (Boolean) 


204
205
206
 
# File 'lib/semantic_range.rb', line 204

def self.gt?(a, b, loose: false)
  compare(a, b, loose: loose) > 0
end

.gte?(a, b, loose: false) ⇒ Boolean Also known as: gte

Returns:

  • (Boolean) 


216
217
218
 
# File 'lib/semantic_range.rb', line 216

def self.gte?(a, b, loose: false)
  compare(a, b, loose: loose) >= 0
end

.gtr?(version, range, loose: false, platform: nil) ⇒ Boolean Also known as: gtr

Returns:

  • (Boolean) 


57
58
59
 
# File 'lib/semantic_range.rb', line 57

def self.gtr?(version, range, loose: false, platform: nil)
  outside?(version, range, '>', loose: loose, platform: platform)
end

.increment!(version, release, identifier, loose: false) ⇒ Object 



249
250
251
252
253
 
# File 'lib/semantic_range.rb', line 249

def self.increment!(version, release, identifier, loose: false)
  Version.new(version, loose: loose).increment!(release, identifier).version
rescue InvalidIncrement, InvalidVersion
  nil
end

.lt?(a, b, loose: false) ⇒ Boolean Also known as: lt

Returns:

  • (Boolean) 


200
201
202
 
# File 'lib/semantic_range.rb', line 200

def self.lt?(a, b, loose: false)
  compare(a, b, loose: loose) < 0
end

.lte?(a, b, loose: false) ⇒ Boolean Also known as: lte

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/semantic_range.rb', line 220

def self.lte?(a, b, loose: false)
  compare(a, b, loose: loose) <= 0
end

.ltr?(version, range, loose: false, platform: nil) ⇒ Boolean Also known as: ltr

Returns:

  • (Boolean) 


53
54
55
 
# File 'lib/semantic_range.rb', line 53

def self.ltr?(version, range, loose: false, platform: nil)
  outside?(version, range, '<', loose: loose, platform: platform)
end

.max_satisfying(versions, range, loose: false, platform: nil) ⇒ Object 



162
163
164
165
166
167
168
 
# File 'lib/semantic_range.rb', line 162

def self.max_satisfying(versions, range, loose: false, platform: nil)
  versions.select { |version|
    satisfies?(version, range, loose: loose, platform: platform)
  }.sort { |a, b|
    rcompare(a, b, loose: loose)
  }[0] || nil
end

.neq?(a, b, loose: false) ⇒ Boolean Also known as: neq

Returns:

  • (Boolean) 


212
213
214
 
# File 'lib/semantic_range.rb', line 212

def self.neq?(a, b, loose: false)
  compare(a, b, loose: loose) != 0
end

.outside?(version, range, hilo, loose: false, platform: nil) ⇒ Boolean Also known as: outside

Returns:

  • (Boolean) 


88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/semantic_range.rb', line 88

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: loose, platform: platform)

  case hilo
  when '>'
    comp = '>'
    ecomp = '>='
  when '<'
    comp = '<'
    ecomp = '<='
  end

  range.set.each do |comparators|
    high = nil
    low = nil

    comparators.each do |comparator|
      if comparator.semver == ANY
        comparator = Comparator.new('>=0.0.0', loose)
      end

      high = high || comparator
      low = low || comparator

      case hilo
      when '>'
        if gt?(comparator.semver, high.semver, loose: loose)
          high = comparator
        elsif lt?(comparator.semver, low.semver, loose: loose)
          low = comparator
        end
      when '<'
        if lt?(comparator.semver, high.semver, loose: loose)
          high = comparator
        elsif gt?(comparator.semver, low.semver, loose: loose)
          low = comparator
        end
      end
    end

    return false if (high.operator == comp || high.operator == ecomp)

    case hilo
    when '>'
      if (low.operator.empty? || low.operator == comp) && lte?(version, low.semver, loose: loose)
        return false;
      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: loose)
        return false;
      elsif low.operator == ecomp && gt?(version, low.semver, loose: loose)
        return false;
      end
    end
  end
  true
end

.parse(version, loose: false) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/semantic_range.rb', line 234

def self.parse(version, loose: false)
  return version if version.is_a?(Version)

  return nil unless version.is_a?(String)

  stripped_version = version.strip

  return nil if stripped_version.length > MAX_LENGTH

  rxp = loose ? LOOSE : FULL
  return nil if !rxp.match(stripped_version)

  Version.new(stripped_version, loose: loose)
end

.rcompare(a, b, loose: false) ⇒ Object 



188
189
190
 
# File 'lib/semantic_range.rb', line 188

def self.rcompare(a, b, loose: false)
  compare(b, a, loose: true)
end

.rsort(list, loose: false) ⇒ Object 



196
197
198
 
# File 'lib/semantic_range.rb', line 196

def self.rsort(list, loose: false)
  # TODO
end

.satisfies?(version, range, loose: false, platform: nil) ⇒ Boolean Also known as: satisfies

Returns:

  • (Boolean) 


151
152
153
154
 
# File 'lib/semantic_range.rb', line 151

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

.sort(list, loose: false) ⇒ Object 



192
193
194
 
# File 'lib/semantic_range.rb', line 192

def self.sort(list, loose: false)
  # TODO
end

.to_comparators(range, loose: false, platform: nil) ⇒ Object 



266
267
268
269
270
 
# File 'lib/semantic_range.rb', line 266

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

.valid(version, loose: false) ⇒ Object 



224
225
226
227
 
# File 'lib/semantic_range.rb', line 224

def self.valid(version, loose: false)
  v = parse(version, loose: loose)
  return v ? v.version : nil
end

.valid_range(range, loose: false, platform: nil) ⇒ Object 



170
171
172
173
174
175
176
177
178
 
# File 'lib/semantic_range.rb', line 170

def self.valid_range(range, loose: false, platform: nil)
  begin
    r = Range.new(range, loose: loose, platform: platform).range
    r = '*' if r.nil? || r.empty?
    r
  rescue
    nil
  end
end