pickle 0.2.5 → 0.2.6

data/.gitignore

@@ -1,3 +1,5 @@
 pkg
 doc/*
 .garlic
+webrat*
+cucumber_test_app

data/History.txt

@@ -1,3 +1,10 @@
+== 0.2.6 - 5 Apr 2010
+
+* 2 improvements
+  * running specs is now doable without being in a rails app - just do 'rake spec'
+  * running features is more straightforward, 'rake cucumber' then follow the instructions
+  
+  
 == 0.2.5 - 17 Mar 2010
 
 * 2 improvements

data/README.rdoc

@@ -45,18 +45,15 @@ It's tested against all stable branches of 2.x rails, and edge, with the latest
 
 == Run the tests
 
-You can run the test with <b>garlic</b> http://github.com/ianwhite/garlic, which tests against different versions of rails.
-  
-Or, you can make a test rails app:
+To run the specs do:
 
-  cd ~/wherever_you_work
-  rails pickle_test_project; cd pickle_test_project
-  script/generate rspec
-  script/generate cucumber --rspec
-  script/plugin install git://github.com/ianwhite/pickle.git
-  cd vendor/plugins/pickle
   rake spec
-  cucumber features
+  
+To run the features do:
+
+  rake cucumber
+ 
+The first time you do this, instructions will appear about how to set up a test rails app. 
 
 == Contributors
 

data/Rakefile

@@ -4,6 +4,7 @@ $LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base) and !$LOAD_PATH.includ
 
 require 'spec/rake/spectask'
 require 'spec/rake/verify_rcov'
+require 'cucumber/rake/task'
 
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
 require 'pickle/version'
@@ -29,61 +30,41 @@ end
 namespace :rcov do
   desc "Verify RCov threshold for #{PluginName}"
   RCov::VerifyTask.new(:verify => :rcov) do |t|
-    t.threshold = 100.0
+    t.threshold = 99.23
     t.index_html = File.join(File.dirname(__FILE__), 'doc/coverage/index.html')
   end
 end
 
-# cucumber features require an enclosing rails app
-plugins_base = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-cucumber_base = File.join(plugins_base, 'cucumber/lib')
-if File.exists?(cucumber_base) && plugins_base =~ /\/vendor\/plugins$/ # if we're in rails app
-  $:.unshift(cucumber_base)
-  require 'cucumber/rake/task'
-
-  desc "Run features for #{PluginName} (progress)"
-  Cucumber::Rake::Task.new(:features) do |t|
-    t.fork = true
-    t.cucumber_opts = ['--format', 'progress', '--require', 'features']
-  end
-  
-  desc "Run features for #{PluginName} (full output)"
-  namespace :features do
-    Cucumber::Rake::Task.new(:full) do |t|
-      t.cucumber_opts = ['--format', 'pretty', '--require', 'features']
-    end
-  end
+desc "Run features for #{PluginName} (progress)"
+Cucumber::Rake::Task.new(:cucumber => [:cucumber_test_app]) do |t|
+  t.cucumber_opts = ['--format', 'pretty', '--require', 'features']
 end
 
-# the following optional tasks are for CI, gems and doc building
-begin
-  require 'hanna/rdoctask'
-  require 'garlic/tasks'
-  require 'grancher/task'
+desc "setup a rails app for running cucumber"
+file "cucumber_test_app" do
+  raise <<-EOD
+
+** Please setup a test rails app in cucumber_test_app **
+
+Until this is automated, do something like:
   
-  task :cruise => ['garlic:all', 'doc:publish']
+(make sure cucumber, cucumber-rails, rspec, rspec-rails, machinist, and factory_girl are all installed as gems)
   
-  Rake::RDocTask.new(:doc) do |d|
-    d.options << '--all'
-    d.rdoc_dir = 'doc'
-    d.main     = 'README.rdoc'
-    d.title    = "#{PluginName} API docs"
-    d.rdoc_files.include('README.rdoc', 'History.txt', 'License.txt', 'Todo.txt', 'lib/**/*.rb')
-  end
+  rails cucumber_test_app
+  cd cucumber_test_app
+  script/generate rspec
+  script/generate cucumber
+  cd vendor/plugins
+  ln -s ../../.. pickle
+  cd ../../..
+  
+Then run
 
