measured 2.0.0 → 2.8.2

data/dev.yml

@@ -2,7 +2,7 @@ name: measured
 
 up:
   - ruby:
-      version: 2.3.1
+      version: 3.0.2
   - bundler
 
 commands:
@@ -14,9 +14,5 @@ commands:
       if [[ $# -eq 0 ]]; then
         bundle exec rake test
       else
-        bundle exec ruby -Itest "$@"
+        bundle exec rake test "$@"
       fi
-
-packages:
-  - git@github.com:Shopify/dev-shopify.git
-

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/arithmetic.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
 module Measured::Arithmetic
+  extend Forwardable
+  def_delegators :@value, :zero?, :positive?, :negative?, :finite?, :infinite?
+
   def +(other)
     arithmetic_operation(other, :+)
   end
@@ -18,6 +22,8 @@ module Measured::Arithmetic
   def coerce(other)
     if other.is_a?(self.class)
       [other, self]
+    elsif other.is_a?(Numeric) && other.zero?
+      [self.class.new(other, self.unit), self]
     else
       raise TypeError, "Cannot coerce #{other.class} to #{self.class}"
     end
@@ -27,6 +33,10 @@ module Measured::Arithmetic
     raise TypeError, "#{self.class} cannot be converted to an integer"
   end
 
+  def nonzero?
+    value.nonzero? ? self : false
+  end
+
   private
 
   def arithmetic_operation(other, operator)

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,17 @@ module Measured
   end
 end
 
+require "measured/unit_error"
+require "measured/cycle_detected"
+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,55 @@
+# 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), nil, freeze: true))
+    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.transform_values do |value1|
+        if value1.is_a?(Hash)
+          value1.transform_values do |value2|
+            if value2.is_a?(Hash)
+              Rational(value2["numerator"], value2["denominator"])
+            else
+              value2
+            end
+          end
+        else
+          value1
+        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,110 @@
+# 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
+    validate_no_cycles
+
+    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 validate_no_cycles
+    graph = units.select { |unit| unit.conversion_unit.present? }.group_by { |unit| unit.name }
+    validate_acyclic_graph(graph, from: graph.keys[0])
+  end
+
+  # This uses a depth-first search algorithm: https://en.wikipedia.org/wiki/Depth-first_search
+  def validate_acyclic_graph(graph, from:, visited: [])
+    graph[from]&.each do |edge|
+      adjacent_node = edge.conversion_unit
+      if visited.include?(adjacent_node)
+        raise Measured::CycleDetected.new(edge)
+      else
+        validate_acyclic_graph(graph, from: adjacent_node, visited: visited + [adjacent_node])
+      end
+    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/cycle_detected.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module Measured
+  class CycleDetected < UnitError
+    attr_reader :unit
+
+    def initialize(unit)
+      super("The following conversion introduces cycles in the unit system: #{unit}. Remove the conversion or fix the cycle.")
+      @unit = unit
+    end
+  end
+end

data/lib/measured/measurable.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
 class Measured::Measurable < Numeric
+  DEFAULT_FORMAT_STRING = "%.2<value>f %<unit>s"
+
   include Measured::Arithmetic
 
   attr_reader :unit, :value
@@ -9,7 +12,7 @@ class Measured::Measurable < Numeric
     @unit = unit_from_unit_or_name!(unit)
     @value = case value
     when Float
-      BigDecimal(value, Float::DIG + 1)
+      BigDecimal(value, Float::DIG)
     when BigDecimal, Rational
       value
     when Integer
@@ -17,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)
@@ -28,19 +43,25 @@ class Measured::Measurable < Numeric
     self.class.new(new_value, new_unit)
   end
 
+  def format(format_string=nil, with_conversion_string: true)
+    kwargs = {
+      value: self.value,
+      unit: self.unit.to_s(with_conversion_string: with_conversion_string),
+    }
+    (format_string || DEFAULT_FORMAT_STRING) % kwargs
+  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)
@@ -76,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
 
@@ -32,6 +33,6 @@ module Measured::Parser
 
     raise Measured::UnitError, "Cannot parse measurement from '#{string}'" unless result
 
-    [result.captures[0].to_r, result.captures[1]]
+    [result.captures[0].to_r, -result.captures[1]]
   end
 end

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
+  def to_s(with_conversion_string: true)
+    if with_conversion_string && @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

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)
@@ -8,12 +10,54 @@ class Measured::UnitSystemBuilder
     nil
   end
 
+  def si_unit(unit_name, aliases: [], value: nil)
+    @units += build_si_units(unit_name, aliases: aliases, value: value)
+    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
 
+  SI_PREFIXES = [
+    ["y", "yocto", -24],
+    ["z", "zepto", -21],
+    ["a", "atto", -18],
+    ["f", "femto", -15],
+    ["p", "pico", -12],
+    ["n", "nano", -9],
+    ["μ", "micro", -6],
+    ["m", "milli", -3],
+    ["c", "centi", -2],
+    ["d", "deci", -1],
+    ["da", "deca", 1],
+    ["h", "hecto", 2],
+    ["k", "kilo", 3],
+    ["M", "mega", 6],
+    ["G", "giga", 9],
+    ["T", "tera", 12],
+    ["P", "peta", 15],
+    ["E", "exa", 18],
+    ["Z", "zetta", 21],
+    ["Y", "yotta", 24],
+  ].map(&:freeze).freeze
+
+  def build_si_units(name, aliases: [], value: nil)
+    si_units = [build_unit(name, aliases: aliases, value: value)]
+    SI_PREFIXES.each do |short, long, exp|
+      long_names = aliases.map { |suffix| "#{long}#{suffix}" }
+      si_units << build_unit("#{short}#{name}", aliases: long_names, value: "#{10 ** exp} #{name}")
+    end
+    si_units
+  end
+
   def build_unit(name, aliases: [], value: nil)
     unit = Measured::Unit.new(name, aliases: aliases, value: value)
     check_for_duplicate_unit_names!(unit)
@@ -23,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,8 +1,11 @@
+# frozen_string_literal: true
 Measured::Length = Measured.build do
-  unit :m, aliases: [:meter, :metre, :meters, :metres]
-  unit :cm, value: "1/100 m", aliases: [:centimeter, :centimetre, :centimeters, :centimetres]
-  unit :mm, value: "1/1000 m", aliases: [:millimeter, :millimetre, :millimeters, :millimetres]
+  si_unit :m, aliases: [:meter, :metre, :meters, :metres]
+
   unit :in, value: "0.0254 m", aliases: [:inch, :inches]
   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