ianwhite-pickle 0.1.4 → 0.1.5

data/History.txt

@@ -1,3 +1,21 @@
+== 0.1.5
+
+* API change
+  * CaptureModel, etc are now 'capture_model' methods
+
+* 3 major enhancements
+  * Steps for asserting that <n> models exist, matching certain criteria
+  * Steps for asserting associations added to generated pickle steps
+      'Then the user should be in the post's commenters'
+      'Then the forum: "awesome" should be the 2nd post's forum'
+  * configuration can now occur any time before a step is defined, which makes
+    for much more intuitive env.rb
+
+* 1 minor enhancement
+  * predicate matching is less prone to step conflicts because we preload a 
+    big list of all the predicate and column methods
+  * field values now handle booleans and numerics
+
 == 0.1.4
 
 * 1 major enhancement

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Ian White - ian.w.white@ardes.com
+Copyright (c) 2008-2009 Ian White - ian.w.white@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/pickle.rb

@@ -1,4 +1,5 @@
 require 'active_support'
+require 'pickle/version'
 require 'pickle/adapter'
 require 'pickle/config'
 require 'pickle/parser'
@@ -9,12 +10,28 @@ require 'pickle/injector'
 # make the parser aware of models in the session (for fields refering to models)
 Pickle::Parser.send :include, Pickle::Parser::WithSession
 
+module Pickle
+  class << self
+    def config
+      @config ||= Config.new
+    end
+    
+    def configure(&block)
+      config.configure(&block)
+    end
+  
+    def parser(options = {})
+      @parser ||= Parser.new({:config => config}.merge(options))
+    end
+  end
+end
+
 # inject the pickle session into integration session if we have one (TODO: inject into merb etc?)
 if defined?(ActionController::Integration::Session)
   Pickle::Injector.inject Pickle::Session, :into => ActionController::Integration::Session
 end
 
-# shortcuts for useful regexps when defining pickle steps
-CaptureModel         = Pickle.parser.capture_model
-CapturePluralFactory = Pickle.parser.capture_plural_factory
-CaptureFields        = Pickle.parser.capture_fields
+# shortcuts to regexps for use in step definitions
+class << self
+  delegate :capture_model, :capture_fields, :capture_factory, :capture_plural_factory, :capture_predicate, :to => 'Pickle.parser'
+end

data/lib/pickle/adapter.rb

@@ -3,12 +3,13 @@ module Pickle
   # can easily create an adaptor to make it work with Pickle.
   #
   # The factory adaptor must have a #factories class method that returns 
-  # its instances, and each instance must respond to a #name method which
-  # identifies the factory by name (default is attr_reader for @name), and a
-  # #create method which takes an optional attributes hash,
-  # and returns a newly created object
+  # its instances, and each instance must respond to:
+  #
+  #   #name : identifies the factory by name (default is attr_reader)
+  #   #klass : returns the associated model class for this factory (default is attr_reader)
+  #   #create(attrs = {}) : returns a newly created object
   class Adapter
-    attr_reader :name
+    attr_reader :name, :klass
     
     def self.factories
       raise NotImplementedError, "return an array of factory adapter objects"
@@ -17,25 +18,23 @@ module Pickle
     def create(attrs = {})
       raise NotImplementedError, "create and return an object with the given attributes"
     end
+  
+    cattr_writer :model_classes
+    self.model_classes = nil
     
-    # by default the models are active_record subclasses, but you can set this to whatever classes you want
-    class << self
-      attr_writer :model_classes
-      
-      def model_classes
-        @model_classes ||= returning(::ActiveRecord::Base.send(:subclasses)) do |classes|
-          defined?(CGI::Session::ActiveRecordStore::Session) && classes.delete(CGI::Session::ActiveRecordStore::Session)
-        end
+    def self.model_classes
+      @@model_classes ||= returning(::ActiveRecord::Base.send(:subclasses)) do |classes|
+        defined?(CGI::Session::ActiveRecordStore::Session) && classes.delete(CGI::Session::ActiveRecordStore::Session)
       end
     end
-    
+  
     # machinist adapter
     class Machinist < Adapter
       def self.factories
         factories = []
         model_classes.each do |klass|
           factories << new(klass, "make") if klass.instance_variable_get('@blueprint')
-          # if there are special make_special methods, add blueprints for them
+          # if there are make_<special> methods, add blueprints for them
           klass.methods.select{|m| m =~ /^make_/ && m !~ /_unsaved$/}.each do |method|
             factories << new(klass, method)
           end
