emeals 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c883efc225e72b90fe4943bcce321f9933664452
-  data.tar.gz: f7b246806d4fc330a5bf42235871ec8ae4615e48
+  metadata.gz: 88f64929d0e17e3a429aef954e2508bf354afb6c
+  data.tar.gz: 7811beff315cd7d5b8a06720f1b696611f4a1658
 SHA512:
-  metadata.gz: 4f3596e65d12aeb0d1a58362eb83b408aa83fa05210b4b53b81fd63ecf921eebf1f39818edf17481bbb3f28cc0c1e39995888ad82cc68c2cbafc88e70586033f
-  data.tar.gz: 27e5874c713d6de1662e74a9d56cb4d54385eb794ee5369925db7f81e6e447fc9d5986c02153f8fb26c8ee8ba509a03a2b604608b69eb4ac5e2634e8aba1ed5f
+  metadata.gz: ba0a4c7c3ea79ba9a535569d33b97ac40429341d4fa219f908e02a35dd068c8852469486d0537e87e2845f521abf33a14b15e0127da7a0dd75849bea44083e1f
+  data.tar.gz: 9056e857a31afc51ad2ac0429a26c6f70a3ed51566c7d0097b2dc560c36c3426632a4a0054546d63f949b7e2ac090223d3e3557cd691c9fbebac3729eae1f547

data/.ruby-version

@@ -1 +1 @@
-2.0.0
+2.0.0-p0

data/lib/emeals/dish.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
 class Emeals::Dish
-  attr_accessor :name, :ingredients, :instructions
+  attr_reader :name, :ingredients, :instructions
 
-  def initialize(name)
+  def initialize(name, ingredients = [], instructions = [])
     @name = name
-    @ingredients = []
-    @instructions = []
+    @ingredients = ingredients
+    @instructions = instructions
   end
 end
 
@@ -37,7 +37,7 @@ class Emeals::Quantity
 end
 
 class Emeals::Ingredient
-  attr_accessor :quantity, :description
+  attr_reader :quantity, :description
 
   def initialize(amount, unit, description)
     @quantity = Emeals::Quantity.new(amount, unit)
@@ -58,4 +58,4 @@ class Emeals::Ingredient
   def ==(other)
     other.quantity == @quantity && other.description == @description
   end
-end
+end

data/lib/emeals/meal.rb

@@ -5,98 +5,81 @@ require 'emeals/dish'
 class Emeals::Meal
   attr_reader :entree, :side, :flags, :times
 
-  def initialize(entree = nil, side = nil)
+  def initialize(entree = nil, side = nil, flags = [], times = {})
     @entree = entree
     @side = side
-    @flags = []
-    @times = {}
+    @flags = flags
+    @times = times
   end
 
-  def parse!(meal_text)
-    parse_state = :header
-    names = []
-    entree_instructions = []
-    side_instructions = []
-    meal_text.split("\n").each do |line|
-      case parse_state
-        when :header
-          parse_flags(line)
-          parse_state = :names
-        when :names
-          if line =~ /Prep Cook Total/
-            entree_name, side_name = separate_entree_and_side_names(names)
-            @entree = Emeals::Dish.new(entree_name)
-            @side = Emeals::Dish.new(side_name)
-            parse_state = :times
-          else
-            names << line
-          end
-        when :times
-          parse_times(line)
-          parse_state = :entree_ingredients
-        when :entree_ingredients
-          if line.include? "-------"
-            parse_state = :side_ingredients
-          else
-            add_ingredients_to_dish(line, @entree)
-          end
-        when :side_ingredients
-          if line =~ /^[A-Z]/
-            entree_instructions << line
-            parse_state = :entree_instructions
-          else
-            add_ingredients_to_dish(line, @side)
-          end
-        when :entree_instructions
-          if line.include? "-------"
-            add_instructions_to_dish(entree_instructions, @entree)
-            parse_state = :side_instructions
-          else
-            entree_instructions << line
-          end
-        when :side_instructions
-          if line =~ /^Copyright/
-            side_instructions = side_instructions[0..-3]
-            break
-          else
-            side_instructions << line
-          end
-        else
-
-      end
-    end
-
-    add_instructions_to_dish(side_instructions, @side)
-    self
+  def self.parse(meal_text)
+    Emeals::MealParser.new(meal_text).parse
   end
 
   FLAGS = {
-      "Slow Cooker"    => :slow_cooker,
-      "On the Grill"   => :on_the_grill,
-      "Super Fast"     => :super_fast,
-      "Marinate Ahead" => :marinate_ahead
+    "Slow Cooker"    => :slow_cooker,
+    "On the Grill"   => :on_the_grill,
+    "Super Fast"     => :super_fast,
+    "Marinate Ahead" => :marinate_ahead
   }
 
