Class: PGVersion

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/pgversion.rb

Overview

Represents a Postgres release version. Note that breaking changes generally only happen during major or minor version changes. Point releases are strictly focused on fixing data integrity or security issues.

Constant Summary collapse

VERSION = 
"0.0.5"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(major, minor, point = nil, host: nil, compiler: nil, bit_depth: nil) ⇒ PGVersion

Initialize a new PGVersion


57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/pgversion.rb', line 57

def initialize(major, minor, point=nil, host: nil, compiler: nil, bit_depth: nil)
  @major = major
  @minor = minor
  if point.is_a?(Integer) || (major >=10 && point.nil?)
    @point = point
    @state = :release
  else
    verstr_states = ALLOWED_STATES.reject { |s| s == :release }.map(&:to_s)
    @state, @revision = point.to_s.match(
                        /(#{verstr_states.join('|')})(\d+)/
                                        ) && $1.to_sym, $2.to_i
    @point = nil
    unless @state && @revision
      raise ArgumentError, "Unknown point release: #{point}"
    end
  end
  @host = host
  @compiler = compiler
  @bit_depth = bit_depth
end

Instance Attribute Details

#bit_depth ⇒ Object (readonly)

Bit depth of the given binary


37
38
39
 
# File 'lib/pgversion.rb', line 37

def bit_depth
  @bit_depth
end

#compiler ⇒ Object (readonly)

The compiler used to build the given binary


35
36
37
 
# File 'lib/pgversion.rb', line 35

def compiler
  @compiler
end

#host ⇒ Object (readonly)

The host architecture of the given binary


33
34
35
 
# File 'lib/pgversion.rb', line 33

def host
  @host
end

#major ⇒ Object (readonly)

The major and minor version taken together determine the stable interface to Postgres. New features may be introduced or breaking changes made when either of these change.


13
14
15
 
# File 'lib/pgversion.rb', line 13

def major
  @major
end

#minor ⇒ Object (readonly)

The major and minor version taken together determine the stable interface to Postgres. New features may be introduced or breaking changes made when either of these change.


18
19
20
 
# File 'lib/pgversion.rb', line 18

def minor
  @minor
end

#point ⇒ Object (readonly)

The point release, for release states. Always nil when state is not :release.


22
23
24
 
# File 'lib/pgversion.rb', line 22

def point
  @point
end

#revision ⇒ Object (readonly)

The revision, for non-release states. A release in a given state may go through several revisions in that state before moving to the next state. Nil when state is :release.


30
31
32
 
# File 'lib/pgversion.rb', line 30

def revision
  @revision
end

Class Method Details

.parse(version_str) ⇒ Object

Parse a Postgres version string, as produced by the function version(), into a PGVersion.

Raises:

  • (ArgumentError) 

41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/pgversion.rb', line 41

def self.parse(version_str)
  result = version_str.match VERSION_REGEXP
  raise ArgumentError, "Could not parse version string: #{version_str}" unless result
  point = result[3]
  if point =~ /\A\d+\Z/
    point = point.to_i
  end
  PGVersion.new(result[1].to_i,
                result[2].to_i,
                point,
                host: result[4],
                compiler: result[5],
                bit_depth: result[6].to_i)
end

Instance Method Details

#<=>(other) ⇒ Object

Compare to another PGVersion.


79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/pgversion.rb', line 79

def <=>(other)
  if self.major < other.major
    -1
  elsif self.major > other.major
    1
  else
    if self.minor < other.minor
      -1
    elsif self.minor > other.minor
      1
    else
      self_state_idx = ALLOWED_STATES.index(self.state)
      other_state_idx = ALLOWED_STATES.index(other.state)
      if self_state_idx < other_state_idx
        -1
      elsif self_state_idx > other_state_idx
        1
      elsif self.state == :release
        self.point <=> other.point
      else
        self.revision <=> other.revision
      end
    end
  end
end

#alpha? ⇒ Boolean

Returns:

  • (Boolean) 

108
 
# File 'lib/pgversion.rb', line 108

def alpha?; @state == :alpha; end

#beta? ⇒ Boolean

Returns:

  • (Boolean) 

107
 
# File 'lib/pgversion.rb', line 107

def beta?; @state == :beta; end

#major_minor ⇒ Object

Return the major and minor components of the version as a String, omitting the point release


112
113
114
115
116
117
118
119
 
# File 'lib/pgversion.rb', line 112

def major_minor
  case major
  when 10
    "#{major}"
  else
    "#{major}.#{minor}"
  end
end

#rc? ⇒ Boolean

Returns:

  • (Boolean) 

106
 
# File 'lib/pgversion.rb', line 106

def rc?; @state == :rc; end

#release? ⇒ Boolean

Returns:

  • (Boolean) 

105
 
# File 'lib/pgversion.rb', line 105

def release?; @state == :release; end

#to_s ⇒ Object 


121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/pgversion.rb', line 121

def to_s
  patch = if release?
            point.nil? ? "" : ".#{point}"
          else
            "#{state}#{revision}"
          end
  v = "PostgreSQL #{major}.#{minor}#{patch}"
  if host
    v << " on #{host}"
  end
  if compiler
    v << ", compiled by #{compiler}"
  end
  if bit_depth
    v << ", #{bit_depth}-bit"
  end
  v
end