-  namespace :doc do
-    task :publish => :doc do
-      Rake::Task['doc:push'].invoke unless uptodate?('.git/refs/heads/gh-pages', 'doc')
-    end
-    
-    Grancher::Task.new(:push) do |g|
-      g.keep_all
-      g.directory 'doc', 'doc'
-      g.branch = 'gh-pages'
-      g.push_to = 'origin'
-    end
-  end
-rescue LoadError
+  rake cucumber
+
+** thanks! **
+
+EOD
 end
 
 begin

data/Todo.txt

@@ -1,4 +1,3 @@
 * add 'scope' steps see http://gist.github.com/239570
 * cleanup path_to_pickle and paths.rb (maybe have poly_pickle_path with same semantics as polymorphic_path, but accepting pickle refs)
-* fix problem with save_and_open_emails
 * Translations

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/features/support/env.rb

@@ -5,7 +5,7 @@
 # files.
 
 ENV["RAILS_ENV"] ||= "cucumber"
-require File.expand_path(File.dirname(__FILE__) + '/../../../../../config/environment')
+require File.expand_path(File.dirname(__FILE__) + '/../../cucumber_test_app/config/environment')
 
 require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
 require 'cucumber/rails/world'

data/lib/pickle/adapter.rb

@@ -11,10 +11,6 @@ module Pickle
   class Adapter
     attr_reader :name, :klass
     
-    def self.factories
-      raise NotImplementedError, "return an array of factory adapter objects"
-    end
-  
     def create(attrs = {})
       raise NotImplementedError, "create and return an object with the given attributes"
     end
@@ -22,12 +18,24 @@ module Pickle
     cattr_writer :model_classes
     self.model_classes = nil
     
-    def self.model_classes
-      # remove abstract, framework, and non-table classes
-      @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).reject do |klass|
-        klass.abstract_class? || !klass.table_exists? ||
-         (defined?(CGI::Session::ActiveRecordStore::Session) && klass == CGI::Session::ActiveRecordStore::Session) ||
-         (defined?(::ActiveRecord::SessionStore::Session) && klass == ::ActiveRecord::SessionStore::Session)
+    class << self
+      def factories
+        raise NotImplementedError, "return an array of factory adapter objects"
+      end
+
+      def model_classes
+        @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).select {|klass| suitable_for_pickle?(klass)}
+      end
+      
+      # return true if a klass should be used by pickle
+      def suitable_for_pickle?(klass)
+        !klass.abstract_class? && klass.table_exists? && !framework_class?(klass)
+      end
+
+      # return true if the passed class is a special framework class
+      def framework_class?(klass)
+        ((defined?(CGI::Session::ActiveRecordStore::Session) && klass == CGI::Session::ActiveRecordStore::Session)) ||
+        ((defined?(::ActiveRecord::SessionStore::Session) && klass == ::ActiveRecord::SessionStore::Session))
       end
     end
   

data/lib/pickle/email.rb

@@ -34,7 +34,7 @@ module Pickle
     # web browser if on OS X. (depends on webrat)
     def save_and_open_emails
       emails_to_open = @emails || emails
-      filename = "#{RAILS_ROOT}/tmp/webrat-email-#{Time.now.to_i}.html"
+      filename = "webrat-email-#{Time.now.to_i}.html"
       File.open(filename, "w") do |f|
         emails_to_open.each_with_index do |e, i|
           f.write "<h1>Email #{i+1}</h1><pre>#{e}</pre><hr />"

