mrflip-pickle 0.1.13

data/lib/pickle/session/parser.rb

@@ -0,0 +1,24 @@
+module Pickle
+  module Session
+    # add ability to parse model names as fields, using a session
+    module Parser
+      def self.included(parser_class)
+        parser_class.alias_method_chain :parse_field, :model
+      end
+
+      attr_accessor :session
+
+      def match_field
+        "(?:\\w+: (?:#{match_model}|#{match_value}))"
+      end
+
+      def parse_field_with_model(field)
+        if session && field =~ /^(\w+): #{capture_model}$/
+          {$1 => session.model($2)}
+        else
+          parse_field_without_model(field)
+        end
+      end    
+    end
+  end
+end

data/lib/pickle/version.rb

@@ -0,0 +1,9 @@
+module Pickle
+  module Version
+    Major = 0
+    Minor = 1
+    Tiny  = 13
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+end

data/lib/pickle/world.rb

@@ -0,0 +1,9 @@
+require 'pickle'
+
+# make cucumber world pickle aware
+World(Pickle::Session)
+
+# shortcuts to regexps for use in step definition regexps
+class << self
+  delegate :capture_model, :capture_fields, :capture_factory, :capture_plural_factory, :capture_predicate, :to => 'Pickle.parser'
+end

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,41 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    File.exists?('features/support/env.rb') or raise "features/support/env.rb not found, try running script/generate cucumber"
+    @generate_email_steps = args.include?('email')
+    if @generate_path_steps = args.include?('path') || args.include?('paths')
+      File.exists?('features/support/paths.rb') or raise "features/support/paths.rb not found, is your cucumber up to date?"
+    end
+  end
+  
+  def manifest
+    record do |m|
+      m.directory File.join('features/step_definitions')
+      
+      current_env = File.read('features/support/env.rb')
+      env_assigns = {:current_env => current_env, :pickle => false, :pickle_path => false, :pickle_email => false}
+      
+      if @generate_path_steps
+        env_assigns[:pickle_path] = true unless current_env.include?("require 'pickle/path/world'")
+        current_paths = File.read('features/support/paths.rb')
+        unless current_paths.include?('#{capture_model}')
+          if current_paths =~ /^(.*)(\n\s+else\n\s+raise "Can't find.*".*$)/m
+            env_assigns[:current_paths_header] = $1
+            env_assigns[:current_paths_footer] = $2
+            m.template 'paths.rb', File.join('features/support', "paths.rb"), :assigns => env_assigns, :collision => :force
+          end
+        end
+      end
+      
+      if @generate_email_steps
+        env_assigns[:pickle_email] = true unless current_env.include?("require 'pickle/email/world'")
+        m.template 'email_steps.rb', File.join('features/step_definitions', "email_steps.rb") 
+      end
+      
+      env_assigns[:pickle] = true unless current_env.include?("require 'pickle/world'")
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', "pickle_steps.rb")
+      
+      m.template 'env.rb', File.join('features/support', "env.rb"), :assigns => env_assigns, :collision => :force
+    end
+  end
+end

data/rails_generators/pickle/templates/email_steps.rb

@@ -0,0 +1,50 @@
+# this file generated by script/generate pickle email
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+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
+
+Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
+  to =~ /^#{capture_model}$/ && to = model($1).email
+  emails("to: \"#{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|
+  to =~ /^#{capture_model}$/ && to = model($1).email
+  email(email_ref, "to: \"#{to}\"").should_not 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/env.rb

@@ -0,0 +1,14 @@
+<%= current_env -%>
+<%- if pickle -%>
+require 'pickle/world'
+# Example of configuring pickle:
+#
+# Pickle.configure do |config|
+#   config.adapters = [:machinist]
+#   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
+# end
+<%- end -%>
+<%- if pickle_path -%>require 'pickle/path/world'
+<%- end -%>
+<%- if pickle_email -%>require 'pickle/email/world'
+<%- end -%>

data/rails_generators/pickle/templates/paths.rb

@@ -0,0 +1,20 @@
+<%= current_paths_header %>
+    # added by script/generate pickle path
+
+    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
+
+    when /^the (.+?) page$/                                         # translate to named route
+      send "#{$1.downcase.gsub(' ','_')}_path"
+  
+    # end added by pickle path
+<%= current_paths_footer %>

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -0,0 +1,41 @@
+# 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
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should_not be_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 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 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.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

@@ -0,0 +1,164 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+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
+    
+    if defined?(CGI::Session::ActiveRecordStore::Session)
+      it "should not include CGI::Session::ActiveRecordStore::Session" do
+        Pickle::Adapter.model_classes.should_not include(CGI::Session::ActiveRecordStore)
+      end
+    end
+  
+    if defined?(ActiveRecord::SessionStore::Session)
+      it "should not include ActiveRecord::SessionStore::Session" do
+        Pickle::Adapter.model_classes.should_not include(ActiveRecord::SessionStore::Session)
+      end
+    end
+  
+    it "should not include classes without a table" do
+      klass = Class.new(ActiveRecord::Base)
+      Pickle::Adapter.model_classes.should_not include(klass)
+    end
+
+    it "should not include abstract classes without a table" do
+      klass = Class.new(ActiveRecord::Base)
+      klass.abstract_class = true
+      Pickle::Adapter.model_classes.should_not include(klass)
+    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
+      before do
+        Pickle::Adapter::ActiveRecord.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+      end
+      
+      it ".factories should create one for each active record class" do
+        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass1).once
+        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass2).once
+        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass3).once
+        Pickle::Adapter::ActiveRecord.factories
+      end
+      
+      describe ".new(Class)" do
+        before do
+          @factory = Pickle::Adapter::ActiveRecord.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
+  
+    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/lib/pickle_config_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Config do
+  before do
+    @config = Pickle::Config.new
+  end
+  
+  it "#adapters should default to :machinist, :factory_girl, :active_record" do
+    @config.adapters.should == [:machinist, :factory_girl, :active_record]
+  end
+  
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::ActiveRecord" do
+    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::ActiveRecord]
+  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::ActiveRecord.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::ActiveRecord.should_receive(:factories).and_return([@active_record = mock('active_record', :name => 'active_record')])
+      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'active_record' => @active_record}
+    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::ActiveRecord.should_receive(:factories).and_return([@active_record_two = mock('two', :name => 'two'), @active_record_three = mock('three', :name => 'three')])
+      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @active_record_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'])
+      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'
+    end
+    
+    it "should create OpenStruct(search: 'foo', replace: 'faz') mapping" do
+      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replace => 'faz')
+    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 == OpenStruct.new(:search => 'foo', :replace => 'faz')
+      @config.mappings.last.should == OpenStruct.new(:search => 'bar', :replace => '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