class Measured::Unit

Attributes

aliases[R]
conversion_amount[R]
conversion_unit[R]
inverse_conversion_amount[R]
name[R]
names[R]
unit_system[R]

Public Class Methods

new(name, aliases: [], value: nil, unit_system: nil) click to toggle source
# File lib/measured/unit.rb, line 7
def initialize(name, aliases: [], value: nil, unit_system: nil)
  @name = name.to_s.freeze
  @aliases = aliases.map(&:to_s).map(&:freeze).freeze
  @names = ([@name] + @aliases).sort!.freeze
  @conversion_amount, @conversion_unit = parse_value(value) if value
  @inverse_conversion_amount = (1 / conversion_amount if conversion_amount)
  @conversion_string = ("#{conversion_amount} #{conversion_unit}" if conversion_amount || conversion_unit)
  @unit_system = unit_system
end

Public Instance Methods

<=>(other) click to toggle source
# File lib/measured/unit.rb, line 41
def <=>(other)
  if self.class == other.class
    names_comparison = names <=> other.names
    if names_comparison != 0
      names_comparison
    else
      conversion_amount <=> other.conversion_amount
    end
  else
    name <=> other
  end
end
inspect() click to toggle source
# File lib/measured/unit.rb, line 34
def inspect
  pieces = [name]
  pieces << "(#{aliases.join(", ")})" if aliases.any?
  pieces << @conversion_string if @conversion_string
  "#<#{self.class.name}: #{pieces.join(" ")}>".freeze
end
to_s() click to toggle source
# File lib/measured/unit.rb, line 26
def to_s
  if @conversion_string
    "#{name} (#{@conversion_string})".freeze
  else
    name
  end
end
with(name: nil, unit_system: nil, aliases: nil, value: nil) click to toggle source
# File lib/measured/unit.rb, line 17
def with(name: nil, unit_system: nil, aliases: nil, value: nil)
  self.class.new(
    name || self.name,
    aliases: aliases || self.aliases,
    value: value || @conversion_string,
    unit_system: unit_system || self.unit_system
  )
end

Private Instance Methods

parse_value(tokens) click to toggle source
# File lib/measured/unit.rb, line 56
def parse_value(tokens)
  case tokens
  when String
    tokens = Measured::Parser.parse_string(tokens)
  when Array
    raise Measured::UnitError, "Cannot parse [number, unit] formatted tokens from #{tokens}." unless tokens.size == 2
  else
    raise Measured::UnitError, "Unit must be defined as string or array, but received #{tokens}"
  end

  [tokens[0].to_r, tokens[1].freeze]
end