measured 2.0.0 → 2.8.2

data/lib/measured/units/volume.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+Measured::Volume = Measured.build do
+  si_unit :l, aliases: [:liter, :litre, :liters, :litres]
+
+  unit :m3, value: "1000 l", aliases: [:cubic_meter, :cubic_metre, :cubic_meters, :cubic_metres]
+  unit :cm3, value: "0.001 l", aliases: [:cubic_centimeter, :cubic_centimetre, :cubic_centimeters, :cubic_centimetres]
+  unit :mm3, value: "0.000001 l", aliases: [:cubic_millimeter, :cubic_millimetre, :cubic_millimeters, :cubic_millimetres]
+  unit :in3, value: "0.016387064 l", aliases: [:cubic_inch, :cubic_inches]
+  unit :ft3, value: "1728 in3", aliases: [:cubic_foot, :cubic_feet]
+  unit :gal, value: "4.54609 l", aliases: [:imp_gal, :imperial_gallon, :imp_gals, :imperial_gallons]
+  unit :us_gal, value: "231 in3", aliases: [:us_gallon, :us_gals, :us_gallons]
+  unit :qt, value: "0.25 gal", aliases: [:imp_qt, :imperial_quart, :imp_qts, :imperial_quarts]
+  unit :us_qt, value: "0.25 us_gal", aliases: [:us_quart, :us_quarts]
+  unit :pt, value: "0.125 gal", aliases: [:imp_pt, :imperial_pint, :imp_pts, :imperial_pints]
+  unit :us_pt, value: "0.125 us_gal", aliases: [:us_pint, :us_pints]
+  unit :oz, value: "0.00625 gal", aliases: [:fl_oz, :imp_fl_oz, :imperial_fluid_ounce, :imperial_fluid_ounces]
+  unit :us_oz, value: "0.0078125 us_gal", aliases: [:us_fl_oz, :us_fluid_ounce, :us_fluid_ounces]
+
+  cache Measured::Cache::Json, "volume.json"
+end

data/lib/measured/units/weight.rb

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
 Measured::Weight = Measured.build do
-  unit :g, aliases: [:gram, :grams]
-  unit :kg, value: "1000 g", aliases: [:kilogram, :kilograms]
+  si_unit :g, aliases: [:gram, :grams]
+
+  unit :t, value: "1000 kg", aliases: [:metric_ton, :metric_tons]
+  unit :slug, value: "14.593903 kg", aliases: [:slugs]
+  unit :N, value: "0.10197162129779283 kg", aliases: [:newtons, :newton]
+  unit :long_ton, value: "2240 lb", aliases: [:long_tons, :weight_ton, :weight_tons, 'W/T', :imperial_ton, :imperial_tons, :displacement_ton, :displacement_tons]
+  unit :short_ton, value: "2000 lb", aliases: [:short_tons]
   unit :lb, value: "0.45359237 kg", aliases: [:lbs, :pound, :pounds]
   unit :oz, value: "1/16 lb", aliases: [:ounce, :ounces]
+
+  cache Measured::Cache::Json, "weight.json"
 end

data/lib/measured/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Measured
-  VERSION = "2.0.0"
+  VERSION = "2.8.2"
 end

data/lib/measured.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require "measured/base"
 
 require "measured/units/length"
 require "measured/units/weight"
+require "measured/units/volume"

data/measured.gemspec

@@ -6,23 +6,31 @@ 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.authors       = ["Kevin McPhillips", "Jason Gedge", "Javier Honduvilla Coto"]
+  spec.email         = ["gems@shopify.com"]
   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.description   = %q{Wrapper objects which encapsulate measurements and their associated units in Ruby.}
   spec.homepage      = "https://github.com/Shopify/measured"
   spec.license       = "MIT"
 
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
   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.2"
+  spec.add_runtime_dependency "activesupport", ">= 5.2"
 
   spec.add_development_dependency "rake", "> 10.0"
   spec.add_development_dependency "minitest", "> 5.5.1"
   spec.add_development_dependency "minitest-reporters"