-  %w(slow_cooker on_the_grill super_fast marinate_ahead).each do |flag|
+  FLAGS.values.each do |flag|
     define_method "#{flag}?" do
-      @flags.include? flag.to_sym
+      @flags.include? flag
     end
   end
+end
+
+class Emeals::MealParser
+  def initialize(meal_text)
+    @meal_text = meal_text
+  end
+
+  def parse
+    entree_name = side_name = flags = times = nil
+    names = entree_ingredients = side_ingredients = []
+    parse_state = :header
+    entree_instructions = []
+    side_instructions = []
+    @meal_text.split("\n").each do |line|
+      case parse_state
+      when :header
+        flags, parse_state = parse_flags(line)
+      when :names
+        entree_name, side_name, names, parse_state = parse_names(line, names)
+      when :times
+        times, parse_state = parse_times(line)
+      when :entree_ingredients
+        entree_ingredients, parse_state = parse_entree_ingredients(line, entree_ingredients)
+      when :side_ingredients
+        side_ingredients, entree_instructions, parse_state = parse_side_ingredients(line, side_ingredients)
+      when :entree_instructions
+        entree_instructions, parse_state = parse_entree_instructions(line, entree_instructions)
+      when :side_instructions
+        side_instructions, parse_state = parse_side_instructions(line, side_instructions)
+      else
+        break
+      end
+    end
+    entree = Emeals::Dish.new(entree_name, entree_ingredients, format_instructions(entree_instructions))
+    side   = Emeals::Dish.new(side_name,   side_ingredients,   format_instructions(side_instructions))
+    Emeals::Meal.new(entree, side, flags, times)
+  end
 
   private
 
   def separate_entree_and_side_names(names)
     case names.size
-      when 2
-        names
-      when 3
-        if names[1].length < names[0].length
-          [join_names(names[0..1]), names[2]]
-        else
-          [names[0], join_names(names[1..2])]
-        end
+    when 2
+      names
+    when 3
+      if names[1].length < names[0].length
+        [join_names(names[0..1]), names[2]]
       else
-        [join_names(names[0..1]), join_names(names[2..-1])]
+        [names[0], join_names(names[1..2])]
+      end
+    else
+      [join_names(names[0..1]), join_names(names[2..-1])]
     end
   end
 
@@ -105,31 +88,70 @@ class Emeals::Meal
   end
 
   def parse_flags(line)
-    FLAGS.each do |flag, sym|
-      @flags << sym if line.include? flag
+    [Emeals::Meal::FLAGS.select {|flag, sym| line.include? flag }.values, :names]
+  end
+
+  def parse_names(line, names)
+    if line =~ /Prep Cook Total/
+      entree_name, side_name = separate_entree_and_side_names(names)
+      [entree_name, side_name, nil, :times]
+    else
+      [nil, nil, names + [line], :names]
     end
   end
 
   def parse_times(line)
     times = line.split(" ")
-    @times[:prep] = times.first
-    @times[:cook] = times[1]
-    @times[:total] = times[2..-1].join(" ")
+    [{prep: times.first, cook: times[1], total: times[2..-1].join(" ")}, :entree_ingredients]
+  end
+
+  def parse_entree_ingredients(line, ingredients)
+    if line.include? "-------"
+      [ingredients, :side_ingredients]
+    else
+      [find_ingredients(ingredients, line), :entree_ingredients]
+    end
+  end
+
+  def parse_side_ingredients(line, ingredients)
+    if line =~ /^[A-Z]/
+      [ingredients, [line], :entree_instructions]
+    else
+      [find_ingredients(ingredients, line), nil, :side_ingredients]
+    end
+  end
+
+  def parse_entree_instructions(line, instructions)
+    if line.include? "-------"
+      [instructions, :side_instructions]
+    else
+      [instructions + [line], :entree_instructions]
+    end
+  end
+
+  def parse_side_instructions(line, instructions)
+    if line =~ /^Copyright/
+      [instructions[0..-3], nil]
+    else
+      [instructions + [line], :side_instructions]
+    end
   end
 
   INGREDIENT_REGEX = /(?:\d|\xC2\xBC|\xC2\xBD)+ .+?(?=, (?:\d|\xC2\xBC|\xC2\xBD)+|$)/
 