data/pickle.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pickle}
-  s.version = "0.2.5"
+  s.version = "0.2.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ian White"]
-  s.date = %q{2010-03-17}
+  s.date = %q{2010-04-05}
   s.description = %q{Easy model creation and reference in your cucumber features}
   s.email = %q{ian.w.white@gmail.com}
   s.extra_rdoc_files = [
@@ -46,7 +46,6 @@ Gem::Specification.new do |s|
      "features/support/paths.rb",
      "features/support/pickle.rb",
      "features/support/pickle_app.rb",
-     "garlic.rb",
      "init.rb",
      "lib/pickle.rb",
      "lib/pickle/adapter.rb",
@@ -69,15 +68,15 @@ Gem::Specification.new do |s|
      "rails_generators/pickle/templates/paths.rb",
      "rails_generators/pickle/templates/pickle.rb",
      "rails_generators/pickle/templates/pickle_steps.rb",
-     "spec/lib/pickle_adapter_spec.rb",
-     "spec/lib/pickle_config_spec.rb",
-     "spec/lib/pickle_email_parser_spec.rb",
-     "spec/lib/pickle_email_spec.rb",
-     "spec/lib/pickle_parser_matchers_spec.rb",
-     "spec/lib/pickle_parser_spec.rb",
-     "spec/lib/pickle_path_spec.rb",
-     "spec/lib/pickle_session_spec.rb",
-     "spec/lib/pickle_spec.rb",
+     "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
      "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/ianwhite/pickle/tree}
@@ -86,15 +85,15 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{Easy model creation and reference in your cucumber features}
   s.test_files = [
-    "spec/lib/pickle_adapter_spec.rb",
-     "spec/lib/pickle_config_spec.rb",
-     "spec/lib/pickle_email_parser_spec.rb",
-     "spec/lib/pickle_email_spec.rb",
-     "spec/lib/pickle_parser_matchers_spec.rb",
-     "spec/lib/pickle_parser_spec.rb",
-     "spec/lib/pickle_path_spec.rb",
-     "spec/lib/pickle_session_spec.rb",
-     "spec/lib/pickle_spec.rb",
+    "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
      "spec/spec_helper.rb"
   ]
 

data/spec/{lib/pickle_adapter_spec.rb → pickle/adapter_spec.rb}

@@ -1,4 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'activerecord'
+require 'factory_girl'
+require 'machinist/active_record'
 
 describe Pickle::Adapter do
   it ".factories should raise NotImplementedError" do
@@ -9,32 +13,47 @@ describe Pickle::Adapter do
     lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
   end
   
-  describe ".model_classes" do
+  describe ".suitable_for_pickle?(klass)" do
+    let :klass do
+      mock('Class', :abstract_class? => false, :table_exists? => true)
+    end
+    
     before do
-      Pickle::Adapter.model_classes = nil
+      Pickle::Adapter.stub!(:framework_class?).and_return(false)
     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
+    it "a non abstract class that has a table, and is not a framework class, is suitable_for_pickle" do
+      Pickle::Adapter.should be_suitable_for_pickle(klass)
     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
+    
+    it "an abtract_class is not suitable_for_pickle" do
+      klass.stub!(:abstract_class?).and_return(true)
+      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
     end
+    
+    it "a class with no table is not suitable_for_pickle" do
+      klass.stub!(:table_exists?).and_return(false)
+      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
+    end
+    
+    it "an frame_work class is not suitable_for_pickle" do
+      Pickle::Adapter.should_receive(:framework_class?).with(klass).and_return(true)
+      Pickle::Adapter.should_not be_suitable_for_pickle(klass)
+    end
+  end
   
-    it "should not include classes without a table" do
-      klass = Class.new(ActiveRecord::Base)
-      Pickle::Adapter.model_classes.should_not include(klass)
+  describe ".model_classes" do
+    before do
+      Pickle::Adapter.model_classes = nil
     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)
+    
+    it "should only include #suitable_for_pickle classes" do
+      klass1 = Class.new(ActiveRecord::Base)
+      klass2 = Class.new(ActiveRecord::Base)
+      Pickle::Adapter.should_receive(:suitable_for_pickle?).with(klass1).and_return(true)
+      Pickle::Adapter.should_receive(:suitable_for_pickle?).with(klass2).and_return(false)
+      Pickle::Adapter.model_classes.should include(klass1)
+      Pickle::Adapter.model_classes.should_not include(klass2)
     end
   end
   