-  spec.add_development_dependency "mocha", "> 1.1.0"
+  spec.add_development_dependency "mocha", ">= 1.4.0"
   spec.add_development_dependency "pry"
 end

data/test/arithmetic_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "test_helper"
 
 class Measured::ArithmeticTest < ActiveSupport::TestCase
@@ -7,6 +8,41 @@ class Measured::ArithmeticTest < ActiveSupport::TestCase
     @four = Magic.new(4, :magic_missile)
   end
 
+  test "should be able to sum same units" do
+    assert_equal Magic.new(9, :magic_missile), [@two, @three, @four].sum
+  end
+
+  test 'can check for finite?' do
+    assert Magic.new(0, :magic_missile).finite?
+    refute Magic.new(Float::INFINITY, :magic_missile).finite?
+  end
+
+  test 'can check for infinite?' do
+    assert Magic.new(Float::INFINITY, :magic_missile).infinite?
+    refute Magic.new(0, :magic_missile).infinite?
+  end
+
+  test 'can check for zero?' do
+    assert Magic.new(0, :magic_missile).zero?
+    refute Magic.new(1, :magic_missile).zero?
+  end
+
+  test 'can check for nonzero?' do
+    assert_equal Magic.new(10, :magic_missile), Magic.new(10, :magic_missile).nonzero?
+    assert Magic.new(10, :magic_missile).nonzero?
+    refute Magic.new(0, :magic_missile).nonzero?
+  end
+
+  test 'can check for positive?' do
+    assert Magic.new(1, :magic_missile).positive?
+    refute Magic.new(-1, :magic_missile).positive?
+  end
+
+  test 'can check for negative?' do
+    assert Magic.new(-1, :magic_missile).negative?
+    refute Magic.new(1, :magic_missile).negative?
+  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

data/test/cache/json_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Measured::Cache::JsonTest < ActiveSupport::TestCase
+  setup do
+    @cache = Measured::Cache::Json.new("test.json")
+    @table_json = { "a" => { "b" => { "numerator" => 2, "denominator" => 3 } } }.to_json
+    @table_hash = { "a" => { "b" => Rational(2, 3) } }
+  end
+
+  test "#initialize sets the filename and path" do
+    assert_equal "test.json", @cache.filename
+    assert_match(/.+\/cache\/test\.json$/, @cache.path.to_s)
+    refute_match "../", @cache.path.to_s
+  end
+
+  test "#exist? returns false if the file does not exist" do
+    File.expects(:exist?).with(@cache.path).returns(false)
+    refute_predicate @cache, :exist?
+  end
+
+  test "#exist? returns true if the file exists" do
+    File.expects(:exist?).with(@cache.path).returns(true)
+    assert_predicate @cache, :exist?
+  end
+
+  test "#read returns nil if the file does not exist" do
+    File.expects(:exist?).with(@cache.path).returns(false)
+    assert_nil @cache.read
+  end
+
+  test "#read loads the file if it exists" do
+    File.expects(:exist?).with(@cache.path).returns(true)
+    File.expects(:read).with(@cache.path).returns(@table_json)
+    assert_equal @table_hash, @cache.read
+  end
+
+  test "#write raises not implemented" do
+    assert_raises(ArgumentError) do
+      @cache.write({})
+    end
+  end
+end

data/test/cache/json_writer_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Measured::Cache::JsonWriterTest < ActiveSupport::TestCase
+  class JsonTestWithWriter < Measured::Cache::Json
+    prepend Measured::Cache::JsonWriter
+  end
+
+  setup do
+    @cache = JsonTestWithWriter.new("test.json")
+    @table_json = JSON.pretty_generate({ "a" => { "b" => { "numerator" => 2, "denominator" => 3 } } })
+    @table_hash = { "a" => { "b" => Rational(2, 3) } }
+  end
+
+  test "#write writes the file" do
+    f = stub
+    f.expects(:write).with("// Do not modify this file directly. Regenerate it with 'rake cache:write'.\n")
+    f.expects(:write).with(@table_json)
+
+    File.expects(:open).with(@cache.path, "w").returns(123).yields(f)
+    assert_equal 123, @cache.write(@table_hash)
+  end
+end