-  def add_ingredients_to_dish(line, dish)
+  def find_ingredients(ingredients, line)
     if line =~ /^\d|\xC2\xBC|\xC2\xBD/
-      line.scan(INGREDIENT_REGEX).each do |match|
-        dish.ingredients << Emeals::Ingredient.parse(match)
+      ingredients + line.scan(INGREDIENT_REGEX).map do |match|
+        Emeals::Ingredient.parse(match)
       end
     else
-      dish.ingredients.last.description << " #{line}"
+      # TODO we shouldn't be modifying this in-place
+      ingredients.last.description << " #{line}"
+      ingredients
     end
   end
 
-  def add_instructions_to_dish(lines, dish)
-    dish.instructions = lines.join(" ").split(/\. ?/)
+  def format_instructions(instructions)
+    instructions.join(" ").split(/\. ?/)
   end
 end

data/lib/emeals/menu.rb

@@ -1,34 +1,46 @@
 require 'emeals/meal'
 
 class Emeals::Menu
-  attr_reader :count, :meals
+  attr_reader :meals
 
-  def initialize
-    @count = 0
-    @meals = []
+  def initialize(meals)
+    @meals = meals
   end
 
-  def parse!(menu_text)
+  def count
+    @meals.size
+  end
+
+  def self.parse(menu_text)
+    Emeals::MenuParser.new(menu_text).parse
+  end
+end
+
+class Emeals::MenuParser
+  def initialize(menu_text)
+    @menu_text = menu_text
+  end
+
+  def parse
     buffer = []
+    meals  = []
     add_to_buffer = false
-    menu_text.split("\n").each do |line|
+
+    @menu_text.split("\n").each do |line|
       if line =~ /Meal (\d+)/
-        unless buffer.empty? and !add_to_buffer
-          @count = @count + 1
-          @meals << Emeals::Meal.new.parse!(buffer.join("\n"))
+        if add_to_buffer and !buffer.empty?
+          meals << Emeals::Meal.parse(buffer.join("\n"))
         end
 
-        add_to_buffer = @count < $1.to_i
+        add_to_buffer = meals.size < $1.to_i
         buffer = add_to_buffer ? [line] : []
         next unless add_to_buffer
       else
         buffer << line if add_to_buffer
       end
     end
-    self
-  end
 
-  def self.parse(menu_text)
-    new.parse!(menu_text)
+    Emeals::Menu.new(meals)
   end
-end
+end
+

data/lib/emeals/version.rb

@@ -1,3 +1,3 @@
 module Emeals
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/client_spec.rb

@@ -22,80 +22,7 @@ describe Emeals::Client do
     expect(@menu.count).to eq 7
   end
 
-  describe "entree names" do
-    it "reads the names of entrees when the side wraps to two lines" do
-      expect(@meals[5].entree.name).to eq "Baked Cod Provencal"
-    end
-
-    it "reads the names of entrees which wrap to two lines" do
-      expect(@meals.first.entree.name).to eq "Spicy Sausage and Egg Scramble"
-    end
-
-    it "reads the names of entrees when both the side and entree wrap to two lines" do
-      expect(@meals.last.entree.name).to eq "Peppery Grilled Ribeye Steaks"
-    end
-  end
-
-  describe "side names" do
-    it "reads the names of sides that are a single line" do
-      expect(@meals.first.side.name).to eq "Oregano Roasted Zucchini"
-    end
-
-    it "reads the names of sides that wrap to two lines" do
-      expect(@meals[5].side.name).to eq "Roasted Asparagus with Sun-Dried Tomatoes"
-    end
-
-    it "reads the names of sides when both the side and entree wrap to two lines" do
-      expect(@meals.last.side.name).to eq "Heirloom Tomato and Spinach Salad"
-    end
-  end
-
-  describe "flags" do
-    it "reads a meal with no flags correctly" do
-      expect(@meals.first.flags).to be_empty
-    end
-
-    it "reads the slow cooker flag correctly" do
-      expect(@meals[1].flags).to eq [:slow_cooker]
-      expect(@meals[1]).to be_slow_cooker
-    end
-
-    it "reads the on the grill flag correctly" do
-      expect(@meals[3].flags).to eq [:on_the_grill]
-      expect(@meals[3]).to be_on_the_grill
-    end
-
-    it "reads the super fast flag correctly" do
-      expect(@meals[5].flags).to eq [:super_fast]
-      expect(@meals[5]).to be_super_fast
-    end
-
-    it "reads the marinate ahead flag correctly" do
-      expect(@meals[6].flags).to eq [:marinate_ahead]
-      expect(@meals[6]).to be_marinate_ahead
-    end
-  end
-
-  describe "times" do
-    it "reads prep times correctly" do
-      expect(@meals.first.times[:prep]).to eq "10m"
-      expect(@meals[5].times[:prep]).to eq "15m"
-    end
-
-    it "reads cook times correctly" do
-      expect(@meals.first.times[:cook]).to eq "20m"
-      expect(@meals[1].times[:cook]).to eq "4h"
-    end
-
-    it "reads total times correctly" do
-      expect(@meals.first.times[:total]).to eq "30m"
-      expect(@meals[1].times[:total]).to eq "4h 10m"
-    end
-  end
-
   describe "entree ingredients" do