data/spec/{lib/pickle_config_spec.rb → pickle/config_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Pickle::Config do
   before do

data/spec/{lib/pickle_email_parser_spec.rb → pickle/email/parser_spec.rb}

@@ -1,4 +1,6 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'pickle/email/parser'
 
 describe Pickle::Email::Parser do
   include Pickle::Parser::Matchers
@@ -46,4 +48,4 @@ describe Pickle::Email::Parser do
       match[1].should == 'last'
     end
   end
-end
+end

data/spec/{lib/pickle_email_spec.rb → pickle/email_spec.rb}

@@ -1,4 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'pickle/email'
+require 'pickle/email/parser'
+require 'actionmailer'
 
 describe Pickle::Email do
   include Pickle::Session
@@ -120,11 +124,11 @@ describe Pickle::Email do
     
     it "should create a file in Rails/tmp with the emails in it" do
       save_and_open_emails
-      File.read("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html").should == "<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />"
+      File.read("webrat-email-#{@now.to_i}.html").should == "<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />"
     end
 
     it "should call open_in_browser on created tmp file" do
-      should_receive(:open_in_browser).with("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html")
+      should_receive(:open_in_browser).with("webrat-email-#{@now.to_i}.html")
       save_and_open_emails
     end
   end
@@ -150,4 +154,4 @@ describe Pickle::Email do
       click_first_link_in_email(@email1)
     end
   end
-end
+end

data/spec/{lib/pickle_parser_matchers_spec.rb → pickle/parser/matchers_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Pickle::Parser::Matchers do
   include Pickle::Parser::Matchers

data/spec/pickle/parser_spec.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Pickle::Parser do
+  before do
+    @parser = Pickle::Parser.new(:config => Pickle::Config.new)
+  end
+  
+  it "should raise error when created with no config" do
+    lambda{ Pickle::Parser.new }.should raise_error(ArgumentError)
+  end
+  
+  describe "when a 'user' factory exists in config" do
+    before do
+      @parser.config.stub(:factories).and_return('user' => mock('User'))
+    end
+    
+    describe 'misc regexps' do
+      describe '/^#{capture_model} exists/' do
+        before do
+          @regexp = /^(#{@parser.capture_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
+        @parser.parse_field('a: "b"').should == {'a' => 'b'}
+      end
+  
+      it "should raise error for invalid field 'a : b'" do
+        lambda { @parser.parse_field('a : b') }.should raise_error(ArgumentError)
+      end
+    end
+  
+    describe '#parse_fields' do
+      it 'should return {} for blank argument' do
+        @parser.parse_fields(nil).should == {}
+        @parser.parse_fields('').should == {}
+      end
+    
+      it 'should raise error for invalid argument' do
+        lambda { @parser.parse_fields('foo foo') }.should raise_error(ArgumentError)
+      end
+    
+      it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
+        @parser.parse_fields('foo: "bar"').should == { "foo" => "bar"}
+      end
+    
+      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
+  
+    describe '#parse_model' do
+      it '("a user") should == ["user", ""]' do
+        @parser.parse_model("a user").should == ["user", ""]
+      end
+  
+      it '("the user") should == ["user", ""]' do
+        @parser.parse_model("the user").should == ["user", ""]
+      end
+  
+      it '("1 user") should == ["user", ""]' do
+        @parser.parse_model("1 user").should == ["user", ""]
+      end
+    
+      it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
+        @parser.parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
+      end
+    
+      it '(\'that user: "herbie"\') should == ["user", "herbie"]' do
+        @parser.parse_model('that user: "herbie"').should == ["user", "herbie"]
+      end
+    
+      it '(\'the 12th user\') should == ["user", 11]' do
+        @parser.parse_model('the 12th user').should == ["user", 11]
+      end
+  
+      it '(\'the last user\') should == ["user", -1]' do
+        @parser.parse_model('the last user').should == ["user", -1]
+      end
+    
+      it '("the first user") should == ["user", 0]' do
+        @parser.parse_model('the first user').should == ["user", 0]
+      end
+  
+      it '("the 1st user") should == ["user", 0]' do
+        @parser.parse_model('the 1st user').should == ["user", 0]
+      end
+    end
+  
+    describe "#parse_index" do
+      it '("1st") should == 0' do
+        @parser.parse_index("1st").should == 0
+      end
+  
+      it '("24th") should == 23' do
+        @parser.parse_index("24th").should == 23
+      end
+      it '("first") should == 0' do
+        @parser.parse_index("first").should == 0
+      end
+    
+      it '("last") should == -1' do
+        @parser.parse_index("last").should == -1
+      end
+    end
+  end
+
+  describe "customised mappings" do
+    describe "config maps 'I|myself' to 'user: \"me\"'" do
+      before do
+        @config = Pickle::Config.new do |c|
+          c.map 'I', 'myself', :to => 'user: "me"'
+        end
+        @parser = Pickle::Parser.new(:config => @config)
+        @parser.config.stub(:factories).and_return('user' => mock('User'))
+      end
+
+      it "'I' should match /\#{match_model}/" do
+        'I'.should match(/#{@parser.match_model}/)
+      end
+  
+      it "'myself' should match /\#{match_model}/" do
+        'myself'.should match(/#{@parser.match_model}/)
+      end
+  
+      it "parse_model('I') should == ['user', 'me']" do
+        @parser.parse_model('I').should == ["user", "me"]
+      end
+
+      it "parse_model('myself') should == ['user', 'me']" do
+        @parser.parse_model('myself').should == ["user", "me"]
+      end
+    end
+  end
+end