@@ -56,11 +55,11 @@ module Pickle
     # factory-girl adapter
     class FactoryGirl < Adapter
       def self.factories
-        (::Factory.factories.keys rescue []).map {|key| new(key)}
+        (::Factory.factories.values rescue []).map {|factory| new(factory)}
       end
       
-      def initialize(key)
-        @name = key.to_s
+      def initialize(factory)
+        @klass, @name = factory.build_class, factory.factory_name.to_s
       end
     
       def create(attrs = {})

data/lib/pickle/config.rb

@@ -1,17 +1,8 @@
 require 'ostruct'
 
 module Pickle
-  class << self
-    def config(&block)
-      @config ||= Config.new
-    ensure
-      @config.configure(&block) if block_given?
-    end
-    alias_method :configure, :config
-  end
-  
   class Config
-    attr_writer :adapters, :factories, :mappings
+    attr_writer :adapters, :factories, :mappings, :predicates
     
     def initialize(&block)
       configure(&block) if block_given?
@@ -39,6 +30,12 @@ module Pickle
       factories.keys
     end
     
+    def predicates
+      @predicates ||= Pickle::Adapter.model_classes.map do |klass|
+        klass.public_instance_methods.select{|m| m =~ /\?$/} + klass.column_names
+      end.flatten.uniq
+    end
+    
     def mappings
       @mappings ||= []
     end

data/lib/pickle/injector.rb

@@ -1,18 +1,18 @@
 module Pickle
   module Injector
-    def self.inject(session_class, options = {})
-      target = options[:into] || ActionController::Integration::Session
-      session_method = options[:name] || session_class.name.underscore.gsub('/','_')
-      session_options = options[:options] || {}
+    def self.inject(delegate_class, options = {})
+      target_class  = options[:into] || raise('inject requires a target class specified with :into')
+      delegate_name = options[:name] || delegate_class.name.underscore.gsub('/','_')
+      init_delegate = options[:init] || lambda { new }
       
       # create a session object on demand (in target)
-      target.send(:define_method, session_method) do
-        instance_variable_get("@#{session_method}") || instance_variable_set("@#{session_method}", session_class.new(session_options))
+      target_class.send(:define_method, delegate_name) do
+        instance_variable_get("@#{delegate_name}") || instance_variable_set("@#{delegate_name}", delegate_class.instance_eval(&init_delegate))
       end
       
-      # delegate session methods to the session object (in target)
-      delegate_methods = session_class.public_instance_methods - Object.instance_methods
-      target.delegate *(delegate_methods + [{:to => session_method}])
+      # in the target, delegate the public instance methods of delegate_class to the delegate_name method
+      delegate_methods = delegate_class.public_instance_methods - Object.instance_methods
+      target_class.delegate *(delegate_methods + [{:to => delegate_name}])
     end
   end
 end

data/lib/pickle/parser.rb

@@ -1,17 +1,13 @@
 require 'pickle/parser/matchers'
 
 module Pickle
-  def self.parser(options = {})
-    @parser ||= Parser.new(options)
-  end
-  
   class Parser
     include Matchers
     
     attr_reader :config
     
     def initialize(options = {})
-      @config = options[:config] || Pickle.config
+      @config = options[:config] || raise(ArgumentError, "Parser.new requires a :config")
     end
     
     # given a string like 'foo: "bar", bar: "baz"' returns {"foo" => "bar", "bar" => "baz"}
@@ -27,10 +23,10 @@ module Pickle
       end
     end
     
-    # given a string like 'foo: "bar"' returns {key => value}
+    # given a string like 'foo: expr' returns {key => value}
     def parse_field(field)
       if field =~ /^#{capture_key_and_value_in_field}$/
-        { $1 => $2 }
+        { $1 => eval($2) }
       else
         raise ArgumentError, "The field argument is not in the correct format.\n\n'#{field}' did not match: #{match_field}"
       end

data/lib/pickle/parser/matchers.rb

@@ -21,8 +21,12 @@ module Pickle
         "(?::? \"#{match_quoted}\")"
       end
 
+      def match_value
+        "(?:\"#{match_quoted}\"|true|false|\\d+(?:\\.\\d+)?)"
+      end
+
       def match_field
-        "(?:\\w+: \"#{match_quoted}\")"
+        "(?:\\w+: #{match_value})"
       end
   
       def match_fields
@@ -53,6 +57,10 @@ module Pickle
         "(?:#{match_mapping}|#{match_prefix}?(?:#{match_indexed_model}|#{match_labeled_model}))"
       end
   