data/test/cache/null_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Measured::Cache::NullTest < ActiveSupport::TestCase
+  setup do
+    @cache = Measured::Cache::Null.new
+  end
+
+  test "#exist? false" do
+    assert_equal false, @cache.exist?
+  end
+
+  test "#read returns nil" do
+    assert_nil @cache.read
+  end
+
+  test "#write returns nil" do
+    assert_nil @cache.write({})
+  end
+end

data/test/cache_consistency_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require "test_helper"
+
+# In general we do not want to expose the inner workings of the caching and unit systems as part of the API.
+# But we do want to be able to test that there is no conflict between what's in the cache file and what is defined
+# in the unit systems. So we compromise by reaching into implementation to force compare them.
+class Measured::CacheConsistencyTest < ActiveSupport::TestCase
+  measurable_subclasses.select { |m| m.unit_system.cached? }.each do |measurable|
+    test "cached measurable #{ measurable } is not out of sync with the definition" do
+      builder = measurable.unit_system.instance_variable_get("@conversion_table_builder")
+      cache = builder.instance_variable_get("@cache")
+
+      expected = builder.send(:generate_table)
+      actual = cache.read
+
+      assert expected == actual, "The contents of the file cache for `#{ measurable }` does not match what the unit system generated.\nTry running `rake cache:write` to update the caches."
+    end
+  end
+end

data/test/conversion_table_builder_test.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Measured::ConversionTableBuilderTest < ActiveSupport::TestCase
+  test "#initialize creates a new object with the units" do
+    units = [Measured::Unit.new(:test)]
+
+    assert_equal units, Measured::ConversionTableBuilder.new(units).units
+  end
+
+  test "#to_h should return a hash for the simple case" do
+    conversion_table = Measured::ConversionTableBuilder.new([Measured::Unit.new(:test)]).to_h
+
+    expected = {
+      "test" => {"test" => Rational(1, 1)}
+    }
+
+    assert_equal expected, conversion_table
+    assert_instance_of Rational, conversion_table.values.first.values.first
+  end
+
+  test "#to_h returns expected nested hashes with BigDecimal conversion factors in a tiny data set" do
+    conversion_table = Measured::ConversionTableBuilder.new([
+      Measured::Unit.new(:m),
+      Measured::Unit.new(:cm, value: "0.01 m"),
+    ]).to_h
+
+    expected = {
+      "m" => {
+        "m" => Rational(1, 1),
+        "cm" => Rational(100, 1),
+      },
+      "cm" => {
+        "m" => Rational(1, 100),
+        "cm" => Rational(1, 1),
+      }
+    }
+
+    assert_equal expected, conversion_table
+
+    conversion_table.values.map(&:values).flatten.each do |value|
+      assert_instance_of Rational, value
+    end
+  end
+
+  test "#to_h returns expected nested hashes factors" do
+    conversion_table = Measured::ConversionTableBuilder.new([
+      Measured::Unit.new(:m),
+      Measured::Unit.new(:cm, value: "0.01 m"),
+      Measured::Unit.new(:mm, value: "0.001 m"),
+    ]).to_h
+
+    expected = {
+      "m" => {
+        "m" => Rational(1, 1),
+        "cm" => Rational(100, 1),
+        "mm" => Rational(1000, 1),
+      },
+      "cm" => {
+        "m" => Rational(1, 100),
+        "cm" => Rational(1, 1),
+        "mm" => Rational(10, 1),
+      },
+      "mm" => {
+        "m" => Rational(1, 1000),
+        "cm" => Rational(1, 10),
+        "mm" => Rational(1, 1),
+      }
+    }
+
+    assert_equal expected, conversion_table
+
+    conversion_table.values.map(&:values).flatten.each do |value|
+      assert_instance_of Rational, value
+    end
+  end
+
+  test "#to_h returns expected nested hashes in an indrect path" do
+    conversion_table = Measured::ConversionTableBuilder.new([
+      Measured::Unit.new(:mm),
+      Measured::Unit.new(:cm, value: "10 mm"),
+      Measured::Unit.new(:dm, value: "10 cm"),
+      Measured::Unit.new(:m, value: "10 dm"),
+    ]).to_h
+
+    expected = {
+      "m" => {
+        "m" => Rational(1, 1),
+        "dm" => Rational(10, 1),
+        "cm" => Rational(100, 1),
+        "mm" => Rational(1000, 1),
+      },
+      "cm" => {
+        "m" => Rational(1, 100),
+        "dm" => Rational(1, 10),
+        "cm" => Rational(1, 1),
+        "mm" => Rational(10, 1),
+      },
+      "dm" => {
+        "m" => Rational(1, 10),
+        "cm" => Rational(10, 1),
+        "dm" => Rational(1, 1),
+        "mm" => Rational(100, 1),
+      },
+      "mm" => {
+        "m" => Rational(1, 1000),
+        "dm" => Rational(1, 100),
+        "cm" => Rational(1, 10),
+        "mm" => Rational(1, 1),
+      }
+    }
+
+    assert_equal expected, conversion_table
+
+    conversion_table.values.map(&:values).flatten.each do |value|
+      assert_instance_of Rational, value
+    end
+  end
+
+  test "#to_h raises exception when there are cycles" do
+    unit1 = Measured::Unit.new(:pallets, value: "1 liters")
+    unit2 = Measured::Unit.new(:liters, value: "0.1 cases")
+    unit3 = Measured::Unit.new(:cases, value: "0.1 pallets")
+
+    assert_raises(Measured::CycleDetected) do
+      Measured::ConversionTableBuilder.new([unit1, unit2, unit3]).to_h
+    end
+  end
+
+  test "#cached? returns true if there's a cache" do
+    builder = Measured::ConversionTableBuilder.new([Measured::Unit.new(:test)], cache: { class: AlwaysTrueCache })
+    assert_predicate builder, :cached?
+  end
+
+  test "#cached? returns false if there is not a cache" do
+    builder = Measured::ConversionTableBuilder.new([Measured::Unit.new(:test)])
+    refute_predicate builder, :cached?
+  end
+
+  test "#write_cache pushes the generated table into the cache and writes it" do
+    builder = Measured::ConversionTableBuilder.new([Measured::Unit.new(:test)], cache: { class: AlwaysTrueCache })
+    AlwaysTrueCache.any_instance.expects(:exist?).returns(false)
+    table = builder.to_h
+    AlwaysTrueCache.any_instance.expects(:write).with(table).returns(123)
+    assert_equal 123, builder.update_cache
+  end
+end

