Parse fraction characters

Author: mhuggins

.travis.yml

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

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

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 @@ def #{operator}(obj)
       end
     END
   end
-  
+
   def **(obj)
     case obj
     when Numeric
@@ -56,82 +76,96 @@ def **(obj)
       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 }

lib/ruby-measurement/unit.rb

@@ -3,85 +3,85 @@
 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

spec/ruby-measurement/core_ext/string_spec.rb

@@ -6,29 +6,29 @@
       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 }