judit-pickle 0.4.2

data/rails_generators/pickle/templates/email_steps.rb

@@ -0,0 +1,63 @@
+# this file generated by script/generate pickle email
+#
+# add email mappings in features/support/email.rb
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+# Clear the deliveries array, useful if your background sends email that you want to ignore
+Given(/^all emails? (?:have|has) been delivered$/) do
+  ActionMailer::Base.deliveries.clear
+end
+
+Given(/^(\d)+ emails? should be delivered$/) do |count|
+  emails.size.should == count.to_i
+end
+
+When(/^(?:I|they) follow "([^"]*?)" in #{capture_email}$/) do |link, email_ref|
+  visit_in_email(email(email_ref), link)
+end
+
+When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
+  click_first_link_in_email(email(email_ref))
+end
+
+Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
+  emails("to: \"#{email_for(to)}\"").size.should == count.to_i
+end
+
+Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
+  emails(fields).size.should == count.to_i
+end
+
+Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
+  email(email_ref, "to: \"#{email_for(to)}\"").should_not be_nil
+end
+
+Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
+  email(email_ref, "to: \"#{email_for(to)}\"").should be_nil
+end
+
+Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
+  email(email_ref, fields).should_not be_nil
+end
+
+Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
+  email(email_ref).body.should =~ /#{text}/
+end
+
+Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
+  email(email_ref).body.should_not =~ /#{text}/
+end
+
+Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
+  email(email_ref).body.should =~ /#{path_to(page)}/
+end
+
+Then(/^show me the emails?$/) do
+   save_and_open_emails
+end

data/rails_generators/pickle/templates/paths.rb

@@ -0,0 +1,47 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+
+    # the following are examples using path_to_pickle
+
+    when /^#{capture_model}(?:'s)? page$/                           # eg. the forum's page
+      path_to_pickle $1
+
+    when /^#{capture_model}(?:'s)? #{capture_model}(?:'s)? page$/   # eg. the forum's post's page
+      path_to_pickle $1, $2
+
+    when /^#{capture_model}(?:'s)? #{capture_model}'s (.+?) page$/  # eg. the forum's post's comments page
+      path_to_pickle $1, $2, :extra => $3                           #  or the forum's post's edit page
+
+    when /^#{capture_model}(?:'s)? (.+?) page$/                     # eg. the forum's posts page
+      path_to_pickle $1, :extra => $2                               #  or the forum's edit page
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/rails_generators/pickle/templates/pickle.rb

