measured 2.4.0 → 2.5.0

data/dev.yml

@@ -2,7 +2,7 @@ name: measured
 
 up:
   - ruby:
-      version: 2.3.1
+      version: 2.6.3
   - bundler
 
 commands:

data/gemfiles/{activesupport-4.2.gemfile → activesupport-5.0.gemfile}

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec path: '..'
 
-gem 'activesupport', '~> 4.2'
+gem 'activesupport', '~> 5.0'

data/gemfiles/activesupport-5.1.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'activesupport', '~> 5.1'

data/gemfiles/activesupport-6.0.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'activesupport', '~> 6.0.0.rc1'

data/lib/measured/base.rb

@@ -2,6 +2,7 @@ require "forwardable"
 require "measured/version"
 require "active_support/all"
 require "bigdecimal"
+require "json"
 
 module Measured
   class UnitError < StandardError ; end
@@ -44,4 +45,7 @@ require "measured/unit"
 require "measured/unit_system"
 require "measured/unit_system_builder"
 require "measured/conversion_table_builder"
+require "measured/cache/null"
+require "measured/cache/json_writer"
+require "measured/cache/json"
 require "measured/measurable"

data/lib/measured/cache/json.rb

@@ -0,0 +1,48 @@
+module Measured::Cache
+  class Json
+    attr_reader :filename, :path
+
+    def initialize(filename)
+      @filename = filename
+      @path = Pathname.new(File.join(File.dirname(__FILE__), "../../../cache", @filename)).cleanpath
+    end
+
+    def exist?
+      File.exist?(@path)
+    end
+
+    def read
+      return unless exist?
+      decode(JSON.load(File.read(@path)))
+    end
+
+    def write(table)
+      raise ArgumentError, "Cannot overwrite file cache at runtime."
+    end
+
+    private
+
+    # JSON dump and load of Rational objects exists, but it changes the behaviour of JSON globally if required.
+    # Instead, the same marshalling technique is rewritten here to prevent changing this behaviour project wide.
+    # https://github.com/ruby/ruby/blob/trunk/ext/json/lib/json/add/rational.rb
+    def encode(table)
+      table.each_with_object(table.dup) do |(k1, v1), accu|
+        v1.each do |k2, v2|
+          if v2.is_a?(Rational)
+            accu[k1][k2] = { "numerator" => v2.numerator, "denominator" => v2.denominator }
+          end
+        end
+      end
+    end
+
+    def decode(table)
+      table.each_with_object(table.dup) do |(k1, v1), accu|
+        v1.each do |k2, v2|
+          if v2.is_a?(Hash)
+            accu[k1][k2] = Rational(v2["numerator"], v2["denominator"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/measured/cache/json_writer.rb

@@ -0,0 +1,8 @@
+module Measured::Cache::JsonWriter
+  def write(table)
+    File.open(@path, "w") do |f|
+      f.write("// Do not modify this file directly. Regenerate it with 'rake cache:write'.\n")
+      f.write(JSON.pretty_generate(encode(table)))
+    end
+  end
+end

data/lib/measured/cache/null.rb

@@ -0,0 +1,15 @@
+module Measured::Cache
+  class Null
+    def exist?
+      false
+    end
+
+    def read
+      nil
+    end
+
+    def write(table)
+      nil
+    end
+  end
+end

data/lib/measured/conversion_table_builder.rb

@@ -1,14 +1,29 @@
 class Measured::ConversionTableBuilder
   attr_reader :units
 
-  def initialize(units)
+  def initialize(units, cache: nil)
     @units = units
+    cache ||= { class: Measured::Cache::Null }
+    @cache = cache[:class].new(*cache[:args])
   end
 
   def to_h
-    table = {}
+    return @cache.read if cached?
+    generate_table
+  end
+
+  def update_cache
+    @cache.write(generate_table)
+  end
+
+  def cached?
+    @cache.exist?
+  end
 
-    units.map{|u| u.name}.each do |to_unit|
+  private
+
+  def generate_table
+    units.map(&:name).each_with_object({}) do |to_unit, table|
       to_table = {to_unit => Rational(1, 1)}
 
       table.each do |from_unit, from_table|
@@ -19,12 +34,8 @@ class Measured::ConversionTableBuilder
 
       table[to_unit] = to_table
     end
-
-    table
   end
 
-  private
-
   def find_conversion(to:, from:)
     conversion = find_direct_conversion_cached(to: to, from: from) || find_tree_traversal_conversion(to: to, from: from)
 
@@ -34,13 +45,13 @@ class Measured::ConversionTableBuilder
   end
 
   def find_direct_conversion_cached(to:, from:)
-    @cache ||= {}
-    @cache[to] ||= {}
+    @direct_conversion_cache ||= {}
+    @direct_conversion_cache[to] ||= {}
 
-    if @cache[to].key?(from)
-       @cache[to][from]
+    if @direct_conversion_cache[to].key?(from)
+       @direct_conversion_cache[to][from]
     else
-      @cache[to][from] = find_direct_conversion(to: to, from: from)
+      @direct_conversion_cache[to][from] = find_direct_conversion(to: to, from: from)
     end
   end
 

data/lib/measured/unit_system.rb

@@ -1,9 +1,9 @@
 class Measured::UnitSystem
   attr_reader :units
 
-  def initialize(units)
+  def initialize(units, cache: nil)
     @units = units.map { |unit| unit.with_unit_system(self) }
-    @conversion_table_builder = Measured::ConversionTableBuilder.new(@units)
+    @conversion_table_builder = Measured::ConversionTableBuilder.new(@units, cache: cache)
   end
 
   def unit_names_with_aliases
@@ -41,6 +41,14 @@ class Measured::UnitSystem
     value.to_r * conversion
   end
 
+  def update_cache
+    @conversion_table_builder.update_cache
+  end
+
+  def cached?
+    @conversion_table_builder.cached?
+  end
+
   protected
 
   def conversion_table

data/lib/measured/unit_system_builder.rb

@@ -1,6 +1,7 @@
 class Measured::UnitSystemBuilder
   def initialize
     @units = []
+    @cache = nil
   end
 
   def unit(unit_name, aliases: [], value: nil)
@@ -13,8 +14,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

data/lib/measured/units/length.rb

@@ -5,4 +5,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

@@ -12,4 +12,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

@@ -8,4 +8,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,3 @@
 module Measured
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end

data/measured.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   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.0"
 
   spec.add_development_dependency "rake", "> 10.0"
   spec.add_development_dependency "minitest", "> 5.5.1"

data/test/cache/json_test.rb

@@ -0,0 +1,42 @@
+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,22 @@
+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,19 @@
+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,18 @@
+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

@@ -115,4 +115,22 @@ class Measured::ConversionTableBuilderTest < ActiveSupport::TestCase
       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

@@ -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