ianwhite-pickle 0.1.1

data/History.txt

@@ -0,0 +1,11 @@
+== 0.1.1
+
+* 1 major enhancement:
+  * made pickle a github gem
+
+* 1 minor enhancement:
+  * Added intentions for pickle in README.textile
+
+== Prior to gems
+
+* Initial release: everything is subject to sweeping change

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ian White - ian.w.white@ardes.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,67 @@
+h1. Pickle [Experimental: In development]
+
+Stick this in vendor/plugins to have cucumber steps that create your models easily from factory_girl/machinist
+
+References to the models are stored, not for the purpose of checking the db (although you could use it for
+that), but for enabling easy reference to urls, and for building complex givens which require a bunch of
+models collaborating
+
+h2. Example
+
+If you have a user model, which has admin? and moderator? predicate methods
+and let's say you have an :admin, :user, and :moderator factory, you can do this in a Scenario:
+
+  And an admin exists
+  And a moderator exists
+  
+  # the following is just to show how refs work, obviously you'd not want to test this
+  Then the moderator should be a moderator
+  And the admin should be an admin
+  And the moderator should not be an admin
+  
+h2. Usage
+
+  script/generate pickle
+
+h2. API
+
+h3. Regexps for us in your own steps
+
+If you want to use pickle expressions in your own steps, make sure you 
+require pickle in that file
+
+  require 'pickle'
+
+For matching english versions of model names you get 
+
+  #match_model, #capture_model
+
+  Given /^#{capture_model} exists$/ do |model_name|
+    model(model_name).should_not == nil
+  end
+
+  Then /^I should be at the (.*?) page$/ |page|
+	if page =~ /#{match_model}'s/
+	  url_for(model(page.sub("'s",''))
+	else
+	  # ...
+	end
+  end
+  
+For matching a field string, you get
+
+  #match_fields, #capture_fields
+  
+  Given /^#{capture_model} exists with #{capture_fields}$/ do |model_name, fields|
+    create_model(model_name, fields)
+  end
+  
+Take a look at features/step_definitions/pickle_steps.rb for more examples
+
+h3. Creating and tracking models
+
+ #create_model(<model_name>[, <field string>])
+ 
+ #find_model(<model_name>[, <field string>])
+ 
+ #model(<model_model>) # refers to a model that has already been created/found (ie. referred to in a scenario)

data/Todo.txt

@@ -0,0 +1,5 @@
+* make a gem release with version number
+
+* create a generator for the pickle steps
+
+* add machinist, and fallback to no factory pattern if none available

data/lib/pickle/injector.rb

@@ -0,0 +1,18 @@
+module Pickle
+  module Injector
+    def self.inject(session, options = {})
+      target = options[:into] || ActionController::Integration::Session
+      session_name = session.name.underscore.gsub('/','_')
+      
+      target.class_eval <<-end_eval, __FILE__, __LINE__
+        def #{session_name}
+          @#{session_name} ||= #{session.name}.new
+        end
+      end_eval
+
+      delegate_methods = session.instance_methods - Object.instance_methods
+      delegate_methods << {:to => session_name}
+      target.delegate *delegate_methods
+    end
+  end
+end

data/lib/pickle/parser.rb

@@ -0,0 +1,82 @@
+module Pickle
+  module Parser
+    module Match
+      Ordinal = '(?:\d+(?:st|nd|rd|th))'
+      Index   = "(?:first|last|#{Ordinal})"
+      Prefix  = '(?:1 |a |an |another |the |that )'
+      Quoted  = '(?:[^\\"]|\\.)*'
+      Name    = '(?::? "' + Quoted + '")'
+      
+      # model matching - depends on Parse::Config, so load before this if non standard config requried
+      ModelMapping  = "(?:#{Pickle::Config.mappings.map(&:first).map{|s| "(?:#{s})"}.join('|')})"
+      ModelName     = "(?:#{Pickle::Config.names.map{|n| n.to_s.gsub('_','[_ ]').gsub('/','[:\/ ]')}.join('|')})"
+      IndexedModel  = "(?:(?:#{Index} )?#{ModelName})"
+      NamedModel    = "(?:#{ModelName}#{Name}?)"
+      Model         = "(?:#{ModelMapping}|#{Prefix}?(?:#{IndexedModel}|#{NamedModel}))"
+      Field         = '(?:\w+: (?:' + Model + '|"' + Quoted + '"))'
+      Fields        = "(?:#{Field}, )*#{Field}"
+      
+    end
+    
+    # these are expressions which capture a sub expression
+    module Capture
+      Ordinal = '(?:(\d+)(?:st|nd|rd|th))'
+      Name    = '(?::? "(' + Match::Quoted + ')")'
+      Field   = '(?:(\w+): "(' + Match::Quoted + ')")'
+    end
+    
+    # given a string like 'foo: "bar", bar: "baz"' returns {"foo" => "bar", "bar" => "baz"}
+    def parse_fields(fields)
+      if fields.blank?
+        {}
+      elsif fields =~ /^#{Match::Fields}$/
+        fields.scan(/(#{Match::Field})(?:,|$)/).inject({}) do |m, match|
+          m.merge(parse_field(match[0]))
+        end
+      else
+        raise ArgumentError, "The fields string is not in the correct format.\n\n'#{fields}' did not match: #{Match::Fields}" 
+      end
+    end
+    
+    # given a string like 'foo: "bar"' returns {key => value}
+    def parse_field(field)
+      if field =~ /^#{Capture::Field}$/
+        { $1 => $2 }
+      else
+        raise ArgumentError, "The field argument is not in the correct format.\n\n'#{field}' did not match: #{Match::Field}"
+      end
+    end
+    
+    # returns really underscored name
+    def canonical(str)
+      str.to_s.gsub(' ','_').underscore
+    end
+    
+    def parse_index(index)
+      case index
+      when '', /last/ then -1
+      when /#{Capture::Ordinal}/ then $1.to_i - 1
+      when /first/ then 0
+      end
+    end
+    
+  private
+    # return [factory, name or integer index]
+    def parse_model(name)
+      apply_mappings!(name)
+      if /(#{Match::ModelName})#{Capture::Name}$/ =~ name
+        [canonical($1), canonical($2)]
+      elsif /(#{Match::Index}) (#{Match::ModelName})$/ =~ name
+        [canonical($2), parse_index($1)]
+      else
+        /(#{Match::ModelName})#{Capture::Name}?$/ =~ name && [canonical($1), canonical($2)]
+      end
+    end
+    
+    def apply_mappings!(string)
+      Pickle::Config.mappings.each do |(search, replace)|
+        string.sub! /^(?:#{search})$/, replace
+      end
+    end
+  end
+end

data/lib/pickle/session.rb

@@ -0,0 +1,106 @@
+module Pickle
+  class Session
+    include Parser
+    
+    def create_model(a_model_name, fields = nil)
+      factory, name = *parse_model(a_model_name)
+      raise ArgumentError, "Can't create a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
+      record = Factory(factory, parse_fields(fields))
+      store_model(factory, name, record)
+    end
+
+    def find_model(a_model_name, fields)
+      model, name = *parse_model(a_model_name)
+      raise ArgumentError, "Can't find a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
+      model_class = model.classify.constantize
+      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
+        store_model(model, name, record)
+      else
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{model} with #{fields}"
+      end
+    end
+    
+    # return the original model stored by create_model or find_model
+    def original_model(a_model_name)
+      factory, name_or_index = *parse_model(a_model_name)
+      
+      if name_or_index.blank?
+        models_by_factory(factory).last
+      elsif name_or_index.is_a?(Integer)
+        models_by_factory(factory)[name_or_index]
+      else
+        models_by_name(factory)[name_or_index] or raise "model: #{a_model_name} does not refer to known model in this scenario"
+      end
+    end
+
+    # predicate version which raises no errors
+    def original_model?(a_model_name)
+      (original_model(a_model_name) rescue nil) ? true : false
+    end
+    
+    # return a newly selected model
+    def model(a_model_name)
+      if model = original_model(a_model_name)
+        model.class.find(model.id) or raise ActiveRecord::RecordNotFound, "model: #{a_model_name} could not be found in the database"
+      end
+    end
+    
+    # predicate version which raises no errors
+    def model?(a_model_name)
+      (model(a_model_name) rescue nil) ? true : false
+    end
+    
+    # return all original models of specified type
+    def original_models(factory)
+      models_by_factory(factory)
+    end
+      
+    # return all models of specified type (freshly selected from the database)
+    def models(factory)
+      original_models(factory).map do |model|
+        model.class.find(model.id)
+      end
+    end
+    
+    def parse_field_with_model(field)
+      if field =~ /^(\w+): (#{Match::Model})$/
+        {$1 => model($2)}
+      else
+        parse_field_without_model(field)
+      end
+    end
+    alias_method_chain :parse_field, :model
+
+  private
+    def convert_models_to_attributes(ar_class, attrs)
+      attrs.each do |key, val|
+        if val.is_a?(ActiveRecord::Base) && ar_class.column_names.include?("#{key}_id")
+          attrs["#{key}_id"] = val.id
+          attrs["#{key}_type"] = val.class.name if ar_class.column_names.include?("#{key}_type")
+          attrs.delete(key)
+        end
+      end
+    end
+    
+    def models_by_name(factory)
+      @models_by_name ||= {}
+      @models_by_name[factory] ||= {}
+    end
+    
+    def models_by_factory(factory)
+      @models_by_factory ||= {}
+      @models_by_factory[factory] ||= []
+    end
+    
+    # if the factory name != the model name, store under both names
+    def store_model(factory, name, record)
+      store_record(canonical(record.class.name), name, record) if canonical(record.class.name) != factory
+      store_record(factory, name, record)
+    end
+
+    def store_record(factory, name, record)
+      models_by_name(factory)[name] = record
+      models_by_factory(factory) << record
+    end
+  end
+end

data/lib/pickle/steps.rb

@@ -0,0 +1,27 @@
+# inject the pickle session into integration session
+Pickle::Injector.inject Pickle::Session, :into => ActionController::Integration::Session
+
+# make some Regexp shortcuts for use in steps
+MatchModel  = Pickle::Parser::Match::Model
+MatchFields = Pickle::Parser::Match::Fields
+
+# start with some obvious steps
+Given(/^(#{MatchModel}) exists$/) do |name|
+  create_model(name)
+end
+
+Given(/^(#{MatchModel}) exists with (#{MatchFields})$/) do |name, fields|
+  create_model(name, fields)
+end
+
+Then(/^(#{MatchModel}) should exist with (#{MatchFields})$/) do |name, fields|
+  find_model(name, fields).should_not == nil
+end
+
+Then(/^(#{MatchModel}) should be (?:an? )?"(.*?)"$/) do |name, predicate|
+  model(name).should send("be_#{predicate.gsub(' ','_')}")
+end
+
+Then(/^(#{MatchModel}) should not be (?:an? )?"(.*?)"$/) do |name, predicate|
+  model(name).should_not send("be_#{predicate.gsub(' ','_')}")
+end

data/lib/pickle.rb

@@ -0,0 +1,47 @@
+# Pickle == cucumber + factory
+#
+# = Usage
+#   # in features/steps/_env.rb
+#   require 'pickle/steps'
+#
+# If you need to configure pickle, do it like this
+#
+#   Pickle::Config.map 'I|me|my', :to => 'user: "me"'
+#   require 'pickle/steps'
+module Pickle
+  module Version
+    Major = 0
+    Minor = 1
+    Tiny  = 1
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+    
+  module Config
+    class << self
+      attr_writer :model_names, :factory_names, :names, :mappings
+      
+      def model_names
+        @model_names ||= Dir["#{RAILS_ROOT}/app/models/**/*.rb"].reject{|f| f =~ /observer.rb$/}.map{|f| f.sub("#{RAILS_ROOT}/app/models/",'').sub(".rb",'')}
+      end
+
+      def factory_names
+        require 'factory_girl'
+        @factory_names ||= Factory.factories.keys.map(&:to_s)
+      end
+
+      def names
+        @names ||= (model_names | factory_names)
+      end
+      
+      def mappings
+        @mappings ||= []
+      end
+      
+      def map(search, options)
+        raise ArgumentError, "Usage: map 'search', :to => 'replace'" unless search.is_a?(String) && options[:to].is_a?(String)
+        self.mappings << [search, options[:to]]
+      end
+    end
+  end
+end

data/spec/lib/pickle_config_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Config do
+  before do
+    # zero pickle config before each example
+    [:names, :model_names, :factory_names, :mappings].each do |config_var|
+      instance_variable_set "@orig_#{config_var}", Pickle::Config.send(config_var)
+      Pickle::Config.send("#{config_var}=", nil)
+    end
+  end
+  
+  after do
+    # restore pickle config back after each example
+    [:model_names, :factory_names, :names, :mappings].each do |config_var|
+      Pickle::Config.send "#{config_var}=", instance_variable_get("@orig_#{config_var}")
+    end
+  end
+  
+  it ":factory_names should default to stringified keys of Factory.factories" do
+    Factory.factories.should_receive(:keys).and_return([:one, :two])
+    Pickle::Config.factory_names.should == ['one', 'two']
+  end
+  
+  it ":model_names should default to directory listing of app/models excluding observers" do
+    models_path = "#{RAILS_ROOT}/app/models"
+    Dir.should_receive(:[]).with("#{models_path}/**/*.rb").and_return([
+      "#{models_path}/one.rb",
+      "#{models_path}/one/a.rb",
+      "#{models_path}/one/b.rb",
+      "#{models_path}/one/b/i.rb",
+      "#{models_path}/one_observer.rb",
+      "#{models_path}/two.rb"
+    ])
+    Pickle::Config.model_names.should == ['one', 'one/a', 'one/b', 'one/b/i', 'two']
+  end
+  
+  it ":names should default to set (Array) :factory and :model names" do
+    Pickle::Config.factory_names = ['one', 'two']
+    Pickle::Config.model_names = ['two', 'one/a', 'one/b']
+    Pickle::Config.names.sort.should == ['one', 'one/a', 'one/b', 'two']
+  end
+  
+  it ":mappings should default to []" do
+    Pickle::Config.mappings.should == []
+  end
+end

data/spec/lib/pickle_injector_spec.rb

@@ -0,0 +1,22 @@
+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
+    end
+    
+    it "object should respond_to Pickle:Session methods" do
+      @object.should respond_to(:model)
+      @object.should respond_to(:create_model)
+      @object.should respond_to(:find_model)
+    end
+    
+    it "object.model (a pickle method) should call object.pickle_session.model" do
+      @object.pickle_session.should_receive(:model).with('a user')
+      @object.model('a user')
+    end
+  end
+end

data/spec/lib/pickle_parser_spec.rb

@@ -0,0 +1,164 @@
+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"']
+  
+    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']
+  end
+  
+  describe 'misc regexps' do
+    describe '/^(#{Pickle::Parser::Match::Model}) exists/' do
+      before do
+        @regexp = /^(#{Pickle::Parser::Match::Model}) exists$/
+      end
+      
+      it "should match 'a user exists'" do
+        'a user exists'.should match(@regexp)
+      end
+      
+      it "should caputure 'a user' from  'a user exists'" do
+        'a user exists'.match(@regexp)[1].should == 'a user'
+      end
+    end
+  end
+  
+  describe '#parse_field' do
+    it "should return {'a' => 'b'} for 'a: \"b\"'" do
+      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)
+    end
+  end
+  
+  describe '#parse_fields' do
+    it 'should return {} for blank argument' do
+      parse_fields(nil).should == {}
+      parse_fields('').should == {}
+    end
+    
+    it 'should raise error for invalid argument' do
+      lambda { parse_fields('foo foo') }.should raise_error(ArgumentError)
+    end
+    
+    it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
+      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"}
+    end
+  end
+  
+  describe '#parse_model' do
+    it '("a user") should == ["user", ""]' do
+      parse_model("a user").should == ["user", ""]
+    end
+
+    it '("the user") should == ["user", ""]' do
+      parse_model("the user").should == ["user", ""]
+    end
+
+    it '("1 fast car") should == ["fast_car", ""]' do
+      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"]
+    end
+    
+    it '(\'that fast car: "herbie"\') should == ["fast_car", "herbie"]' do
+      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]
+    end
+
+    it '(\'the last user\') should == ["user", -1]' do
+      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]
+    end
+
+    it '("the 1st user") should == ["user", 0]' do
+      parse_model('the 1st user').should == ["user", 0]
+    end
+  end
+  
+  describe "#parse_index" do
+    it '("1st") should == 0' do
+      parse_index("1st").should == 0
+    end
+
+    it '("24th") should == 23' do
+      parse_index("24th").should == 23
+    end
+    it '("first") should == 0' do
+      parse_index("first").should == 0
+    end
+    
+    it '("last") should == -1' do
+      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}/)
+      end
+      
+      it "'myself' should match /\#{Pickle::Parser::Match::Model}/" do
+        'myself'.should match(/#{Pickle::Parser::Match::Model}/)
+      end
+      
+      it "parse_the_model_name('I') should == ['user', 'me']" do
+        parse_model('I').should == ["user", "me"]
+      end
+  
+      it "parse_the_model_name('myself') should == ['user', 'me']" do
+        parse_model('I').should == ["user", "me"]
+      end
+    end
+  end
+end

data/spec/lib/pickle_session_spec.rb

@@ -0,0 +1,281 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Session do
+  before do
+    @session = Pickle::Session.new
+  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]
+    end
+
+    describe "the original user should be retrievable with" do
+      it "original_model('the user')" do
+        @session.original_model('the user').should == @user
+      end
+
+      it "original_model('1st user')" do
+        @session.original_model('1st user').should == @user
+      end
+
+      it "original_model('last user')" do
+        @session.original_model('last user').should == @user
+      end
+    end
+
+    describe "(found from db)" do
+      before do
+        @user.stub!(:id).and_return(100)
+        @user.class.should_receive(:find).with(100).and_return(@user_from_db = @user.dup)
+      end
+    
+      it "models('user') should be array containing user" do
+        @session.models('user').should == [@user_from_db]
+      end
+  
+      describe "user should be retrievable with" do
+        it "model('the user')" do
+          @session.model('the user').should == @user_from_db
+        end
+
+        it "model('1st user')" do
+          @session.model('1st user').should == @user_from_db
+        end
+
+        it "model('last user')" do
+          @session.model('last user').should == @user_from_db
+        end
+      end
+    end
+  end
+  
+  describe "#create_model" do
+    before do
+      @user = mock_model(User)
+      Factory.stub!(:create).and_return(@user)
+    end
+    
+    describe "('a user')" do
+      def do_create_model
+        @session.create_model('a user')
+      end
+  
+      it "should call Factory.create('user', {})" do
+        Factory.should_receive(:create).with('user', {}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        it_should_behave_like "after storing a single user"
+      end
+    end
+    
+    describe "('1 user', 'foo: \"bar\", baz: \"bing bong\"')" do
+      def do_create_model
+        @session.create_model('1 user', 'foo: "bar", baz: "bing bong"')
+      end
+  
+      it "should call Factory.create('user', {'foo' => 'bar', 'baz' => 'bing bong'})" do
+        Factory.should_receive(:create).with('user', {'foo' => 'bar', 'baz' => 'bing bong'}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        it_should_behave_like "after storing a single user"
+      end
+    end  
+
+    describe "('an user: \"fred\")" do
+      def do_create_model
+        @session.create_model('an user: "fred"')
+      end
+  
+      it "should call Factory.create('user', {})" do
+        Factory.should_receive(:create).with('user', {}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        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
+        end
+      
+        it "original_model?('the user: \"shirl\"') should be false" do
+          @session.original_model?('the user: "shirl"').should == false
+        end
+        
+        it "model?('the user: \"shirl\"') should be false" do
+          @session.model?('the user: "shirl"').should == false
+        end
+      end
+    end  
+  end
+
+  describe '#find_model' do
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return(@user)
+    end
+    
+    def do_find_model
+      @session.find_model('a user', 'hair: "pink"')
+    end
+    
+    it "should call User.find :first, :conditions => {'hair' => 'pink'}" do
+      User.should_receive(:find).with(:first, :conditions => {'hair' => 'pink'}).and_return(@user)
+      do_find_model
+    end
+    
+    it "should raise RecordNotFound when no record returned" do
+      User.should_receive(:find).and_return(nil)
+      lambda { do_find_model }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+    
+    describe "after find," do
+      before { do_find_model }
+      
+      it_should_behave_like "after storing a single user"
+    end
+  end
+  
+  describe 'creating \'a super admin: "fred"\', then \'a user: "shirl"\', \'then 1 super_admin\'' do
+    before do
+      @user = @fred = mock_model(User)
+      @shirl  = mock_model(User)
+      @noname = mock_model(User)
+      Factory.stub!(:create).and_return(@fred, @shirl, @noname)
+    end
+    
+    def do_create_users
+      @session.create_model('a super admin: "fred"')
+      @session.create_model('a user: "shirl"')
+      @session.create_model('1 super_admin')
+    end
+    
+    it "should call Factory.create with <'super_admin'>, <'user'>, <'super_admin'>" do
+      Factory.should_receive(:create).with('super_admin', {}).twice
+      Factory.should_receive(:create).with('user', {}).once
+      do_create_users
+    end
+    
+    describe "after create," do
+      before do
+        do_create_users
+      end
+      
+      it "original_models('user') should == [@fred, @shirl, @noname]" do
+        @session.original_models('user').should == [@fred, @shirl, @noname]
+      end
+      
+      it "original_models('super_admin') should == [@fred, @noname]" do
+        @session.original_models('super_admin').should == [@fred, @noname]
+      end
+      
+      describe "#original_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
+        end
+
+        it "'the super admin' should be @noname (the last super admin created)" do
+          @session.original_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
+        end
+        
+        it "'the first user' should be @fred" do
+          @session.original_model('the first user').should == @fred
+        end
+        
+        it "'the 2nd user' should be @shirl" do
+          @session.original_model('the 2nd user').should == @shirl
+        end
+        
+        it "'the last user' should be @noname" do
+          @session.original_model('the last user').should == @noname
+        end
+        
+        it "'the user: \"fred\" should be @fred" do
+          @session.original_model('the user: "fred"').should == @fred
+        end
+        
+        it "'the user: \"shirl\" should be @shirl" do
+          @session.original_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
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return(@user)
+      Factory.stub!(:create).and_return(@user)
+      @session.create_model('the user: "me"')
+    end
+  
+    it 'model("I") should return the user' do
+      @session.model('I').should == @user
+    end
+
+    it 'model("myself") should return the user' 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
+    end
+    
+    it "#parse_fields 'author: the user' should return {\"author\" => <user>}" do
+      @session.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}
+    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'}
+    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' => ""}
+    end
+  end
+  
+  describe "convert_models_to_attributes(ar_class, :user => <a user>)" do
+    before do 
+      @user = mock_model(User)
+    end
+    
+    describe "(when ar_class has column 'user_id')" do
+      before do
+        @ar_class = mock('ActiveRecord', :column_names => ['user_id'])
+      end
+      
+      it "should return {'user_id' => <the user.id>}" do
+        @session.send(:convert_models_to_attributes, @ar_class, :user => @user).should == {'user_id' => @user.id}
+      end
+    end
+    
+    describe "(when ar_class has columns 'user_id', 'user_type')" do
+      before do
+        @ar_class = mock('ActiveRecord', :column_names => ['user_id', 'user_type'])
+      end
+      
+      it "should return {'user_id' => <the user.id>, 'user_type' => <the user.type>}" do
+        @session.send(:convert_models_to_attributes, @ar_class, :user => @user).should == {'user_id' => @user.id, 'user_type' => @user.class.name}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ianwhite-pickle
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ian White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-27 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Easy model creation and reference in your cucumber features
+email: ian.w.white@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pickle/injector.rb
+- lib/pickle/parser.rb
+- lib/pickle/session.rb
+- lib/pickle/steps.rb
+- lib/pickle.rb
+- License.txt
+- README.textile
+- Todo.txt
+- History.txt
+- spec/lib/pickle_config_spec.rb
+- spec/lib/pickle_injector_spec.rb
+- spec/lib/pickle_parser_spec.rb
+- spec/lib/pickle_session_spec.rb
+has_rdoc: true
+homepage: http://github.com/ianwhite/pickle/tree
+post_install_message: 
+rdoc_options: 
+- --title
+- Pickle
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Easy model creation and reference in your cucumber features
+test_files: 
+- spec/lib/pickle_config_spec.rb
+- spec/lib/pickle_injector_spec.rb
+- spec/lib/pickle_parser_spec.rb
+- spec/lib/pickle_session_spec.rb