measured 2.0.0.pre1 → 2.0.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 430f3e67cfe5f11eaa88db5f2b3d666ca5a7d557
-  data.tar.gz: 7ff421483024bec50b0703850d042eae46295b8c
+  metadata.gz: 10bd5a0ef33c55999eb30825b49399c3ab2ec183
+  data.tar.gz: 9307127d9fb8b0e7610919aaa18f53f4b9465e75
 SHA512:
-  metadata.gz: 6c15fc5aa920d22f6db7c7edd7fb52a66eb0af84b3c3326bbec64a37a387b7a764fe69d7c6d1f2ce41e2335045cfe8af5fb4c581b76ae72507c0eec7e7e21926
-  data.tar.gz: da4b602746ac0d5cb06353cc75deae90bfbcf56cec313196547dec347bbc7db50ff1f50a0d679ac95fa0fbcd715a22d0b678cef943c4ff7163aba36010ed6077
+  metadata.gz: 98b681bbf014999d0f328067af5d30259452deef6588b13b45d3db1afbadb117b20e19abcfb973620fe1a06984936807a9acea2a9c8433bc23e1332080f1b05e
+  data.tar.gz: 4bb6841e99399a8bc73f1063f3973f0b3e92f7273540b18393547e162b941a3d4f6fbddcd846e5fda6f7e61b8b22292112914b3dfc59879f23060fa4d4a035c0

data/lib/measured/case_insensitive_unit.rb

@@ -1,13 +1,5 @@
 class Measured::CaseInsensitiveUnit < Measured::Unit
-  def initialize(name, aliases: [], value: nil)
-    super(name.to_s.downcase, aliases: aliases.map(&:to_s).map!(&:downcase), value: value)
-  end
-
-  def name_eql?(name_to_compare)
-    super(name_to_compare.to_s.downcase)
-  end
-
-  def names_include?(name_to_compare)
-    super(name_to_compare.to_s.downcase)
+  def initialize(name, aliases: [], value: nil, unit_system: nil)
+    super(name.to_s.downcase, aliases: aliases.map(&:to_s).map!(&:downcase), value: value, unit_system: unit_system)
   end
 end

data/lib/measured/case_insensitive_unit_system.rb

@@ -3,8 +3,6 @@ class Measured::CaseInsensitiveUnitSystem < Measured::UnitSystem
     super(name.to_s.downcase)
   end
 
-  protected
-
   def unit_for(name)
     unit_name_to_unit[name.to_s.downcase]
   end

data/lib/measured/measurable.rb

@@ -6,7 +6,7 @@ class Measured::Measurable < Numeric
   def initialize(value, unit)
     raise Measured::UnitError, "Unit value cannot be blank" if value.blank?
 
-    @unit = self.class.unit_system.to_unit_name!(unit)
+    @unit = unit_from_unit_or_name!(unit)
     @value = case value
     when Float
       BigDecimal(value, Float::DIG + 1)
@@ -20,12 +20,12 @@ class Measured::Measurable < Numeric
   end
 
   def convert_to(new_unit)
-    new_unit_name = self.class.unit_system.to_unit_name(new_unit)
-    return self if new_unit_name == @unit
+    new_unit = unit_from_unit_or_name!(new_unit)
+    return self if new_unit == unit
 
-    value = self.class.unit_system.convert(@value, from: @unit, to: new_unit_name)
+    new_value = unit.unit_system.convert(value, from: unit, to: new_unit)
 
-    self.class.new(value, new_unit)
+    self.class.new(new_value, new_unit)
   end
 
   def to_s
@@ -62,6 +62,10 @@ class Measured::Measurable < Numeric
 
   private
 
+  def unit_from_unit_or_name!(value)
+    value.is_a?(Measured::Unit) ? value : self.class.unit_system.unit_for!(value)
+  end
+
   def value_string
     @value_string ||= begin
       str = case value

data/lib/measured/unit.rb

@@ -1,12 +1,22 @@
 class Measured::Unit
   include Comparable
 
-  attr_reader :name, :names, :conversion_amount, :conversion_unit
+  attr_reader :name, :names, :conversion_amount, :conversion_unit, :unit_system
 