-    include Emeals
-
     let(:dish) { @meals.first.entree }
 
     it "reads the correct number of ingredients" do
@@ -116,8 +43,6 @@ describe Emeals::Client do
   end
 
   describe "side ingredients" do
-    include Emeals
-
     let(:dish) { @meals[3].side }
 
     it "reads the correct number of ingredients" do
@@ -176,4 +101,4 @@ describe Emeals::Client do
       end
     end
   end
-end
+end

data/spec/fixtures/meal.erb

@@ -0,0 +1,31 @@
+Meal 1 <%= @flags %>
+<%= @entree %>
+<%= @side %>
+Prep Cook Total
+<%= [@prep_time, @cook_time, @total_time].join(" ") %>
+¼ lb ground pork sausage
+½ small onion, minced
+<%= "#{@entree_ingredients}\n" unless @entree_ingredients == "" -%>
+4 large eggs, lightly beaten
+¼ teaspoon kosher salt, ¼ teaspoon pepper
+---------------------------------------------------------------
+1 lb fresh zucchini, trimmed and thinly sliced
+1 tablespoon chopped fresh oregano
+<%= "#{@side_ingredients}\n" unless @side_ingredients == "" -%>
+1 tablespoon olive oil
+¼ teaspoon kosher salt, ¼ teaspoon pepper
+Heat a nonstick skillet over medium-high heat.
+Add sausage to pan; cook 6 minutes or until
+done. Drain on a paper towel-lined plate,
+reserving 1 tablespoon drippings in pan. <%= "#{@entree_instructions} " unless @entree_instructions == "" %>Add
+onion to pan over medium heat. Cook 3
+minutes or until lightly browned. Add eggs; cook
+2 minutes, stirring constantly. Stir in sausage,
+salt and pepper; cook until eggs are thickened
+and set. Note: Remaining pork sausage can be
+frozen for up to 2 months.
+---------------------------------------------------------------
+Preheat oven to 425 degrees. Toss zucchini,
+oregano, oil, salt and pepper in a large roasting
+pan. <%= "#{@side_instructions} " unless @side_instructions == "" %>Bake 20 minutes or until just tender.
+