+      def match_predicate
+        "(?:#{config.predicates.map{|m| m.sub(/\?$/,'').gsub('_','[_ ]')}.join('|')})"
+      end
+      
       # create capture analogues of match methods
       instance_methods.select{|m| m =~ /^match_/}.each do |method|
         eval <<-end_eval                   
@@ -72,7 +80,7 @@ module Pickle
       end
   
       def capture_key_and_value_in_field
-        "(?:(\\w+): \"(#{match_quoted})\")"
+        "(?:(\\w+): #{capture_value})"
       end
     end
   end

data/lib/pickle/parser/with_session.rb

@@ -9,7 +9,7 @@ module Pickle
       attr_accessor :session
 
       def match_field
-        "(?:\\w+: (?:#{match_model}|\"#{match_quoted}\"))"
+        "(?:\\w+: (?:#{match_model}|#{match_value}))"
       end
 
       def parse_field_with_model(field)

data/lib/pickle/session.rb

@@ -2,7 +2,7 @@ module Pickle
   class Session
     def initialize(options = {})
       self.parser = options[:parser] || Pickle.parser
-      @config = options[:config] || parser.config
+      @config = parser.config
     end
 
     def create_model(a_model_name, fields = nil)
@@ -12,45 +12,52 @@ module Pickle
       store_model(factory, label, record)
     end
 
-    def find_model(a_model_name, fields)
-      model, name = *parser.parse_model(a_model_name)
+    def find_model(a_model_name, fields = nil)
+      factory, name = *parser.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
+      model_class = config.factories[factory].klass
       if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parser.parse_fields(fields)))
-        store_model(model, name, record)
-      else
-        raise ActiveRecord::RecordNotFound, "Couldn't find #{model} with #{fields}"
+        store_model(factory, name, record)
       end
     end
     
+    def find_models(factory, fields = nil)
+      model_class = config.factories[factory].klass
+      records = model_class.find(:all, :conditions => convert_models_to_attributes(model_class, parser.parse_fields(fields)))
+      records.each {|record| store_model(factory, nil, record)}
+    end
+    
+    def clear_models(factory)
+      models_by_name(factory).clear
+      models_by_factory(factory).clear
+    end
+      
     # return the original model stored by create_model or find_model
-    def created_model(a_model_name)
-      factory, name_or_index = *parser.parse_model(a_model_name)
+    def created_model(name)
+      factory, name_or_index = *parser.parse_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"
+        models_by_name(factory)[name_or_index] or raise "model: #{name} does not refer to known model in this scenario"
       end
     end
 
     # predicate version which raises no errors
-    def created_model?(a_model_name)
-      (created_model(a_model_name) rescue nil) ? true : false
+    def created_model?(name)
+      (created_model(name) rescue nil) ? true : false
     end
     
     # return a newly selected model
-    def model(a_model_name)
-      if model = created_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
+    def model(name)
+      (model = created_model(name)) && model.class.find(model.id)
     end
     
     # predicate version which raises no errors
-    def model?(a_model_name)
-      (model(a_model_name) rescue nil) ? true : false
+    def model?(name)
+      (model(name) rescue nil) ? true : false
     end
     
     # return all original models of specified type
@@ -60,9 +67,7 @@ module Pickle
       
     # return all models of specified type (freshly selected from the database)
     def models(factory)
-      created_models(factory).map do |model|
-        model.class.find(model.id)
-      end
+      created_models(factory).map{|model| model.class.find(model.id) }
     end
     
   protected

data/lib/pickle/version.rb

@@ -2,7 +2,7 @@ module Pickle
   module Version
     Major = 0
     Minor = 1
-    Tiny  = 4
+    Tiny  = 5
     
     String = [Major, Minor, Tiny].join('.')
   end

data/rails_generators/pickle/templates/env.rb

@@ -1,9 +1,10 @@
 <%= current_env %>
-# to configure pickle, uncomment the following lines
-# require 'pickle/config'
+require 'pickle'
+
+# Example of configuring pickle:
+#
 # Pickle.configure do |config|
 #   config.adaptors = [:machinist]
 #   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
 # end
 
-require 'pickle'

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -1,31 +1,42 @@
 # this file generated by script/generate pickle
 
