measured 2.4.0 → 2.7.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.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,11 +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
@@ -22,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
@@ -38,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_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), 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.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

@@ -1,14 +1,32 @@
+# frozen_string_literal: true
 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
+
+  private
 
-    units.map{|u| u.name}.each do |to_unit|
+  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|
@@ -19,28 +37,41 @@ class Measured::ConversionTableBuilder
 
       table[to_unit] = to_table
     end
+  end
 
-    table
+  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
 
-  private
+  # 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::UnitError, "Cannot find conversion path from #{ from } to #{ to }." unless conversion
+    raise Measured::MissingConversionPath.new(from, to) unless conversion
 
     conversion
   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
 
@@ -76,5 +107,4 @@ class Measured::ConversionTableBuilder
 
     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,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
 
@@ -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
+    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 if 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