-  def initialize(name, aliases: [], value: nil)
+  def initialize(name, aliases: [], value: nil, unit_system: nil)
     @name = name.to_s
     @names = ([@name] + aliases.map(&:to_s)).sort
     @conversion_amount, @conversion_unit = parse_value(value) if value
+    @unit_system = unit_system
+  end
+
+  def with_unit_system(unit_system)
+    self.class.new(
+      name,
+      aliases: names - [name],
+      value: conversion_string,
+      unit_system: unit_system
+    )
   end
 
   def to_s
@@ -23,10 +33,11 @@ class Measured::Unit
 
   def <=>(other)
     if self.class == other.class
-      if other.names != @names
-        other.names <=> @names
+      names_comparison = @names <=> other.names
+      if names_comparison != 0
+        names_comparison
       else
-        other.conversion_amount <=> @conversion_amount
+        @conversion_amount <=> other.conversion_amount
       end
     else
       @name <=> other

data/lib/measured/unit_system.rb

@@ -2,7 +2,7 @@ class Measured::UnitSystem
   attr_reader :units
 
   def initialize(units)
-    @units = units.dup
+    @units = units.map { |unit| unit.with_unit_system(self) }
   end
 
   def unit_names_with_aliases
@@ -22,20 +22,18 @@ class Measured::UnitSystem
     unit ? unit.name == name.to_s : false
   end
 
-  def to_unit_name(name)
-    to_unit_name!(name)
-  rescue Measured::UnitError
-    nil
+  def unit_for(name)
+    unit_name_to_unit[name.to_s]
   end
 
-  def to_unit_name!(name)
-    unit_for!(name).name
+  def unit_for!(name)
+    unit = unit_for(name)
+    raise Measured::UnitError, "Unit '#{name}' does not exist" unless unit
+    unit
   end
 
   def convert(value, from:, to:)
-    from_unit = unit_for!(from)
-    to_unit = unit_for!(to)
-    conversion = conversion_table[from][to]
+    conversion = conversion_table.fetch(from.name, {})[to.name]
 
     raise Measured::UnitError, "Cannot find conversion entry from #{from} to #{to}" unless conversion
 
@@ -54,14 +52,4 @@ class Measured::UnitSystem
       hash
     end
   end
-
-  def unit_for(name)
-    unit_name_to_unit[name.to_s]
-  end
-
-  def unit_for!(name)
-    unit = unit_for(name)
-    raise Measured::UnitError, "Unit '#{name}' does not exist" unless unit
-    unit
-  end
 end

data/lib/measured/version.rb

@@ -1,3 +1,3 @@
 module Measured
-  VERSION = "2.0.0.pre1"
+  VERSION = "2.0.0.pre2"
 end

data/test/arithmetic_test.rb

@@ -79,9 +79,10 @@ class Measured::ArithmeticTest < ActiveSupport::TestCase
   test "arithmetic operations favours unit of left" do
     left = Magic.new(1, :arcane)
     right = Magic.new(1, :magic_missile)
+    arcane = Magic.unit_system.unit_for!(:arcane)
 
-    assert_equal "arcane", (left + right).unit
-    assert_equal "arcane", (left - right).unit
+    assert_equal arcane, (left + right).unit
+    assert_equal arcane, (left - right).unit
   end
 
   test "#coerce should return other as-is when same class" do

data/test/case_insensitive_unit_system_test.rb

@@ -2,19 +2,20 @@ require "test_helper"
 
 class Measured::CaseInsensitiveUnitSystemTest < ActiveSupport::TestCase
   setup do
-    @conversion = Measured::CaseInsensitiveUnitSystem.new([
-      Measured::CaseInsensitiveUnit.new(:m),
-      Measured::CaseInsensitiveUnit.new(:in, aliases: [:inch], value: "0.0254 m"),
-      Measured::CaseInsensitiveUnit.new(:ft, aliases: [:feet, :foot], value: "0.3048 m"),
-    ])
+    @unit_fireball = Magic.unit_system.unit_for!(:fireball)
+
+    @unit_m = Measured::CaseInsensitiveUnit.new(:m)
+    @unit_in = Measured::CaseInsensitiveUnit.new(:in, aliases: [:inch], value: "0.0254 m")
+    @unit_ft = Measured::CaseInsensitiveUnit.new(:ft, aliases: %w(Feet FOOT), value: "0.3048 m")
+    @conversion = Measured::CaseInsensitiveUnitSystem.new([@unit_m, @unit_in, @unit_ft])
   end
 
