recipe_scrapers 0.1.0

data/lib/recipe_scrapers/models/nutrient.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Models
+    # One nutrition fact split into its parts. {Models::Recipe#parsed_nutrients} holds these.
+    #
+    # @!attribute [r] name
+    #   @return [String, nil] the key the page uses, such as "calories" or "fatContent"
+    # @!attribute [r] unit
+    #   @return [String, nil] "g", "mg", "µg", "kcal" or "kJ" for mass and energy, any other unit as written
+    # @!attribute [r] amount
+    #   @return [Float, nil] the number, with every decimal the page writes
+    Nutrient = Data.define(:name, :unit, :amount) do
+      def initialize(name: nil, unit: nil, amount: nil)
+        super
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/models/recipe.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Models
+    # The recipe a page holds, with every field already read. {RecipeScrapers.scrape} and
+    # {RecipeScrapers.parse} return one. It is a Ruby Data object: frozen, compared by value, and free
+    # of the page it came from. A field the page does not publish is nil.
+    #
+    # {#to_h} converts the nested value objects too, so the result holds only strings, numbers,
+    # arrays and hashes, ready for JSON.
+    #
+    # @example
+    #   recipe = RecipeScrapers.scrape("https://www.recipetineats.com/crispy-potato-straws-pommes-paille/")
+    #   recipe.title                          # => "Crispy potato straws (Pommes Paille)"
+    #   recipe.to_h[:parsed_ingredients].first
+    #   # => { amount: 1.0, unit: nil, name: "potato, or other starchy or all-rounder potato" }
+    #
+    # @!attribute [r] url
+    #   @return [String] the address the recipe was read from
+    # @!attribute [r] title
+    #   @return [String, nil] the name of the recipe
+    # @!attribute [r] author
+    #   @return [String, nil] the author, several joined with ", "
+    # @!attribute [r] site_name
+    #   @return [String, nil] the name of the website
+    # @!attribute [r] language
+    #   @return [String, nil] the language tag of the recipe, such as "en-US"
+    # @!attribute [r] canonical_url
+    #   @return [String] the canonical link of the page resolved against {Models::Recipe#url}, or the
+    #     url itself when the page has none
+    # @!attribute [r] host
+    #   @return [String] the host of {Models::Recipe#url}, without "www."
+    # @!attribute [r] description
+    #   @return [String, nil] a sentence or short paragraph about the recipe
+    # @!attribute [r] image
+    #   @return [String, nil] the address of the main image, resolved against {Models::Recipe#url}
+    # @!attribute [r] ingredients
+    #   The ingredient lines as the page writes them. A line with no letter and no digit, such as
+    #   "*", is a separator and left out. A line that ends in a colon and has no digit, such as
+    #   "For the sauce:", is a group heading and goes to {Models::Recipe#ingredient_groups}
+    #   instead. See {Models::Recipe#parsed_ingredients}.
+    #
+    #   @return [Array<String>, nil]
+    # @!attribute [r] parsed_ingredients
+    #   Every line of {Models::Recipe#ingredients}, in the same order, split into an amount, a unit and a name.
+    #
+    #   @example
+    #     recipe.parsed_ingredients.first.to_h # => { amount: 1.5, unit: "cups", name: "vegetable oil" }
+    #   @return [Array<Models::Ingredient>, nil]
+    # @!attribute [r] ingredient_groups
+    #   The ingredients in the groups the page shows, such as "For the sauce". The groups come from
+    #   the HTML when the page marks them up, otherwise from the heading lines of the ingredient
+    #   list. A page without groups gives one group with a nil purpose.
+    #
+    #   @return [Array<Models::IngredientGroup>, nil] nil when the page has no ingredients
+    # @!attribute [r] instructions_list
+    #   @return [Array<String>, nil] the steps, with section headings as their own entries
+    # @!attribute [r] instructions
+    #   @return [String, nil] the steps joined with newlines
+    # @!attribute [r] category
+    #   @return [String, nil] the course, such as "Dessert"
+    # @!attribute [r] cuisine
+    #   @return [String, nil] the cuisine, such as "Italian"
+    # @!attribute [r] cooking_method
+    #   @return [String, nil] how it is cooked, such as "Baking"
+    # @!attribute [r] keywords
+    #   @return [Array<String>, nil] the keywords, without facet entries such as "diet: vegan"
+    # @!attribute [r] dietary_restrictions
+    #   @return [Array<String>, nil] the diets the recipe suits, such as "VeganDiet"
+    # @!attribute [r] equipment
+    #   @return [Array<String>, nil] the tools a site declares, schema.org has none
+    # @!attribute [r] yields
+    #   @return [String, nil] how much it makes, as "4 servings" or "12 items"
+    # @!attribute [r] total_time
+    #   @return [Integer, nil] the total time in minutes
+    # @!attribute [r] prep_time
+    #   @return [Integer, nil] the preparation time in minutes
+    # @!attribute [r] cook_time
+    #   @return [Integer, nil] the cooking time in minutes
+    # @!attribute [r] nutrients
+    #   The nutrition facts as the page publishes them, keyed by the schema.org property name.
+    #   Nothing is parsed here. See {Models::Recipe#parsed_nutrients}.
+    #
+    #   @example
+    #     recipe.nutrients # => { "calories" => "219 kcal", "fatContent" => "7 g" }
+    #   @return [Hash{String => String}, nil]
+    # @!attribute [r] parsed_nutrients
+    #   Every entry of {Models::Recipe#nutrients}, in the order the page lists them, split into a name, a unit
+    #   and an amount. The name is the key the page uses. A value with no number is left out.
+    #
+    #   @example
+    #     recipe.parsed_nutrients.first.to_h # => { name: "calories", unit: "kcal", amount: 219.0 }
+    #   @return [Array<Models::Nutrient>, nil]
+    # @!attribute [r] ratings
+    #   @return [Float, nil] the average rating
+    # @!attribute [r] ratings_count
+    #   @return [Integer, nil] how many ratings the average is made of
+    # @!attribute [r] links
+    #   @return [Array<String>] the href of every link on the page, as written
+    Recipe = Data.define(
+      :url, :title, :author, :site_name, :language, :canonical_url, :host, :description, :image, :ingredients,
+      :parsed_ingredients, :ingredient_groups, :instructions_list, :instructions, :category, :cuisine,
+      :cooking_method, :keywords, :dietary_restrictions, :equipment, :yields, :total_time, :prep_time, :cook_time,
+      :nutrients, :parsed_nutrients, :ratings, :ratings_count, :links
+    ) do
+      # The recipe as plain data. Every nested value object becomes a hash as well.
+      #
+      # @return [Hash{Symbol => Object}]
+      def to_h(&)
+        super.transform_values { |value| plain(value) }.to_h(&)
+      end
+
+      private
+
+      def plain(value)
+        case value
+        when Data then plain(value.to_h)
+        when Hash then value.transform_values { |item| plain(item) }
+        when Array then value.map { |item| plain(item) }
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/chain.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  # Turn text into values.
+  module Parsers
+    # Runs the parsers of a field in order until one returns something. A parser returns a hash of
+    # the model's attributes, which becomes the model, or nil. A parser that raises, or returns a
+    # hash with an unknown key, goes to {Configuration#error_tracker}, and the next one is tried.
+    #
+    # @api private
+    module Chain
+      FIELDS = %i[ingredients nutrients].freeze
+      MODELS = { ingredients: Models::Ingredient, nutrients: Models::Nutrient }.freeze
+      private_constant :MODELS
+
+      class << self
+        def defaults
+          { ingredients: [Ingredients], nutrients: [Nutrients] }
+        end
+
+        def field!(field)
+          return field if FIELDS.include?(field)
+
+          raise ArgumentError, "no parser can be set for #{field.inspect}, only for #{FIELDS.join(", ")}"
+        end
+
+        def run(field, parsers, text, language:)
+          parsers.each do |parser|
+            result = attempt(field, parser, text, language)
+            return result unless result.nil?
+          end
+          nil
+        end
+
+        private
+
+        def attempt(field, parser, text, language)
+          model(field, parser.call(text, language: language))
+        rescue StandardError => e
+          RecipeScrapers.config.error_tracker.call(e)
+          nil
+        end
+
+        def model(field, result)
+          return result if result.nil? || result.is_a?(Data)
+
+          MODELS.fetch(field).new(**result)
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/durations.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Parsers
+    module Durations
+      LANGUAGES = {
+        english: { hours: %w[h hr hrs hour hours], minutes: %w[m min mins minute minutes],
+                   seconds: %w[s sec secs second seconds] },
+        german: { hours: %w[std stunde stunden], minutes: %w[minuten],
+                  seconds: %w[sek sekunde sekunden] },
+        french: { hours: %w[heure heures], minutes: %w[minute minutes], seconds: %w[seconde secondes] },
+        italian: { hours: %w[ora ore], minutes: %w[minuto minuti], seconds: %w[secondo secondi] },
+        dutch: { hours: %w[uur], minutes: %w[minuut minuten], seconds: %w[seconde seconden] },
+        swedish: { hours: %w[tim timme timmar], minutes: %w[minut minuter],
+                   seconds: %w[sekund sekunder] },
+        norwegian: { hours: %w[time timer], minutes: %w[minutt minutter], seconds: %w[sekund sekunder] },
+        hungarian: { hours: %w[óra órát], minutes: %w[perc percet], seconds: %w[másodperc] },
+        russian: { hours: %w[ч час часа часов], minutes: %w[м мин минута минуты минут минуту],
+                   seconds: %w[с сек секунда секунды секунд] }
+      }.freeze
+
+      HOURS, MINUTES, SECONDS = %i[hours minutes seconds].map do |unit|
+        words = LANGUAGES.values.flat_map { |language| language.fetch(unit) }.uniq
+        /(\d+)\s*(?:#{words.sort_by { |word| -word.length }.join("|")})\b/i
+      end
+
+      ISO = /\AP(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?)?\z/
+      ISO_UNIT_MINUTES = [10_080, 1440, 60, 1, 1 / 60.0].freeze
+      NUMBER = /\d+/
+      RANGE = /(\d+)\s*(?:-|–|—|to|до)\s*\d+/
+
+      class << self
+        def minutes(value)
+          return nil if value.nil?
+          return value if value.is_a?(Integer)
+          return minutes(value["@value"]) if value.is_a?(Hash)
+
+          text = Text.normalize(value)
+          return nil if text.nil?
+
+          from_iso(text) || from_words(text.gsub(RANGE, '\\1'))
+        end
+
+        private
+
+        def from_iso(text)
+          match = ISO.match(text)
+          return nil unless match&.captures&.any?
+
+          total = match.captures.zip(ISO_UNIT_MINUTES).sum { |count, minutes| count.to_f * minutes }.round
+          total.positive? ? total : nil
+        end
+
+        def from_words(text)
+          hours, mins, secs = [HOURS, MINUTES, SECONDS].map { |unit| text[unit, 1] }
+          return sole_number(text) if [hours, mins, secs].compact.empty?
+          return nil unless [hours, mins, secs].compact.size == text.scan(NUMBER).size
+
+          total = (hours.to_i * 60) + mins.to_i
+          total.positive? ? total : nil
+        end
+
+        def sole_number(text)
+          numbers = text.scan(NUMBER)
+          numbers.size == 1 ? numbers.first.to_i : nil
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/ingredients.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Parsers
+    # The bundled parser of ingredient lines. It reads the amount, the unit and the name with the
+    # words of the recipe language. Put it after your own parser to keep it as the fallback.
+    #
+    # @example
+    #   RecipeScrapers::Parsers::Ingredients.call("1 1/2 cups flour", language: "en").to_h
+    #   # => { amount: 1.5, unit: "cups", name: "flour" }
+    class Ingredients
+      QUANTITY = Quantity::QUANTITY
+      SUM = Quantity::SUM
+      UPPER_BOUND = /(?:(?:\s*[-–—]\s*|\s+(?:to|or|o|a|à|bis|до|или)\s+)#{QUANTITY})?/o
+      WORD_END = /(?![\p{L}\d'’-])/
+      PREPARATION = /\p{Ll}[\p{L}-]*(?:\s+\p{Ll}[\p{L}-]*)?/
+      CONNECTOR = /\A(?:(?:of|de|di)\s+)?(?:an?\s+)?/i
+      PARENTHESES = /\([^()]*\)/
+      SPACE_BEFORE_PUNCTUATION = /\s+([,.;:])/
+      EDGE_PUNCTUATION = /\A[\s,;:.]+|[\s,;:]+\z/
+      BULLET = /\A[♥♡＊*•·]+\s*/
+      ARTICLES = %w[a an].freeze
+      LOCK = Mutex.new
+      private_constant :QUANTITY, :SUM, :UPPER_BOUND, :WORD_END, :PREPARATION, :CONNECTOR, :PARENTHESES,
+                       :SPACE_BEFORE_PUNCTUATION, :EDGE_PUNCTUATION, :BULLET, :ARTICLES, :LOCK
+
+      class << self
+        # @param line [String] one ingredient line
+        # @param language [String, nil] the language tag of the recipe
+        # @return [Models::Ingredient]
+        def call(line, language: nil)
+          for_language(language).call(line)
+        end
+
+        # @param language [String, nil]
+        # @return [Ingredients] a parser for the vocabulary of the language, built once per vocabulary
+        #
+        # @api private
+        def for_language(language)
+          names = Vocabulary.names_for(language)
+          LOCK.synchronize { instances[names] ||= new(Vocabulary.combine(names)) }
+        end
+
+        private
+
+        def instances
+          @instances ||= {}
+        end
+      end
+
+      # @return [Vocabulary] the words this parser reads
+      #
+      # @api private
+      attr_reader :vocabulary
+
+      # @param vocabulary [Vocabulary]
+      #
+      # @api private
+      def initialize(vocabulary)
+        @vocabulary = vocabulary
+        @patterns = build_patterns
+      end
+
+      # @param line [String] one ingredient line
+      # @return [Models::Ingredient]
+      #
+      # @api private
+      def call(line, **)
+        parsed = parse_text(without_parentheses(line.to_s))
+        return parsed unless parsed.name.nil? && line.to_s.include?("(")
+
+        parse_text(tidy(line.to_s.gsub(PARENTHESES, " ").delete("()")))
+      end
+
+      private
+
+      def build_patterns
+        [
+          /\A#{qualifier}#{measure}\s*(?<ingredient>.*)\z/,
+          /\A(?:#{adjective})?(?<unit>#{pinch_word})\s+(?:of\s+)?(?<ingredient>.+)\z/i,
+          /\A(?<note>#{PREPARATION})\s+(?<amount>#{SUM})#{UPPER_BOUND}\s*#{unit}\s+(?<ingredient>.+)\z/,
+          /\A(?<ingredient>[^:]+?)\s*:\s*#{qualifier}#{numeric_measure}(?:\.?\s+(?<note>\D+?))?\.?\z/,
+          /\A(?<ingredient>.+?)(?:\s*[,\-–—]\s*|\s+)#{qualifier}#{numeric_measure}\z/,
+          /\A(?<ingredient>.+?)\s*[:,\-–—]\s*(?<unit>#{pinch_word})\z/i,
+          /\A(?<ingredient>.+?)\s+(?<unit>#{unit_word})\s*(?<amount>#{QUANTITY})\z/
+        ].freeze
+      end
+
+      def words(list) = Vocabulary.alternation(list)
+      def unit_word = @unit_word ||= /(?:#{words(vocabulary.units)})/i
+      def pinch_word = @pinch_word ||= /(?:#{words(vocabulary.pinches)})#{WORD_END}/i
+      def adjective = @adjective ||= /(?:#{words(vocabulary.sizes)})\s+/i
+      def qualifier = @qualifier ||= /(?:(?:#{words(vocabulary.qualifiers)})\s+|~\s*)*/i
+      def size = @size ||= /#{QUANTITY}#{UPPER_BOUND}\s*-?\s*#{unit_word}\.?(?:-|\s)\s*/
+      def unit_lead = @unit_lead ||= /(?:#{size})?(?:#{adjective})?/
+      def alternative = @alternative ||= %r{(?:\s*[/+]\s*|\s+)#{QUANTITY}#{UPPER_BOUND}\s*#{unit_word}\.?#{WORD_END}}
+      def unit = @unit ||= /#{unit_lead}(?<unit>#{unit_word})\.?#{WORD_END}(?:#{alternative})*/
+      def counted_word = /(?:#{words(vocabulary.number_words.keys - ARTICLES)})(?=\s)/i
+      def article = /an?(?=\s+#{unit_lead}#{unit_word}#{WORD_END})/i
+      def numeric_measure = /(?<amount>#{SUM})#{UPPER_BOUND}\s*(?:#{unit})?/
+      def measure = /(?<amount>#{SUM}|#{counted_word}|#{article})#{UPPER_BOUND}\s*(?:#{unit})?/
+
+      def parse_text(text)
+        @patterns.each do |pattern|
+          match = text.match(pattern)
+          return measured(match) if match && !match[:ingredient].start_with?("%")
+        end
+        row(nil, nil, text)
+      end
+
+      def measured(match)
+        names = match.names
+        unit = match[:unit]&.squeeze(" ")
+        ingredient = match[:ingredient]
+        ingredient = ingredient.sub(CONNECTOR, "") if match.begin(:ingredient).positive?
+        ingredient = [ingredient, match[:note]].compact.join(", ") if names.include?("note")
+        row(names.include?("amount") ? amount(match[:amount]) : 1.0, unit, ingredient)
+      end
+
+      def row(amount, unit, ingredient)
+        cleaned = ingredient.gsub(EDGE_PUNCTUATION, "")
+        Models::Ingredient.new(amount: amount, unit: unit, name: cleaned.empty? ? nil : cleaned)
+      end
+
+      def amount(quantity)
+        word = vocabulary.number_words[quantity.downcase]
+        return word.to_f if word
+
+        Quantity.value(quantity)
+      end
+
+      def without_parentheses(text)
+        reduced = text.gsub(PARENTHESES, " ")
+        return tidy(reduced) if reduced == text
+
+        without_parentheses(reduced)
+      end
+
+      def tidy(text)
+        text.gsub(SPACE_BEFORE_PUNCTUATION, "\\1").squeeze(" ").strip.sub(BULLET, "")
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/nutrients.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Parsers
+    # The bundled parser of nutrient values. It reads the first number and the word after it, and
+    # drops text in parentheses. Mass and energy units are written as symbols, so "grams" and "г" become
+    # "g" and "calories" becomes "kcal".
+    #
+    # @example
+    #   RecipeScrapers::Parsers::Nutrients.call("12.5 grams").to_h # => { name: nil, unit: "g", amount: 12.5 }
+    module Nutrients
+      PARENTHESES = /\([^()]*\)/
+      CONNECTORS = %w[of de di].freeze
+      MEASURE = /(?<amount>#{Quantity::QUANTITY})\s*(?<unit>[\p{L}µ][\p{L}-]*)?/o
+      CANONICAL_UNITS = {
+        "g" => %w[g gr grs gram grams gramm gramos gramas grammi gramme grammes г гр грамм грамма граммов],
+        "mg" => %w[mg milligram milligrams milligramm мг],
+        "µg" => %w[µg μg mcg microgram micrograms мкг],
+        "kcal" => %w[
+          kcal kcals kkal cal cals calorie calories kalorien kalorier calorías calorias ккал калорий калории
+        ],
+        "kJ" => %w[kj кдж]
+      }.flat_map { |canonical, spellings| spellings.map { |spelling| [spelling, canonical] } }.to_h.freeze
+      private_constant :PARENTHESES, :CONNECTORS, :MEASURE, :CANONICAL_UNITS
+
+      class << self
+        # @param text [String] one nutrient value
+        # @return [Models::Nutrient, nil] without a name, which {Models::Recipe#parsed_nutrients} fills in. Nil
+        #   when the value has no number
+        def call(text, **)
+          match = text.to_s.gsub(PARENTHESES, " ").match(MEASURE)
+          return nil if match.nil?
+
+          Models::Nutrient.new(amount: Quantity.total(match[:amount]), unit: unit(match[:unit]))
+        end
+
+        private
+
+        def unit(written)
+          return nil if written.nil? || CONNECTORS.include?(written.downcase)
+
+          CANONICAL_UNITS.fetch(written.downcase, written)
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/quantity.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Parsers
+    module Quantity
+      NUMBER = /\d+(?:[.,]\d+)?/
+      SLASH_FRACTION = %r{\d+\s*[/⁄]\s*\d+}
+      VULGAR = /[½⅓⅔¼¾⅕⅖⅗⅘⅙⅚⅐⅛⅜⅝⅞⅑⅒]/
+      JOINER = /\s+(?:and|und|y|e)\s+|\s*と\s*/
+      QUANTITY = /
+        \d+(?:#{JOINER}|\s*)#{VULGAR}|\d+(?:#{JOINER}|\s+)#{SLASH_FRACTION}|#{SLASH_FRACTION}|#{NUMBER}|#{VULGAR}
+      /xo
+      PLUS = /\s*\+\s*/
+      SUM = /#{QUANTITY}(?:#{PLUS}#{QUANTITY})*/o
+      SLASH_SPACING = %r{\s*([/⁄])\s*}
+      WHOLE_AND_FRACTION = /#{JOINER}|\s+|(?=#{VULGAR})/o
+
+      class << self
+        def value(sum)
+          amount = total(sum).round(2)
+          amount.zero? ? nil : amount
+        end
+
+        def total(sum)
+          sum.split(PLUS).sum { |term| term_value(term) }.to_f
+        end
+
+        private
+
+        def term_value(term)
+          whole, fraction = term.gsub(SLASH_SPACING, "\\1").split(WHOLE_AND_FRACTION, 2)
+          part_value(whole) + part_value(fraction)
+        end
+
+        def part_value(part)
+          return 0 if part.nil?
+
+          numerator, denominator = part.unicode_normalize(:nfkd).split(%r{[/⁄]})
+          return Rational(numerator.to_i, denominator.to_i) if denominator.to_i.positive?
+
+          Rational(numerator.tr(",", "."))
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/ratings.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RecipeScrapers
+  module Parsers
+    module Ratings
+      DECIMAL = /\d+(?:[.,]\d+)?/
+      DIGIT_GROUPING = /[,. ]/
+
+      class << self
+        def average(node)
+          return nil if node.nil?
+
+          value = node["ratingValue"].to_s[DECIMAL]&.tr(",", ".")&.to_f
+          value&.positive? ? value : nil
+        end
+
+        def count(node)
+          return nil if node.nil?
+
+          total = (node["ratingCount"] || node["reviewCount"]).to_s.gsub(DIGIT_GROUPING, "")[/\A\d+/]&.to_i
+          total&.positive? ? total : nil
+        end
+      end
+    end
+  end
+end

data/lib/recipe_scrapers/parsers/vocabulary/common.yml

@@ -0,0 +1,7 @@
+units: [g, gr, grs, gram, grams, gramm, gramos, gramas, grammi, kg, kilo, kilos, kilogram, kilograms, quilo,
+  quilos, mg, ml, milliliter, milliliters, millilitre, millilitres, l, liter, liters, litre, litres, litro,
+  litros, dl, cl, krm, cm, mm, count]
+qualifiers: [ca., circa, "null"]
+number_words:
+  a: 1
+  an: 1

data/lib/recipe_scrapers/parsers/vocabulary/de.yml

@@ -0,0 +1,5 @@
+languages: [de]
+units: [el, tl, msp, prise, stück, stk, st, bund, dose, dosen, päckchen, pck, pkt, pk, becher, scheibe,
+  scheiben, zehe, zehen, spritzer, tasse, tassen]
+pinches: [prise]
+sizes: [kleine, kleiner, kleines, kl., große, großer, großes]

data/lib/recipe_scrapers/parsers/vocabulary/en.yml

@@ -0,0 +1,26 @@
+languages: [en]
+units: [cup, cups, c, tsp, tsps, teaspoon, teaspoons, t, tbsp, tbsps, tbs, tbl, tablespoon, tablespoons, oz,
+  ounce, ounces, lb, lbs, pound, pounds, quart, quarts, qt, pint, pints, pt, gallon, gallons, clove, cloves,
+  can, cans, tin, tins, jar, jars, package, packages, packet, packets, pkg, bag, bags, box, boxes, bunch,
+  bunches, sprig, sprigs, slice, slices, stick, sticks, head, heads, stalk, stalks, pinch, pinches, dash,
+  dashes, handful, handfuls, drizzle, splash, sprinkle, knob, piece, pieces, pc, pcs, sheet, sheets, scoop,
+  scoops, container, containers, ear, ears, drop, drops, bottle, bottles, envelope, envelopes, block, blocks,
+  shot, shots, each, count, serving, servings, portion, portions, ptn, ptns, thumb, thumbs, batch, foot, feet,
+  leaf, leaves, bar, bars, loaf, loaves, spear, spears, inch, inches, fl oz, fluid ounce, fluid ounces]
+pinches: [pinch, pinches, dash, dashes, handful, handfuls, drizzle, splash, sprinkle, knob]
+sizes: [large, small, medium, big, small-to-medium, heaping, heaped, level, scant, rounded, generous]
+qualifiers: [about, approx., approx, approximately, around, scant, generous, heaping, heaped, "optional:"]
+number_words:
+  one: 1
+  two: 2
+  three: 3
+  four: 4
+  five: 5
+  six: 6
+  seven: 7
+  eight: 8
+  nine: 9
+  ten: 10
+  eleven: 11
+  twelve: 12
+  half: 0.5

data/lib/recipe_scrapers/parsers/vocabulary/es.yml

@@ -0,0 +1,4 @@
+languages: [es]
+units: [cucharada, cucharadas, cucharadita, cucharaditas, cda, cdas, cdta, cdtas, taza, tazas, diente,
+  dientes, pizca, pizcas, lata, latas, rama, ramas, ramita, ramitas, trozo, trozos, paquete, paquetes]
+pinches: [pizca]

data/lib/recipe_scrapers/parsers/vocabulary/fr.yml

@@ -0,0 +1,5 @@
+languages: [fr]
+units: [cs, cc, pincée, pincées, poignée, poignées, gousse, gousses, brin, brins, feuille, feuilles, tranche,
+  tranches, tran, sachet, sachets, cuillère, cuillères, c. à soupe, c. à café, cuillère à soupe,
+  cuillères à soupe, cuillère à café, cuillères à café]
+pinches: [pincée, poignée]

data/lib/recipe_scrapers/parsers/vocabulary/hu.yml

@@ -0,0 +1,3 @@
+languages: [hu]
+units: [ek, evőkanál, kk, kávéskanál, teáskanál, dkg, db, darab, gerezd, csipet, szál, fej, csomag, bögre]
+sizes: [nagy, kis]

data/lib/recipe_scrapers/parsers/vocabulary/it.yml

@@ -0,0 +1,4 @@
+languages: [it]
+units: [cucchiaio, cucchiai, cucchiaino, cucchiaini, pizzico, spicchio, spicchi, bicchiere, bicchieri,
+  bustina, bustine, fetta, fette, rametto, grappolo]
+pinches: [pizzico]

data/lib/recipe_scrapers/parsers/vocabulary/ja.yml

@@ -0,0 +1,2 @@
+languages: [ja]
+units: [大さじ, 小さじ, 個, 缶, カップ, 本, 枚, 片]

data/lib/recipe_scrapers/parsers/vocabulary/nl.yml

@@ -0,0 +1,4 @@
+languages: [nl]
+units: [el, tl, eetlepel, eetlepels, theelepel, theelepels, teen, teentje, teentjes, takje, takjes, blik,
+  zakje, snuf]
+pinches: [snuf]

data/lib/recipe_scrapers/parsers/vocabulary/pt.yml

@@ -0,0 +1,8 @@
+languages: [pt]
+units: [xícara, xícaras, colher, colheres, dente, dentes, pitada, pitadas, fatia, fatias, rodela, rodelas,
+  rolo, rolos, medida, medidas, lata, latas, tablete, tabletes, cháv, chávena, chávenas, unid, c. de sopa,
+  c. de café, c. de chá, xícara de chá, xícaras de chá, colher de sopa, colheres de sopa, colher de chá,
+  colheres de chá]
+number_words:
+  meia: 0.5
+  meio: 0.5

data/lib/recipe_scrapers/parsers/vocabulary/ru.yml

@@ -0,0 +1,7 @@
+languages: [ru]
+units: [г, гр, грамм, грамма, граммов, кг, мл, л, стакан, стакана, стаканов, шт, зубчик, зубчика, зубчиков,
+  щепотка, щепотки, пучок, пучка, штука, штуки, штук, стебель, стебля, головка, головки, веточка, веточки,
+  веточек, ст. л, стол. л, ч. л, ст. ложка, ст. ложки, ст. ложек, ч. ложка, ч. ложки, ч. ложек, дес. ложка,
+  дес. ложки, ложка, ложки, ложек, столовая ложка, столовые ложки, столовых ложки, столовых ложек,
+  чайная ложка, чайные ложки, чайных ложки, чайных ложек]
+pinches: [щепотка]

data/lib/recipe_scrapers/parsers/vocabulary/scandinavian.yml

@@ -0,0 +1,3 @@
+languages: [sv, "no", nb, nn, da]
+units: [ss, ts, tsk, msk, spsk, burk, boks, pakke, kvist, kvister, skiva, skivor, skive, skiver, kruka, potte,
+  näve, stykk, stykker, stang, båt, båter, tärning, tärningar, st, stk, pkt]

data/lib/recipe_scrapers/parsers/vocabulary/sk.yml

@@ -0,0 +1,3 @@
+languages: [sk]
+units: [ks, pl, čl, štipka, lyžica, lyžice, lyžička, lyžičky]
+pinches: [štipka]

data/lib/recipe_scrapers/parsers/vocabulary/tr.yml

@@ -0,0 +1,2 @@
+languages: [tr]
+units: [adet, diş, tutam, paket, çay kaşığı, yemek kaşığı, tatlı kaşığı, su bardağı, çay bardağı]