measured 2.3.0 → 2.6.0

data/lib/measured/unit_system_builder.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
 class Measured::UnitSystemBuilder
   def initialize
     @units = []
+    @cache = nil
   end
 
   def unit(unit_name, aliases: [], value: nil)
@@ -13,8 +15,13 @@ class Measured::UnitSystemBuilder
     nil
   end
 
+  def cache(cache_class, *args)
+    @cache = {class: cache_class, args: args}
+    nil
+  end
+
   def build
-    Measured::UnitSystem.new(@units)
+    Measured::UnitSystem.new(@units, cache: @cache)
   end
 
   private
@@ -39,8 +46,8 @@ class Measured::UnitSystemBuilder
     ["P", "peta", 15],
     ["E", "exa", 18],
     ["Z", "zetta", 21],
-    ["Y", "yotta", 24]
-  ]
+    ["Y", "yotta", 24],
+  ].map(&:freeze).freeze
 
   def build_si_units(name, aliases: [], value: nil)
     si_units = [build_unit(name, aliases: aliases, value: value)]
@@ -60,7 +67,7 @@ class Measured::UnitSystemBuilder
   def check_for_duplicate_unit_names!(unit)
     names = @units.flat_map(&:names)
     if names.any? { |name| unit.names.include?(name) }
-      raise Measured::UnitError, "Unit #{unit.name} has already been added."
+      raise Measured::UnitAlreadyAdded.new(unit.name)
     end
   end
 end

data/lib/measured/units/length.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Measured::Length = Measured.build do
   si_unit :m, aliases: [:meter, :metre, :meters, :metres]
 
@@ -5,4 +6,6 @@ Measured::Length = Measured.build do
   unit :ft, value: "12 in", aliases: [:foot, :feet]
   unit :yd, value: "3 ft", aliases: [:yard, :yards]
   unit :mi, value: "5280 ft", aliases: [:mile, :miles]
+
+  cache Measured::Cache::Json, "length.json"
 end

data/lib/measured/units/volume.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Measured::Volume = Measured.build do
   si_unit :l, aliases: [:liter, :litre, :liters, :litres]
 
@@ -12,4 +13,6 @@ Measured::Volume = Measured.build do
   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]
-end
+
+  cache Measured::Cache::Json, "volume.json"
+end

data/lib/measured/units/weight.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 Measured::Weight = Measured.build do
   si_unit :g, aliases: [:gram, :grams]
 
@@ -8,4 +9,6 @@ Measured::Weight = Measured.build do
   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.3.0"
+  VERSION = "2.6.0"
 end

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

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,137 @@
+# 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 "#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)
@@ -261,7 +261,7 @@ class Measured::MeasurableTest < ActiveSupport::TestCase
 
   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
 
@@ -279,7 +279,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
 
@@ -295,10 +295,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