Module: Versionomy

Defined in:
lib/versionomy/interface.rb,
lib/versionomy/value.rb,
lib/versionomy/format.rb,
lib/versionomy/schema.rb,
lib/versionomy/errors.rb,
lib/versionomy/version.rb,
lib/versionomy/conversion.rb,
lib/versionomy/format/base.rb,
lib/versionomy/schema/field.rb,
lib/versionomy/schema/wrapper.rb,
lib/versionomy/conversion/base.rb,
lib/versionomy/format/delimiter.rb,
lib/versionomy/conversion/parsing.rb,
lib/versionomy/format_definitions/semver.rb,
lib/versionomy/format_definitions/standard.rb,
lib/versionomy/format_definitions/rubygems.rb

Overview

Versionomy

The Versionomy module contains some convenience methods for creating and parsing version numbers.

Defined Under Namespace

Modules: Conversion, Errors, Format, Schema Classes: Value

Constant Summary

Formats =

Versionomy::Formats is an alias for Versionomy::Format, for backward compatibility with version 0.1.0 code. It is deprecated; use Versionomy::Format instead.

Format
VERSION_STRING =

Current gem version, as a frozen string.

::File.read(::File.dirname(__FILE__)+'/../../Version').strip.freeze
VERSION =

Current gem version, as a Versionomy::Value.

::Versionomy.parse(VERSION_STRING, :standard)

Class Method Summary collapse

Class Method Details

.create(values_ = nil, format_ = nil, unparse_params_ = nil) ⇒ Object

Create a new version number given a hash or array of values, and an optional format.

The values should either be a hash of field names and values, or an array of values that will be interpreted in field order.

The format can be specified as a format object or the name of a format registered with Versionomy::Format. If the format is omitted or set to nil, the default_format will be used.

You can also optionally provide default parameters to be used when unparsing this value or any derived from it.

Raises Versionomy::Errors::UnknownFormatError if a name is given that is not registered.



93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/versionomy/interface.rb', line 93

def create(values_=nil, format_=nil, unparse_params_=nil)
  if format_.kind_of?(::Hash) && unparse_params_.nil?
    unparse_params_ = format_
    format_ = nil
  end
  if format_.kind_of?(::String) || format_.kind_of?(::Symbol)
    format_ = Format.get(format_, true)
  end
  format_ ||= default_format
  Value.new(values_ || [], format_, unparse_params_)
end

.default_format ⇒ Object

Gets the current default format. Usually this is the “standard” format returned by Versionomy::Format.standard.



53
54
55
 
# File 'lib/versionomy/interface.rb', line 53

def default_format
  @default_format ||= Format.standard
end

.default_format=(format_) ⇒ Object

Sets the default format used by other methods of this convenience interface. Usually, this is set to the “standard” format returned by Versionomy::Format.standard and should not be changed.

The format can be specified as a format object or the name of a format registered with Versionomy::Format. If the format is set to nil, the default_format will be reset to the “standard” format.

Raises Versionomy::Errors::UnknownFormatError if a name is given that is not registered.



69
70
71
72
73
74
 
# File 'lib/versionomy/interface.rb', line 69

def default_format=(format_)
  if format_.kind_of?(::String) || format_.kind_of?(::Symbol)
    format_ = Format.get(format_, true)
  end
  @default_format = format_
end

.parse(str_, format_ = nil, parse_params_ = nil) ⇒ Object

Create a new version number given a string to parse, and an optional format.

The format can be specified as a format object or the name of a format registered with Versionomy::Format. If the format is omitted or set to nil, the default_format will be used.

The parameter hash, if present, will be passed as parsing parameters to the format.

Raises Versionomy::Errors::UnknownFormatError if a name is given that is not registered.

May raise Versionomy::Errors::ParseError if parsing failed.



121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/versionomy/interface.rb', line 121

def parse(str_, format_=nil, parse_params_=nil)
  if format_.kind_of?(::Hash) && parse_params_.nil?
    parse_params_ = format_
    format_ = nil
  end
  if format_.kind_of?(::String) || format_.kind_of?(::Symbol)
    format_ = Format.get(format_, true)
  end
  format_ ||= default_format
  format_.parse(str_, parse_params_)
end

.ruby_version ⇒ Object

Get the ruby version as a Versionomy::Value, using the builtin constants RUBY_VERSION and RUBY_PATCHLEVEL.



205
206
207
208
209
210
211
212
213
214
 
# File 'lib/versionomy/interface.rb', line 205

def ruby_version
  @ruby_version ||= begin
    version_ = parse(::RUBY_VERSION, :standard)
    if version_.release_type == :final
      version_ = version_.change({:patchlevel => ::RUBY_PATCHLEVEL},
        :patchlevel_required => true, :patchlevel_delim => '-p')
    end
    version_
  end
end

.semver(input_) ⇒ Object

Convenience method for creating a version number using the Semantic Versioning format (see semver.org/).

You may pass a string to parse, or a hash with the following keys, all of which are optional:

:major

Major version number

:minor

Minor version number

:patch

Patch version number

:prerelease_suffix

A prerelease suffix (e.g. “b2”)

May raise Versionomy::Errors::ParseError if parsing failed.



150
151
152
153
154
155
156
 
# File 'lib/versionomy/interface.rb', line 150

def semver(input_)
  if input_.kind_of?(::Hash)
    create(input_, :semver)
  else
    parse(input_.to_s, :semver)
  end
end

.version_of(mod_) ⇒ Object

Get the version of the given module as a Versionomy::Value. Tries a number of common approaches to embedding version numbers into modules, such as string or array constants, submodules containing constants, or module method calls. Returns the version number, or nil if it wasn't found or couldn't be interpreted.



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/versionomy/interface.rb', line 166

def version_of(mod_)
  version_ = nil
  [:VERSION, :VERSION_STRING, :GemVersion].each do |sym_|
    if mod_.const_defined?(sym_)
      version_ = mod_.const_get(sym_)
      break
    end
  end
  if version_.kind_of?(::Module)
    if version_.const_defined?(:STRING)
      version_ = version_.const_get(:STRING)
    elsif version_.const_defined?(:VERSION)
      version_ = version_.const_get(:VERSION)
    elsif version_.const_defined?(:MAJOR) && version_.const_defined?(:MINOR) && version_.const_defined?(:TINY)
      version_ = Value.new([version_.const_get(:MAJOR), version_.const_get(:MINOR), version_.const_get(:TINY)], :standard)
    end
  end
  unless version_.kind_of?(::String) || version_.kind_of?(::Array) || version_.kind_of?(Value)
    [:version, :release].each do |sym_|
      if mod_.respond_to?(sym_)
        version_ = mod_.send(sym_)
        break
      end
    end
  end
  if version_.kind_of?(::String)
    version_ = parse(version_, :standard) rescue nil
  elsif version_.kind_of?(::Array)
    version_ = create(version_, :standard) rescue nil
  elsif !version_.kind_of?(Value)
    version_ = nil
  end
  version_
end