pickle-dupe 0.1.0 → 0.2.0

data/README.rdoc

@@ -2,15 +2,20 @@
 
 Pickle-dupe is an add-on to pickle that works with Dupe, an Active Resource mocking/factory.
 
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+== Installation
+
+Pickle-dupe requires the following gems
+* pickle
+* dupe
+
+To install pickle-dupe gem, do:
+    sudo gem install pickle-dupe
+
+== Usage
+In order to use pickle with dupe, you need to add :dupe to your pickle's configuration as follows:
+    Pickle.configure do |config|
+      config.adapters = [:dupe]
+    end
 
 == Copyright
 

data/Rakefile

@@ -11,6 +11,7 @@ begin
     gem.homepage = "http://github.com/iawgens/pickle-dupe"
     gem.authors = ["iawgens"]
     gem.add_dependency "pickle",">=0.2.1"
+    gem.add_dependency "dupe",">=0.4.8"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
@@ -28,8 +29,8 @@ end
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
+    test.libs << 'spec'
+    test.pattern = 'spec/**/*_spec.rb'
     test.verbose = true
   end
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/features/app/active_resources.rb

@@ -1,8 +1,12 @@
 class AbstractResource < ActiveResource::Base
   self.site = ''
 end
+
 class Recipe < AbstractResource
 end
 
 class Ingredient < AbstractResource
+end
+
+class Step < AbstractResource
 end

data/features/app/dupe_definitions.rb

@@ -11,19 +11,24 @@ Dupe.define :recipe do |recipe|
     Dupe.next :recipe_title
   end
   
-  # recipe.ingredients do |ingredients|
-  #     ingredients.split(', ').map do |ingredient|
-  #       Dupe.find(:ingredient) do |i|
-  #         i.label == labelize(ingredient)
-  #       end
-  #     end
-  #   end
+  # has_many ingredients
+  recipe.ingredients []
+  
+  # has_many steps
+  recipe.steps []
   
   recipe.after_create do |r|
     r.label = labelize(r.title)
   end
 end
 
+Dupe.define :step do |step|
+  step.uniquify :title
+  
+  step.after_create do |s|
+    s.label = labelize(s.title)
+  end
+end
 
 # Not Applicable in Dupe
 # Dupe.define :fancy_recipe, :class => Recipe do |t|
@@ -33,6 +38,9 @@ end
 Dupe.define :ingredient do |ingredient|
   ingredient.uniquify :name
   
+  #belongs_to_many recipes
+  ingredient.recipes []
+  
   ingredient.after_create do |i|
     i.label = labelize(i.name)
   end

data/features/pickle/create_from_dupe.feature

@@ -6,7 +6,8 @@ Feature: I can easily create models from dupe
   Scenario: I create a recipe, and see if it looks right
     Given a recipe exists
     Then a recipe should exist
-    
+  
+	@basic_test
   Scenario: I create a recipe with specific name, and see if it looks right
     Given a recipe exists with name: "Chicken Recipe"
     Then a recipe should exist with name: "Chicken Recipe"
@@ -14,31 +15,45 @@ Feature: I can easily create models from dupe
   Scenario: I create stub recipes, and see if it looks right
     Given 3 recipes exist
 	  Then 3 recipes should exist
-	  
-	Scenario: I create some recipes, and some ingredients
+	
+	@many_to_one_association
+	Scenario: I create some recipes, and some steps
 	  Given a recipe: "one" exists
-	  And an ingredient exists with recipe: recipe "one"
-	  And another ingredient exists with recipe: recipe "one"
+	  And a step exists with recipe: recipe "one"
+	  And another step exists with recipe: recipe "one"
 	  And a recipe: "two" exists
-	  And an ingredient exists with recipe: recipe "two"
-	  
-    # TODO: GC 02/05/2010 named factory definition is not yet supported by dupe 
+	  And a step exists with recipe: recipe "two"
+
+    # TODO: GC 02/05/2010 named factory definition is not yet supported by dupe
     # And a fancy recipe exists
     # And an ingredient exists with recipe: the fancy recipe
+    
+    # testing custom step
+	  Then the first step should be step of the recipe: "one"
+	  And the 2nd step should be step of recipe "one"
+	  And the last step should be step of recipe "two"
 	  
-	  Then the first ingredient should be ingredient of the recipe: "one"
-	  And the 2nd ingredient should be the ingredient of recipe "one"
-	  And the last ingredient should be the recipe of recipe "two"
-	  
-	  Then the first ingredient should be in recipe "one"'s ingredients
-	  And the 2nd ingredient should be in recipe: "one"'s ingredients
-	  And the last ingredient should be in recipe "two"'s ingredients
-	  And recipe "two" should be the last ingredient's recipe
+	  Then the first step should be in recipe "one"'s steps
+	  And the 2nd step should be in recipe: "one"'s steps
+	  And the last step should be in recipe "two"'s steps
+	  And recipe "two" should be the last step's recipe
 	  
