quantified 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b82fde76b902f73feeafc005768ef407964241c1
+  data.tar.gz: b36878a61fde1cf01bb5b982295d15a66fa1317c
+SHA512:
+  metadata.gz: eb74b18116d50c2cff3a550c47cd93569d901e96f6f265e73d6a27774401e9591dad3893de93e2beac5f3e45128b00fe73a57365b02973600f8a41d152fa5685
+  data.tar.gz: 6b0391b2b1a160eefccacbdb7cfea0c210fb56fa2a4ca6cd549882c8c08f0052f0b1adb3aa806a156bc7c7a8a69159bc2844c9f876e57c1c813df4356d8fc93d

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile*.lock
+.DS_Store
+._*
+*.orig
+pkg/
+doc/
+.yardoc/

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+script: bundle exec rake
+sudo: false
+
+rvm:
+- "2.0"
+- "2.1"
+- "2.2"

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 James MacAulay
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# Quantified [![Build Status](https://travis-ci.org/Shopify/quantified.svg?branch=master)](https://travis-ci.org/Shopify/quantified)
+
+Pretty quantifiable measurements which feel like ActiveSupport::Duration.
+
+Access whichever included attributes you want like so:
+
+    require 'quantified/mass'
+    require 'quantified/length'
+
+Add methods to Numeric (only plural, must correspond with plural unit names):
+
+    Mass.numeric_methods :grams, :kilograms, :ounces, :pounds
+    Length.numeric_methods :metres, :centimetres, :inches, :feet
+
+Then you can do things like this:
+
+    1.feet == 12.inches
+    # => true
+
+    18.inches.to_feet
+    # => #<Quantified::Length: 1.5 feet>
+
+    (2.5).feet.in_millimetres.to_s
+    # => "762.0 millimetres"
+
+
+You can easily define new attributes. Here's length.rb:
+
+    module Quantified
+      class Length < Attribute
+        system :metric do
+          primitive :metre
+
+          one :centimetre, :is => Length.new(0.01, :metres)
+          one :millimetre, :is => Length.new(0.1, :centimetres)
+          one :kilometre, :is => Length.new(1000, :metres)
+        end
+
+        system :imperial do
+          primitive :inch
+          one :inch, :is => Length.new(2.540, :centimetres)
+
+          one :foot, :plural => :feet, :is => Length.new(12, :inches)
+          one :yard, :is => Length.new(3, :feet)
+          one :mile, :is => Length.new(5280, :feet)
+        end
+      end
+    end

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+task :default => :test
+
+desc 'Test the plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/quantified.rb

@@ -0,0 +1,6 @@
+require 'quantified/version'
+require 'quantified/attribute'
+require 'quantified/mass'
+require 'quantified/length'
+
+require 'bigdecimal'

data/lib/quantified/attribute.rb