-  test "#unit_names_with_aliases lists all allowed unit names" do
-    assert_equal ["feet", "foot", "ft", "in", "inch", "m"], @conversion.unit_names_with_aliases
+  test "#unit_names_with_aliases lists all allowed unit names in lowercase" do
+    assert_equal %w(feet foot ft in inch m), @conversion.unit_names_with_aliases
   end
 
-  test "#unit_names lists all base unit names without aliases" do
-    assert_equal ["ft", "in", "m"], @conversion.unit_names
+  test "#unit_names lists all base unit names without aliases in lowercase" do
+    assert_equal %w(ft in m), @conversion.unit_names
   end
 
   test "#unit? checks if the unit is part of the units but not aliases" do
@@ -43,56 +44,58 @@ class Measured::CaseInsensitiveUnitSystemTest < ActiveSupport::TestCase
     refute @conversion.unit_or_alias?(nil)
   end
 
-  test "#to_unit_name converts a unit name to its base unit" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name("fire")
+  test "#unit_for converts a unit name to its base unit" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for("fire")
   end
 
-  test "#to_unit_name does not care about string or symbol" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name(:fire)
+  test "#unit_for does not care about string or symbol" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for(:fire)
   end
 
-  test "#to_unit_name passes through if already base unit name" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name("fireball")
+  test "#unit_for passes through if already base unit name" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for("fireball")
   end
 
-  test "#to_unit_name returns nil if not found" do
-    assert_nil Magic.unit_system.to_unit_name("thunder")
+  test "#unit_for returns nil if not found" do
+    assert_nil Magic.unit_system.unit_for("thunder")
   end
 
-  test "#to_unit_name! converts a unit name to its base unit" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name!("fire")
+  test "#unit_for! converts a unit name to its base unit" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for!("fire")
   end
 
-  test "#to_unit_name! does not care about string or symbol" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name!(:fire)
+  test "#unit_for! does not care about string or symbol" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for!(:fire)
   end
 
-  test "#to_unit_name! passes through if already base unit name" do
-    assert_equal "fireball", Magic.unit_system.to_unit_name!("fireball")
+  test "#unit_for! passes through if already base unit name" do
+    assert_equal @unit_fireball, Magic.unit_system.unit_for!("fireball")
   end
 
-  test "#to_unit_name! raises if not found" do
+  test "#unit_for! raises if not found" do
     assert_raises_with_message(Measured::UnitError, "Unit 'thunder' does not exist") do
-      Magic.unit_system.to_unit_name!("thunder")
+      Magic.unit_system.unit_for!("thunder")
     end
   end
 
   test "#convert raises if either unit is not found" do
+    unit_bad = Measured::Unit.new(:doesnt_exist)
+
     assert_raises Measured::UnitError do
-      Magic.unit_system.convert(1, from: "fire", to: "doesnt_exist")
+      Magic.unit_system.convert(1, from: @unit_fireball, to: unit_bad)
     end
 
     assert_raises Measured::UnitError do
-      Magic.unit_system.convert(1, from: "doesnt_exist", to: "fire")
+      Magic.unit_system.convert(1, from: unit_bad, to: @unit_fireball)
     end
   end
 
   test "#convert converts between two known units" do
-    assert_equal BigDecimal("3"), @conversion.convert(BigDecimal("36"), from: "in", to: "ft")
-    assert_equal BigDecimal("18"), @conversion.convert(BigDecimal("1.5"), from: "ft", to: "in")
+    assert_equal 3, @conversion.convert(36, from: @unit_in, to: @unit_ft)
+    assert_equal 18, @conversion.convert(Rational(3, 2), from: @unit_ft, to: @unit_in)
   end
 
   test "#convert handles the same unit" do
