ingreedy 0.0.7 → 0.0.8

data/lib/ingreedy/ingreedy_parser.rb

@@ -1,105 +1,22 @@
-require 'parslet'
+require "parslet"
 
-require_relative 'amount_parser'
-require_relative 'rationalizer'
-require_relative 'unit_variation_mapper'
+require_relative "amount_parser"
+require_relative "rationalizer"
+require_relative "root_parser"
+require_relative "unit_variation_mapper"
 
 module Ingreedy
-
-  class Parser < Parslet::Parser
-
+  class Parser
     attr_reader :original_query
-    Result = Struct.new(:amount, :unit, :container_amount, :container_unit, :ingredient, :original_query)
-
-    rule(:range) do
-      AmountParser.new.as(:amount) >>
-      whitespace.maybe >>
-      str('-') >>
-      whitespace.maybe >>
-      AmountParser.new.as(:amount_end)
-    end
-
-    rule(:amount) do
-      AmountParser.new.as(:amount)
-    end
-
-    rule(:whitespace) do
-      match("\s")
-    end
-
-    rule(:container_amount) do
-      AmountParser.new
-    end
-
-    rule(:unit) do
-      if unit_matches.any?
-        unit_matches.map { |u| str(u) }.inject(:|)
-      else
-        str('')
-      end
-    end
-
-    rule(:container_unit) do
-      unit
-    end
-
-    rule(:unit_and_preposition) do
-      unit.as(:unit) >> (preposition_or_whitespace | any.absent?)
-    end
 
-    rule(:preposition_or_whitespace) do
-      if prepositions.empty?
-        whitespace
-      else
-        preposition | whitespace
-      end
-    end
-
-    rule(:preposition) do
-      whitespace >>
-      prepositions.map { |con| str(con) }.inject(:|) >>
-      whitespace
-    end
-
-    rule(:amount_unit_separator) do
-      whitespace | str('-')
-    end
-
-    rule(:container_size) do
-      # e.g. (12 ounce) or 12 ounce
-      str('(').maybe >>
-      container_amount.as(:container_amount) >>
-      amount_unit_separator.maybe >>
-      container_unit.as(:container_unit) >>
-      str(')').maybe >> preposition_or_whitespace
-    end
-
-    rule(:amount_and_unit) do
-      (range | amount) >>
-      whitespace.maybe >>
-      unit_and_preposition.maybe >>
-      container_size.maybe
-    end
-
-    rule(:quantity) do
-      amount_and_unit | unit_and_preposition
-    end
-
-    rule(:standard_format) do
-      # e.g. 1/2 (12 oz) can black beans
-      quantity >> any.repeat.as(:ingredient)
-    end
-
-    rule(:reverse_format) do
-      # e.g. flour 200g
-      ((whitespace >> quantity).absent? >> any).repeat.as(:ingredient) >> whitespace >> quantity
-    end
-
-    rule(:ingredient_addition) do
-      standard_format | reverse_format
-    end
-
-    root :ingredient_addition
+    Result = Struct.new(
+      :amount,
+      :unit,
+      :container_amount,
+      :container_unit,
+      :ingredient,
+      :original_query,
+    )
 
     def initialize(original_query)
       @original_query = original_query
@@ -107,31 +24,32 @@ module Ingreedy
 
     def parse
       result = Result.new
-      result[:original_query] = original_query
+      result.original_query = original_query
 
-      parslet = super(original_query)
+      parslet = RootParser.new(original_query).parse
 
-      result[:amount] = rationalize parslet[:amount]
-      result[:amount] = [result[:amount], rationalize(parslet[:amount_end])] if parslet[:amount_end]
-      result[:container_amount] = rationalize(parslet[:container_amount])
+      result.amount = rationalize parslet[:amount]
+      result.amount = [
+        result.amount,
+        rationalize(parslet[:amount_end]),
+      ] if parslet[:amount_end]
 
-      result[:unit] = convert_unit_variation_to_canonical(parslet[:unit].to_s) if parslet[:unit]
-      result[:container_unit] = convert_unit_variation_to_canonical(parslet[:container_unit].to_s) if parslet[:container_unit]
+      result.container_amount = rationalize(parslet[:container_amount])
 
-      result[:ingredient] = parslet[:ingredient].to_s.lstrip.rstrip #TODO cheating
+      result.unit = convert_unit_variation_to_canonical(
+        parslet[:unit].to_s,
+      ) if parslet[:unit]
 
-      result
-    end
+      result.container_unit = convert_unit_variation_to_canonical(
+        parslet[:container_unit].to_s,
+      ) if parslet[:container_unit]
 
-    private
+      result.ingredient = parslet[:ingredient].to_s.lstrip.rstrip # TODO: hack
 