@@ -0,0 +1,222 @@
+module Quantified
+  class Attribute
+    include Comparable
+
+    attr_reader :amount, :unit
+
+    def initialize(amount, unit)
+      raise ArgumentError, "amount must be a Numeric" unless amount.is_a?(Numeric)
+      @amount, @unit = amount, unit.to_sym
+    end
+
+    def to_s
+      "#{amount} #{unit}"
+    end
+
+    def inspect
+      "#<#{self.class.name}: #{amount} #{unit}>"
+    end
+
+    def ==(other)
+      (BigDecimal.new(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit) || BigDecimal.new(self.class.convert(amount, unit, other.unit).to_s) == BigDecimal.new(other.amount.to_s)
+    rescue NoMethodError
+      amount == other
+    end
+
+    def eql?(other)
+      self.class == other.class && BigDecimal.new(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit
+    end
+
+    def <=>(other)
+      if self.class == other.class
+        self.class.convert(amount, unit, other.unit) <=> other.amount
+      else
+        amount <=> other
+      end
+    end
+
+    def system
+      self.class.units_to_systems[unit]
+    end
+
+    def coerce(other)
+      [other, amount]
+    end
+
+    def method_missing(meth, *args)
+      if args.size == 1 && self.class == (other = args.first).class
+        other_amount_in_self_units = self.class.convert(other.amount, other.unit, unit)
+        self.class.new(amount.send(meth, other_amount_in_self_units), unit)
+      else
+        amount.send(meth, *args)
+      end
+    end
+
+    def self.conversion_rate(from, to)
+      return nil unless conversions[from] and conversions[to]
+      conversions[from][to] ||=
+      (1.0 / conversions[to][from] if conversions[to][from]) || begin
+        shared_conversions = conversions[from].keys & conversions[to].keys
+        if shared_conversions.any?
+          primitive = shared_conversions.first
+          conversions[from][primitive] * (1.0 / conversions[to][primitive])
+        else
+          conversions[from].each do |conversion_unit, multiple|
+            if conversions[to].include?(conversion_unit)
+              return multiple * conversion_rate(conversion) * (1.0 / conversions[to][conversion_unit])
+            end
+          end
+          from_primitive = (conversions[from].keys & primitives).first
+          to_primitive = (conversions[to].keys & primitives).first
+          if from_primitive_to_primitive_multiple = conversion_rate(from_primitive, to_primitive)
+            return conversions[from][from_primitive] * from_primitive_to_primitive_multiple * (1.0 / conversions[to][to_primitive])
+          end
+          raise StandardError, "No conversion path from #{from} to #{to}"
+        end
+      end
+    end
+
+    def self.units(system = nil)
+      if system
+        systems_to_units[system.to_sym].dup
+      else
+        primitives | conversions.keys
+      end
+    end
+
+    def self.non_primitives
+      conversions.keys
+    end
+
+    def self.systems
+      systems_to_units.keys
+    end
+
+    def self.add_numeric_methods?
+      add_numeric_methods
+    end
+
+    def self.numeric_methods(*args)
+      args.each do |arg|
+        add_numeric_method_for(arg.to_sym)
+      end
+    end
+
+    protected
+
+    class << self
+      def primitives;              @primitives ||= [];             end
+      def add_numeric_methods;     @add_numeric_methods ||= false; end
+      attr_writer :add_numeric_methods
+      def conversions;             @conversions ||= {};            end
+      attr_reader :current_system
+      attr_writer :current_system
+      def systems_to_units;        @systems_to_units ||= {};       end
+      def units_to_systems;        @units_to_systems ||= {};       end
+    end
+
+    def self.system(system_name, &block)
+      old_system = current_system
+      self.current_system = system_name.to_sym
+      yield
+      self.current_system = old_system
+    end
+
+    def self.primitive(sym, options = {})
+      unit_sym = pluralize_unit(sym, options[:plural]).to_sym
+      primitives << unit_sym
+      add_to_system(unit_sym)
+      add_methods_for(unit_sym, options)
+    end
+
+    def self.add_to_system(unit_sym)
+      if current_system
+        units_to_systems[unit_sym] ||= begin
+          sys_ary = systems_to_units[current_system] ||= []
+          sys_ary << unit_sym
+          current_system
+        end
+      end
+    end
+
+    def self.one(sym, options = {})
+      unit_sym = pluralize_unit(sym, options[:plural]).to_sym
+      add_to_system(unit_sym)
+      register_unit(unit_sym, options[:is].unit, options[:is].amount)
+      add_methods_for(unit_sym, options)
+    end
+
+    def self.register_unit(multiple_unit, other_unit, multiple)
+      multiple_unit, other_unit = multiple_unit.to_sym, other_unit.to_sym
+      conversions[multiple_unit] ||= {}
+      conversions[other_unit] ||= {}
+
+      if primitives.include?(multiple_unit) || primitives.include?(other_unit)
+        add_conversion(multiple_unit, other_unit, multiple)
+      else
+        [multiple_unit, other_unit].each do |this_unit|
+          conversions[this_unit].each do |this_other_unit, this_multiple|
+            if primitives.include?(this_other_unit)
+              add_conversion(multiple_unit, this_other_unit, multiple * this_multiple)
+            end
+          end
+        end
+      end
+    end
+
+    def self.add_conversion(multiple_unit, other_unit, multiple)
+      conversions[multiple_unit] ||= {}
+      conversions[multiple_unit][other_unit] = multiple
+      conversions[other_unit] ||= {}
+      conversions[other_unit][multiple_unit] = (1.0 / multiple)
+    end
+
+    def self.convert(amount, from, to)
+      from, to = from.to_sym, to.to_sym
+      amount * conversion_rate(from, to)
+    end
+
+    def self.add_methods_for(sym, options = {})
+      add_conversion_method_for(sym, options)
+      add_numeric_method = if options.has_key?(:add_numeric_methods)
+        options[:add_numeric_methods]
+      else
+        add_numeric_methods
+      end
+      add_numeric_method_for(sym.to_s, options) if add_numeric_method
+    end
+
+    def self.add_conversion_method_for(sym, options = {})
+      unit_name = sym.to_s
+      class_eval do
+        define_method("to_#{unit_name}") do
+          return self if unit_name == unit.to_s
+          self.class.new(self.class.convert(amount, unit, unit_name), unit_name)
+        end
+        alias_method("in_#{unit_name}", "to_#{unit_name}")
+      end
+    end
+
+    def self.add_numeric_method_for(unit_name, options = {})
+      unit_name = unit_name.to_sym
+      raise ArgumentError, "#{unit_name.inspect} is not a unit in #{name}" unless units.include?(unit_name)
+      klass = self
+      Numeric.class_eval do
+        define_method(unit_name) do
+          klass.new(self, unit_name.to_sym)
+        end
+      end
+    end
+
+    PLURAL_EXCEPTIONS = {
+      'inch' => 'inches',
+      'foot' => 'feet',
+    }
+    private_constant :PLURAL_EXCEPTIONS
+
+    def self.pluralize_unit(word, provided_plural = nil)
+      return provided_plural unless provided_plural.nil?
+      PLURAL_EXCEPTIONS[word.to_s] || "#{word}s"
+    end
+  end
+end

data/lib/quantified/length.rb

@@ -0,0 +1,20 @@
+module Quantified
+  class Length < Attribute
+    system :metric do
+      primitive :metre
+
+      one :centimetre, :is => Length.new(0.01, :metres)
+      one :millimetre, :is => Length.new(0.1, :centimetres)
+      one :kilometre, :is => Length.new(1000, :metres)
+    end
+
+    system :imperial do
+      primitive :inch
+      one :inch, :is => Length.new(0.0254, :metres)
+
+      one :foot, :plural => :feet, :is => Length.new(12, :inches)
+      one :yard, :is => Length.new(3, :feet)
+      one :mile, :is => Length.new(5280, :feet)
+    end
+  end
+end

data/lib/quantified/mass.rb

@@ -0,0 +1,19 @@
+module Quantified
+  class Mass < Attribute
+    system :metric do
+      primitive :gram
+
+      one :milligram, :is => Mass.new(0.001, :grams)
+      one :kilogram, :is => Mass.new(1000, :grams)
+    end
+
+    system :imperial do
+      primitive :ounce
+      one :ounce, :is => Mass.new(28.349523125, :grams)
+
+      one :pound, :is => Mass.new(16, :ounces)
+      one :stone, :is => Mass.new(14, :pounds)
+      one :short_ton, :is => Mass.new(2000, :pounds)
+    end
+  end
+end

data/lib/quantified/version.rb

@@ -0,0 +1,3 @@
+module Quantified
+  VERSION = "1.0.0"
+end

data/quantified.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'quantified/version'
+
+Gem::Specification.new do |s|
+  s.name        = "quantified"
+  s.version     = Quantified::VERSION
+  s.license     = 'MIT'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["James MacAulay", "Willem van Bergen"]
+  s.email       = ["james@shopify.com"]
+  s.homepage    = "https://github.com/Shopify/quantified"
+  s.summary     = "Pretty quantifiable measurements which feel like ActiveSupport::Duration."
+  s.description = s.summary
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('test-unit')
+
+  s.files        = `git ls-files`.split($/)
+  s.executables  = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files   = s.files.grep(%r{^(test|spec|features)/})
+  s.require_path = ['lib']
+end

data/test/length_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+require 'quantified/length'
+
+class LengthTest < Test::Unit::TestCase
+  include Quantified
+  Length.numeric_methods :metres, :centimetres, :inches, :feet
+
+  def setup
+    @length = Length.new(5, :feet)
+  end
+
+  def test_inspect
+    assert_equal "#<Quantified::Length: 5 feet>", @length.inspect
+  end
+
+  def test_to_s
+    assert_equal "5 feet", @length.to_s
+  end
+
+  def test_initialize_from_numeric
+    assert_equal "5 feet", 5.feet.to_s
+  end
+
+  def test_equalities
+    assert_equal 1.feet, (1.0).feet
+    # == based on value
+    assert_equal 6.feet, Length.new(2, :yards)
+    # eql? based on value and unit
+    assert !6.feet.eql?(Length.new(2, :yards))
+    # equal? based on object identity
+    assert !2.feet.equal?(2.feet)
+  end
+
+  def test_convert_mm_to_inches
+    assert_equal 12, Length.new(304.8, :millimetres).to_inches
+  end
+
+  def test_convert_yards_to_feet
+    assert 6.feet.eql?(Length.new(2, :yards).to_feet)
+  end
+
+  def test_convert_feet_to_yards
+    assert Length.new(2, :yards).eql?(6.feet.to_yards)
+  end
+
+  def test_convert_yards_to_millimetres
+    assert_in_epsilon Length.new(914.4, :millimetres).to_f, Length.new(1, :yards).to_millimetres.to_f
+  end
+
+  def test_convert_millimetres_to_yards
+    assert_in_epsilon Length.new(1, :yards).to_f, Length.new(914.4, :millimetres).to_yards.to_f
+  end
+
+  def test_convert_metres_to_inches
+    assert_in_epsilon 1.inches.to_f, (0.0254).metres.to_inches.to_f
+  end
+
+  def test_comparison_with_numeric
+    assert 2.feet > 1
+    assert 2.feet == 2
+    assert 2.feet <= 2
+    assert 2.feet < 3
+  end
+
+  def test_method_missing_to_i
+    assert_equal 2, (2.4).feet.to_i
+  end
+
+  def test_method_missing_to_f
+    assert_equal 2.4, (2.4).feet.to_f
+  end
+
+  def test_method_missing_minus
+    assert_equal 2.feet, 5.feet - 3.feet
+  end
+
+  def test_numeric_methods_not_added_for_some_units
+    assert_raises(NoMethodError) do
+      2.yards
+    end
+    assert_raises(NoMethodError) do
+      2.millimetres
+    end
+  end
+
+  def test_systems
+    assert_equal [:metric, :imperial], Length.systems
+    assert_equal [:metres, :centimetres, :millimetres, :kilometres], Length.units(:metric)
+    assert_equal [:inches, :feet, :yards, :miles], Length.units(:imperial)
+
+    assert_equal :metric, 2.centimetres.system
+    assert_equal :imperial, 2.feet.system
+  end
+end

data/test/mass_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+require 'quantified/mass'
+
+class MassTest < Test::Unit::TestCase
+  include Quantified
+  Mass.numeric_methods :grams, :kilograms, :ounces, :pounds
+
+  def setup
+    @mass = Mass.new(5, :pounds)
+  end
+
+  def test_inspect
+    assert_equal "#<Quantified::Mass: 5 pounds>", @mass.inspect
+  end
+
+  def test_to_s
+    assert_equal "5 pounds", @mass.to_s
+  end
+
+  def test_initialize_from_numeric
+    assert_equal "5 pounds", 5.pounds.to_s
+  end
+
+  def test_equalities
+    assert_equal 1.pounds, (1.0).pounds
+    # == based on value
+    assert_equal 4000.pounds, Mass.new(2, :short_tons)
+    # eql? based on value and unit
+    assert !4000.pounds.eql?(Mass.new(2, :short_tons))
+    # equal? based on object identity
+    assert !2.pounds.equal?(2.pounds)
+  end
+
+  def test_convert_short_tons_to_pounds
+    assert 4000.pounds.eql?(Mass.new(2, :short_tons).to_pounds)
+  end
+
+  def test_convert_pounds_to_short_tons
+    assert Mass.new(2, :short_tons).eql?(4000.pounds.to_short_tons)
+  end
+
+  def test_convert_short_tons_to_milligrams
+    assert Mass.new(907_184_740, :milligrams).eql?(Mass.new(1, :short_tons).to_milligrams)
+  end
+
+  def test_convert_milligrams_to_short_tons
+    assert Mass.new(1, :short_tons).eql?(Mass.new(907_184_740, :milligrams).to_short_tons)
+  end
+
+  def test_convert_grams_to_ounces
+    assert 1.ounces.eql?((28.349523125).grams.to_ounces)
+    assert 1.ounces.eql?((28.349523125).grams.in_ounces)
+  end
+
+  def test_comparison_with_numeric
+    assert 2.pounds > 1
+    assert 2.pounds == 2
+    assert 2.pounds <= 2
+    assert 2.pounds < 3
+  end
+
+  def test_method_missing_to_i
+    assert_equal 2, (2.4).pounds.to_i
+  end
+
+  def test_method_missing_to_f
+    assert_equal 2.4, (2.4).pounds.to_f
+  end
+
+  def test_method_missing_minus
+    assert_equal 2.pounds, 5.pounds - 3.pounds
+  end
+
+  def test_numeric_methods_not_added_for_some_units
+    assert_raises NoMethodError do
+      2.short_tons
+    end
+    assert_raises NoMethodError do
+      2.milligrams
+    end
+  end
+
+  def test_systems
+    assert_equal [:metric, :imperial], Mass.systems
+    assert_equal [:grams, :milligrams, :kilograms], Mass.units(:metric)
+    assert_equal [:ounces, :pounds, :stones, :short_tons], Mass.units(:imperial)
+  end
+
+  def test_right_side_comparison_with_fixnum
+    assert Mass.new(14, :grams) < 20
+  end
+
+  def test_left_side_comparison_with_fixnum
+    assert 20 > Mass.new(14, :grams)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+# require 'active_support/inflector'
+
+require 'quantified'
+
+class Test::Unit::TestCase
+  EPSILON = 0.00001
+
+  def assert_in_epsilon(expected, actual, msg = nil)
+    assert_in_delta expected, actual, EPSILON, msg
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: quantified
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James MacAulay
+- Willem van Bergen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Pretty quantifiable measurements which feel like ActiveSupport::Duration.
+email:
+- james@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/quantified.rb
+- lib/quantified/attribute.rb
+- lib/quantified/length.rb
+- lib/quantified/mass.rb
+- lib/quantified/version.rb
+- quantified.gemspec
+- test/length_test.rb
+- test/mass_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Shopify/quantified
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Pretty quantifiable measurements which feel like ActiveSupport::Duration.
+test_files:
+- test/length_test.rb
+- test/mass_test.rb
+- test/test_helper.rb