-    assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "in", to: "in")
+    assert_equal 2, @conversion.convert(2, from: @unit_in, to: @unit_in)
   end
 end

data/test/case_insensitive_unit_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class Measured::CaseInsensitiveUnitTest < ActiveSupport::TestCase
   setup do
     @unit = Measured::CaseInsensitiveUnit.new(:Pie, value: "10 Cake")
-    @unit_with_aliases = Measured::CaseInsensitiveUnit.new(:Pie, aliases: ["Cake", "Tart"])
+    @unit_with_aliases = Measured::CaseInsensitiveUnit.new(:Pie, aliases: %w(Cake Tart))
   end
 
   test "#initialize converts the name to a downcased string" do
@@ -15,7 +15,7 @@ class Measured::CaseInsensitiveUnitTest < ActiveSupport::TestCase
   end
 
   test "#initialize parses out the unit and the number part" do
-    assert_equal BigDecimal(10), @unit.conversion_amount
+    assert_equal 10, @unit.conversion_amount
     assert_equal "Cake", @unit.conversion_unit
 
     unit = Measured::CaseInsensitiveUnit.new(:pie, value: "5.5 sweets")
@@ -39,12 +39,12 @@ class Measured::CaseInsensitiveUnitTest < ActiveSupport::TestCase
 
   test "#to_s returns an expected string" do
     assert_equal "pie", Measured::CaseInsensitiveUnit.new(:pie).to_s
-    assert_equal "pie (1/2 sweet)", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).to_s
+    assert_equal "pie (1/2 sweet)", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: "0.5 sweet").to_s
   end
 
   test "#inspect returns an expected string" do
     assert_equal "#<Measured::Unit: pie (pie) >", Measured::CaseInsensitiveUnit.new(:pie).inspect
-    assert_equal "#<Measured::Unit: pie (cake, pie) 1/2 sweet>", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).inspect
+    assert_equal "#<Measured::Unit: pie (cake, pie) 1/2 sweet>", Measured::CaseInsensitiveUnit.new(:pie, aliases: ["cake"], value: "1/2 sweet").inspect
   end
 
   test "includes Comparable mixin" do
@@ -62,18 +62,18 @@ class Measured::CaseInsensitiveUnitTest < ActiveSupport::TestCase
     assert_equal 0, @unit <=> Measured::CaseInsensitiveUnit.new("Pie", value: [10, :cake])
   end
 
-  test "#<=> is 1 for " do
-    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pies, value: "10 cake")
-    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new("pie", aliases: ["pies"], value: "10 cake")
-    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pie, value: [11, :cake])
+  test "#<=> is 1 for units with names that come after Pie lexicographically" do
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pancake, value: "10 cake")
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new("pie", aliases: ["pancakes"], value: "10 cake")
   end
 
-  test "#inverse_conversion_amount returns 1/amount for BigDecimal" do
-    assert_equal BigDecimal(1) / 10, @unit.inverse_conversion_amount
+  test "#<=> compares #conversion_amount when unit names the same" do
+    assert_equal -1, @unit <=> Measured::CaseInsensitiveUnit.new(:pie, value: [11, :pancake])
+    assert_equal 0, @unit <=> Measured::CaseInsensitiveUnit.new(:pie, value: [10, :foo])
+    assert_equal 1, @unit <=> Measured::CaseInsensitiveUnit.new(:pie, value: [9, :pancake])
   end
 
-  test "#inverse_conversion_amount swaps the numerator and denominator for Rational" do
-    unit = Measured::CaseInsensitiveUnit.new(:pie, value: [Rational(3, 7), "cake"])
-    assert_equal Rational(7, 3), unit.inverse_conversion_amount
+  test "#inverse_conversion_amount returns 1/amount" do
+    assert_equal Rational(1, 10), @unit.inverse_conversion_amount
   end
 end

data/test/measurable_test.rb

@@ -3,7 +3,10 @@ require "test_helper"
 class Measured::MeasurableTest < ActiveSupport::TestCase
 
   setup do