@@ -0,0 +1,28 @@
+# this file generated by script/generate pickle [paths] [email]
+#
+# Make sure that you are loading your factory of choice in your cucumber environment
+#
+# For machinist add: features/support/machinist.rb
+#
+#    require 'machinist/active_record' # or your chosen adaptor
+#    require File.dirname(__FILE__) + '/../../spec/blueprints' # or wherever your blueprints are
+#    Before { Sham.reset } # to reset Sham's seed between scenarios so each run has same random sequences
+#
+# For FactoryGirl add: features/support/factory_girl.rb
+#
+#    require 'factory_girl'
+#    require File.dirname(__FILE__) + '/../../spec/factories' # or wherever your factories are
+#
+# You may also need to add gem dependencies on your factory of choice in <tt>config/environments/cucumber.rb</tt>
+
+require 'pickle/world'
+# Example of configuring pickle:
+#
+# Pickle.configure do |config|
+#   config.adapters = [:machinist]
+#   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
+# end
+<%- if pickle_path -%>require 'pickle/path/world'
+<%- end -%>
+<%- if pickle_email -%>require 'pickle/email/world'
+<%- end -%>

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -0,0 +1,100 @@
+# this file generated by script/generate pickle
+
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
+end
+
+# 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
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  create_models_from_table(plural_factory, table)
+end
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model!(name, fields)
+end
+
+# not find a model
+Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == model!(b)
+end
+
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should include(model!(target))
+end
+
+# assert model is not in another model's has_many assoc
+Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not include(model!(target))
+end
+
+# 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
+
+# assert model is not another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
+end
+
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# model.attribute.should eql(value)
+# model.attribute.should_not eql(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub(' ', '_')
+  
+  case expected
+  when 'nil', 'true', 'false'
+    actual_value.send(expectation, send("be_#{expected}"))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    actual_value.send(expectation, eql(expected.to_f))
+  else
+    actual_value.to_s.send(expectation, eql(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  model!(name).send(association).size.should == size.to_i
+end

data/spec/pickle/adapter_spec.rb

@@ -0,0 +1,186 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'active_record'
+require 'factory_girl'
+require 'machinist/active_record'
+require 'pickle/adapters/active_record'
+
+describe Pickle::Adapter do
+  it ".factories should raise NotImplementedError" do
+    lambda { Pickle::Adapter.factories }.should raise_error(NotImplementedError)
+  end
+
+  it "#create should raise NotImplementedError" do
+    lambda { Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
+  end
+
+  describe ".model_classes" do
+    before do
+      Pickle::Adapter.model_classes = nil
+    end
+
+    it "should only include #suitable_for_pickle classes" do
+      klass1 = Class.new(ActiveRecord::Base)
+      klass2 = Class.new(ActiveRecord::Base)
+      klass3 = Class.new(ActiveRecord::Base)
+      klass4 = Class.new(ActiveRecord::Base)
+      klass5 = Class.new(ActiveRecord::Base)
+      klass6 = Class.new(ActiveRecord::Base)
+      [klass1, klass2, klass3, klass4, klass5, klass6].each { |k| k.stub!(:table_exists?).and_return(true) }
+
+      klass2.stub!(:name).and_return("CGI::Session::ActiveRecordStore::Session")
+      klass3.stub!(:name).and_return("ActiveRecord::SessionStore::Session")
+      klass4.stub!(:table_exists?).and_return(false)
+      klass5.stub!(:abstract_class?).and_return(true)
+      Pickle::Adapter.model_classes.should include(klass1, klass6)
+      Pickle::Adapter.model_classes.should_not include(klass2, klass3, klass4, klass5)
+    end
+  end
+
+  describe "adapters: " do
+    before do
+      @klass1 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('One') }
+      @klass2 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('One::Two') }
+      @klass3 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('Three') }
+    end
+
+    describe 'ActiveRecord' do
+
+#DEPRECATION WARNING: subclasses is deprecated and will be removed from Rails 3.0 (use descendants instead). (called from __send__ at /Users/pivotal/workspace/factorylabs/protosite/vendor/cache/ruby/1.8/gems/pickle-0.3.1/lib/pickle/adapters/active_record.rb:21)
+
+      describe ".model_classes" do
+        it "calls .descendants" do
+          ::ActiveRecord::Base.should_receive(:descendants).and_return([])
+          ::ActiveRecord::Base.should_not_receive(:subclasses).and_return([])
+
+          ActiveRecord::Base::PickleAdapter.model_classes
+        end
+
+        it "calls .subclasses when .descendants doesn't respond" do
+          ::ActiveRecord::Base.should_receive(:subclasses).and_return([])
+
+          ActiveRecord::Base::PickleAdapter.model_classes
+        end
+
+      end
+
+      describe 'with class stubs' do
+        before do
+          Pickle::Adapter::Orm.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        end
+
+        it ".factories should create one for each active record class" do
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass1).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass2).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass3).once
+          Pickle::Adapter::Orm.factories.length.should == 3
+        end
+
+        describe ".new(Class)" do
+          before do
+            @factory = Pickle::Adapter::Orm.new(@klass2)
+          end
+
+          it "should have underscored (s/_) name of Class as #name" do
+            @factory.name.should == 'one_two'
+          end
+
+          it "#create(attrs) should call Class.create!(attrs)" do
+            @klass2.should_receive(:create!).with({:key => "val"})
+            @factory.create(:key => "val")
+          end
+        end
+      end
+
+
+    end
+
+    describe 'FactoryGirl' do
+      before do
+        Pickle::Adapter::FactoryGirl.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        @orig_factories, Factory.factories = Factory.factories, {}
+
+        Factory.define(:one, :class => @klass1) {}
+        Factory.define(:two, :class => @klass2) {}
+        @factory1 = Factory.factories[:one]
+        @factory2 = Factory.factories[:two]
+      end
+
+      after do
+        Factory.factories = @orig_factories
+      end
+
+      it ".factories should create one for each factory" do
+        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)" do
+        before do
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
+        end
+
+        it "should have name of factory_name" do
+          @factory.name.should == 'one'
+        end
+
+        it "should have klass of build_class" do
+          @factory.klass.should == @klass1
+        end
+
+        it "#create(attrs) should call Factory(<:key>, attrs)" do
+          Factory.should_receive(:create).with("one", {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+
+    describe 'Machinist' do
+      before do
+        Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+
+        @klass1.blueprint {}
+        @klass3.blueprint {}
+        @klass3.blueprint(:special) {}
+      end
+
+      it ".factories should create one for each master blueprint, and special case" do
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, :master).once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :master).once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :special).once
+        Pickle::Adapter::Machinist.factories
+      end
+
+      describe ".new(Class, :master)" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(@klass1, :master)
+        end
+
+        it "should have underscored (s/_) name of Class as #name" do
+          @factory.name.should == 'one'
+        end
+
+        it "#create(attrs) should call Class.make(:master, attrs)" do
+          @klass1.should_receive(:make).with(:master, {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+
+      describe ".new(Class, :special)" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(@klass3, :special)
+        end
+
+        it "should have 'special_<Class name>' as #name" do
+          @factory.name.should == 'special_three'
+        end
+
+        it "#create(attrs) should call Class.make(:special, attrs)" do
+          @klass3.should_receive(:make).with(:special, {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+end

data/spec/pickle/config_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Pickle::Config do
+  before do
+    @config = Pickle::Config.new
+  end
+
+  it "#adapters should default to :machinist, :factory_girl, :orm" do
+    @config.adapters.should == [:machinist, :factory_girl, :orm]
+  end
+
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::Orm" do
+    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Orm]
+  end
+
+  describe "setting adapters to [:machinist, SomeAdapter]" do
+    class SomeAdapter; end
+
+    before do
+      @config.adapters = [:machinist, SomeAdapter]
+    end
+
+    it "#adapter_classes should be Adapter::Machinist, SomeAdapter" do
+      @config.adapter_classes.should == [Pickle::Adapter::Machinist, SomeAdapter]
+    end
+  end
+
+  describe "#factories" do
+    it "should call adaptor.factories for each adaptor" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([])
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([])
+      @config.factories
+    end
+
+    it "should aggregate factories into a hash using factory name as key" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist = mock('machinist', :name => 'machinist')])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl = mock('factory_girl', :name => 'factory_girl')])
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm = mock('orm', :name => 'orm')])
+      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'orm' => @orm}
+    end
+
+    it "should give preference to adaptors first in the list" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist_one = mock('one', :name => 'one')])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl_one = mock('one', :name => 'one'), @factory_girl_two = mock('two', :name => 'two')])
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm_two = mock('two', :name => 'two'), @orm_three = mock('three', :name => 'three')])
+      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @orm_three}
+    end
+  end
+
+  it "#mappings should default to []" do
+    @config.mappings.should == []
+  end
+
+  describe '#predicates' do
+    it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
+      class1 = mock('Class1',
+                    :public_instance_methods => ['nope', 'foo?', 'bar?'],
+                    :column_names => ['one', 'two'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      class2 = mock('Class2',
+                    :public_instance_methods => ['not', 'foo?', 'faz?'],
+                    :column_names => ['two', 'three'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      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'
+    end
+
+    it "should create Mapping('foo', 'faz') mapping" do
+      @config.mappings.first.tap do |mapping|
+        mapping.should be_kind_of Pickle::Config::Mapping
+        mapping.search.should == 'foo'
+        mapping.replacement.should == 'faz'
+      end
+    end
+  end
+
+  describe "#map 'foo', 'bar' :to => 'faz'" do
+    before do
+      @config.map 'foo', 'bar', :to => 'faz'
+    end
+
+    it "should create 2 mappings" do
+      @config.mappings.first.should == Pickle::Config::Mapping.new('foo', 'faz')
+      @config.mappings.last.should == Pickle::Config::Mapping.new('bar', 'faz')
+    end
+  end
+
+  it "#configure(&block) should execiute on self" do
+    @config.should_receive(:foo).with(:bar)
+    @config.configure do |c|
+      c.foo :bar
+    end
+  end
+end

data/spec/pickle/email/parser_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'pickle/email/parser'
+
+describe Pickle::Email::Parser do
+  include Pickle::Parser::Matchers
+  include Pickle::Email::Parser
+  
+  describe "#match_email" do
+    it "should match 'the email'" do
+      'the email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the first email'" do
+      'the first email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the last email'" do
+      'the last email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the 3rd email'" do
+      'the 3rd email'.should match(/^#{match_email}$/)
+    end
+    
+    it "should match 'an email'" do
+      'an email'.should match(/^#{match_email}$/)
+    end
+  end
+  
+  it "#capture_email should just capture match_email" do
+    capture_email.should == "(#{match_email})"
+  end
+  
+  describe "#capture_index_in_email" do
+    it "should extract the '2nd' from 'the 2nd email'" do
+      match = 'the 2nd email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == '2nd'
+    end
+    
+    it "should extract nil from 'the email'" do
+      match = 'the email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == nil
+    end
+    
+    it "should extract the 'last' from 'the last email'" do
+      match = 'the last email'.match(/^#{capture_index_in_email}$/)
+      match[1].should == 'last'
+    end
+  end
+end