Module: Vers::GemVersion

Extended by:
GemVersion
Included in:
GemVersion
Defined in:
lib/vers/gem_version.rb

Defined Under Namespace

Classes: Segment

Constant Summary collapse

PATTERN = 
/\A[0-9]+(?:\.[0-9A-Za-z]+)*(?:-[0-9A-Za-z][0-9A-Za-z.-]*)?\z/

Instance Method Summary collapse

Instance Method Details

#compare(left, right) ⇒ Object 



12
13
14
 
# File 'lib/vers/gem_version.rb', line 12

def compare(left, right)
  compare_segments(parse(left), parse(right))
end

#compare_missing(segments) ⇒ Object 



72
73
74
75
76
77
78
79
 
# File 'lib/vers/gem_version.rb', line 72

def compare_missing(segments)
  segments.each do |segment|
    return 1 unless segment.numeric
    return -1 unless VersionComparison.compare_numbers(segment.value, "0").zero?
  end

  0
end

#compare_segments(left, right) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/vers/gem_version.rb', line 50

def compare_segments(left, right)
  left.zip(right).each do |left_segment, right_segment|
    break unless left_segment && right_segment

    if left_segment.numeric != right_segment.numeric
      return left_segment.numeric ? 1 : -1
    end

    comparison = if left_segment.numeric
                   VersionComparison.compare_numbers(left_segment.value, right_segment.value)
                 else
                   left_segment.value <=> right_segment.value
                 end
    return comparison unless comparison.zero?
  end

  return 0 if left.length == right.length
  return compare_missing(right.drop(left.length)) if left.length < right.length

  -compare_missing(left.drop(right.length))
end

#normalize(value) ⇒ Object 



42
43
44
 
# File 'lib/vers/gem_version.rb', line 42

def normalize(value)
  value.to_s.strip
end

#parse(value) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/vers/gem_version.rb', line 16

def parse(value)
  segments = []

  value.to_s.strip.scan(/-|\d+|[A-Za-z]+/) do |part|
    if part == "-"
      segments << Segment.new("pre", false)
    else
      segments << Segment.new(part, VersionComparison.numeric?(part))
    end
  end

  first_text = segments.index { |segment| !segment.numeric }
  if first_text && first_text.positive?
    start = first_text
    start -= 1 while start.positive? && segments[start - 1].numeric && VersionComparison.compare_numbers(segments[start - 1].value, "0").zero?
    segments.slice!(start...first_text) if start < first_text
  end

  segments.pop while segments.last&.numeric && VersionComparison.compare_numbers(segments.last.value, "0").zero?
  segments
end

#prerelease?(value) ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
 
# File 'lib/vers/gem_version.rb', line 46

def prerelease?(value)
  parse(value).any? { |segment| !segment.numeric }
end

#valid?(value) ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
 
# File 'lib/vers/gem_version.rb', line 38

def valid?(value)
  value.to_s.strip.match?(PATTERN)
end