-    @magic = Magic.new(10, :magic_missile)
+    @arcane = Magic.unit_system.unit_for!(:arcane)
+    @fireball = Magic.unit_system.unit_for!(:fireball)
+    @magic_missile = Magic.unit_system.unit_for!(:magic_missile)
+    @magic = Magic.new(10, @magic_missile)
   end
 
   test "#initialize requires two params, the amount and the unit" do
@@ -16,9 +19,9 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     end
   end
 
-  test "#initialize converts unit to string from symbol" do
-    magic = Magic.new(1, :arcane)
-    assert_equal "arcane", magic.unit
+  test "#initialize converts unit string and symbol to Unit instance" do
+    assert_equal @arcane, Magic.new(1, "arcane").unit
+    assert_equal @arcane, Magic.new(1, :arcane).unit
   end
 
   test "#initialize raises if it is an unknown unit" do
@@ -27,23 +30,19 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     end
   end
 
-  test "#initialize converts numbers and strings into BigDecimal" do
-    assert_equal BigDecimal(1), Magic.new(1, :arcane).value
-    assert_equal BigDecimal("2.3"), Magic.new("2.3", :arcane).value
-    assert_equal BigDecimal("5"), Magic.new("5", :arcane).value
+  test "#initialize keeps Rationals, BigDecimals, and Integers as-is" do
+    assert_equal 10, Magic.new(10, :fire).value
+    assert_equal Rational(1, 3), Magic.new(Rational(1, 3), :fire).value
+    assert_equal BigDecimal("123.887788"), Magic.new(BigDecimal("123.887788"), :fire).value
   end
 
-  test "#initialize converts floats to strings and then to BigDecimal so it does not raise" do
-    assert_equal BigDecimal("1.2345"), Magic.new(1.2345, :fire).value
-  end
-
-  test "#initialize converts numbers and strings BigDecimal and does not round large numbers" do
+  test "#initialize converts floats and strings to BigDecimal and does not round large numbers" do
     assert_equal BigDecimal(9.1234572342342, 14), Magic.new(9.1234572342342, :fire).value
-    assert_equal BigDecimal("9.1234572342342"), Magic.new(9.1234572342342, :fire).value
+    assert_equal BigDecimal("9.1234572342342"), Magic.new("9.1234572342342", :fire).value
   end
 
-  test "#initialize converts to the base unit name" do
-    assert_equal "fireball", Magic.new(1, :fire).unit
+  test "#initialize converts to the base unit" do
+    assert_equal @fireball, Magic.new(1, :fire).unit
   end
 
   test "#initialize raises an expected error when initializing with nil value" do
@@ -74,19 +73,19 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     assert_equal "Unit '' does not exist", exception.message
   end
 
-  test "#unit allows you to read the unit string" do
-    assert_equal "magic_missile", @magic.unit
+  test "#unit allows you to read the unit" do
+    assert_equal @magic_missile, @magic.unit
   end
 
   test "#value allows you to read the numeric value" do
-    assert_equal BigDecimal(10), @magic.value
+    assert_equal 10, @magic.value
   end
 
-  test ".conversion is set and cached" do
-    conversion = CaseSensitiveMagic.unit_system
+  test ".unit_system is set and cached" do
+    unit_system = CaseSensitiveMagic.unit_system
 
-    assert_instance_of Measured::UnitSystem, conversion
-    assert_equal conversion.__id__, CaseSensitiveMagic.unit_system.__id__
+    assert_instance_of Measured::UnitSystem, unit_system
+    assert_equal unit_system.__id__, CaseSensitiveMagic.unit_system.__id__
   end
 
   test ".unit_names returns just the base unit names" do
@@ -118,19 +117,19 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
 
   test "#convert_to raises on an invalid unit" do
     assert_raises Measured::UnitError do
-      @magic.convert_to(:punch)
+      @magic.convert_to(Measured::Unit.new(:punch))
     end
   end
 
   test "#convert_to returns a new object of the same type in the new unit" do
-    converted = @magic.convert_to(:arcane)
+    converted = @magic.convert_to(@arcane)
 
     assert_equal converted, @magic
     refute_equal converted.object_id, @magic.object_id
     assert_equal BigDecimal(10), @magic.value
