measured 0.0.1

data/lib/measured/measurable.rb

@@ -0,0 +1,67 @@
+class Measured::Measurable
+  include Comparable
+  include Measured::Arithmetic
+
+  attr_reader :unit, :value
+
+  def initialize(value, unit)
+    raise Measured::UnitError, "Unit #{ unit } does not exits." unless self.class.conversion.unit_or_alias?(unit)
+
+    @value = value
+    @value = BigDecimal(@value) unless @value.is_a?(BigDecimal)
+
+    @unit = self.class.conversion.to_unit_name(unit)
+  end
+
+  def convert_to(new_unit)
+    new_unit_name = self.class.conversion.to_unit_name(new_unit)
+    value = self.class.conversion.convert(@value, from: @unit, to: new_unit_name)
+
+    self.class.new(value, new_unit)
+  end
+
+  def convert_to!(new_unit)
+    converted = convert_to(new_unit)
+
+    @value = converted.value
+    @unit = converted.unit
+
+    self
+  end
+
+  def to_s
+    [value.to_f.to_s.gsub(/\.0\Z/, ""), unit].join(" ")
+  end
+
+  def inspect
+    "#<#{ self.class }: #{ value } #{ unit }>"
+  end
+
+  def <=>(other)
+    if other.is_a?(self.class) && unit == other.unit
+      value <=> other.value
+    end
+  end
+
+  def ==(other)
+    !!(other.is_a?(self.class) && unit == other.unit && value == other.value)
+  end
+
+  alias_method :eql?, :==
+
+  class << self
+
+    def conversion
+      @conversion ||= Measured::Conversion.new
+    end
+
+    def units
+      conversion.unit_names
+    end
+
+    def units_with_aliases
+      conversion.unit_names_with_aliases
+    end
+
+  end
+end

data/lib/measured/unit.rb

@@ -0,0 +1,59 @@
+class Measured::Unit
+  include Comparable
+
+  def initialize(name, aliases: [], value: nil)
+    @name = name.to_s
+    @names = ([@name] + aliases.map{|n| n.to_s }).sort
+
+    @conversion_amount, @conversion_unit = parse_value(value) if value
+  end
+
+  attr_reader :name, :names, :conversion_amount, :conversion_unit
+
+  def to_s
+    if conversion_string
+      "#{ @name } (#{ conversion_string })"
+    else
+      @name
+    end
+  end
+
+  def inspect
+    "#<Measured::Unit: #{ @name } (#{ @names.join(", ") }) #{ conversion_string }>"
+  end
+
+  def <=>(other)
+    if self.class == other.class
+      if other.names != @names
+        other.names <=> @names
+      else
+        other.conversion_amount <=> @conversion_amount
+      end
+    else
+      @name <=> other
+    end
+  end
+
+  def inverse_conversion_amount
+    if conversion_amount.is_a?(Rational)
+      Rational(conversion_amount.denominator, conversion_amount.numerator)
+    else
+      BigDecimal(1) /  conversion_amount
+    end
+  end
+
+  private
+
+  def conversion_string
+    "#{ conversion_amount } #{ conversion_unit }" if @conversion_amount || @conversion_unit
+  end
+
+  def parse_value(tokens)
+    tokens = tokens.split(" ") if tokens.is_a?(String)
+    raise Measured::UnitError, "Cannot parse 'number unit' or [number, unit] formatted tokens from #{ tokens }." unless tokens.size == 2
+
+    tokens[0] = BigDecimal(tokens[0]) unless tokens[0].is_a?(BigDecimal) || tokens[0].is_a?(Rational)
+
+    tokens
+  end
+end

data/lib/measured/units/length.rb

@@ -0,0 +1,26 @@
+class Measured::Length < Measured::Measurable
+
+  conversion.set_base :m,
+    aliases: [:meter, :metre, :meters, :metres]
+
+  conversion.add :cm,
+    aliases: [:centimeter, :centimetre, :centimeters, :centimetres],
+    value: "0.01 m"
+
+  conversion.add :mm,
+    aliases: [:millimeter, :millimetre, :millimeters, :millimetres],
+    value: "0.001 m"
+
+  conversion.add :in,
+    aliases: [:inch, :inches],
+    value: "0.0254 m"
+
+  conversion.add :ft,
+    aliases: [:foot, :feet],
+    value: "0.3048 m"
+
+  conversion.add :yd,
+    aliases: [:yard, :yards],
+    value: "0.9144 m"
+
+end

