ingreedyfork 0.1.10

data/lib/ingreedy/dictionary.rb

@@ -0,0 +1,35 @@
+module Ingreedy
+  class Dictionary
+    attr_reader :units, :numbers, :prepositions
+
+    def initialize(entries = {})
+      @units = entries[:units] || raise("No units found in dictionary")
+      @numbers = entries[:numbers] || {}
+      @prepositions = entries[:prepositions] || []
+    end
+
+    # https://en.wikipedia.org/wiki/Number_Forms
+    def vulgar_fractions
+      {
+        "\u00BC" => "1/4",
+        "\u00BD" => "1/2",
+        "\u00BE" => "3/4",
+        "\u2150" => "1/7",
+        "\u2151" => "1/9",
+        "\u2152" => "1/10",
+        "\u2153" => "1/3",
+        "\u2154" => "2/3",
+        "\u2155" => "1/5",
+        "\u2156" => "2/5",
+        "\u2157" => "3/5",
+        "\u2158" => "4/5",
+        "\u2159" => "1/6",
+        "\u215A" => "5/6",
+        "\u215B" => "1/8",
+        "\u215C" => "3/8",
+        "\u215D" => "5/8",
+        "\u215E" => "7/8",
+      }
+    end
+  end
+end

data/lib/ingreedy/dictionary_collection.rb

@@ -0,0 +1,37 @@
+require "yaml"
+require_relative "dictionary"
+
+module Ingreedy
+  class DictionaryCollection
+    def initialize
+      @collection = {}
+    end
+
+    def []=(locale, attributes)
+      @collection[locale] = Dictionary.new(attributes)
+    end
+
+    def current
+      @collection[locale] ||= Dictionary.new load_yaml(locale)
+    end
+
+    private
+
+    def locale
+      Ingreedy.locale || i18n_gem_locale || :en
+    end
+
+    def i18n_gem_locale
+      I18n.locale if defined?(I18n)
+    end
+
+    def load_yaml(locale)
+      path = File.expand_path(
+        File.join(File.dirname(__FILE__), "dictionaries", "#{locale}.yml"),
+      )
+      YAML.load_file(path)
+    rescue Errno::ENOENT
+      raise "No dictionary found for :#{locale} locale"
+    end
+  end
+end

data/lib/ingreedy/ingreedy_parser.rb

@@ -0,0 +1,80 @@
+require "parslet"
+
+require_relative "amount_parser"
+require_relative "rationalizer"
+require_relative "root_parser"
+require_relative "unit_variation_mapper"
+
+module Ingreedy
+  class Parser
+    attr_reader :original_query
+
+    Result = Struct.new(
+      :amount,
+      :unit,
+      :container_amount,
+      :container_unit,
+      :ingredient,
+      :original_query,
+    )
+
+    def initialize(original_query)
+      @original_query = original_query
+    end
+
+    def parse
+      result = Result.new
+      result.original_query = 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.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.ingredient = parslet[:ingredient].to_s.lstrip.rstrip # TODO: hack
+
+      result
+    end
+
+    private
+
+    def convert_unit_variation_to_canonical(unit_variation)
+      UnitVariationMapper.unit_from_variation(unit_variation)
+    end
+
+    def rationalize(amount)
+      return unless amount
+      integer = amount[:integer_amount]
+      integer &&= integer.to_s
+
+      float = amount[:float_amount]
+      float &&= float.to_s
+
+      fraction = amount[:fraction_amount]
+      fraction &&= fraction.to_s
+
+      word = amount[:word_integer_amount]
+      word &&= word.to_s
+
+      Rationalizer.rationalize(
+        integer: integer,
+        float: float,
+        fraction: fraction,
+        word: word,
+      )
+    end
+  end
+end

data/lib/ingreedy/rationalizer.rb

@@ -0,0 +1,54 @@
+module Ingreedy
+  class Rationalizer
+    def self.rationalize(options)
+      new(options).rationalize
+    end
+
+    def initialize(options)
+      @integer  = options.fetch(:integer, nil)
+      @float    = options.fetch(:float, nil)
+      @fraction = options.fetch(:fraction, nil)
+      @word     = options.fetch(:word, nil)
+    end
+
+    def rationalize
+      if Ingreedy.preserve_amounts
+        (normalized_word || compound_fraction || @float || @integer)
+      else
+        (normalized_word || rationalized_fraction || rationalized_float || @integer).to_r
+      end
+    end
+
+    private
+
+    def normalized_word
+      return unless @word
+      Ingreedy.dictionaries.current.numbers[Unicode.downcase(@word)]
+    end
+
+    def normalized_fraction
+      @fraction.tap do |fraction|
+        Ingreedy.dictionaries.current.vulgar_fractions.each do |char, amount|
+          fraction.gsub!(char, amount.to_s)
+        end
+      end
+    end
+
+    def rationalized_fraction
+      return unless @fraction
+      result = normalized_fraction
+      result = result.to_r + @integer.to_i
+      result
+    end
+
+    def compound_fraction
+      return unless @fraction
+      "#{@integer} #{normalized_fraction}".strip
+    end
+
+    def rationalized_float
+      return unless @float
+      @float.tr(",", ".")
+    end
+  end
+end

data/lib/ingreedy/root_parser.rb

@@ -0,0 +1,122 @@
+module Ingreedy
+  class RootParser < Parslet::Parser
+    rule(:range) do
+      AmountParser.new.as(:amount) >>
+        whitespace.maybe >>
+        range_separator >>
+        whitespace.maybe >>
+        AmountParser.new.as(:amount_end)
+    end
+
+    rule(:range_separator) do
+      str("-") | str("~")
+    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

@@ -0,0 +1,39 @@
+module Ingreedy
+  class UnitVariationMapper
+    def self.regexp
+      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
+      # 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 do |_unit, variations|
+        variations.include?(variation)
+      end
+
+      if hash_entry_as_array
+        hash_entry_as_array.first
+      else
+        # try again with the variation downcased
+        # (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
+
+    def self.variations_map
+      Ingreedy.dictionaries.current.units
+    end
+  end
+end

data/lib/ingreedy/version.rb

@@ -0,0 +1,3 @@
+module Ingreedy
+  VERSION = "0.1.10"
+end

data/lib/ingreedy.rb

@@ -0,0 +1,24 @@
+path = File.expand_path(File.join(File.dirname(__FILE__), "ingreedy"))
+
+require File.join(path, "case_insensitive_parser")
+require File.join(path, "ingreedy_parser")
+require File.join(path, "dictionary_collection")
+
+module Ingreedy
+  ParseFailed = Class.new(StandardError)
+
+  class << self
+    attr_accessor :locale, :preserve_amounts
+  end
+
+  def self.parse(query)
+    parser = Parser.new(query)
+    parser.parse
+  rescue Parslet::ParseFailed => e
+    fail ParseFailed.new(e.message), e.backtrace
+  end
+
+  def self.dictionaries
+    @dictionaries ||= DictionaryCollection.new
+  end
+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