-    assert_equal "magic_missile", @magic.unit
+    assert_equal @magic_missile, @magic.unit
     assert_equal BigDecimal(1), converted.value
-    assert_equal "arcane", converted.unit
+    assert_equal @arcane, converted.unit
   end
 
   test "#convert_to from and to the same unit returns the same object" do
@@ -139,12 +138,12 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
   end
 
   test "#to_s outputs the number and the unit" do
-    assert_equal "10 fireball", Magic.new(10, :fire).to_s
+    assert_equal "10 fireball (2/3 magic_missile)", Magic.new(10, :fire).to_s
     assert_equal "1.234 magic_missile", Magic.new("1.234", :magic_missile).to_s
   end
 
   test "#inspect shows the number and the unit" do
-    assert_equal "#<Magic: 10 fireball>", Magic.new(10, :fire).inspect
+    assert_equal "#<Magic: 10 fireball (2/3 magic_missile)>", Magic.new(10, :fire).inspect
     assert_equal "#<Magic: 1.234 magic_missile>", Magic.new(1.234, :magic_missile).inspect
   end
 
@@ -204,11 +203,4 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     assert_raises(ArgumentError) { @magic < 0.00 }
   end
 
-  test "#eql? should be the same if the classes and amount match, and unit is converted" do
-    assert @magic == @magic
-    assert Magic.new(10, :magic_missile) == Magic.new("10", "magic_missile")
-    assert Magic.new(1, :arcane) == Magic.new(10, :magic_missile)
-    refute Magic.new(1, :arcane) == Magic.new(10.1, :magic_missile)
-  end
-
 end

data/test/test_helper.rb

@@ -23,6 +23,7 @@ class ActiveSupport::TestCase
     from_amount, from_unit = from.split(" ")
     to_amount, to_unit = to.split(" ")
 
+    to_unit = klass.unit_system.unit_for!(to_unit)
     assert_close_bigdecimal BigDecimal(to_amount), klass.new(from_amount, from_unit).convert_to(to_unit).value
   end
 
@@ -30,6 +31,7 @@ class ActiveSupport::TestCase
     from_amount, from_unit = from.split(" ")
     to_amount, to_unit = to.split(" ")
 
+    to_unit = klass.unit_system.unit_for!(to_unit)
     assert_equal BigDecimal(to_amount), klass.new(from_amount, from_unit).convert_to(to_unit).value
   end
 

data/test/unit_system_builder_test.rb

@@ -43,7 +43,7 @@ class Measured::UnitSystemBuilderTest < ActiveSupport::TestCase
       unit :BOLD, value: "100 normal"
     end
 
-    assert_equal 2, measurable.new(200, :normal).convert_to(:BOLD).value
+    assert_equal 'BOLD', measurable.unit_system.unit_for!(:BOLD).name
   end
 
   test "case-insensitive conversion is produced by default" do
@@ -53,6 +53,6 @@ class Measured::UnitSystemBuilderTest < ActiveSupport::TestCase
       unit :bolder, value: "100 normal"
     end
 
-    assert_equal 20, measurable.new(200, :normal).convert_to(:bOlD).value
+    assert_equal 'bold', measurable.unit_system.unit_for!(:bOlD).name
   end
 end

data/test/unit_system_test.rb

@@ -2,19 +2,20 @@ require "test_helper"
 
 class Measured::UnitSystemTest < ActiveSupport::TestCase
   setup do
-    @conversion = Measured::UnitSystem.new([
-      Measured::Unit.new(:m),
-      Measured::Unit.new(:in, aliases: [:Inch], value: "0.0254 m"),
-      Measured::Unit.new(:ft, aliases: [:Feet, :Foot], value: "0.3048 m"),
-    ])
+    @unit_fireball = CaseSensitiveMagic.unit_system.unit_for!(:fireball)
+
+    @unit_m = Measured::Unit.new(:m)
+    @unit_in = Measured::Unit.new(:in, aliases: [:Inch], value: "0.0254 m")
+    @unit_ft = Measured::Unit.new(:ft, aliases: %w(Feet Foot), value: "0.3048 m")
+    @conversion = Measured::UnitSystem.new([@unit_m, @unit_in, @unit_ft])
   end
 
   test "#unit_names_with_aliases lists all allowed unit names" do
