ruby-measurement 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d9f8dac16cbf7f18dfbebf4f9ed90b4ab1236bf
-  data.tar.gz: 18689f648cb2a657e68db270e74442f0eb0aa5ee
+  metadata.gz: 31687bfdd62b83ca04ffba2a8d1c106d767f8ac4
+  data.tar.gz: 5eb61379bb4dc5b1eaf051c96cf1c55353bb4b0b
 SHA512:
-  metadata.gz: 1c83f8edb8c522cbc94b1623b74166bb5afc44c71ceb5f149eb7c11bea352bf6bcbbbdcec1544e39874a80884b3ea30c823978e8f637afa015877676196e484e
-  data.tar.gz: c68397ddd27017653b7de555a2ad99eaa3ba00eafdfa8060f9d46fde7636b37e7fa61b96a8000d4cfdd70d0b26a8c3120404c8fa96b34af731eefa10b340614c
+  metadata.gz: 25e76a22f35f3e5af25a1f79bf0f396eeba2273da6d6d8011dc11f34e02e868b374227aa1f95ee6a541ddaf1b98d6408ddb30f6898a49c43d12852128e8ba79f
+  data.tar.gz: e7f70d5166d49109632bbc8c8a0b8cf3c706fea85c5dc4b3abaddebc0af46581468394ffdae920fdea235bad66dcf1cc0d9b6aa9afe6ab52988ac593454d8d4c

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+sudo: false
 
 rvm:
   - 1.9.3

data/CHANGELOG.md

@@ -1,32 +1,35 @@
+## ruby-measurement 1.2.3 (Mar 27, 2016)
+
+* Updated parsing to accept UTF-8 fractions (½, ⅓, etc.). *Matt Huggins*
+
 ## ruby-measurement 1.2.2 (Jul 13, 2014)
 
-* Fix `Measurement::Unit#==` to properly compare units. *Matt Huggins*
+* Fixed `Measurement::Unit#==` to properly compare units. *Matt Huggins*
 
 ## ruby-measurement 1.2.1 (Jul 27, 2013)
 
-* Implement `Measurement.names` to list all available units. *Daniele Palombo*
+* Added `Measurement.names` to list all available units. *Daniele Palombo*
 
 ## ruby-measurement 1.2.0 (Mar 16, 2013)
 
-* Implement `String#to_measurement`, `String#to_unit`,
+* Added `String#to_measurement`, `String#to_unit`,
   `Symbol#to_unit`, and `Numeric#to_measurement`. *Matt Huggins*
 
 ## ruby-measurement 1.1.0 (Feb 6, 2013)
 
-* Move unit definition logic into `Unit` class. *Matt Huggins*
-* Create test suite. *Matt Huggins*
-* Fix parsing of `'` and `"` for feet and inches. *Matt Huggins*
-* Implement missing metric weights and U.S. customary capacities.
-  *Matt Huggins*
-* Fix several conversions that were found to be miscalculating.
+* Moved unit definition logic into `Unit` class. *Matt Huggins*
+* Added test suite. *Matt Huggins*
+* Fixed parsing of `'` and `"` for feet and inches. *Matt Huggins*
+* Added missing metric weights and U.S. customary capacities. *Matt Huggins*
+* Fixed several conversions that were found to be miscalculating.
   *Matt Huggins*
 
 ## ruby-measurement 1.0.0 (Jan 22, 2013)
 
-* Fix parsing of mixed fractions. *Matt Huggins*
-* Allow parsing of quantity & unit to work when not separated by a space.
+* Fixed parsing of mixed fractions. *Matt Huggins*
+* Updated parsing of quantity & unit to work when not separated by a space.
   *Matt Huggins*
-* Change `Measurement` initializer to accept quantity & unit instead of a
+* Updated `Measurement` initializer to accept quantity & unit instead of a
   single string for parsing. *Matt Huggins*
 
 ## ruby-measurement 0.0.1 (Jan 21, 2013)

data/lib/ruby-measurement/core_ext/string.rb

@@ -4,7 +4,7 @@ class String
   def to_measurement
     Measurement.parse(self)
   end
-  
+
   def to_unit
     Measurement::Unit[self] or raise ArgumentError, "Invalid unit: #{self}"
   end

data/lib/ruby-measurement/measurement.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'ruby-measurement/unit'
 require 'ruby-measurement/version'
 
@@ -7,28 +9,46 @@ class Measurement
   SCIENTIFIC_REGEX  = /\A#{SCIENTIFIC_NUMBER}\s*#{UNIT_REGEX}?\z/.freeze
   RATIONAL_REGEX    = /\A([+-]?\d+\s+)?((\d+)\/(\d+))?\s*#{UNIT_REGEX}?\z/.freeze
   COMPLEX_REGEX     = /\A#{SCIENTIFIC_NUMBER}?#{SCIENTIFIC_NUMBER}i\s*#{UNIT_REGEX}?\z/.freeze