-    def unit_matches
-      @unit_matches ||= original_query.scan(UnitVariationMapper.regexp).sort_by(&:length).reverse
+      result
     end
 
-    def prepositions
-      Ingreedy.dictionaries.current.prepositions
-    end
+    private
 
     def convert_unit_variation_to_canonical(unit_variation)
       UnitVariationMapper.unit_from_variation(unit_variation)
@@ -152,10 +70,10 @@ module Ingreedy
       word &&= word.to_s
 
       Rationalizer.rationalize(
-        integer:  integer,
-        float:    float,
+        integer: integer,
+        float: float,
         fraction: fraction,
-        word:     word
+        word: word,
       )
     end
   end

data/lib/ingreedy/rationalizer.rb

@@ -22,7 +22,7 @@ module Ingreedy
       elsif @integer
         result = @integer.to_r
       elsif @float
-        result = @float.gsub(',', '.').to_r
+        result = @float.tr(",", ".").to_r
       end
 
       result
@@ -30,17 +30,19 @@ module Ingreedy
 
     private
 
-      def rationalize_fraction
-        vulgar_fractions.each { |char, amount| @fraction.gsub!(char, amount.to_s) }
-        @fraction.to_r
+    def rationalize_fraction
+      vulgar_fractions.each do |char, amount|
+        @fraction.gsub!(char, amount.to_s)
       end
+      @fraction.to_r
+    end
 
-      def vulgar_fractions
-        Ingreedy.dictionaries.current.vulgar_fractions
-      end
+    def vulgar_fractions
+      Ingreedy.dictionaries.current.vulgar_fractions
+    end
 
-      def rationalize_word
-        Ingreedy.dictionaries.current.numbers[@word.downcase]
-      end
+    def rationalize_word
+      Ingreedy.dictionaries.current.numbers[@word.downcase]
+    end
   end
 end

data/lib/ingreedy/root_parser.rb

@@ -0,0 +1,118 @@
+module Ingreedy
+  class RootParser < Parslet::Parser
+    rule(:range) do
+      AmountParser.new.as(:amount) >>
+        whitespace.maybe >>
+        str("-") >>
+        whitespace.maybe >>
+        AmountParser.new.as(:amount_end)
+    end
+
+    rule(:amount) do
+      AmountParser.new.as(:amount)
+    end
+
+    rule(:whitespace) do
+      match("\s")
+    end
+
+    rule(:container_amount) do
+      AmountParser.new
+    end
+
+    rule(:unit) do
+      if unit_matches.any?
+        unit_matches.map { |u| str(u) }.inject(:|)
+      else
+        str("")
+      end
+    end
+
+    rule(:container_unit) do
+      unit
+    end
+
+    rule(:unit_and_preposition) do
+      unit.as(:unit) >> (preposition_or_whitespace | any.absent?)
+    end
+
+    rule(:preposition_or_whitespace) do
+      if prepositions.empty?
+        whitespace
+      else
+        preposition | whitespace
+      end
+    end
+
+    rule(:preposition) do
+      whitespace >>
+        prepositions.map { |con| str(con) }.inject(:|) >>
+        whitespace
+    end
+
+    rule(:amount_unit_separator) do
+      whitespace | str("-")
+    end
+
+    rule(:container_size) do
+      # e.g. (12 ounce) or 12 ounce
+      str("(").maybe >>
+        container_amount.as(:container_amount) >>
+        amount_unit_separator.maybe >>
+        container_unit.as(:container_unit) >>
+        str(")").maybe >> preposition_or_whitespace
+    end
+
+    rule(:amount_and_unit) do
+      (range | amount) >>
+        whitespace.maybe >>
+        unit_and_preposition.maybe >>
+        container_size.maybe
+    end
+
+    rule(:quantity) do
+      amount_and_unit | unit_and_preposition
+    end
+
+    rule(:standard_format) do
+      # e.g. 1/2 (12 oz) can black beans
+      quantity >> any.repeat.as(:ingredient)
+    end
+
+    rule(:reverse_format) do
+      # e.g. flour 200g
+      ((whitespace >> quantity).absent? >> any).repeat.as(:ingredient) >>
+        whitespace >>
+        quantity
+    end
+
+    rule(:ingredient_addition) do
+      standard_format | reverse_format
+    end
+
+    root :ingredient_addition
+
+    def initialize(original_query)
+      @original_query = original_query
+    end
+
+    def parse
+      super(original_query)
+    end
+
+    private
+
+    attr_reader :original_query
+
+    def prepositions
+      Ingreedy.dictionaries.current.prepositions
+    end
+
+    def unit_matches
+      @unit_matches ||= original_query.
+                        scan(UnitVariationMapper.regexp).
+                        sort_by(&:length).
+                        reverse
+    end
+  end
+end