-    assert_equal ["Feet", "Foot", "Inch", "ft", "in", "m"], @conversion.unit_names_with_aliases
+    assert_equal %w(Feet Foot Inch ft in m), @conversion.unit_names_with_aliases
   end
 
   test "#unit_names lists all unit names without aliases" do
-    assert_equal ["ft", "in", "m"], @conversion.unit_names
+    assert_equal %w(ft in m), @conversion.unit_names
   end
 
   test "#unit? checks if the unit is part of the units but not aliases" do
@@ -44,56 +45,58 @@ class Measured::UnitSystemTest < ActiveSupport::TestCase
     refute @conversion.unit_or_alias?(nil)
   end
 
-  test "#to_unit_name converts a unit name to its base unit" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name("fire")
+  test "#unit_for converts a unit name to its base unit" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for("fire")
   end
 
-  test "#to_unit_name does not care about string or symbol" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name(:fire)
+  test "#unit_for does not care about string or symbol" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for(:fire)
   end
 
-  test "#to_unit_name passes through if already base unit name" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name("fireball")
+  test "#unit_for passes through if already base unit name" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for("fireball")
   end
 
-  test "#to_unit_name returns nil if not found" do
-    assert_nil CaseSensitiveMagic.unit_system.to_unit_name("thunder")
+  test "#unit_for returns nil if not found" do
+    assert_nil CaseSensitiveMagic.unit_system.unit_for("thunder")
   end
 
-  test "#to_unit_name! converts a unit name to its base unit" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name!("fire")
+  test "#unit_for! converts a unit name to its base unit" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for!("fire")
   end
 
-  test "#to_unit_name! does not care about string or symbol" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name!(:fire)
+  test "#unit_for! does not care about string or symbol" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for!(:fire)
   end
 
-  test "#to_unit_name! passes through if already base unit name" do
-    assert_equal "fireball", CaseSensitiveMagic.unit_system.to_unit_name!("fireball")
+  test "#unit_for! passes through if already base unit name" do
+    assert_equal @unit_fireball, CaseSensitiveMagic.unit_system.unit_for!("fireball")
   end
 
-  test "#to_unit_name! raises if not found" do
+  test "#unit_for! raises if not found" do
     assert_raises_with_message(Measured::UnitError, "Unit 'thunder' does not exist") do
-      CaseSensitiveMagic.unit_system.to_unit_name!("thunder")
+      CaseSensitiveMagic.unit_system.unit_for!("thunder")
     end
   end
 
   test "#convert raises if either unit is not found" do
+    unit_bad = Measured::Unit.new(:doesnt_exist)
+
     assert_raises Measured::UnitError do
-      CaseSensitiveMagic.unit_system.convert(1, from: "fire", to: "doesnt_exist")
+      CaseSensitiveMagic.unit_system.convert(1, from: @unit_fireball, to: unit_bad)
     end
 
     assert_raises Measured::UnitError do
-      CaseSensitiveMagic.unit_system.convert(1, from: "doesnt_exist", to: "fire")
+      CaseSensitiveMagic.unit_system.convert(1, from: unit_bad, to: @unit_fireball)
     end
   end
 
   test "#convert converts between two known units" do
-    assert_equal BigDecimal("3"), @conversion.convert(BigDecimal("36"), from: "in", to: "ft")
-    assert_equal BigDecimal("18"), @conversion.convert(BigDecimal("1.5"), from: "ft", to: "in")
+    assert_equal 3, @conversion.convert(36, from: @unit_in, to: @unit_ft)
+    assert_equal 18, @conversion.convert(Rational(3, 2), from: @unit_ft, to: @unit_in)
   end
 
   test "#convert handles the same unit" do
-    assert_equal BigDecimal("2"), @conversion.convert(BigDecimal("2"), from: "in", to: "in")
+    assert_equal 2, @conversion.convert(2, from: @unit_in, to: @unit_in)
   end
 end

