pickle 0.1.16

data/features/step_definitions/extra_email_steps.rb

@@ -0,0 +1,7 @@
+Given(/^an email "(.*?)" with body: "(.*?)" is delivered to (.+?)$/) do |subject, body, to|
+  Notifier.deliver_email(to, subject, body)
+end
+
+Given(/^#{capture_model}'s email is delivered$/) do |model|
+  Notifier.deliver_user_email(model(model))
+end

data/features/step_definitions/fork_steps.rb

@@ -0,0 +1,4 @@
+# example of making your own matcher with the pickle backend
+Then(/^#{capture_model} should be tine of #{capture_model}$/) do |tine, fork|
+  model(fork).tines.should include(model(tine))
+end

data/features/step_definitions/generator_steps.rb

@@ -0,0 +1,42 @@
+Before do
+  `mv #{Rails.root}/features/ #{Rails.root}/features.orig/ > /dev/null 2>&1`
+end
+
+After do
+  `rm -rf #{Rails.root}/features`
+  `mv #{Rails.root}/features.orig/ #{Rails.root}/features/ > /dev/null 2>&1`
+end
+
+Given(/^cucumber has been freshly generated$/) do
+  `cd #{Rails.root}; script/generate cucumber -f`
+end
+
+Given(/^env\.rb already requires (.+)$/) do |file|
+  File.open("#{Rails.root}/features/support/env.rb", "a") do |env|
+    env << "require '#{file}'\n"
+  end
+end
+
+When(/^I run "(.*)"$/) do |command|
+  @output = `cd #{Rails.root}; #{command}`
+end
+
+Then(/^I should see "(.*)"$/) do |text|
+  @output.should include(text)
+end
+
+Then(/^the file (.+?) should exist$/) do |file|
+  File.exist?("#{Rails.root}/#{file}").should == true
+end
+
+Then(/^the file (.+?) should match \/(.*?)\/$/) do |file, regexp|
+  File.read("#{Rails.root}/#{file}").should match(/#{regexp}/m)
+end
+
+Then(/^the file (.+?) should not match \/(.*?)\/$/) do |file, regexp|
+  File.read("#{Rails.root}/#{file}").should_not match(/#{regexp}/m)
+end
+
+Then /^the file features\/support\/paths\.rb should be identical to the local support\/paths\.rb$/ do
+  File.read("#{Rails.root}/features/support/paths.rb").should == File.read("#{File.dirname(__FILE__)}/../support/paths.rb")
+end

data/features/step_definitions/path_steps.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+Then(/^(.+?) should match route \/(.+?)$/) do |page, route|
+  regexp = route.gsub(/:(\w*?)id/,'\d+')
+  path_to(page).should =~ /#{regexp}/
+end
+
+When(/^I go to (.+)$/) do |page|
+  visit path_to(page)
+end
+
+Then(/^I should be at (.+)$/) do |page|
+  request.path.should =~ /#{path_to(page)}/
+end

data/features/step_definitions/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/features/support/env.rb

@@ -0,0 +1,34 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + '../../../../../../config/environment')
+require 'cucumber/rails/world'
+
+require 'cucumber/formatter/unicode'
+
+Cucumber::Rails.use_transactional_fixtures
+
+require 'webrat'
+
+Webrat.configure do |config|
+  config.mode = :rails
+end
+
+# Comment out the next line if you're not using RSpec's matchers (should / should_not) in your steps.
+require 'cucumber/rails/rspec'
+require 'webrat/core/matchers'
+
+# Pickle
+require 'pickle/world'
+require 'pickle/path/world'
+require 'pickle/email/world'
+
+Pickle.configure do |c|
+  c.map 'I', :to => 'user: "me"'
+  c.map 'killah fork', :to => 'fancy fork: "of cornwood"'
+end
+
+# test app setup
+__APP__ = File.expand_path(File.join(File.dirname(__FILE__), '../app'))
+require "#{__APP__}/app"
+require "#{__APP__}/factories"
+require "#{__APP__}/blueprints"

data/features/support/paths.rb

@@ -0,0 +1,46 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in webrat_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+    
+    when /the homepage/
+      '/'
+    
+    # Add more mappings here.
+    # Here is a more fancy example:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    # 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
+
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/garlic.rb

@@ -0,0 +1,36 @@
+garlic do
+  repo 'rails', :url => 'git://github.com/rails/rails'
+  repo 'rspec', :url => 'git://github.com/dchelimsky/rspec'
+  repo 'rspec-rails', :url => 'git://github.com/dchelimsky/rspec-rails'
+  repo 'factory_girl', :url => 'git://github.com/thoughtbot/factory_girl'
+  repo 'machinist', :url => 'git://github.com/notahat/machinist'
+  repo 'cucumber', :url => 'git://github.com/aslakhellesoy/cucumber'
+  repo 'webrat', :url => 'git://github.com/brynary/webrat'
+  repo 'pickle', :path => '.'
+
+  ['2-3-stable', '2-2-stable', '2-1-stable'].each do |rails|
+  
+    target rails, :tree_ish => "origin/#{rails}" do
+      prepare do
+        plugin 'pickle', :clone => true
+        plugin 'rspec'
+        plugin 'rspec-rails' do
+          `script/generate rspec -f`
+        end
+        plugin 'factory_girl'
+        plugin 'cucumber' do
+          `script/generate cucumber -f`
+        end
+        plugin 'machinist'
+        plugin 'webrat'
+      end
+  
+      run do
+        cd "vendor/plugins/pickle" do
+          sh "rake rcov:verify && rake features"
+        end
+      end
+    end
+    
+  end
+end

data/lib/pickle.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+require 'pickle/version'
+require 'pickle/adapter'
+require 'pickle/config'
+require 'pickle/parser'
+require 'pickle/session'
+require 'pickle/session/parser'
+
+# make the parser aware of models in the session (for fields refering to models)
+Pickle::Parser.send :include, Pickle::Session::Parser
+
+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

data/lib/pickle/adapter.rb

@@ -0,0 +1,87 @@
+module Pickle
+  # Abstract Factory adapter class, if you have a factory type setup, you
+  # 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:
+  #
+  #   #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, :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
+  
+    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)
+      end
+    end
+  
+    # machinist adapter
+    class Machinist < Adapter
+      def self.factories
+        factories = []
+        model_classes.each do |klass|
+          if blueprints = klass.instance_variable_get('@blueprints')
+            blueprints.keys.each {|blueprint| factories << new(klass, blueprint)}
+          end
+        end
+        factories
+      end
+      
+      def initialize(klass, blueprint)
+        @klass, @blueprint = klass, blueprint
+        @name = @klass.name.underscore.gsub('/','_')
+        @name = "#{@blueprint}_#{@name}" unless @blueprint == :master
+      end
+      
+      def create(attrs = {})
+        @klass.send(:make, @blueprint, attrs)
+      end
+    end
+    
+    # factory-girl adapter
+    class FactoryGirl < Adapter
+      def self.factories
+        (::Factory.factories.values rescue []).map {|factory| new(factory)}
+      end
+      
+      def initialize(factory)
+        @klass, @name = factory.build_class, factory.factory_name.to_s
+      end
+    
+      def create(attrs = {})
+        Factory.create(@name, attrs)
+      end
+    end
+        
+    # fallback active record adapter
+    class ActiveRecord < Adapter
+      def self.factories
+        model_classes.map {|klass| new(klass) }
+      end
+
+      def initialize(klass)
+        @klass, @name = klass, klass.name.underscore.gsub('/','_')
+      end
+
+      def create(attrs = {})
+        @klass.send(:create!, attrs)
+      end
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+
+module Pickle
+  class Config
+    attr_writer :adapters, :factories, :mappings, :predicates
+    
+    def initialize(&block)
+      configure(&block) if block_given?
+    end
+    
+    def configure(&block)
+      yield(self)
+    end
+    
+    def adapters
+      @adapters ||= [:machinist, :factory_girl, :active_record]
+    end
+    
+    def adapter_classes
+      adapters.map {|a| a.is_a?(Class) ? a : "pickle/adapter/#{a}".classify.constantize}
+    end
+    
+    def factories
+      @factories ||= adapter_classes.reverse.inject({}) do |factories, adapter|
+        factories.merge(adapter.factories.inject({}){|h, f| h.merge(f.name => f)})
+      end
+    end
+    
+    def predicates
+      @predicates ||= Pickle::Adapter.model_classes.map do |k|
+        k.public_instance_methods.select{|m| m =~ /\?$/} + k.column_names
+      end.flatten.uniq
+    end
+    
+    def mappings
+      @mappings ||= []
+    end
+    
+    # Usage: map 'me', 'myself', 'I', :to => 'user: "me"'
+    def map(*args)
+      options = args.extract_options!
+      raise ArgumentError, "Usage: map 'search' [, 'search2', ...] :to => 'replace'" unless args.any? && options[:to].is_a?(String)
+      args.each do |search|
+        self.mappings << OpenStruct.new(:search => search, :replacement => options[:to])
+      end
+    end
+  end
+end

data/lib/pickle/email.rb

@@ -0,0 +1,36 @@
+module Pickle
+  module Email
+    # return the deliveries array, optionally selected by the passed fields
+    def emails(fields = nil)
+      @emails = ActionMailer::Base.deliveries.select {|m| email_has_fields?(m, fields)}
+    end
+
+    def email(ref, fields = nil)
+      (match = ref.match(/^#{capture_index_in_email}$/)) or raise ArgumentError, "argument should match #{match_email}"
+      @emails or raise RuntimeError, "Call #emails before calling #email"
+      index = parse_index(match[1])
+      email_has_fields?(@emails[index], fields) ? @emails[index] : nil
+    end
+    
+    def email_has_fields?(email, fields)
+      parse_fields(fields).each do |key, val|
+        return false unless (Array(email.send(key)) & Array(val)).any?
+      end
+      true
+    end
+    
+  protected
+    # Saves the emails out to RAILS_ROOT/tmp/ and opens it in the default
+    # 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"
+      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 />"
+        end
+      end
+      open_in_browser(filename)
+    end
+  end
+end

data/lib/pickle/email/parser.rb

@@ -0,0 +1,18 @@
+module Pickle
+  module Email
+    # add ability to parse emails
+    module Parser
+      def match_email
+        "(?:#{match_prefix}?(?:#{match_index} )?email)"
+      end
+
+      def capture_email
+        "(#{match_email})"
+      end
+      
+      def capture_index_in_email
+        "(?:#{match_prefix}?(?:#{capture_index} )?email)"
+      end
+    end
+  end
+end