measured 2.3.0 → 2.6.0

data/dev.yml

@@ -2,7 +2,7 @@ name: measured
 
 up:
   - ruby:
-      version: 2.3.1
+      version: 2.6.3
   - bundler
 
 commands:
@@ -14,5 +14,5 @@ commands:
       if [[ $# -eq 0 ]]; then
         bundle exec rake test
       else
-        bundle exec ruby -Itest "$@"
+        bundle exec rake test "$@"
       fi

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

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

data/gemfiles/activesupport-6.0.gemfile

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

data/gemfiles/activesupport-6.1.gemfile

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

data/lib/measured.rb

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

data/lib/measured/arithmetic.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Measured::Arithmetic
   def +(other)
     arithmetic_operation(other, :+)

data/lib/measured/base.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+require "forwardable"
 require "measured/version"
 require "active_support/all"
 require "bigdecimal"
+require "json"
 
 module Measured
-  class UnitError < StandardError ; end
-
   class << self
     def build(&block)
       builder = UnitSystemBuilder.new
@@ -21,10 +22,9 @@ module Measured
 
     def method_missing(method, *args)
       class_name = "Measured::#{ method }"
+      klass = class_name.safe_constantize
 
-      if Measurable.subclasses.map(&:to_s).include?(class_name)
-        klass = class_name.constantize
-
+      if klass && klass < Measurable
         Measured.define_singleton_method(method) do |value, unit|
           klass.new(value, unit)
         end
@@ -37,10 +37,16 @@ module Measured
   end
 end
 
+require "measured/unit_error"
+require "measured/unit_already_added"
+require "measured/missing_conversion_path"
 require "measured/arithmetic"
 require "measured/parser"
 require "measured/unit"
 require "measured/unit_system"
 require "measured/unit_system_builder"
-require "measured/conversion_table"
+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,49 @@
+# frozen_string_literal: true
+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,9 @@
+# frozen_string_literal: true
+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,16 @@
+# frozen_string_literal: true
+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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+class Measured::ConversionTableBuilder
+  attr_reader :units
+
+  def initialize(units, cache: nil)
+    @units = units
+    cache ||= { class: Measured::Cache::Null }
+    @cache = cache[:class].new(*cache[:args])
+  end
+
+  def to_h
+    return @cache.read if cached?
+    generate_table
+  end
+
+  def update_cache
+    @cache.write(generate_table)
+  end
+
+  def cached?
+    @cache.exist?
+  end
+
+  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|
+        conversion = find_conversion(to: from_unit, from: to_unit)
+        to_table[from_unit] = conversion
+        from_table[to_unit] = 1 / conversion
+      end
+
+      table[to_unit] = to_table
+    end
+  end
+
+  def find_conversion(to:, from:)
+    conversion = find_direct_conversion_cached(to: to, from: from) || find_tree_traversal_conversion(to: to, from: from)
+
+    raise Measured::MissingConversionPath.new(from, to) unless conversion
+
+    conversion
+  end
+
+  def find_direct_conversion_cached(to:, from:)
+    @direct_conversion_cache ||= {}
+    @direct_conversion_cache[to] ||= {}
+
+    if @direct_conversion_cache[to].key?(from)
+       @direct_conversion_cache[to][from]
+    else
+      @direct_conversion_cache[to][from] = find_direct_conversion(to: to, from: from)
+    end
+  end
+
+  def find_direct_conversion(to:, from:)
+    units.each do |unit|
+      return unit.conversion_amount if unit.name == from && unit.conversion_unit == to
+      return unit.inverse_conversion_amount if unit.name == to && unit.conversion_unit == from
+    end
+
+    nil
+  end
+
+  def find_tree_traversal_conversion(to:, from:)
+    traverse(from: from, to: to, units_remaining: units.map(&:name), amount: 1)
+  end
+
+  def traverse(from:, to:, units_remaining:, amount:)
+    units_remaining = units_remaining - [from]
+
+    units_remaining.each do |name|
+      conversion = find_direct_conversion_cached(from: from, to: name)
+
+      if conversion
+        new_amount = amount * conversion
+        if name == to
+          return new_amount
+        else
+          result = traverse(from: name, to: to, units_remaining: units_remaining, amount: new_amount)
+          return result if result
+        end
+      end
+    end
+
+    nil
+  end
+end

data/lib/measured/measurable.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 class Measured::Measurable < Numeric
-  DEFAULT_FORMAT_STRING = '%.2<value>f %<unit>s'
+  DEFAULT_FORMAT_STRING = "%.2<value>f %<unit>s"
 
   include Measured::Arithmetic
 
@@ -19,6 +20,18 @@ class Measured::Measurable < Numeric
     else
       BigDecimal(value)
     end
+
+    @value_string = begin
+      str = case value
+      when Rational
+        value.denominator == 1 ? value.numerator.to_s : value.to_f.to_s
+      when BigDecimal
+        value.to_s("F")
+      else
+        value.to_f.to_s
+      end
+      str.gsub(/\.0*\Z/, "")
+    end.freeze
   end
 
   def convert_to(new_unit)
@@ -39,18 +52,16 @@ class Measured::Measurable < Numeric
   end
 
   def to_s
-    @to_s ||= "#{value_string} #{unit.name}"
+    "#{@value_string} #{unit.name}"
   end
 
   def humanize
-    @humanize ||= begin
-      unit_string = value == 1 ? unit.name : ActiveSupport::Inflector.pluralize(unit.name)
-      "#{value_string} #{unit_string}"
-    end
+    unit_string = value == 1 ? unit.name : ActiveSupport::Inflector.pluralize(unit.name)
+    "#{@value_string} #{unit_string}"
   end
 
   def inspect
-    @inspect ||= "#<#{self.class}: #{value_string} #{unit.inspect}>"
+    "#<#{self.class}: #{@value_string} #{unit.inspect}>"
   end
 
   def <=>(other)
@@ -86,18 +97,4 @@ class Measured::Measurable < Numeric
   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
-      when Rational
-        value.denominator == 1 ? value.numerator.to_s : value.to_f.to_s
-      when BigDecimal
-        value.to_s("F")
-      else
-        value.to_f.to_s
-      end
-      str.gsub(/\.0*\Z/, "")
-    end
-  end
 end

data/lib/measured/missing_conversion_path.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Measured
+  class MissingConversionPath < UnitError
+    attr_reader :from, :to
+
+    def initialize(from, to)
+      super("Cannot find conversion path from #{from} to #{to}.")
+      @from = from
+      @to = to
+    end
+  end
+end

data/lib/measured/parser.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Measured::Parser
   extend self
 

data/lib/measured/unit.rb

@@ -1,43 +1,41 @@
+# frozen_string_literal: true
 class Measured::Unit
   include Comparable
 
-  attr_reader :name, :aliases, :conversion_amount, :conversion_unit, :unit_system
+  attr_reader :name, :names, :aliases, :conversion_amount, :conversion_unit, :unit_system, :inverse_conversion_amount
 
   def initialize(name, aliases: [], value: nil, unit_system: nil)
     @name = name.to_s.freeze
     @aliases = aliases.map(&:to_s).map(&:freeze).freeze
+    @names = ([@name] + @aliases).sort!.freeze
     @conversion_amount, @conversion_unit = parse_value(value) if value
+    @inverse_conversion_amount = (1 / conversion_amount if conversion_amount)
+    @conversion_string = ("#{conversion_amount} #{conversion_unit}" if conversion_amount || conversion_unit)
     @unit_system = unit_system
   end
 
-  def with_unit_system(unit_system)
+  def with(name: nil, unit_system: nil, aliases: nil, value: nil)
     self.class.new(
-      name,
-      aliases: aliases,
-      value: conversion_string,
-      unit_system: unit_system
+      name || self.name,
+      aliases: aliases || self.aliases,
+      value: value || @conversion_string,
+      unit_system: unit_system || self.unit_system
     )
   end
 
-  def names
-    @names ||= ([name] + aliases).sort!.freeze
-  end
-
   def to_s
-    @to_s ||= if conversion_string
-      "#{name} (#{conversion_string})".freeze
+    if @conversion_string
+      "#{name} (#{@conversion_string})".freeze
     else
       name
     end
   end
 
   def inspect
-    @inspect ||= begin
-      pieces = [name]
-      pieces << "(#{aliases.join(", ")})" if aliases.any?
-      pieces << conversion_string if conversion_string
-      "#<#{self.class.name}: #{pieces.join(" ")}>".freeze
-    end
+    pieces = [name]
+    pieces << "(#{aliases.join(", ")})" if aliases.any?
+    pieces << @conversion_string if @conversion_string
+    "#<#{self.class.name}: #{pieces.join(" ")}>".freeze
   end
 
   def <=>(other)
@@ -53,16 +51,8 @@ class Measured::Unit
     end
   end
 
-  def inverse_conversion_amount
-    @inverse_conversion_amount ||= 1 / conversion_amount
-  end
-
   private
 
-  def conversion_string
-    @conversion_string ||= ("#{conversion_amount} #{conversion_unit}" if conversion_amount || conversion_unit)
-  end
-
   def parse_value(tokens)
     case tokens
     when String

data/lib/measured/unit_already_added.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Measured
+  class UnitAlreadyAdded < UnitError
+    attr_reader :unit_name
+
+    def initialize(unit_name)
+      super("Unit #{unit_name} has already been added.")
+      @unit_name = unit_name
+    end
+  end
+end

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,16 +1,22 @@
+# frozen_string_literal: true
 class Measured::UnitSystem
-  attr_reader :units
-
-  def initialize(units)
-    @units = units.map { |unit| unit.with_unit_system(self) }
-  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)
@@ -40,16 +46,15 @@ class Measured::UnitSystem
     value.to_r * conversion
   end
 
-  protected
-
-  def conversion_table
-    @conversion_table ||= Measured::ConversionTable.build(@units)
+  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