data/test/measurable_test.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require "test_helper"
 
 class Measured::MeasurableTest < ActiveSupport::TestCase
-
   setup do
     @arcane = Magic.unit_system.unit_for!(:arcane)
     @fireball = Magic.unit_system.unit_for!(:fireball)
@@ -216,6 +216,27 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     assert_equal "5 fireball", Magic.new(Rational(5, 1), :fire).to_s
   end
 
+  test "#to_s outputs the correct number of decimals" do
+    assert_equal "9.3 fireball", Magic.new(9.3, :fire).to_s
+  end
+
+  test "#format outputs a formatted string" do
+    measured_object = Magic.new(9.342, :magic_missile)
+    assert_equal "9.3", measured_object.format("%.1<value>f")
+    assert_equal "magic_missile", measured_object.format("%<unit>s")
+    assert_equal "9.34 magic_missile", measured_object.format("%.2<value>f %<unit>s")
+    assert_equal "9.342000 magic_missile", measured_object.format("%<value>f %<unit>s")
+  end
+
+  test "#format with no formatting string uses the default one" do
+    assert_equal "9.34 magic_missile", Magic.new(9.342, :magic_missile).format
+  end
+
+  test "#format can drop the conversion amount" do
+    assert_equal "1.00 fireball (2/3 magic_missile)", Magic.new(1, :fireball).format
+    assert_equal "1.00 fireball", Magic.new(1, :fireball).format(with_conversion_string: false)
+  end
+
   test "#humanize outputs the number and the unit properly pluralized" do
     assert_equal "1 fireball", Magic.new("1", :fire).humanize
     assert_equal "10 fireballs", Magic.new(10, :fire).humanize