-Given(/^#{CaptureModel} exists$/) do |name|
-  create_model(name)
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
 end
 
-Given(/^#{CaptureModel} exists with #{CaptureFields}$/) do |name, fields|
-  create_model(name, fields)
+# create n models
+Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  count.to_i.times { create_model(plural_factory.singularize, fields) }
 end
 
-Given(/^(\d+) #{CapturePluralFactory} exist$/) do |amount, plural_factory|
-  amount.to_i.times { create_model(plural_factory.singularize) }
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should_not be_nil
 end
 
-Given(/^(\d+) #{CapturePluralFactory} exist with #{CaptureFields}$/) do |amount, plural_factory, fields|
-  amount.to_i.times { create_model(plural_factory.singularize, fields) }
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  clear_models(plural_factory.singularize)
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
 end
 
-Then(/^#{CaptureModel} should exist with #{CaptureFields}$/) do |name, fields|
-  find_model(name, fields).should_not be_nil
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be in #{capture_model}'s (\w+)$/) do |target, owner, association|
+  model(owner).send(association).should include(model(target))
 end
 
-Then(/^#{CaptureModel} should (?:be|have) (?:an? )?([\w ]+)$/) do |name, predicate|
-  predicate_method = predicate.gsub(' ', '_')
-  model(name).should send("be_#{predicate_method}")
+# assert model is another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should be #{capture_model}'s (\w+)$/) do |target, owner, association|
+  model(owner).send(association).should == model(target)
 end
 
-Then(/^#{CaptureModel} should not (?:be|have) (?:an? )?([\w ]+)$/) do |name, predicate|
-  predicate_method = predicate.gsub(' ', '_')
-  model(name).should_not send("be_#{predicate_method}")
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  model(name).should send("be_#{predicate.gsub(' ', '_')}")
 end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  model(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+end

data/spec/lib/pickle_adapter_spec.rb

@@ -48,25 +48,31 @@ describe Pickle::Adapter do
   describe '::FactoryGirl' do
     before do
       # set up a fake object space
-      Factory.stub!(:factories).and_return(:one => nil, :two => nil)
+      @factory1 = mock('factory1', :factory_name => :one, :build_class => (@class1 = mock('Class1')))
+      @factory2 = mock('factory2', :factory_name => :two, :build_class => (@class2 = mock('Class2')))
+      Factory.stub!(:factories).and_return(:factory1 => @factory1, :factory2 => @factory2)
     end
     
     describe ".factories" do
       it "should create one for each factory" do
-        Pickle::Adapter::FactoryGirl.should_receive(:new).with(:one).once
-        Pickle::Adapter::FactoryGirl.should_receive(:new).with(:two).once
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory1).once
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory2).once
         Pickle::Adapter::FactoryGirl.factories
       end
       
-      describe ".new(:factory_name)" do
+      describe ".new(factory)" do
         before do
-          @factory = Pickle::Adapter::FactoryGirl.new(:one)
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
         end
         
-        it "should have name of factory key" do
+        it "should have name of factory_name" do
           @factory.name.should == 'one'
         end
         
+        it "should have klass of build_class" do
+          @factory.klass.should == @class1
+        end
+        
         it "#create(attrs) should call Factory(<:key>, attrs)" do
           Factory.should_receive(:create).with("one", {:key => "val"})
           @factory.create(:key => "val")

data/spec/lib/pickle_config_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
-require 'pickle/config'
 
 describe Pickle::Config do
   before do
@@ -58,6 +57,21 @@ describe Pickle::Config do
     @config.mappings.should == []
   end
 
+  describe '#predicates' do
+    it "should be list of all ? public instance methods + columns methods of Adapter.model_classes" do
+      class1 = mock('Class1', :public_instance_methods => ['nope', 'foo?', 'bar?'], :column_names => ['one', 'two'])
+      class2 = mock('Class2', :public_instance_methods => ['not', 'foo?', 'faz?'], :column_names => ['two', 'three'])
+      Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
+      
+      @config.predicates.to_set.should == ['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set
+    end
+    
+    it "should be overridable" do
+      @config.predicates = %w(lame?)
+      @config.predicates.should == %w(lame?)
+    end
+  end
+  
   describe "#map 'foo', :to => 'faz'" do
     before do
       @config.map 'foo', :to => 'faz'
@@ -84,17 +98,4 @@ describe Pickle::Config do
       c.foo :bar
     end
   end
-  
-  describe "Pickle.config" do
-    it "should refer to same object" do
-      Pickle.config.should == Pickle.config
-    end
-    
-    it "called with (&block) should execute on the config" do
-      Pickle.config.should_receive(:foo).with(:bar)
-      Pickle.config do |c|
-        c.foo :bar
-      end
-    end
-  end
 end

data/spec/lib/pickle_parser_matchers_spec.rb

@@ -1,54 +1,70 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
-describe Pickle::Parser::Matchers, "with config defining factories: user, car, fast_car" do
+describe Pickle::Parser::Matchers 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')
-      }
+
+  describe "(config: [factories: user, car, fast_car] [predicates: name, status, fancy?, super_fancy?]" do
+    def config
+      @config ||= Pickle::Config.new do |c|
+        c.factories = {
+          'user'      => mock('factory'),
+          'car'       => mock('factory'),
+          'fast_car'  => mock('factory')
+        }
+        c.predicates = %w(name status fancy? super_fancy?)
+      end
     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}$/)
+    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
-    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}$/)
+      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
-    end
   
-    atom_should_match     :match_ordinal, ['1st', '2nd', '23rd', '104th']
-    atom_should_not_match :match_ordinal, ['1', '2']
+      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_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_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_field, ['foo: "this is the life"', 'bar_man: "and so is this"', 'boolean: false', 'boolean: true', 'numeric: 10', 'numeric: 12.5']
+      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_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_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']
+      atom_should_match     :match_predicate, ['name', 'status', 'fancy', 'super fancy', 'super_fancy']
+      atom_should_not_match :match_predicate, ['nameo', 'increment', 'not a predicate']
+    
+      atom_should_match     :match_factory, ['user', 'fast car', 'fast_car', 'car']
+      atom_should_not_match :match_factory, ['users', 'faster car', 'event created']
+    
+      atom_should_match     :match_plural_factory, ['users', 'fast cars']
+      atom_should_not_match :match_plural_factory, ['usereres', 'fasts cars']
+    end
+  end
+  
+  describe "capture methods" do
+    it "capture_field should == '(' + match_field + ')'" do
+      should_receive(:match_field).and_return('MATCH_FIELD')
+      capture_field.should == '(MATCH_FIELD)'
+    end
   end
 end

data/spec/lib/pickle_parser_spec.rb

@@ -2,16 +2,11 @@ require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
 
 describe Pickle::Parser do
   before do
-    @parser = Pickle::Parser.new
+    @parser = Pickle::Parser.new(:config => Pickle::Config.new)
   end
   
-  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
+  it "should raise error when created with no config" do
+    lambda{ Pickle::Parser.new }.should raise_error(ArgumentError)
   end
   
   describe 'misc regexps' do
@@ -54,8 +49,24 @@ describe Pickle::Parser do
       @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
-      @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", gump: "123"').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => "123"}
+    it '("bool: true") should == { "bool" => true}' do
+      @parser.parse_fields('bool: true').should == {"bool" => true}
+    end
+    
+    it '("bool: false") should == { "bool" => false}' do
+      @parser.parse_fields('bool: false').should == {"bool" => false}
+    end
+    
+    it '("int: 10") should == { "int" => 10 }' do
+      @parser.parse_fields('int: 10').should == {"int" => 10}
+    end
+
+    it '("float: 10.1") should == { "float" => 10.1 }' do
+      @parser.parse_fields('float: 10.1').should == {"float" => 10.1}
+    end
+
+    it '(\'foo: "bar", bar_man: "wonga wonga", gump: 123\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}' do
+      @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", gump: 123').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}
     end
   end
   

data/spec/lib/pickle_session_spec.rb

@@ -135,11 +135,6 @@ describe Pickle::Session do
       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 }
       
@@ -147,6 +142,38 @@ describe Pickle::Session do
     end
   end
   
+  describe "#find_models" do
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return([@user])
+    end
+
+    def do_find_models
+      @session.find_models('user', 'hair: "pink"')
+    end
+
+    it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
+      User.should_receive(:find).with(:all, :conditions => {'hair' => 'pink'}).and_return([@user])
+      do_find_models
+    end
+
+    describe "after find," do
+      before { do_find_models }
+
+      it_should_behave_like "after storing a single user"
+    end
+  end
+  
+  describe '#clear_models(<factory_name>)' do
+    it "should clear the storage for that factory name" do
+      @session.send :store_model, 'user', nil, mock('user')
+      @session.send :store_model, 'car', nil, mock('user')
+      @session.clear_models('user')
+      @session.created_models('user').size.should == 0
+      @session.created_models('car').size.should == 1
+    end
+  end
+    
   describe 'creating \'a super admin: "fred"\', then \'a user: "shirl"\', \'then 1 super_admin\'' do
     before do
       @user = @fred = mock_model(User)

data/spec/lib/pickle_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle do
+  it ".config should be same object on multiple calls" do
+    Pickle.config.should == Pickle.config
+  end
+  
+  it ".configure should configure the .config object" do
+    Pickle.config.should_receive(:foo).with(:bar)
+    Pickle.configure do |c|
+      c.foo :bar
+    end
+  end
+
+  it ".parser should create a parser with the default config" do
+    Pickle.instance_variable_set('@parser', nil)
+    Pickle::Parser.should_receive(:new).with(:config => Pickle.config)
+    Pickle.parser
+  end
+  
+  it ".parser should be same object on multiple calls" do
+    Pickle.parser.should == Pickle.parser
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ianwhite-pickle
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - Ian White
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-01 00:00:00 -08:00
+date: 2009-01-03 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -44,6 +44,7 @@ files:
 - spec/lib/pickle_parser_matchers_spec.rb
 - spec/lib/pickle_parser_spec.rb
 - spec/lib/pickle_session_spec.rb
+- spec/lib/pickle_spec.rb
 has_rdoc: true
 homepage: http://github.com/ianwhite/pickle/tree
 post_install_message: 
@@ -79,3 +80,4 @@ test_files:
 - spec/lib/pickle_parser_matchers_spec.rb
 - spec/lib/pickle_parser_spec.rb
 - spec/lib/pickle_session_spec.rb
+- spec/lib/pickle_spec.rb

data/README.textile

@@ -1,98 +0,0 @@
-h1. Pickle
-
-Stick this in vendor/plugins to have cucumber steps that create your models easily from factory_girl/machinist/active_record
-
-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. Get Started
-
-  script/generate pickle
-
-Now have a look at features/step_definitions/pickle_steps.rb
-
-h2. API
-
-h3. Regexps for us in your own steps
-
-For capturing english versions of model names you get 
-
-  *CaptureModel*
-
-<pre>
-  Given /^#{CaptureModel} exists$/ do |model_name|
-    model(model_name).should_not == nil
-  end
-
-  Then /^I should be at the (.*?) page$/ |page|
-  if page =~ /#{CaptureModel}'s/
-    url_for(model($1))
-  else
-    # ...
-  end
-  end
-</pre>
-
-For capturing a field string, you get
-
-*CaptureFields*
-  
-<pre>
-  Given /^#{CaptureModel} exists with #{CaptureFields}$/ do |model_name, fields|
-    create_model(model_name, fields)
-  end
-</pre>
-Take a look at features/step_definitions/pickle_steps.rb for more examples
-
-h3. Creating and tracking models
-
-h4. create_model(_model_name_[, _field_string_])
-
-This will create a model using the factory name, and optional model label, with the field_string provided.  The created model can be later referred to via its name.
-
-For example:
-
-<pre>
-  create_model 'a user'         					# => will create a User
-  create_model 'the user: "1"'      			# => will create a User, enabling later reference to it with 'user: "1"'
-  create_model 'the user', 'name: "Fred"'	# => will create a User with attributes {:name => "Fred"}
-</pre>
-
-If you don't use Machinist or FactoryGirl, you can still create models, but you must pass in all the fields required to make them valid.
-
-However, if you do use Machinist or FactoryGirl, then just use the factory or blueprint name, and will be super sweet.
-
-h4. find_model(_model_name_, _field_string_)
-
-This will find a model of the passed class matching the passed field string.  The found model can be later referred to by its name.
-
-For example:
-
-<pre>
-  find_model('a user', 'name: "Fred'")		# => find a user matching those attributes
-</pre>
-
-h4. model(_model_name_) 
-
-Refers to a model that has already been created/found (ie. referred to in a scenario)
-
-For example:
-
-<pre>
-  create_model('a user')
-  model('the user') # => refers to above user
-  model('a user')   # => refers to above user
-
-  create_model('a car: "herbie"')  		# => herbie
-  create_model('a car: "batmobile"')	# => the batmobile
-  model('the first car') 		# => herbie
-  model('the 2nd car') 			# => batmobile
-  model('the car "herbie")	# => herbie
-</pre>
-
-h4. created_model(_model_name_)
-
-*model* always pulls from the db to get a fresh copy.  If you need to access the originally created object for some reason (perhaps it has a one-time key on it that is used in a mailer for example), you can retreive it with *created_model*
-
-h4. more [TODO]