ianwhite-pickle 0.1.1 → 0.1.2

data/spec/lib/pickle_injector_spec.rb

@@ -3,9 +3,9 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 describe Pickle::Injector do
   describe ".inject Pickle::Session, :into => <a class>" do
     before do
-      @class = Class.new
-      Pickle::Injector.inject Pickle::Session, :into => @class
-      @object = @class.new
+      klass = Class.new
+      Pickle::Injector.inject Pickle::Session, :into => klass
+      @object = klass.new
     end
     
     it "object should respond_to Pickle:Session methods" do

data/spec/lib/pickle_parser_matchers_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Parser::Matchers, "with config defining factories: user, car, fast_car" do
+  include Pickle::Parser::Matchers
+  
+  def config
+    @config ||= Pickle::Config.new do |c|
+      c.factories = {
+        'user'      => mock('factory'),
+        'car'       => mock('factory'),
+        'fast_car'  => mock('factory')
+      }
+    end
+  end
+  
+  describe "Match atoms" do
+    def self.atom_should_match(atom, strings)
+      Array(strings).each do |string|
+        it "#{atom} should match '#{string}'" do
+          string.should match(/^#{send atom}$/)
+        end
+      end
+    end
+
+    def self.atom_should_not_match(atom, strings)
+      Array(strings).each do |string|
+        it "#{atom} should NOT match '#{string}'" do
+          string.should_not match(/^#{send atom}$/)
+        end
+      end
+    end
+  
+    atom_should_match     :match_ordinal, ['1st', '2nd', '23rd', '104th']
+    atom_should_not_match :match_ordinal, ['1', '2']
+
+    atom_should_match     :match_index, ['first', 'last', '23rd', '104th']
+    atom_should_not_match :match_index, ['1', '2', 'foo']
+
+    atom_should_match     :match_label, [': "gday"', ': "gday mate"']
+    atom_should_not_match :match_label, [': "gday""', ': gday']
+  
+    atom_should_match     :match_field, ['foo: "this is the life"', 'bar_man: "and so is this"']
+    atom_should_not_match :match_field, ['foo bar: "this aint workin"']
+  
+    atom_should_match     :match_fields, ['foo: "bar"', 'foo: "bar", baz: "bah"']
+    atom_should_not_match :match_fields, ['foo bar: "baz"', 'email: "a", password: "b", and password_confirmation: "c"']
+
+    atom_should_match     :match_model, ['a user', '1st fast car', 'the 23rd fast_car', 'the user: "fred flinstone"']
+    atom_should_not_match :match_model, ['a giraffe', 'a 1st faster car: "jim"', 'an event created']
+  
+    atom_should_match     :match_factory, ['user', 'fast car', 'fast_car', 'car']
+    atom_should_not_match :match_factory, ['users', 'faster car', 'event created']
+  end
+end

data/spec/lib/pickle_parser_spec.rb

@@ -1,51 +1,23 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
 describe Pickle::Parser do
-  include Pickle::Parser
-        
-  describe "Match atoms" do
-    def self.atom_should_match(atom, strings)
-      Array(strings).each do |string|
-        it "#{atom} should match '#{string}'" do
-          string.should match(/^#{eval "Pickle::Parser::#{atom}"}$/)
-        end
-      end
-    end
-
-    def self.atom_should_not_match(atom, strings)
-      Array(strings).each do |string|
-        it "#{atom} should NOT match '#{string}'" do
-          string.should_not match(/^#{eval "Pickle::Parser::#{atom}"}$/)
-        end
-      end
-    end
-    
-    atom_should_match     'Match::Ordinal', ['1st', '2nd', '23rd', '104th']
-    atom_should_not_match 'Match::Ordinal', ['1', '2']
-
-    atom_should_match     'Match::Index', ['first', 'last', '23rd', '104th']
-    atom_should_not_match 'Match::Index', ['1', '2', 'foo']
-
-    atom_should_match     'Match::Name', [': "gday"', ': "gday mate"']
-    atom_should_not_match 'Match::Name', [': "gday""', ': gday']
-    
-    atom_should_match     'Match::Field', ['foo: "this is the life"', 'bar_man: "and so is this"']
-    atom_should_not_match 'Match::Field', ['foo bar: "this aint workin"']
-    
-    atom_should_match     'Match::Fields', ['foo: "bar"', 'foo: "bar", baz: "bah"']
-    atom_should_not_match 'Match::Fields', ['foo bar: "baz"', 'email: "a", password: "b", and password_confirmation: "c"']
+  before do
+    @parser = Pickle::Parser.new
+  end
   
-    atom_should_match     'Match::Model', ['a user', '1st fast car', 'the 23rd fast_car', 'an event:create', 'the 2nd event/create', 'that event create: "zing"']
-    atom_should_not_match 'Match::Model', ['a giraffe', 'a 1st faster car: "jim"', 'an event created']
-    
-    atom_should_match     'Match::ModelName', ['user', 'fast car', 'fast_car', 'event:create', 'event/create', 'event create']
-    atom_should_not_match 'Match::ModelName', ['users', 'faster car', 'event created']
+  it "should use the default config when created with no args" do
+    @parser.config.should == Pickle.config
+  end
+  
+  it "should use the passed config when created with :config option" do
+    parser = Pickle::Parser.new :config => (cfg = mock('config'))
+    parser.config.should == cfg
   end
   
   describe 'misc regexps' do
-    describe '/^(#{Pickle::Parser::Match::Model}) exists/' do
+    describe '/^#{capture_model} exists/' do
       before do
-        @regexp = /^(#{Pickle::Parser::Match::Model}) exists$/
+        @regexp = /^(#{@parser.capture_model}) exists$/
       end
       
       it "should match 'a user exists'" do
@@ -60,104 +32,111 @@ describe Pickle::Parser do
   
   describe '#parse_field' do
     it "should return {'a' => 'b'} for 'a: \"b\"'" do
-      parse_field('a: "b"').should == {'a' => 'b'}
+      @parser.parse_field('a: "b"').should == {'a' => 'b'}
     end
   
     it "should raise error for invalid field 'a : b'" do
-      lambda { parse_field('a : b') }.should raise_error(ArgumentError)
+      lambda { @parser.parse_field('a : b') }.should raise_error(ArgumentError)
     end
   end
   
   describe '#parse_fields' do
     it 'should return {} for blank argument' do
-      parse_fields(nil).should == {}
-      parse_fields('').should == {}
+      @parser.parse_fields(nil).should == {}
+      @parser.parse_fields('').should == {}
     end
     
     it 'should raise error for invalid argument' do
-      lambda { parse_fields('foo foo') }.should raise_error(ArgumentError)
+      lambda { @parser.parse_fields('foo foo') }.should raise_error(ArgumentError)
     end
     
     it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
-      parse_fields('foo: "bar"').should == { "foo" => "bar"}
+      @parser.parse_fields('foo: "bar"').should == { "foo" => "bar"}
     end
     
     it '(\'foo: "bar", bar_man: "wonga wonga", gump: "123"\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => "123"}' do
-      parse_fields('foo: "bar", bar_man: "wonga wonga", gump: "123"').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => "123"}
+      @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", gump: "123"').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => "123"}
     end
   end
   
   describe '#parse_model' do
     it '("a user") should == ["user", ""]' do
-      parse_model("a user").should == ["user", ""]
+      @parser.parse_model("a user").should == ["user", ""]
     end
-
+  
     it '("the user") should == ["user", ""]' do
-      parse_model("the user").should == ["user", ""]
+      @parser.parse_model("the user").should == ["user", ""]
     end
-
+  
     it '("1 fast car") should == ["fast_car", ""]' do
-      parse_model("1 fast car").should == ["fast_car", ""]
+      @parser.parse_model("1 fast car").should == ["fast_car", ""]
     end
     
     it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
-      parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
+      @parser.parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
     end
     
     it '(\'that fast car: "herbie"\') should == ["fast_car", "herbie"]' do
-      parse_model('that fast car: "herbie"').should == ["fast_car", "herbie"]
+      @parser.parse_model('that fast car: "herbie"').should == ["fast_car", "herbie"]
     end
     
     it '(\'the 12th user\') should == ["user", 11]' do
-      parse_model('the 12th user').should == ["user", 11]
+      @parser.parse_model('the 12th user').should == ["user", 11]
     end
-
+  
     it '(\'the last user\') should == ["user", -1]' do
-      parse_model('the last user').should == ["user", -1]
+      @parser.parse_model('the last user').should == ["user", -1]
     end
     
     it '("the first user") should == ["user", 0]' do
-      parse_model('the first user').should == ["user", 0]
+      @parser.parse_model('the first user').should == ["user", 0]
     end
-
+  
     it '("the 1st user") should == ["user", 0]' do
-      parse_model('the 1st user').should == ["user", 0]
+      @parser.parse_model('the 1st user').should == ["user", 0]
     end
   end
   
   describe "#parse_index" do
     it '("1st") should == 0' do
-      parse_index("1st").should == 0
+      @parser.parse_index("1st").should == 0
     end
-
+  
     it '("24th") should == 23' do
-      parse_index("24th").should == 23
+      @parser.parse_index("24th").should == 23
     end
     it '("first") should == 0' do
-      parse_index("first").should == 0
+      @parser.parse_index("first").should == 0
     end
     
     it '("last") should == -1' do
-      parse_index("last").should == -1
+      @parser.parse_index("last").should == -1
     end
   end
   
   describe "customised mappings" do
-    describe 'Pickle::Config.map "I|myself", :to => \'user: "me"\'' do      
-      it "'I' should match /\#{Pickle::Parser::Match::Model}/" do
-        'I'.should match(/#{Pickle::Parser::Match::Model}/)
+    describe "config maps 'I|myself' to 'user: \"me\"'" do
+      before do
+        @config = Pickle::Config.new do |c|
+          c.map 'I', 'myself', :to => 'user: "me"'
+        end
+        @parser = Pickle::Parser.new(:config => @config)
       end
-      
-      it "'myself' should match /\#{Pickle::Parser::Match::Model}/" do
-        'myself'.should match(/#{Pickle::Parser::Match::Model}/)
+
+      it "'I' should match /\#{match_model}/" do
+        'I'.should match(/#{@parser.match_model}/)
       end
-      
-      it "parse_the_model_name('I') should == ['user', 'me']" do
-        parse_model('I').should == ["user", "me"]
+    
+      it "'myself' should match /\#{match_model}/" do
+        'myself'.should match(/#{@parser.match_model}/)
       end
-  
-      it "parse_the_model_name('myself') should == ['user', 'me']" do
-        parse_model('I').should == ["user", "me"]
+    
+      it "parse_model('I') should == ['user', 'me']" do
+        @parser.parse_model('I').should == ["user", "me"]
+      end
+
+      it "parse_model('myself') should == ['user', 'me']" do
+        @parser.parse_model('myself').should == ["user", "me"]
       end
     end
   end

data/spec/lib/pickle_session_spec.rb

@@ -6,21 +6,21 @@ describe Pickle::Session do
   end
 
   describe "after storing a single user", :shared => true do
-    it "original_models('user') should be array containing the original user" do
-      @session.original_models('user').should == [@user]
+    it "created_models('user') should be array containing the original user" do
+      @session.created_models('user').should == [@user]
     end
 
     describe "the original user should be retrievable with" do
-      it "original_model('the user')" do
-        @session.original_model('the user').should == @user
+      it "created_model('the user')" do
+        @session.created_model('the user').should == @user
       end
 
-      it "original_model('1st user')" do
-        @session.original_model('1st user').should == @user
+      it "created_model('1st user')" do
+        @session.created_model('1st user').should == @user
       end
 
-      it "original_model('last user')" do
-        @session.original_model('last user').should == @user
+      it "created_model('last user')" do
+        @session.created_model('last user').should == @user
       end
     end
 
@@ -105,12 +105,12 @@ describe Pickle::Session do
         
         it_should_behave_like "after storing a single user"
               
-        it "original_model('the user: \"fred\"') should retrieve the user" do
-          @session.original_model('the user: "fred"').should == @user
+        it "created_model('the user: \"fred\"') should retrieve the user" do
+          @session.created_model('the user: "fred"').should == @user
         end
       
-        it "original_model?('the user: \"shirl\"') should be false" do
-          @session.original_model?('the user: "shirl"').should == false
+        it "created_model?('the user: \"shirl\"') should be false" do
+          @session.created_model?('the user: "shirl"').should == false
         end
         
         it "model?('the user: \"shirl\"') should be false" do
@@ -172,55 +172,57 @@ describe Pickle::Session do
         do_create_users
       end
       
-      it "original_models('user') should == [@fred, @shirl, @noname]" do
-        @session.original_models('user').should == [@fred, @shirl, @noname]
+      it "created_models('user') should == [@fred, @shirl, @noname]" do
+        @session.created_models('user').should == [@fred, @shirl, @noname]
       end
       
-      it "original_models('super_admin') should == [@fred, @noname]" do
-        @session.original_models('super_admin').should == [@fred, @noname]
+      it "created_models('super_admin') should == [@fred, @noname]" do
+        @session.created_models('super_admin').should == [@fred, @noname]
       end
       
-      describe "#original_model" do
+      describe "#created_model" do
         it "'that user' should be @noname (the last user created - as super_admins are users)" do
-          @session.original_model('that user').should == @noname
+          @session.created_model('that user').should == @noname
         end
 
         it "'the super admin' should be @noname (the last super admin created)" do
-          @session.original_model('that super admin').should == @noname
+          @session.created_model('that super admin').should == @noname
         end
         
         it "'the 1st super admin' should be @fred" do
-          @session.original_model('the 1st super admin').should == @fred
+          @session.created_model('the 1st super admin').should == @fred
         end
         
         it "'the first user' should be @fred" do
-          @session.original_model('the first user').should == @fred
+          @session.created_model('the first user').should == @fred
         end
         
         it "'the 2nd user' should be @shirl" do
-          @session.original_model('the 2nd user').should == @shirl
+          @session.created_model('the 2nd user').should == @shirl
         end
         
         it "'the last user' should be @noname" do
-          @session.original_model('the last user').should == @noname
+          @session.created_model('the last user').should == @noname
         end
         
         it "'the user: \"fred\" should be @fred" do
-          @session.original_model('the user: "fred"').should == @fred
+          @session.created_model('the user: "fred"').should == @fred
         end
         
         it "'the user: \"shirl\" should be @shirl" do
-          @session.original_model('the user: "shirl"').should == @shirl
+          @session.created_model('the user: "shirl"').should == @shirl
         end
       end
     end
   end
 
-  describe "when 'the user: \"me\"' exists (and there is a mapping from 'I|myself' => 'user: \"me\")" do
+  describe "when 'the user: \"me\"' exists and there is a mapping from 'I', 'myself' => 'user: \"me\"" do
     before do
       @user = mock_model(User)
       User.stub!(:find).and_return(@user)
       Factory.stub!(:create).and_return(@user)
+      parser = Pickle::Parser.new(:config => Pickle::Config.new {|c| c.map 'I', 'myself', :to => 'user: "me"'})
+      @session = Pickle::Session.new(:parser => parser)
       @session.create_model('the user: "me"')
     end
   
@@ -232,24 +234,24 @@ describe Pickle::Session do
       @session.model('myself').should == @user
     end
     
-    it "#parse_fields 'author: user \"JIM\"' should raise Error, as model deos not refer" do
-      lambda { @session.parse_fields('author: user "JIM"') }.should raise_error
+    it "#parser.parse_fields 'author: user \"JIM\"' should raise Error, as model deos not refer" do
+      lambda { @session.send(:parser).parse_fields('author: user "JIM"') }.should raise_error
     end
     
-    it "#parse_fields 'author: the user' should return {\"author\" => <user>}" do
-      @session.parse_fields('author: the user').should == {"author" => @user}
+    it "#parser.parse_fields 'author: the user' should return {\"author\" => <user>}" do
+      @session.send(:parser).parse_fields('author: the user').should == {"author" => @user}
     end
 
-    it "#parse_fields 'author: myself' should return {\"author\" => <user>}" do
-      @session.parse_fields('author: myself').should == {"author" => @user}
+    it "#parser.parse_fields 'author: myself' should return {\"author\" => <user>}" do
+      @session.send(:parser).parse_fields('author: myself').should == {"author" => @user}
     end
     
-    it "#parse_fields 'author: the user, approver: I, rating: \"5\"' should return {'author' => <user>, 'approver' => <user>, 'rating' => '5'}" do
-      @session.parse_fields('author: the user, approver: I, rating: "5"').should == {'author' => @user, 'approver' => @user, 'rating' => '5'}
+    it "#parser.parse_fields 'author: the user, approver: I, rating: \"5\"' should return {'author' => <user>, 'approver' => <user>, 'rating' => '5'}" do
+      @session.send(:parser).parse_fields('author: the user, approver: I, rating: "5"').should == {'author' => @user, 'approver' => @user, 'rating' => '5'}
     end
     
-    it "#parse_fields 'author: user: \"me\", approver: \"\"' should return {'author' => <user>, 'approver' => \"\"}" do
-      @session.parse_fields('author: user: "me", approver: ""').should == {'author' => @user, 'approver' => ""}
+    it "#parser.parse_fields 'author: user: \"me\", approver: \"\"' should return {'author' => <user>, 'approver' => \"\"}" do
+      @session.send(:parser).parse_fields('author: user: "me", approver: ""').should == {'author' => @user, 'approver' => ""}
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ianwhite-pickle
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Ian White
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-27 00:00:00 -08:00
+date: 2008-12-31 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -22,17 +22,26 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/pickle/adapter.rb
+- lib/pickle/config.rb
 - lib/pickle/injector.rb
+- lib/pickle/parser/matchers.rb
+- lib/pickle/parser/with_session.rb
 - lib/pickle/parser.rb
 - lib/pickle/session.rb
-- lib/pickle/steps.rb
+- lib/pickle/version.rb
 - lib/pickle.rb
+- rails_generators/pickle/pickle_generator.rb
+- rails_generators/pickle/templates/env.rb
+- rails_generators/pickle/templates/pickle_steps.rb
 - License.txt
 - README.textile
 - Todo.txt
 - History.txt
+- spec/lib/pickle_adapter_spec.rb
 - spec/lib/pickle_config_spec.rb
 - spec/lib/pickle_injector_spec.rb
+- spec/lib/pickle_parser_matchers_spec.rb
 - spec/lib/pickle_parser_spec.rb
 - spec/lib/pickle_session_spec.rb
 has_rdoc: true
@@ -64,7 +73,9 @@ signing_key:
 specification_version: 2
 summary: Easy model creation and reference in your cucumber features
 test_files: 
+- spec/lib/pickle_adapter_spec.rb
 - spec/lib/pickle_config_spec.rb
 - spec/lib/pickle_injector_spec.rb
+- spec/lib/pickle_parser_matchers_spec.rb
 - spec/lib/pickle_parser_spec.rb
 - spec/lib/pickle_session_spec.rb