Module: Vers::NuGetVersion

Defined in:
lib/vers/nuget_version.rb

Constant Summary collapse

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

Class Method Summary collapse

Class Method Details

.compare(a, b) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/vers/nuget_version.rb', line 9

def compare(a, b)
  return 0 if a == b

  parts_a = parse_nuget(a)
  parts_b = parse_nuget(b)

  4.times do |i|
    cmp = parts_a[:numeric][i] <=> parts_b[:numeric][i]
    return cmp unless cmp == 0
  end

  pre_a = parts_a[:prerelease]
  pre_b = parts_b[:prerelease]

  return 1 if pre_a.empty? && !pre_b.empty?
  return -1 if !pre_a.empty? && pre_b.empty?
  return 0 if pre_a.empty? && pre_b.empty?

  compare_prerelease(pre_a, pre_b)
end

.compare_prerelease(a, b) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/vers/nuget_version.rb', line 53

def compare_prerelease(a, b)
  parts_a = a.downcase.split(".")
  parts_b = b.downcase.split(".")

  max_len = [parts_a.length, parts_b.length].max

  max_len.times do |i|
    part_a = i < parts_a.length ? parts_a[i] : nil
    part_b = i < parts_b.length ? parts_b[i] : nil

    return -1 if part_a.nil?
    return 1 if part_b.nil?

    num_a = part_a.match?(/\A\d+\z/) ? part_a.to_i : nil
    num_b = part_b.match?(/\A\d+\z/) ? part_b.to_i : nil

    if num_a && num_b
      cmp = num_a <=> num_b
      return cmp unless cmp == 0
    else
      cmp = part_a <=> part_b
      return cmp unless cmp == 0
    end
  end

  0
end

.normalize(value) ⇒ Object 



85
86
87
 
# File 'lib/vers/nuget_version.rb', line 85

def normalize(value)
  value.to_s.strip
end

.parse_nuget(s) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/vers/nuget_version.rb', line 30

def parse_nuget(s)
  s = s.dup

  if (idx = s.index("+"))
    s = s[0...idx]
  end

  prerelease = ""
  if (idx = s.index("-"))
    prerelease = s[(idx + 1)..]
    s = s[0...idx]
  end

  numeric = [0, 0, 0, 0]
  parts = s.split(".")
  parts.each_with_index do |part, i|
    break if i >= 4
    numeric[i] = part.to_i
  end

  { numeric: numeric, prerelease: prerelease }
end

.prerelease?(value) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/vers/nuget_version.rb', line 89

def prerelease?(value)
  !parse_nuget(value.to_s.strip)[:prerelease].empty?
end

.valid?(value) ⇒ Boolean

Returns:

  • (Boolean) 


81
82
83
 
# File 'lib/vers/nuget_version.rb', line 81

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