data/lib/measured/units/weight.rb

@@ -0,0 +1,18 @@
+class Measured::Weight < Measured::Measurable
+
+  conversion.set_base :g,
+    aliases: [:gram, :grams]
+
+  conversion.add :kg,
+    aliases: [:kilogram, :kilograms],
+    value: "1000 g"
+
+  conversion.add :lb,
+    aliases: [:lbs, :pound, :pounds],
+    value: [Rational(45359237,1e8), "kg"]
+
+  conversion.add :oz,
+    aliases: [:ounce, :ounces],
+    value: [Rational(1,16), "lb"]
+
+end

data/lib/measured/version.rb

@@ -0,0 +1,3 @@
+module Measured
+  VERSION = "0.0.1"
+end

data/lib/measured.rb

@@ -0,0 +1,4 @@
+require "measured/base"
+
+require "measured/units/length"
+require "measured/units/weight"

data/measured.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'measured/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "measured"
+  spec.version       = Measured::VERSION
+  spec.authors       = ["Kevin McPhillips"]
+  spec.email         = ["github@kevinmcphillips.ca"]
+  spec.summary       = %q{Encapsulate measurements with their units in Ruby}
+  spec.description   = %q{Wrapper objects which encapsulate measurments and their associated units in Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", ">= 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.5.1"
+  spec.add_development_dependency "mocha", "~> 1.1.0"
+  spec.add_development_dependency "pry"
+end

data/test/arithmetic_test.rb

@@ -0,0 +1,133 @@
+require "test_helper"
+
+class Measured::ArithmeticTest < ActiveSupport::TestCase
+  setup do
+    @two = Magic.new(2, :magic_missile)
+    @three = Magic.new(3, :magic_missile)
+    @four = Magic.new(4, :magic_missile)
+  end
+
+  test "#+ should add together same units" do
+    assert_equal Magic.new(5, :magic_missile), @two + @three
+    assert_equal Magic.new(5, :magic_missile), @three + @two
+  end
+
+  test "#+ should add a number to the value" do
+    assert_equal Magic.new(5, :magic_missile), @two + 3
+    assert_equal Magic.new(5, :magic_missile), 2 + @three
+  end
+
+  test "#+ should raise if different unit system" do
+    assert_raises TypeError do
+      OtherFakeSystem.new(1, :other_fake_base) + @two
+    end
+
+    assert_raises TypeError do
+      @two + OtherFakeSystem.new(1, :other_fake_base)
+    end
+  end
+
+  test "#+ should raise if adding something nonsense" do
+    assert_raises TypeError do
+      @two + "thing"
+    end
+
+    assert_raises TypeError do
+      "thing" + @two
+    end
+  end
+
+  test "#- should subtract same units" do
+    assert_equal Magic.new(-1, :magic_missile), @two - @three
+    assert_equal Magic.new(1, :magic_missile), @three - @two
+  end
+
+  test "#- should subtract a number from the value" do
+    assert_equal Magic.new(-1, :magic_missile), @two - 3
+    assert_equal Magic.new(1, :magic_missile), 2 - @three
+  end
+
+  test "#- should raise if different unit system" do
+    assert_raises TypeError do
+      OtherFakeSystem.new(1, :other_fake_base) - @two
+    end
+
+    assert_raises TypeError do
+      @two - OtherFakeSystem.new(1, :other_fake_base)
+    end
+  end
+
+  test "#- should raise if subtracting something nonsense" do
+    assert_raises TypeError do
+      @two - "thing"
+    end
+
+    assert_raises NoMethodError do
+      "thing" - @two
+    end
+  end
+
+  test "#* should multiply together same units" do
+    assert_equal Magic.new(6, :magic_missile), @two * @three
+    assert_equal Magic.new(6, :magic_missile), @three * @two
+  end
+
+  test "#* should multiply a number to the value" do
+    assert_equal Magic.new(6, :magic_missile), @two * 3
+    assert_equal Magic.new(6, :magic_missile), 2 * @three
+  end
+
+  test "#* should raise if different unit system" do
+    assert_raises TypeError do
+      OtherFakeSystem.new(1, :other_fake_base) * @two
+    end
+
+    assert_raises TypeError do
+      @two * OtherFakeSystem.new(1, :other_fake_base)
+    end
+  end
+
+  test "#* should raise if multiplying something nonsense" do
+    assert_raises TypeError do
+      @two * "thing"
+    end
+
+    assert_raises TypeError do
+      "thing" * @two
+    end
+  end
+
+  test "#/ should divide together same units" do
+    assert_equal Magic.new("0.5", :magic_missile), @two / @four
+    assert_equal Magic.new(2, :magic_missile), @four / @two
+  end
+
+  test "#/ should divide a number to the value" do
+    assert_equal Magic.new("0.5", :magic_missile), @two / 4
+    assert_equal Magic.new(2, :magic_missile), 2 / @four
+  end
+
+  test "#/ should raise if different unit system" do
+    assert_raises TypeError do
+      OtherFakeSystem.new(1, :other_fake_base) / @two
+    end
+
+    assert_raises TypeError do
+      @two / OtherFakeSystem.new(1, :other_fake_base)
+    end
+  end
+
+  test "#/ should raise if dividing something nonsense" do
+    assert_raises TypeError do
+      @two / "thing"
+    end
+
+    assert_raises NoMethodError do
+      "thing" / @two
+    end
+  end
+
+  test "#-@ returns the negative version" do
+    assert_equal Magic.new(-2, :magic_missile), -@two
+  end
+end

data/test/conversion_table_test.rb

@@ -0,0 +1,19 @@
+require "test_helper"
+
+class Measured::ConversionTableTest < ActiveSupport::TestCase
+  setup do
+    @unit = Measured::Unit.new(:test)
+  end
+
+  test "#initialize accepts a list of units and a base unit" do
+    Measured::ConversionTable.new([@unit])
+  end
+
+  test "#to_h should return a hash for the simple case" do
+    expected = {
+      "test" => {"test" => BigDecimal("1")}
+    }
+
+    assert_equal expected, Measured::ConversionTable.new([@unit]).to_h
+  end
+end

data/test/conversion_test.rb

@@ -0,0 +1,206 @@
+require "test_helper"
+
+class Measured::ConversionTest < ActiveSupport::TestCase
+  setup do
+    @conversion = Measured::Conversion.new
+  end
+
+  test "#base sets the base unit" do
+    @conversion.set_base :m, aliases: [:metre]
+    assert_equal ["m", "metre"], @conversion.base_unit.names
+  end
+
+  test "#base doesn't allow a second base to be added" do
+    @conversion.set_base :m, aliases: [:metre]
+
+    assert_raises Measured::UnitError do
+      @conversion.set_base :in
+    end
+  end
+
+  test "#add adds a new unit" do
+    @conversion.set_base :m
+    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
+
+    assert_equal 2, @conversion.units.count
+  end
+
+  test "#add cannot add duplicate unit names" do
+    @conversion.set_base :m
+    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
+
+    assert_raises Measured::UnitError do
+      @conversion.add :in, aliases: [:thing], value: "123 m"
+    end
+
+    assert_raises Measured::UnitError do
+      @conversion.add :inch, value: "123 m"
+    end
+  end
+
+  test "#add does not allow you to add a unit before the base" do
+    assert_raises Measured::UnitError do
+      @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
+    end
+  end
+
+  test "#unit_names_with_aliases lists all allowed unit names" do
+    @conversion.set_base :m
+    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
+    @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
+
+    assert_equal ["feet", "foot", "ft", "in", "inch", "m"], @conversion.unit_names_with_aliases
+  end
+
+  test "#unit_names lists all base unit names without aliases" do
+    @conversion.set_base :m
+    @conversion.add :in, aliases: [:inch], value: "0.0254 meter"
+    @conversion.add :ft, aliases: [:feet, :foot], value: "0.3048 meter"
+
+    assert_equal ["ft", "in", "m"], @conversion.unit_names
+  end
+
+  test "#unit? checks if the unit is part of the units and aliases" do
+    @conversion.set_base :m
+    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
+
+    assert @conversion.unit?(:inch)
+    assert @conversion.unit?("m")
+    refute @conversion.unit?("in")
+    refute @conversion.unit?(:yard)
+  end
+
+  test "#unit_or_alias? checks if the unit is part of the units but not aliases" do
+    @conversion.set_base :m
+    @conversion.add :inch, aliases: [:in], value: "0.0254 meter"
+
+    assert @conversion.unit_or_alias?(:inch)
+    assert @conversion.unit_or_alias?("m")
+    assert @conversion.unit_or_alias?("in")
+    refute @conversion.unit_or_alias?(:yard)
+  end
+
+  test "#to_unit_name converts a unit name to its base unit" do
+    assert_equal "fireball", Magic.conversion.to_unit_name("fire")
+  end
+
+  test "#to_unit_name does not care about string or symbol" do
+    assert_equal "fireball", Magic.conversion.to_unit_name(:fire)
+  end
+
+  test "#to_unit_name passes through if already base unit name" do
+    assert_equal "fireball", Magic.conversion.to_unit_name("fireball")
+  end
+
+  test "#to_unit_name raises if not found" do
+    assert_raises Measured::UnitError do
+      Magic.conversion.to_unit_name("thunder")
+    end
+  end
+
+  test "#convert raises if either unit is not found" do
+    assert_raises Measured::UnitError do
+      Magic.conversion.convert(1, from: "fire", to: "doesnt_exist")
+    end
+
+    assert_raises Measured::UnitError do
+      Magic.conversion.convert(1, from: "doesnt_exist", to: "fire")
+    end
+  end
+
+  test "#convert converts betwen two known units" do
+    @conversion.set_base :m
+    @conversion.add :cm, value: "0.01 m"
+
+    assert_equal BigDecimal("10"), @conversion.convert(BigDecimal("1000"), from: "cm", to: "m")
+    assert_equal BigDecimal("250"), @conversion.convert(BigDecimal("2.5"), from: "m", to: "cm")
+  end
+
+  test "#convert handles the same unit" do
+    @conversion.set_base :m
+    @conversion.add :cm, value: "0.01 m"
+
+    assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "cm", to: "cm")
+  end
+
+  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in a tiny data set" do
+    @conversion.set_base :m
+    @conversion.add :cm, value: "0.01 m"
+
+    expected = {
+      "m"  => {
+        "m"  => BigDecimal("1"),
+        "cm" => BigDecimal("100")
+      },
+      "cm" => {
+        "cm" => BigDecimal("1"),
+        "m"  => BigDecimal("0.01")
+      }
+    }
+
+    assert_equal expected, @conversion.conversion_table
+  end
+
+  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors" do
+    @conversion.set_base :m
+    @conversion.add :cm, value: "0.01 m"
+    @conversion.add :mm, value: "0.001 m"
+
+    expected = {
+      "m"  => {
+        "m"  => BigDecimal("1"),
+        "cm" => BigDecimal("100"),
+        "mm" => BigDecimal("1000")
+      },
+      "cm" => {
+        "cm" => BigDecimal("1"),
+        "m"  => BigDecimal("0.01"),
+        "mm" => BigDecimal("10")
+      },
+      "mm" => {
+        "mm" => BigDecimal("1"),
+        "m"  => BigDecimal("0.001"),
+        "cm" => BigDecimal("0.1")
+      }
+    }
+
+    assert_equal expected, @conversion.conversion_table
+  end
+
+  test "#conversion_table returns expected nested hashes with BigDecimal conversion factors in an indrect path" do
+    @conversion.set_base :mm
+    @conversion.add :cm, value: "10 mm"
+    @conversion.add :dm, value: "10 cm"
+    @conversion.add :m, value: "10 dm"
+
+    expected = {
+      "m"  => {
+        "m"  => BigDecimal("1"),
+        "cm" => BigDecimal("100"),
+        "dm" => BigDecimal("10"),
+        "mm" => BigDecimal("1000")
+      },
+      "cm" => {
+        "cm" => BigDecimal("1"),
+        "dm" => BigDecimal("0.1"),
+        "m"  => BigDecimal("0.01"),
+        "mm" => BigDecimal("10")
+      },
+      "dm" => {
+        "dm" => BigDecimal("1"),
+        "cm" => BigDecimal("10"),
+        "m"  => BigDecimal("0.1"),
+        "mm" => BigDecimal("100")
+      },
+      "mm" => {
+        "mm" => BigDecimal("1"),
+        "m"  => BigDecimal("0.001"),
+        "dm"  => BigDecimal("0.01"),
+        "cm" => BigDecimal("0.1")
+      }
+    }
+
+    assert_equal expected, @conversion.conversion_table
+  end
+
+end