data/test/unit_test.rb

@@ -3,7 +3,7 @@ require "test_helper"
 class Measured::UnitTest < ActiveSupport::TestCase
   setup do
     @unit = Measured::Unit.new(:Pie, value: "10 Cake")
-    @unit_with_aliases = Measured::Unit.new(:Pie, aliases: ["Cake", "Tart"])
+    @unit_with_aliases = Measured::Unit.new(:Pie, aliases: %w(Cake Tart))
   end
 
   test "#initialize converts the name to a string" do
@@ -15,7 +15,7 @@ class Measured::UnitTest < ActiveSupport::TestCase
   end
 
   test "#initialize parses out the unit and the number part" do
-    assert_equal BigDecimal(10), @unit.conversion_amount
+    assert_equal 10, @unit.conversion_amount
     assert_equal "Cake", @unit.conversion_unit
 
     unit = Measured::Unit.new(:pie, value: "5.5 sweets")
@@ -39,12 +39,12 @@ class Measured::UnitTest < ActiveSupport::TestCase
 
   test "#to_s returns an expected string" do
     assert_equal "pie", Measured::Unit.new(:pie).to_s
-    assert_equal "pie (1/2 sweet)", Measured::Unit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).to_s
+    assert_equal "pie (1/2 sweet)", Measured::Unit.new(:pie, aliases: ["cake"], value: "0.5 sweet").to_s
   end
 
   test "#inspect returns an expected string" do
     assert_equal "#<Measured::Unit: pie (pie) >", Measured::Unit.new(:pie).inspect
-    assert_equal "#<Measured::Unit: pie (cake, pie) 1/2 sweet>", Measured::Unit.new(:pie, aliases: ["cake"], value: [Rational(1,2), "sweet"]).inspect
+    assert_equal "#<Measured::Unit: pie (cake, pie) 1/2 sweet>", Measured::Unit.new(:pie, aliases: ["cake"], value: "1/2 sweet").inspect
   end
 
   test "includes Comparable mixin" do
@@ -62,18 +62,18 @@ class Measured::UnitTest < ActiveSupport::TestCase
     assert_equal 0, @unit <=> Measured::Unit.new("Pie", value: [10, :cake])
   end
 
-  test "#<=> is 1 for units with names that come after Pie lexicographically" do
-    assert_equal 1, @unit <=> Measured::Unit.new(:Pigs, value: "10 bacon")
-    assert_equal 1, @unit <=> Measured::Unit.new("Pig", aliases: %w(Pigs), value: "10 bacon")
-    assert_equal 1, @unit <=> Measured::Unit.new(:Pig, value: [11, :bacon])
+  test "#<=> is -1 for units with names that come after Pie lexicographically" do
+    assert_equal -1, @unit <=> Measured::Unit.new(:Pigs, value: "10 bacon")
+    assert_equal -1, @unit <=> Measured::Unit.new("Pig", aliases: %w(Pigs), value: "10 bacon")
   end
-
-  test "#inverse_conversion_amount returns 1/amount for BigDecimal" do
-    assert_equal BigDecimal(1) / 10, @unit.inverse_conversion_amount
+  
+  test "#<=> compares #conversion_amount when unit names the same" do
+    assert_equal -1, @unit <=> Measured::Unit.new(:Pie, value: [11, :pancake])
+    assert_equal 0, @unit <=> Measured::Unit.new(:Pie, value: [10, :foo])
+    assert_equal 1, @unit <=> Measured::Unit.new(:Pie, value: [9, :pancake])
   end
 
-  test "#inverse_conversion_amount swaps the numerator and denominator for Rational" do
-    unit = Measured::Unit.new(:pie, value: [Rational(3, 7), "cake"])
-    assert_equal Rational(7, 3), unit.inverse_conversion_amount
+  test "#inverse_conversion_amount returns 1/amount" do
+    assert_equal Rational(1, 10), @unit.inverse_conversion_amount
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: measured
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre1
+  version: 2.0.0.pre2
 platform: ruby
 authors:
 - Kevin McPhillips
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-17 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport