kbaum-pickle 0.2.1.1

data/features/support/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)

data/features/support/env.rb

@@ -0,0 +1,55 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a 
+# newer version of cucumber-rails. Consider adding your own code to a new file 
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+ENV["RAILS_ENV"] ||= "cucumber"
+require File.expand_path(File.dirname(__FILE__) + '/../../../../../config/environment')
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/rspec'
+require 'cucumber/rails/world'
+require 'cucumber/rails/active_record'
+require 'cucumber/web/tableish'
+
+require 'webrat'
+require 'webrat/core/matchers'
+require 'cucumber/webrat/element_locator' # Deprecated in favor of #tableish - remove this line if you don't use #element_at or #table_at
+
+Webrat.configure do |config|
+  config.mode = :rails
+  config.open_error_files = false # Set to true if you want error pages to pop up in the browser
+end
+
+
+# If you set this to false, any error raised from within your app will bubble 
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# If you set this to true, each scenario will run in a database transaction.
+# You can still turn off transactions on a per-scenario basis, simply tagging 
+# a feature or scenario with the @no-txn tag. If you are using Capybara,
+# tagging with @culerity or @javascript will also turn transactions off.
+#
+# If you set this to false, transactions will be off for all scenarios,
+# regardless of whether you use @no-txn or not.
+#
+# Beware that turning transactions off will leave data in your database 
+# after each scenario, which can lead to hard-to-debug failures in 
+# subsequent scenarios. If you do this, we recommend you create a Before
+# block that will explicitly put your database in a known state.
+Cucumber::Rails::World.use_transactional_fixtures = true
+
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+require 'database_cleaner'
+DatabaseCleaner.strategy = :truncation
+

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 web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+    
+    when /the home\s?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))
+
+    # 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/features/support/pickle.rb

@@ -0,0 +1,26 @@
+# 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
+require 'pickle/path/world'
+require 'pickle/email/world'

data/features/support/pickle_app.rb

@@ -0,0 +1,4 @@
+Pickle.configure do |c|
+  c.map 'I', :to => 'user: "me"'
+  c.map 'killah fork', :to => 'fancy fork: "of cornwood"'
+end

data/garlic.rb

@@ -0,0 +1,38 @@
+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 'cucumber-rails', :url => 'git://github.com/aslakhellesoy/cucumber-rails'
+  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'
+        plugin 'machinist'
+        plugin 'webrat'
+        plugin 'cucumber-rails' do
+          `script/generate cucumber --webrat -f`
+        end
+      end
+  
+      run do
+        cd "vendor/plugins/pickle" do
+          sh "rake rcov:verify && rake features"
+        end
+      end
+    end
+    
+  end
+end

data/lib/pickle/adapter.rb

@@ -0,0 +1,88 @@
+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 if defined?(::ActiveRecord)
+      @@model_classes ||= []
+    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/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

data/lib/pickle/email/world.rb

@@ -0,0 +1,13 @@
+require 'pickle'
+require 'pickle/email'
+require 'pickle/email/parser'
+
+# add email parser expressions
+Pickle::Parser.send :include, Pickle::Email::Parser
+
+World(Pickle::Email)
+
+# shortcuts for use in step regexps
+class << self
+  delegate :capture_email, :to => 'Pickle.parser'
+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/parser/matchers.rb

@@ -0,0 +1,87 @@
+module Pickle
+  class Parser
+    module Matchers
+      def match_ordinal
+        '(?:\d+(?:st|nd|rd|th))'
+      end
+  
+      def match_index
+        "(?:first|last|#{match_ordinal})"
+      end
+  
+      def match_prefix
+        '(?:(?:a|an|another|the|that) )'
+      end
+  
+      def match_quoted
+        '(?:[^\\"]|\\.)*'
+      end
+  
+      def match_label
+        "(?::? \"#{match_quoted}\")"
+      end
+
+      def match_value
+        "(?:\"#{match_quoted}\"|nil|true|false|[+-]?\\d+(?:\\.\\d+)?)"
+      end
+
+      def match_field
+        "(?:\\w+: #{match_value})"
+      end
+  
+      def match_fields
+        "(?:#{match_field}, )*#{match_field}"
+      end
+  
+      def match_mapping
+        "(?:#{config.mappings.map(&:search).join('|')})"
+      end
+  
+      def match_factory
+        "(?:#{config.factories.keys.map{|n| n.gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      def match_plural_factory
+        "(?:#{config.factories.keys.map{|n| n.pluralize.gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      def match_indexed_model
+        "(?:(?:#{match_index} )?#{match_factory})"
+      end
+  
+      def match_labeled_model
+        "(?:#{match_factory}#{match_label})"
+      end
+  
+      def match_model
+        "(?:#{match_mapping}|#{match_prefix}?(?:#{match_indexed_model}|#{match_labeled_model}))"
+      end
+  
+      def match_predicate
+        "(?:#{config.predicates.map{|m| m.to_s.sub(/\?$/,'').gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      # create capture analogues of match methods
+      instance_methods.select{|m| m =~ /^match_/}.each do |method|
+        eval <<-end_eval                   
+          def #{method.to_s.sub('match_', 'capture_')}         # def capture_field
+            "(" + #{method} + ")"                         #   "(" + match_field + ")"
+          end                                             # end
+        end_eval
+      end
+  
+      # special capture methods
+      def capture_number_in_ordinal
+        '(?:(\d+)(?:st|nd|rd|th))'
+      end
+  
+      def capture_name_in_label
+        "(?::? \"(#{match_quoted})\")"
+      end
+  
+      def capture_key_and_value_in_field
+        "(?:(\\w+): #{capture_value})"
+      end
+    end
+  end
+end

data/lib/pickle/parser.rb

@@ -0,0 +1,65 @@
+require 'pickle/parser/matchers'
+
+module Pickle
+  class Parser
+    include Matchers
+    
+    attr_reader :config
+    
+    def initialize(options = {})
+      @config = options[:config] || raise(ArgumentError, "Parser.new requires a :config")
+    end
+    
+    # given a string like 'foo: "bar", bar: "baz"' returns {"foo" => "bar", "bar" => "baz"}
+    def parse_fields(fields)
+      if fields.blank?
+        {}
+      elsif fields =~ /^#{match_fields}$/
+        fields.scan(/(#{match_field})(?:,|$)/).inject({}) do |m, match|
+          m.merge(parse_field(match[0]))
+        end
+      else
+        raise ArgumentError, "The fields string is not in the correct format.\n\n'#{fields}' did not match: #{match_fields}" 
+      end
+    end
+    
+    # given a string like 'foo: expr' returns {key => value}
+    def parse_field(field)
+      if field =~ /^#{capture_key_and_value_in_field}$/
+        { $1 => eval($2) }
+      else
+        raise ArgumentError, "The field argument is not in the correct format.\n\n'#{field}' did not match: #{match_field}"
+      end
+    end
+    
+    # returns really underscored name
+    def canonical(str)
+      str.to_s.underscore.gsub(' ','_').gsub('/','_')
+    end
+    
+    # return [factory_name, name or integer index]
+    def parse_model(model_name)
+      apply_mappings!(model_name)
+      if /#{capture_index} #{capture_factory}$/ =~ model_name
+        [canonical($2), parse_index($1)]
+      elsif /#{capture_factory}#{capture_name_in_label}?$/ =~ model_name
+        [canonical($1), canonical($2)]
+      end
+    end
+  
+    def parse_index(index)
+      case index
+      when nil, '', 'last' then -1
+      when /#{capture_number_in_ordinal}/ then $1.to_i - 1
+      when 'first' then 0
+      end
+    end
+
+  private
+    def apply_mappings!(string)
+      config.mappings.each do |mapping|
+        string.sub! /^#{mapping.search}$/, mapping.replacement
+      end
+    end
+  end
+end

data/lib/pickle/path/world.rb

@@ -0,0 +1,5 @@
+require 'pickle'
+require 'pickle/path'
+
+# make world pickle/path aware
+World(Pickle::Path)

data/lib/pickle/path.rb

@@ -0,0 +1,45 @@
+module Pickle
+  module Path
+    # given args of pickle model name, and an optional extra action, or segment, will attempt to find
+    # a matching named route
+    #
+    #   path_to_pickle 'the user', :action => 'edit'       # => /users/3/edit
+    #   path_to_pickle 'the user', 'the comment'           # => /users/3/comments/1
+    #   path_to_pickle 'the user', :segment => 'comments'  # => /users/3/comments
+    #
+    # If you don;t know if the 'extra' part of the path is an action or a segment, then just
+    # pass it as 'extra' and this method will run through the possibilities
+    #
+    #   path_to_pickle 'the user', :extra => 'new comment' # => /users/3/comments/new
+    def path_to_pickle(*pickle_names)
+      options = pickle_names.extract_options!
+      resources = pickle_names.map{|n| model(n) || n.to_sym}
+      if options[:extra]
+        parts = options[:extra].underscore.gsub(' ','_').split("_")
+        find_pickle_path_using_action_segment_combinations(resources, parts)
+      else
+        pickle_path_for_resources_action_segment(resources, options[:action], options[:segment])
+      end or raise "Could not figure out a path for #{pickle_names.inspect} #{options.inspect}"
+    end
+    
+  protected
+    def find_pickle_path_using_action_segment_combinations(resources, parts)
+      path = nil
+      (0..parts.length).each do |idx|
+        action  = parts.slice(0, idx).join('_')
+        segment = parts.slice(idx, parts.length).join('_')
+        path = pickle_path_for_resources_action_segment(resources, action, segment) and break
+      end
+      path
+    end
+    
+    def pickle_path_for_resources_action_segment(resources, action, segment)
+      action.blank? or action = action.downcase.gsub(' ','_')
+      segment.blank? or segment = segment.downcase.gsub(' ','_')
+      resource_names = resources.map{|s| s.is_a?(Symbol) ? s.to_s : s.class.name.underscore}.join("_")
+      models = resources.reject{|s| s.is_a?(Symbol)}
+      parts = [action, resource_names, segment].reject(&:blank?)
+      send("#{parts.join('_')}_path", *models) rescue nil
+    end
+  end
+end

data/lib/pickle/session/parser.rb

@@ -0,0 +1,34 @@
+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    
+      
+      def parse_hash(hash)
+        hash.inject({}) do |parsed, (key, val)|
+          if session && val =~ /^#{capture_model}$/
+            parsed.merge(key => session.model($1))
+          else
+            parsed.merge(key => val)
+          end
+        end
+      end
+    end
+  end
+end