-  
+
+  RATIOS = {
+    '¼' => '1/4',
+    '½' => '1/2',
+    '¾' => '3/4',
+    '⅓' => '1/3',
+    '⅔' => '2/3',
+    '⅕' => '1/5',
+    '⅖' => '2/5',
+    '⅗' => '3/5',
+    '⅘' => '4/5',
+    '⅙' => '1/6',
+    '⅚' => '5/6',
+    '⅛' => '1/8',
+    '⅜' => '3/8',
+    '⅝' => '5/8',
+    '⅞' => '7/8',
+  }.freeze
+
   attr_reader :quantity, :unit
-  
+
   def initialize(quantity, unit_name = :count)
     unit = unit_name
     unit = Unit[unit_name.to_s] if unit_name.kind_of?(Symbol) || unit_name.kind_of?(String)
-    
+
     raise ArgumentError, "Invalid quantity: #{quantity}" unless quantity.kind_of?(Numeric)
     raise ArgumentError, "Invalid unit: #{unit_name}" unless unit.kind_of?(Unit)
-    
+
     @quantity = quantity
     @unit = unit
   end
-  
+
   def inspect
     to_s
   end
-  
+
   def to_s
     "#{quantity} #{unit}"
   end
-  
+
   %w(+ - * /).each do |operator|
     class_eval <<-END, __FILE__, __LINE__ + 1
       def #{operator}(obj)
@@ -47,7 +67,7 @@ class Measurement
       end
     END
   end
-  
+
   def **(obj)
     case obj
     when Numeric
@@ -56,82 +76,96 @@ class Measurement
       raise ArgumentError, "Invalid arithmetic: #{self} ** #{obj}"
     end
   end
-  
+
   def ==(obj)
     obj.kind_of?(self.class) && quantity == obj.quantity && unit == obj.unit
   end
-  
+
   def convert_to(unit_name)
     unit = Unit[unit_name]
     raise ArgumentError, "Invalid unit: '#{unit_name}'" unless unit
-    
+
     return dup if unit == @unit
-    
+
     conversion = @unit.conversion(unit.name)
     raise ArgumentError, "Invalid conversion: '#@unit' to '#{unit.name}'" unless conversion
-    
+
     self.class.new(conversion.call(@quantity), unit.name)
   end
-  
+
   def convert_to!(unit_name)
     measurement = convert_to(unit_name)
     @unit, @quantity = measurement.unit, measurement.quantity
     self
   end
-  
-  def self.parse(str = '0')
-    str = str.strip
-    
-    case str
-      when COMPLEX_REGEX then unit_name, quantity = parse_complex(str)
-      when SCIENTIFIC_REGEX then unit_name, quantity = parse_scientific(str)
-      when RATIONAL_REGEX then unit_name, quantity = parse_rational(str)
-      else raise ArgumentError, "Unable to parse: '#{str}'"
+
+  class << self
+    def parse(str = '0')
+      str = normalize(str)
+
+      case str
+        when COMPLEX_REGEX then unit_name, quantity = parse_complex(str)
+        when SCIENTIFIC_REGEX then unit_name, quantity = parse_scientific(str)
+        when RATIONAL_REGEX then unit_name, quantity = parse_rational(str)
+        else raise ArgumentError, "Unable to parse: '#{str}'"
+      end
+
+      unit_name ||= 'count'
+      unit = Unit[unit_name.strip.downcase]
+      raise ArgumentError, "Invalid unit: '#{unit_name}'" unless unit
+
+      new(quantity, unit)
     end