-	  But the first ingredient should not be in the fancy recipe's ingredients
-	  And the last ingredient should not be in recipe "one"'s ingredients
-	  And the fancy recipe should not be the first ingredient's recipe
- 
+	  #But the first ingredient should not be in the fancy recipe's ingredients
+	  But the last step should not be in recipe "one"'s steps
+	  And recipe "two" should not be the first step's recipe
+	  #And the fancy recipe should not be the first ingredient's recipe
+	
+  @many_to_many_association
+	Scenario: I create some ingredients and associate to some recipe
+	  Given an ingredient: "one" exists
+	  And an ingredient: "two" exists
+	  And a recipe exists with ingredients: ingredient "one"
+	  And a recipe exists with ingredients: [ingredient "one", ingredient "two"]
+	  Then the first recipe should be in ingredient "one"'s recipes
+	  And the last recipe should be in ingredient "one"'s recipes
+	  And the last recipe should be in ingredient "two"'s recipes
+	  And the first recipe should not be in ingredient "two"'s recipes
+
   Scenario: Create an ingredient and a recipe refs in a table
     Given 2 recipes exist
     And the following ingredients exist:

data/features/step_definitions/pickle_steps.rb

@@ -1,6 +1,6 @@
 # this file generated by script/generate pickle
 
-# create a model
+# create a model
 Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
   create_model(name, fields)
 end

data/features/step_definitions/recipe_steps.rb

@@ -1,4 +1,6 @@
 # example of making your own matcher with the pickle backend
