measured 2.4.0 → 2.7.0

data/lib/measured/unit_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Measured
+  class UnitError < StandardError ; end
+end

data/lib/measured/unit_system.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
 class Measured::UnitSystem
-  attr_reader :units
-
-  def initialize(units)
-    @units = units.map { |unit| unit.with_unit_system(self) }
-    @conversion_table_builder = Measured::ConversionTableBuilder.new(@units)
-  end
-
-  def unit_names_with_aliases
-    @unit_names_with_aliases ||= @units.flat_map(&:names).sort
-  end
-
-  def unit_names
-    @unit_names ||= @units.map(&:name).sort
+  attr_reader :units, :unit_names, :unit_names_with_aliases
+
+  def initialize(units, cache: nil)
+    @units = units.map { |unit| unit.with(unit_system: self) }
+    @units = @units.map do |unit|
+      next unit unless unit.conversion_unit
+      conversion_unit = @units.find { |u| u.names.include?(unit.conversion_unit) }
+      next unit unless conversion_unit
+      unit.with(value: [unit.conversion_amount, conversion_unit.name])
+    end
+    @unit_names = @units.map(&:name).sort.freeze
+    @unit_names_with_aliases = @units.flat_map(&:names).sort.freeze
+    @unit_name_to_unit = @units.each_with_object({}) do |unit, hash|
+      unit.names.each { |name| hash[name.to_s] = unit }
+    end
+    @conversion_table_builder = Measured::ConversionTableBuilder.new(@units, cache: cache)
+    @conversion_table = @conversion_table_builder.to_h.freeze
   end
 
   def unit_or_alias?(name)
@@ -41,16 +46,15 @@ class Measured::UnitSystem
     value.to_r * conversion
   end
 
-  protected
-
-  def conversion_table
-    @conversion_table ||= @conversion_table_builder.to_h
+  def update_cache
+    @conversion_table_builder.update_cache
   end
 
-  def unit_name_to_unit
-    @unit_name_to_unit ||= @units.inject({}) do |hash, unit|
-      unit.names.each { |name| hash[name.to_s] = unit }
-      hash
-    end
+  def cached?
+    @conversion_table_builder.cached?
   end
+
+  protected
+
+  attr_reader :unit_name_to_unit, :conversion_table
 end

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.4.0"
+  VERSION = "2.7.0"
 end

data/measured.gemspec

@@ -13,16 +13,24 @@ Gem::Specification.new do |spec|
   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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "test_helper"
 
 class Measured::ConversionTableBuilderTest < ActiveSupport::TestCase
@@ -115,4 +116,32 @@ class Measured::ConversionTableBuilderTest < ActiveSupport::TestCase
       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)
@@ -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

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" unless ENV["CI"]
+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