@@ -230,22 +251,16 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
     assert_equal "#<Magic: 1.234 #<Measured::Unit: magic_missile (magic_missiles, magic missile)>>", Magic.new(1.234, :magic_missile).inspect
   end
 
-  test "#zero? always returns false" do
-    refute_predicate Magic.new(0, :fire), :zero?
-    refute_predicate Magic.new(0.0, :fire), :zero?
-    refute_predicate Magic.new("0.0", :fire), :zero?
-  end
-
   test "#<=> compares regardless of the unit" do
-    assert_equal -1, @magic <=> Magic.new(20, :fire)
+    assert_equal (-1), @magic <=> Magic.new(20, :fire)
     assert_equal 1, @magic <=> Magic.new(9, :magic_missile)
     assert_equal 0, @magic <=> Magic.new(Rational(30, 2), :fire)
-    assert_equal -1, @magic <=> Magic.new(11, :magic_missile)
+    assert_equal (-1), @magic <=> Magic.new(11, :magic_missile)
   end
 
   test "#<=> doesn't compare against zero" do
     assert_nil @magic <=> 0
-    assert_nil @magic <=> BigDecimal.new(0)
+    assert_nil @magic <=> BigDecimal(0)
     assert_nil @magic <=> 0.00
   end
 
@@ -263,7 +278,7 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
   test "#== doesn't compare against zero" do
     arcane_zero = Magic.new(0, :arcane)
     refute_equal arcane_zero, 0
-    refute_equal arcane_zero, BigDecimal.new(0)
+    refute_equal arcane_zero, BigDecimal(0)
     refute_equal arcane_zero, 0.0
   end
 
@@ -279,10 +294,10 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
 
   test "#> and #< should not compare against zero" do
     assert_raises(ArgumentError) { @magic > 0 }
-    assert_raises(ArgumentError) { @magic > BigDecimal.new(0) }
+    assert_raises(ArgumentError) { @magic > BigDecimal(0) }
     assert_raises(ArgumentError) { @magic > 0.00 }
     assert_raises(ArgumentError) { @magic < 0 }
-    assert_raises(ArgumentError) { @magic < BigDecimal.new(0) }
+    assert_raises(ArgumentError) { @magic < BigDecimal(0) }
     assert_raises(ArgumentError) { @magic < 0.00 }
   end
 end

data/test/parser_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "test_helper"
 
 class Measured::ParserTest < ActiveSupport::TestCase

data/test/support/always_true_cache.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class AlwaysTrueCache
+  def exist?
+    true
+  end
+
+  def read
+    {}
+  end
+
+  def write(*)
+    nil
+  end
+end

data/test/support/fake_system.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Magic = Measured.build do
   unit :magic_missile, aliases: [:magic_missiles, "magic missile"]
   unit :fireball, value: "2/3 magic_missile", aliases: [:fire, :fireballs]

data/test/support/subclasses.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# Extract the subclasses that exist early on because other classes will get added by tests
+#   later on in execution and in an unpredictable order.
+class ActiveSupport::TestCase
+  cattr_accessor :measurable_subclasses
+  self.measurable_subclasses = Measured::Measurable.subclasses
+end

data/test/test_helper.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+require "pry" unless ENV["CI"]
 require "measured"
 require "minitest/reporters"
 require "minitest/autorun"
-require "mocha/setup"
-require "pry"
+require "mocha/minitest"
 
 ActiveSupport.test_order = :random
 
 Minitest::Reporters.use! [Minitest::Reporters::ProgressReporter.new(color: true)]
 
+require "support/subclasses"
 require "support/fake_system"
+require "support/always_true_cache"
 
 class ActiveSupport::TestCase
-
   protected
 
   def assert_close_bigdecimal exp, act, delta = BigDecimal('0.000001')

data/test/unit_error_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "test_helper"
 
 class Measured::UnitErrorTest < ActiveSupport::TestCase