-Then(/^#{capture_model} should be ingredient of #{capture_model}$/) do |ingredient, recipe|
-  model(recipe).ingredients.should include(model(ingredient))
-end
+Then(/^#{capture_model} should be step of #{capture_model}$/) do |step, recipe|
+  model(recipe).steps.should include(model(step))
+end
+
+# ((?:(?:\w+: (?:(?:(?:I|killah fork)|(?:(?:a|an|another|the|that) )?(?:(?:(?:(?:first|last|(?:\d+(?:st|nd|rd|th))) )?(?:step|recipe|ingredient))|(?:(?:step|recipe|ingredient)(?::? "(?:[^\"]|\.)*"))))|(?:"(?:[^\"]|\.)*"|nil|true|false|[+-]?\d+(?:\.\d+)?))), )*(?:\w+: (?:(?:(?:I|killah fork)|(?:(?:a|an|another|the|that) )?(?:(?:(?:(?:first|last|(?:\d+(?:st|nd|rd|th))) )?(?:step|recipe|ingredient))|(?:(?:step|recipe|ingredient)(?::? "(?:[^\"]|\.)*"))))|(?:"(?:[^\"]|\.)*"|nil|true|false|[+-]?\d+(?:\.\d+)?))))

data/lib/pickle_dupe/adapter.rb

@@ -21,8 +21,100 @@ module Pickle
       end
     
       def create(attrs = {})
-        ::Dupe.create(@name, attrs)
+        duped_object = ::Dupe.create(@name, attrs)
+        assign_missing_associations(duped_object, attrs) unless attrs.blank?
+        
+        return duped_object
       end
+      
+    private
+    
+      # Since ActiveResource does not have the notion of relationship between models, when associating
+      # a duped object to another object, Dupe does not take care of the association in both ways.
+      #
+      # Consider the following example with Recipe and DirectionStep. A recipe has many direction_steps 
+      # and a direction_step belongs to one recipe. To setup dupe data for the cucumber scenario, we do the following:
+      #
+      #   @recipe = Dupe.create :recipe #=> <#Duped::Recipe id=1>
+      #   @direction_step = Dupe.create(:direction_step, {:recipe => @recipe}) 
+      #     #=> <#Duped:DirectionStep recipe=<#Duped::Recipe id=1> id=1>
+      #
+      # That would associate the duped recipe to the duped ingredient. However, the duped recipe has
+      # no knowledge of the direction_step.
+      #
+      #   @recipe.direction_steps #=> nil
+      #
+      # Since Dupe does not handle the reverse association, this method thus assign the association to the 
+      # has_many side when a duped object is assigned to the belongs_to side when using pickle steps.
+      #
+      # To implement this association, you must let Dupe knows that a has_many association is expected by defining
+      # it in dupe definition as follows:
+      #
+      #   Dupe.define :recipe do |recipe|
+      #     recipe.direction_steps []
+      #   end
+      #
+      # Once defined, when you call a pickle step to assign a belongs_to association, like:
+      #
+      #   Given a recipe: "one" exists
+      #   And a direction step exists with recipe: recipe "one"
+      # 
+      # Then the "Then" step would be able to get the direction steps through the recipe duped object, like: 
+      #
+      #   Then the first direction step should be in recipe "one"'s direction steps
+      #
+      # This hack took care of has side when assigning to belongs_to side when it's a many_to_one:
+      #   
+      #   Dupe.create :direction_step, {:recipe => recipe}
+      #
+      # but does not take care of the many_to_many relationship like:
+      #
+      #   Dupe.create :recipe, {:ingredients => [<Duped::Ingredient>,<Duped::Ingredient>]}
+      #
+      def assign_missing_associations(duped_object, attrs)
+        association_objects = collect_association_objects(attrs)
+        association_objects.each {|association_object|
+          
+          # When a pickle step causes Dupe to do the following:
+          # 
+          #  Dupe.create(:direction_step, :recipe => @recipe)
+          #
+          # Then duped_object would be of class Dupe::DirectionStep and association_object would be of
+          # class Dupe::Recipe.
+          #
+          if association_object.kind_of?(Array)
+            association_object.each {|a|
+              assign_association(a, duped_object)
+            }
+          else
+            assign_association(association_object, duped_object)
+          end
+        }
+      end
+      
+      def assign_association(association_object, duped_object)
+        has_one_association = duped_object.__model__.name #=> :direction_step
+        has_many_association = has_one_association.to_s.pluralize.to_sym #=> :direction_steps
+        
+        # The following would check for the existence of the key :direction_steps
+        # in the duped recipe's definition 
+        if association_object.__model__.schema.attribute_templates.keys.include?(has_many_association)
+          association_object[has_many_association] << duped_object
+        else #assume it's a has_one association
+          association_object[has_one_association] = duped_object
+        end
+      end
+      
+      # Selecting association objects from the attributes hash and return as array. Association objects are of class
+      # Dupe::Database::Record
+      # Given :association => <#Duped::Ingredient name="ingredient 1 name" recipes=[] label="ingredient-1-name" id=1> or
+      # :association => [<#Duped...>] will return [[<#Duped...>,<#Duped...>],<#Duped...>]
+      def collect_association_objects(attrs)
+        attrs.select {|k,v| 
+          v.kind_of?(Array) || v.kind_of?(::Dupe::Database::Record)
+        }.collect {|i| i[1]}
+      end
+      
     end
 
   end

data/lib/pickle_dupe/parser.rb

@@ -0,0 +1,56 @@
+module Pickle
+  class Parser
+    def parse_field_with_multi_values(field)
+      # Would handle multiple values like "ingredients: [ingredient \"one\", ingredient \"two"\]"
+      if session && field =~ /^(\w+): #{match_model_in_values}$/
+        field_key = $1
+        
+        models = []
+        values = parse_values(field)
+        values.each do |value|
+          if value =~ /^#{capture_model}$/
+            models << session.model($1)
+          end
+        end
+    
+        {field_key => models}
+      else  
+        parse_field_without_multi_values(field)
+      end
+      
+    end
+    
+    alias_method_chain :parse_field, :multi_values
+    
+    def match_field
+      "(?:\\w+: #{match_values})"
+    end
+    
+    def match_value
+      "(?:#{match_model}|\"#{match_quoted}\"|nil|true|false|[+-]?\\d+(?:\\.\\d+)?)"
+    end
+    
+    def match_values
+      # like [step "one", step "two"]
+      "(?:\\[?(?:#{match_value}, )*#{match_value}\\]?)"
+    end
+    
+    def match_model_in_values
+      "\\[(?:#{match_model}, )*#{match_model}\\]"
+    end
+  
+  private
+    
+    # Given field of "ingredients: [ingredient \"one\", ingredient \"two\"]" return
+    # ["ingredient \"one\"","ingredient \"two\""]
+    def parse_values(field)
+      if field =~ /^\w+: (#{match_values})$/
+        $1.scan(/(#{match_value})(?:,|$|\])/).inject([]) do |m, match|
+          m << match[0]
+        end
+        #TODO GC 02/26/2010 - What to do if it does not match the values pattern?
+      end
+    end
+      
+  end
+end

data/lib/pickle_dupe.rb

@@ -1,3 +1,4 @@
 require 'pickle'
 require 'pickle_dupe/adapter'
 require 'pickle_dupe/session'
+require 'pickle_dupe/parser'

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: pickle-dupe
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - iawgens
@@ -9,19 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-08 00:00:00 -05:00
+date: 2010-03-01 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: pickle
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 1
         version: 0.2.1
-    version: 
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dupe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 8
+        version: 0.4.8
+  type: :runtime
+  version_requirements: *id002
 description: Dupe is Active Resource mocking/factory for use with cucumber. Pickle-dupe is a pickle add-on that works with Dupe
 email: gary.s.cheong@gmail.com
 executables: []
@@ -51,10 +74,8 @@ files:
 - features/support/pickle_dupe_app.rb
 - lib/pickle_dupe.rb
 - lib/pickle_dupe/adapter.rb
+- lib/pickle_dupe/parser.rb
 - lib/pickle_dupe/session.rb
-- spec/pickle_dupe_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/iawgens/pickle-dupe
 licenses: []
@@ -68,21 +89,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Pickle that works with Dupe, an Active Resource mocking/factory
-test_files: 
-- spec/pickle_dupe_spec.rb
-- spec/spec_helper.rb
+test_files: []
+

data/spec/pickle_dupe_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "PickleDupe" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
-end

data/spec/spec.opts

@@ -1 +0,0 @@
---color

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'pickle-dupe'
-require 'spec'
-require 'spec/autorun'
-
-Spec::Runner.configure do |config|
-  
-end