Module: VersionUtils

Defined in:
lib/version_parse.rb,
lib/version_utils.rb,
lib/version_format.rb,
lib/version_compare.rb,
lib/version_manipulation.rb

Class Method Summary collapse

Class Method Details

.compare(v1, v2) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/version_compare.rb', line 4

def self.compare(v1, v2)

  v1 = self.parse(v1)
  v2 = self.parse(v2)

  compare_major = self.compare_segment(v1[:major], v2[:major])
  if compare_major != 0
    return compare_major
  end

  compare_minor = self.compare_segment(v1[:minor], v2[:minor])
  if compare_minor != 0
    return compare_minor
  end

  compare_patch = self.compare_segment(v1[:patch], v2[:patch])
  if compare_patch != 0
    return compare_patch
  end

  return self.compare_pre_releae(v1[:pre_release], v2[:pre_release])

end

.compare_pre_releae(pr1, pr2) ⇒ Object 



50
51
52
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
 
# File 'lib/version_compare.rb', line 50

def self.compare_pre_releae(pr1, pr2)

  if pr1 == nil && pr2 == nil
    return 0
  end

  if pr1 == nil && pr2 != nil
    return 1
  end

  if pr1 != nil && pr2 == nil
    return -1
  end

  pr1 = pr1.gsub(".", "")
  pr2 = pr2.gsub(".", "")

  if pr1 == pr2
    return 0
  end

  if pr1 > pr2
    return 1
  end

  if pr1 < pr2
    return -1
  end
end

.compare_segment(s1, s2) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/version_compare.rb', line 28

def self.compare_segment(s1, s2)
  if s1 == nil
    return -1
  end

  if s2 == nil
    return 1
  end

  if s1 == s2
    return 0
  end

  if s1 < s2
    return -1
  end

  if s1 > s2
    return 1
  end
end

.format(parts) ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/version_format.rb', line 2

def self.format(parts)
  version = []
  version = version + [parts[:major]]

  if parts[:minor] != nil
    version = version + [parts[:minor]]
  end

  if parts[:patch] != nil
    version = version + [parts[:patch]]
  end

  version = version.join(".")

  if parts[:pre_release] != nil
    version = version + "-" + parts[:pre_release]
  end

  if parts[:metadata] != nil
    version = version + "+" + parts[:metadata]
  end

  return version.force_encoding("utf-8")
end

.parse(version) ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/version_parse.rb', line 2

def self.parse(version)

  result = {}

  if version.split("+").length > 1
    metadata = version.split("+")[1]
    result[:metadata] = metadata
    version = version.split("+")[0]
  end

  if version.split("-").length > 1
    part_post_segments = version.split("-")[1]
    pre_release = part_post_segments.split("+")[0]
    result[:pre_release] = pre_release
    version = version.split("-")[0]

  end

  segments = version.split(".")

  result[:major] = Integer(segments[0])

  if segments.length > 1
    result[:minor] = Integer(segments[1])
  else
    result[:minor] = nil
  end

  if segments.length > 2
    result[:patch] = Integer(segments[2])
  else
    result[:patch] = nil
  end

  return result
end

.update_metadata(version, update_build_version) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/version_manipulation.rb', line 58

def self.update_metadata(version, update_build_version)
  if update_build_version
    begin
      build_version = Integer(version[:metadata])
      version[:metadata] = (build_version + 1).to_s
    rescue
      version[:metadata] = nil
    end
  else
    version[:metadata] = nil
  end
  return version
end

.update_patch(version) ⇒ Object 



46
47
48
49
50
51
 
# File 'lib/version_manipulation.rb', line 46

def self.update_patch(version)
  if version[:patch] != nil
    version[:patch] = 0
  end
  return version
end

.update_pre_release(version) ⇒ Object 



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

def self.update_pre_release(version)
  version[:pre_release] = nil
  return version
end

.upgrade_major(version, update_build_version: false) ⇒ Object 



2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/version_manipulation.rb', line 2

def self.upgrade_major(
    version,
    update_build_version: false)

  version = self.parse(version)

  version[:major] += 1

  if version[:minor] != nil
    version[:minor] = 0
  end

  version = self.update_patch(version)
  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)

  return self.format(version)
end

.upgrade_minor(version, update_build_version: false) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/version_manipulation.rb', line 21

def self.upgrade_minor(
    version,
    update_build_version: false)
  version = self.parse(version)

  version[:minor] += 1

  version = self.update_patch(version)
  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)
  return self.format(version)
end

.upgrade_patch(version, update_build_version: false) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/version_manipulation.rb', line 34

def self.upgrade_patch(
    version,
    update_build_version: false)
  version = self.parse(version)

  version[:patch] += 1

  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)
  return self.format(version)
end