-    
-    unit_name ||= 'count'
-    unit = Unit[unit_name.strip.downcase]
-    raise ArgumentError, "Invalid unit: '#{unit_name}'" unless unit
-    
-    new(quantity, unit)
-  end
-  
-  def self.define(unit_name, &block)
-    Unit.define(unit_name, &block)
-  end
-  
-  private
-  
-  def self.parse_complex(str)
-    real, imaginary, unit_name = str.scan(COMPLEX_REGEX).first
-    quantity = Complex(real.to_f, imaginary.to_f).to_f
-    return unit_name, quantity
-  end
-  
-  def self.parse_scientific(str)
-    whole, unit_name = str.scan(SCIENTIFIC_REGEX).first
-    quantity = whole.to_f
-    return unit_name, quantity
-  end
-  
-  def self.parse_rational(str)
-    whole, _, numerator, denominator, unit_name = str.scan(RATIONAL_REGEX).first
-    
-    if numerator && denominator
-      numerator = numerator.to_f + (denominator.to_f * whole.to_f)
-      denominator = denominator.to_f
-      quantity = Rational(numerator, denominator).to_f
-    else
+
+    def define(unit_name, &block)
+      Unit.define(unit_name, &block)
+    end
+
+    private
+
+    def normalize(str)
+      str.dup.tap do |str|
+        if str =~ Regexp.new(/(#{RATIOS.keys.join('|')})/)
+          RATIOS.each do |search, replace|
+            str.gsub!(search) { " #{replace}" }
+          end
+        end
+
+        str.strip!
+      end
+    end
+
+    def parse_complex(str)
+      real, imaginary, unit_name = str.scan(COMPLEX_REGEX).first
+      quantity = Complex(real.to_f, imaginary.to_f).to_f
+      return unit_name, quantity
+    end
+
+    def parse_scientific(str)
+      whole, unit_name = str.scan(SCIENTIFIC_REGEX).first
       quantity = whole.to_f
+      return unit_name, quantity
+    end
+
+    def parse_rational(str)
+      whole, _, numerator, denominator, unit_name = str.scan(RATIONAL_REGEX).first
+
+      if numerator && denominator
+        numerator = numerator.to_f + (denominator.to_f * whole.to_f)
+        denominator = denominator.to_f
+        quantity = Rational(numerator, denominator).to_f
+      else
+        quantity = whole.to_f
+      end
+
+      return unit_name, quantity
     end
-    
-    return unit_name, quantity
   end
-  
+
   define(:count) do |unit|
     unit.convert_to(:dozen) { |value| value / 12.0 }
   end
-  
+
   define(:doz) do |unit|
     unit.alias :dozen
     unit.convert_to(:count) { |value| value * 12.0 }

data/lib/ruby-measurement/unit.rb

@@ -3,85 +3,85 @@ require 'set'
 class Measurement
   class Unit
     attr_reader :name, :aliases, :conversions
-    
+
     @definitions = {}
-    
+
     def initialize(name)
       @name = name.to_s
       @aliases = Set.new
       @conversions = {}
       add_alias(name)
     end
-    
+
     def add_alias(*args)
       args.each do |unit_alias|
         @aliases << unit_alias.to_s
         self.class[unit_alias] = self
       end
     end
-    
+
     def add_conversion(unit_name, &block)
       @conversions[unit_name.to_s] = block
     end
-    
+
     def conversion(unit_name)
       unit = self.class[unit_name]
       return nil unless unit
-      
+
       unit.aliases.each do |unit_alias|
         conversion = @conversions[unit_alias.to_s]
         return conversion if conversion
       end
-      
+
       nil
     end
-    
+
     def inspect
       to_s
     end
-    
+
     def to_s
       name
     end
-    
+
     def ==(obj)
       obj.kind_of?(self.class) && name == obj.name && aliases == obj.aliases && conversions.all? do |key, proc|
         [-2.5, -1, 0, 1, 2.5].all? { |n| proc.call(n) == obj.conversions[key].call(n) }
       end
     end
-    
-    def self.define(unit_name, &block)
-      Builder.new(unit_name, &block)
-    end
-    
-    def self.[](unit_name)
-      @definitions[unit_name.to_s.downcase]
-    end
-    
-    def self.names
-      @definitions.keys
-    end
-    
-    private
-    
-    def self.[]=(unit_name, unit)
-      @definitions[unit_name.to_s.downcase] = unit
+
+    class << self
+      def define(unit_name, &block)
+        Builder.new(unit_name, &block)
+      end
+
+      def [](unit_name)
+        @definitions[unit_name.to_s.downcase]
+      end
+
+      def []=(unit_name, unit)
+        @definitions[unit_name.to_s.downcase] = unit
+      end
+
+      def names
+        @definitions.keys
+      end
     end
-    
+
     class Builder
       def initialize(unit_name, &block)
         @unit = Unit.new(unit_name)
         block.call(self) if block_given?
       end
-      
+
       def alias(*args)
         @unit.add_alias(*args)
       end
-      
+
       def convert_to(unit_name, &block)
         @unit.add_conversion(unit_name, &block)
       end
-      
+
       def to_unit
         @unit
       end

data/lib/ruby-measurement/version.rb

@@ -1,3 +1,3 @@
 class Measurement
-  VERSION = '1.2.2'
+  VERSION = '1.2.3'
 end

data/spec/ruby-measurement/core_ext/string_spec.rb

@@ -6,29 +6,29 @@ RSpec.describe String do
       subject { '3' }
       specify { expect(subject.to_measurement).to eq Measurement.new(3) }
     end
-    
+
     describe 'with valid quantity and unit' do
       subject { '3 dozen' }
       specify { expect(subject.to_measurement).to eq Measurement.new(3, :dozen) }
     end
-    
+
     describe 'with valid quantity and invalid unit' do
       subject { '3 people' }
       specify { expect { subject.to_measurement }.to raise_error }
     end
-    
+
     describe 'with invalid input' do
       subject { 'foobar' }
       specify { expect { subject.to_measurement }.to raise_error }
     end
   end
-  
+
   describe '#to_unit' do
     describe 'with valid unit' do
       subject { 'dozen' }
       specify { expect(subject.to_unit).to eq Measurement::Unit[:dozen] }
     end
-    
+
     describe 'with invalid unit' do
       subject { 'person' }
       specify { expect { subject.to_unit }.to raise_error }