class Version

Encodes version-numbering logic into a convenient class.

Public Class Methods

current(path = nil) click to toggle source

Searches through the parent directories of the calling method and looks for a VERSION or VERSION.yml file to parse out the current version. Pass

Pass a filename to path to override autodetection, or pass a directory name as path to autodetect within a given directory

# File lib/version.rb, line 23
def self.current(path = nil)
  # if path is nil, detect automatically; if path is a directory, detect
  # automatically in the directory; if path is a filename, use it directly
  path = path ? Pathname.new(path) : self.version_file(caller.first)
  path = self.version_file(path) unless path.nil? or path.file?

  return nil unless path

  case path.extname
    when ''      then path.read.strip.to_version
    when '.yml'  then YAML::load(path.read).to_version
  end
end
new(major, minor = 0, revision = nil, *rest) click to toggle source

Creates a new version number, with a major version number, minor revision number, revision number, and optionally more (unnamed) version components.

# File lib/version.rb, line 54
def initialize(major, minor = 0, revision = nil, *rest)
  self.components = [ major, minor, revision, *rest ]
end
version_file(filename) click to toggle source

Attempts to detect the version file for the passed filename. Looks up the directory hierarchy for a file named VERSION or VERSION.yml. Returns a Pathname for the file if found, otherwise nil.

# File lib/version.rb, line 42
def self.version_file(filename)
  Pathname(filename).dirname.expand_path.ascend do |d|
    break d.join('VERSION')     if d.join('VERSION').file?
    break d.join('VERSION.yml') if d.join('VERSION.yml').file?
  end
end

Public Instance Methods

<=>(other) click to toggle source

Compares a Version against any other object that responds to to_version.

# File lib/version.rb, line 159
def <=>(other)
  self.components <=> other.to_version.components
end
[]=(index, value) click to toggle source

Set the component of the Version at index to value. Zeroes out any trailing components.

If index is greater than the length of the version number, pads the version number with zeroes until index.

# File lib/version.rb, line 77
def []=(index, value)
  return self.resize!(index)               if value.nil? || value.to_s.empty?
  return self[self.length + index] = value if index < 0

  length = self.length - index
  zeroes = Array.new length.abs, Version::Component.new('0')
  value  = Version::Component.new(value.to_s)

  if length >= 0
    self.components[index, length] = zeroes
    self.components[index]         = value
  else
    self.components += zeroes
    self.components << value
  end
end
bump(component = -1, pre = false, trim = false) click to toggle source

Bumps the version number.

# File lib/version.rb, line 144
def bump(component = -1, pre = false, trim = false)
  self.dup.bump!(component, pre, trim)
end
bump!(component = -1, pre = false, trim = false) click to toggle source

Bumps the version number and replaces the current object. Pass component to bump a component other than the least-significant part. Set pre to true if you want to bump the component to a prerelease version. Set trim to true if you want the version to be resized to only large enough to contain the component set.

"1.0.4a".bump!                       # => '1.0.4'
"1.0.4a".bump!(:pre)                 # => '1.0.4b'
"1.0.4a".bump!(:minor, false, true)  # => '1.1'
"1.0.4a".bump!(:minor, true, true)   # => '1.1a
"1.0.4a".bump!(:minor, true, false)  # => '1.1.0a'
# File lib/version.rb, line 120
def bump!(component = -1, pre = false, trim = false)
  case component
    when :major    then self.bump!(0,  pre,  trim)
    when :minor    then self.bump!(1,  pre,  trim)
    when :revision then self.bump!(2,  pre,  trim)
    when :pre      then self.bump!(-1, true, trim)
    else
      # resize to match the new length, if applicable
      self.resize!(component + 1) if (trim or component >= self.length)

      # mark all but the changed bit as non-prerelease
      self[0...component].each(&:unprerelease!)

      # I don't even understand this part any more; god help you
      self[component] = self[component].next if     pre and self.prerelease? and component == self.length - 1
      self[component] = self[component].next unless pre and self.prerelease? and component == -1
      self[-1]        = self[-1].next(true)  if pre
      self
  end
end
inspect() click to toggle source

Returns a human-friendly version format.

# File lib/version.rb, line 205
def inspect
  self.to_s.inspect
end
length() click to toggle source

Returns the current length of the version number.

# File lib/version.rb, line 151
def length
  self.components.length
end
prerelease?() click to toggle source
# File lib/version.rb, line 94
def prerelease?
  self.components.any? {|c| c.prerelease? }
end
resize!(length) click to toggle source

Resizes the Version to length, removing any trailing components. Is a no-op if length is greater than its current length.

# File lib/version.rb, line 102
def resize!(length)
  self.components = self.components.take(length)
  self
end
to_a() click to toggle source

Converts the version number into an array of its components.

# File lib/version.rb, line 166
def to_a
  self.components.map {|c| c.to_s }
end
to_hash() click to toggle source

Converts the version number into a hash of its components.

# File lib/version.rb, line 173
def to_hash
  { :major    => self.major,
    :minor    => self.minor,
    :revision => self.revision,
    :rest     => self.length > 3 ? self.to_a.drop(3) : nil }.
    delete_if {|k,v| v.nil? }
end
to_s() click to toggle source

The canonical representation of a version number.

# File lib/version.rb, line 184
def to_s
  self.to_a.join('.')
end
to_version() click to toggle source

Returns self.

# File lib/version.rb, line 191
def to_version
  self
end
to_yaml() click to toggle source

Returns a YAML representation of the version number.

# File lib/version.rb, line 198
def to_yaml
  YAML::dump(self.to_hash)
end

Protected Instance Methods

[](index) click to toggle source

Retrieves the component of the Version at index.

# File lib/version.rb, line 214
def [](index)
  self.components[index] || Component.new('0')
end
components() click to toggle source
# File lib/version.rb, line 218
def components
  @components ||= []
end
components=(components) click to toggle source
# File lib/version.rb, line 222
def components=(components)
  components.each_with_index {|c, i| self[i] = c }
end