data/lib/ingreedy/unit_variation_mapper.rb

@@ -1,34 +1,37 @@
 module Ingreedy
   class UnitVariationMapper
-
     def self.regexp
-      regexp = all_variations.map { |v| Regexp.escape(v) }.join('|')
-      regexp = Regexp.new(regexp, Regexp::IGNORECASE)
+      regexp_string = all_variations.map { |v| Regexp.escape(v) }.join("|")
+      Regexp.new(regexp_string, Regexp::IGNORECASE)
     end
 
     def self.all_variations
       # Return these in order of size, descending
-      # That way, the longer versions will try to be parsed first, then the shorter versions
+      # That way, the longer versions will try to be parsed first,
+      # then the shorter versions
       # e.g. so '1 cup flour' will be parsed as 'cup' instead of 'c'
       variations_map.values.flatten.sort { |a, b| b.length <=> a.length }
     end
 
     def self.unit_from_variation(variation)
       return if variations_map.empty?
-      hash_entry_as_array = variations_map.detect { |unit, variations| variations.include?(variation) }
+
+      hash_entry_as_array = variations_map.detect do |_unit, variations|
+        variations.include?(variation)
+      end
 
       if hash_entry_as_array
         hash_entry_as_array.first
       else
         # try again with the variation downcased
-        # this is a hacky way to deal with the abbreviations for teaspoon and tablespoon
-        hash_entry_as_array = variations_map.detect { |unit, variations| variations.include?(variation.downcase) }
+        # (hack to deal with the abbreviations for teaspoon and tablespoon)
+        hash_entry_as_array = variations_map.detect do |_unit, variations|
+          variations.include?(variation.downcase)
+        end
         hash_entry_as_array.first
       end
     end
 
-    private
-
     def self.variations_map
       Ingreedy.dictionaries.current.units
     end

data/lib/ingreedy/version.rb

@@ -1,4 +1,3 @@
 module Ingreedy
-  VERSION = '0.0.7'
+  VERSION = "0.0.8"
 end
-

data/spec/ingreedy/amount_parser_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Ingreedy::AmountParser do
+  context "given mixed case insensitive english words" do
+    %w(one two three four five six seven eight nine ten eleven twelve).each do |word|
+      word += " "
+      it %(parses a lowercase "#{word}" followed by space) do
+        expect(subject).to parse(word)
+      end
+
+      it %(parses a uppercase "#{word}") do
+        expect(subject).to parse(word.upcase)
+      end
+    end
+  end
+
+  context "simple fractions" do
+    it "parses" do
+      expect(subject).to parse("1/2")
+    end
+
+    it "parses vulgar fractions" do
+      expect(subject).to parse("½")
+    end
+
+    it "captures a fraction" do
+      result = subject.parse("1/2")
+
+      expect(result[:float_amount]).to eq(nil)
+      expect(result[:fraction_amount]).to eq("1/2")
+      expect(result[:integer_amount]).to eq(nil)
+    end
+  end
+
+  context "compound fractions" do
+    it "parses" do
+      expect(subject).to parse("1 1/2")
+    end
+
+    it "captures an integer and a fraction" do
+      result = subject.parse("1 1/2")
+
+      expect(result[:float_amount]).to eq(nil)
+      expect(result[:fraction_amount]).to eq("1/2")
+      expect(result[:integer_amount]).to eq("1")
+    end
+  end
+
+  context "decimals" do
+    it "parses a short decimal" do
+      expect(subject).to parse("1.0")
+    end
+
+    it "parses a long decimal" do
+      expect(subject).to parse("3.1415926")
+    end
+
+    it "captures a float" do
+      result = subject.parse("3.14")
+
+      expect(result[:float_amount]).to eq("3.14")
+      expect(result[:fraction_amount]).to eq(nil)
+      expect(result[:integer_amount]).to eq(nil)
+    end
+
+    it "captures a european style float" do
+      result = subject.parse("3,14")
+
+      expect(result[:float_amount]).to eq("3,14")
+      expect(result[:fraction_amount]).to eq(nil)
+      expect(result[:integer_amount]).to eq(nil)
+    end
+  end
+
+  context "integers" do
+    it "parses a small integer" do
+      expect(subject).to parse("1")
+    end
+
+    it "parses a large integer" do
+      expect(subject).to parse("823842834")
+    end
+
+    it "captures an integer" do
+      result = subject.parse("123")
+
+      expect(result[:float_amount]).to eq(nil)
+      expect(result[:fraction_amount]).to eq(nil)
+      expect(result[:integer_amount]).to eq("123")
+    end
+  end
+
+  context "junk" do
+    it "doesn't parse a non-number" do
+      expect(subject).not_to parse("asdf")
+    end
+  end
+end