data/spec/meal_parser_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+require 'emeals/meal'
+
+describe Emeals::MealParser do
+  describe "entree names" do
+    let(:entree1) { make_meal(entree: 'Baked Cod Provencal').entree.name }
+    let(:entree2) { make_meal(entree: 'Baked Cod Provencal',
+                              side:   "A Side That Wraps Onto\nTwo Lines").entree.name }
+    let(:entree3) { make_meal.entree.name }
+    let(:entree4) { make_meal(side: "A Side That Wraps Onto\nTwo Lines").entree.name }
+
+    it "reads the names of entrees when entree and side are single-line" do
+      expect(entree1).to eq "Baked Cod Provencal"
+    end
+
+    it "reads the names of entrees when the side wraps to two lines" do
+      expect(entree2).to eq "Baked Cod Provencal"
+    end
+
+    it "reads the names of entrees which wrap to two lines" do
+      expect(entree3).to eq "Spicy Sausage and Egg Scramble"
+    end
+
+    it "reads the names of entrees when both the side and entree wrap to two lines" do
+      expect(entree4).to eq "Spicy Sausage and Egg Scramble"
+    end
+  end
+
+  describe "side names" do
+    let(:side1) { make_meal(entree: 'Baked Cod Provencal').side.name }
+    let(:side2) { make_meal.side.name }
+    let(:side3) { make_meal(entree: 'Baked Cod Provencal',
+                              side:   "A Side That Wraps Onto\nTwo Lines").side.name }
+    let(:side4) { make_meal(side: "A Side That Wraps Onto\nTwo Lines").side.name }
+
+    it "reads the names of sides when entree and side are single-line" do
+      expect(side1).to eq "Oregano Roasted Zucchini"
+    end
+
+    it "reads the names of sides when the side wraps to two lines" do
+      expect(side2).to eq "Oregano Roasted Zucchini"
+    end
+
+    it "reads the names of sides which wrap to two lines" do
+      expect(side3).to eq "A Side That Wraps Onto Two Lines"
+    end
+
+    it "reads the names of sides when both the side and entree wrap to two lines" do
+      expect(side4).to eq "A Side That Wraps Onto Two Lines"
+    end
+  end
+
+  describe "flags" do
+    let(:slow_cooker)    { make_meal flags: "Slow Cooker" }
+    let(:on_the_grill)   { make_meal flags: "On the Grill" }
+    let(:super_fast)     { make_meal flags: "Super Fast" }
+    let(:marinate_ahead) { make_meal flags: "Marinate Ahead" }
+
+    it "reads the slow cooker flag correctly" do
+      expect(slow_cooker.flags).to eq [:slow_cooker]
+      expect(slow_cooker).to be_slow_cooker
+    end
+
+    it "reads the on the grill flag correctly" do
+      expect(on_the_grill.flags).to eq [:on_the_grill]
+      expect(on_the_grill).to be_on_the_grill
+    end
+
+    it "reads the super fast flag correctly" do
+      expect(super_fast.flags).to eq [:super_fast]
+      expect(super_fast).to be_super_fast
+    end
+
+    it "reads the marinate ahead flag correctly" do
+      expect(marinate_ahead.flags).to eq [:marinate_ahead]
+      expect(marinate_ahead).to be_marinate_ahead
+    end
+
+    it "reads a meal with no flags correctly" do
+      expect(make_meal.flags).to eq []
+      expect(make_meal).to_not be_slow_cooker
+    end
+  end
+
+  describe "times" do
+    it "reads prep times correctly" do
+      expect(make_meal.times[:prep]).to eq "10m"
+      expect(make_meal(prep_time: "15m").times[:prep]).to eq "15m"
+    end
+
+    it "reads cook times correctly" do
+      expect(make_meal.times[:cook]).to eq "20m"
+      expect(make_meal(cook_time: "4h").times[:cook]).to eq "4h"
+    end
+
+    it "reads total times correctly" do
+      expect(make_meal.times[:total]).to eq "30m"
+      expect(make_meal(total_time: "4h 10m").times[:total]).to eq "4h 10m"
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -4,6 +4,9 @@
 # loaded once.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each {|f| require f}
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true

data/spec/support/templates.rb

@@ -0,0 +1,29 @@
+require 'emeals'
+
+TEMPLATE_DIR = File.join(File.dirname(__FILE__), '..', 'fixtures')
+
+DEFAULT_MEAL_OPTIONS = {
+  entree: "Spicy Sausage and Egg\nScramble",
+  side: "Oregano Roasted Zucchini",
+  flags: "",
+  prep_time: '10m',
+  cook_time: '20m',
+  total_time: '30m',
+  entree_ingredients: "",
+  side_ingredients: "",
+  entree_instructions: "",
+  side_instructions: "",
+  before: "",
+  after: ""
+}
+
+def make_meal(options = {})
+  options = DEFAULT_MEAL_OPTIONS.merge(options)
+
+  ctx = Object.new
+  def ctx.evaluate(options)
+    options.each {|k,v| instance_variable_set("@#{k}", v) }
+    ERB.new(File.read(File.join(TEMPLATE_DIR, 'meal.erb')), nil, '-').result(binding)
+  end
+  Emeals::MealParser.new(ctx.evaluate(options)).parse
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emeals
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Matt Moriarity
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2013-07-21 00:00:00.000000000 Z
 dependencies: []
 description: A client for interpreting eMeals menus.
 email:
@@ -33,10 +33,13 @@ files:
 - lib/emeals/menu.rb
 - lib/emeals/version.rb
 - spec/client_spec.rb
+- spec/fixtures/meal.erb
 - spec/fixtures/menu.pdf
 - spec/fixtures/menu.txt
 - spec/ingredient_spec.rb
+- spec/meal_parser_spec.rb
 - spec/spec_helper.rb
+- spec/support/templates.rb
 homepage: ''
 licenses: []
 metadata: {}
@@ -56,13 +59,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: eMeals Client
 test_files:
 - spec/client_spec.rb
+- spec/fixtures/meal.erb
 - spec/fixtures/menu.pdf
 - spec/fixtures/menu.txt
 - spec/ingredient_spec.rb
+- spec/meal_parser_spec.rb
 - spec/spec_helper.rb
+- spec/support/templates.rb