kbaum-pickle 0.2.1.1

data/lib/pickle/session.rb

@@ -0,0 +1,157 @@
+module Pickle
+  module Session
+    class << self
+      def included(world_class)
+        proxy_to_pickle_parser(world_class)
+      end
+      
+      def extended(world_object)
+        proxy_to_pickle_parser(class << world_object; self; end) # metaclass is not 2.1 compatible
+      end
+      
+    protected
+      def proxy_to_pickle_parser(world_class)
+        world_class.class_eval do
+          unless methods.include?('method_missing_with_pickle_parser')
+            alias_method_chain :method_missing, :pickle_parser
+            alias_method_chain :respond_to?, :pickle_parser
+          end
+        end
+      end
+    end
+    
+    def create_model(a_model_name, fields = nil)
+      factory, label = *parse_model(a_model_name)
+      raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      record = pickle_config.factories[factory].create(fields)
+      store_model(factory, label, record)
+    end
+
+    def find_model(a_model_name, fields = nil)
+      factory, name = *parse_model(a_model_name)
+      raise ArgumentError, "Can't find a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
+      model_class = pickle_config.factories[factory].klass
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, fields))
+        store_model(factory, name, record)
+      end
+    end
+    
+    def find_model!(a_model_name, fields = nil)
+      find_model(a_model_name, fields) or raise "Can't find pickle model: '#{name}' in this scenario"
+    end
+    
+    def find_models(factory, fields = nil)
+      models_by_index(factory).clear
+      model_class = pickle_config.factories[factory].klass
+      records = model_class.find(:all, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
+      records.each {|record| store_model(factory, nil, record)}
+    end
+      
+    # return the original model stored by create_model or find_model
+    def created_model(name)
+      factory, name_or_index = *parse_model(name)
+      
+      if name_or_index.blank?
+        models_by_index(factory).last
+      elsif name_or_index.is_a?(Integer)
+        models_by_index(factory)[name_or_index]
+      else
+        models_by_name(factory)[name_or_index] or raise "Can't find pickle model: '#{name}' in this scenario"
+      end
+    end
+
+    # predicate version which raises no errors
+    def created_model?(name)
+      (created_model(name) rescue nil) ? true : false
+    end
+    
+    # return a newly selected model
+    def model(name)
+      (model = created_model(name)) && model.class.find(model.id)
+    end
+    
+    # predicate version which raises no errors
+    def model?(name)
+      (model(name) rescue nil) ? true : false
+    end
+    
+    # like model, but raise an error if it can't be found
+    def model!(name)
+      model(name) or raise "Can't find pickle model: '#{name}' in this scenario"
+    end
+    
+    # like created_model, but raise an error if it can't be found
+    def created_model!(name)
+      created_model(name) or raise "Can't find pickle model: '#{name}' in this scenario"
+    end
+    
+    # return all original models of specified type
+    def created_models(factory)
+      models_by_index(factory)
+    end
+      
+    # return all models of specified type (freshly selected from the database)
+    def models(factory)
+      created_models(factory).map{|model| model.class.find(model.id) }
+    end
+    
+    def respond_to_with_pickle_parser?(method, include_private = false)
+      respond_to_without_pickle_parser?(method, include_private) || pickle_parser.respond_to?(method, include_private)
+    end
+    
+  protected
+    def method_missing_with_pickle_parser(method, *args, &block)
+      if pickle_parser.respond_to?(method)
+        pickle_parser.send(method, *args, &block)
+      else
+        method_missing_without_pickle_parser(method, *args, &block)
+      end
+    end
+    
+    def pickle_parser=(parser)
+      parser.session = self
+      @pickle_parser = parser
+    end
+    
+    def pickle_parser
+      @pickle_parser or self.pickle_parser = Pickle.parser
+    end
+    
+    def pickle_config
+      pickle_parser.config
+    end
+
+    def convert_models_to_attributes(ar_class, attrs)
+      attrs.each do |key, val|
+        if val.is_a?(ActiveRecord::Base) && ar_class.column_names.include?("#{key}_id")
+          attrs["#{key}_id"] = val.id
+          attrs["#{key}_type"] = val.class.name if ar_class.column_names.include?("#{key}_type")
+          attrs.delete(key)
+        end
+      end
+    end
+    
+    def models_by_name(factory)
+      @models_by_name ||= {}
+      @models_by_name[pickle_parser.canonical(factory)] ||= {}
+    end
+    
+    def models_by_index(factory)
+      @models_by_index ||= {}
+      @models_by_index[pickle_parser.canonical(factory)] ||= []
+    end
+    
+    # if the factory name != the model name, store under both names
+    def store_model(factory, name, record)
+      store_record(record.class.name, name, record) unless pickle_parser.canonical(factory) == pickle_parser.canonical(record.class.name)
+      store_record(factory, name, record)
+    end
+    
+    def store_record(factory, name, record)
+      models_by_name(factory)[name] = record
+      models_by_index(factory) << record
+    end
+  end
+end

data/lib/pickle/version.rb

@@ -0,0 +1,6 @@
+module Pickle
+  module Version
+    String = File.read(File.dirname(File.dirname(__FILE__)) + '/../VERSION').strip
+    Major, Minor, Patch = String.split('.').map{|i| i.to_i}
+  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/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/pickle.gemspec

@@ -0,0 +1,110 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{kbaum-pickle}
+  s.version = "0.2.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ian White"]
+  s.date = %q{2009-12-01}
+  s.description = %q{Easy model creation and reference in your cucumber features}
+  s.email = %q{ian.w.white@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "License.txt",
+     "README.rdoc",
+     "Rakefile",
+     "Todo.txt",
+     "VERSION",
+     "features/app/app.rb",
+     "features/app/blueprints.rb",
+     "features/app/factories.rb",
+     "features/app/views/notifier/email.erb",
+     "features/app/views/notifier/user_email.erb",
+     "features/email/email.feature",
+     "features/generator/generators.feature",
+     "features/path/models_page.feature",
+     "features/path/named_route_page.feature",
+     "features/pickle/create_from_active_record.feature",
+     "features/pickle/create_from_factory_girl.feature",
+     "features/pickle/create_from_machinist.feature",
+     "features/step_definitions/email_steps.rb",
+     "features/step_definitions/extra_email_steps.rb",
+     "features/step_definitions/fork_steps.rb",
+     "features/step_definitions/generator_steps.rb",
+     "features/step_definitions/path_steps.rb",
+     "features/step_definitions/pickle_steps.rb",
+     "features/support/email.rb",
+     "features/support/env.rb",
+     "features/support/paths.rb",
+     "features/support/pickle.rb",
+     "features/support/pickle_app.rb",
+     "garlic.rb",
+     "init.rb",
+     "lib/pickle.rb",
+     "lib/pickle/adapter.rb",
+     "lib/pickle/config.rb",
+     "lib/pickle/email.rb",
+     "lib/pickle/email/parser.rb",
+     "lib/pickle/email/world.rb",
+     "lib/pickle/parser.rb",
+     "lib/pickle/parser/matchers.rb",
+     "lib/pickle/path.rb",
+     "lib/pickle/path/world.rb",
+     "lib/pickle/session.rb",
+     "lib/pickle/session/parser.rb",
+     "lib/pickle/version.rb",
+     "lib/pickle/world.rb",
+     "pickle.gemspec",
+     "rails_generators/pickle/pickle_generator.rb",
+     "rails_generators/pickle/templates/email.rb",
+     "rails_generators/pickle/templates/email_steps.rb",
+     "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/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ianwhite/pickle/tree}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  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/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,40 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    @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')
+      m.directory File.join('features/support')
+      
+      current_pickle = File.exists?('features/support/pickle.rb') ? File.read('features/support/pickle.rb') : ''
+      pickle_assigns = {:pickle_path => false, :pickle_email => false}
+      
+      if @generate_path_steps
+        pickle_assigns[:pickle_path] = true
+        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
+            pickle_assigns[:current_paths_header] = $1
+            pickle_assigns[:current_paths_footer] = $2
+            m.template 'paths.rb', File.join('features/support', 'paths.rb'), :assigns => pickle_assigns, :collision => :force
+          end
+        end
+      end
+      
+      if @generate_email_steps
+        pickle_assigns[:pickle_email] = true
+        m.template 'email_steps.rb', File.join('features/step_definitions', 'email_steps.rb')
+        m.template 'email.rb', File.join('features/support', 'email.rb')
+      end
+
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', 'pickle_steps.rb')      
+      m.template 'pickle.rb', File.join('features/support', 'pickle.rb'), :assigns => pickle_assigns
+    end
+  end
+end

data/rails_generators/pickle/templates/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/rails_generators/pickle/templates/email_steps.rb

@@ -0,0 +1,55 @@
+# 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
+
+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,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.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,73 @@
+# 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|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| create_model(name, hash) }
+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|
+  name = plural_factory.singularize
+  table.hashes.each { |hash| find_model!(name, hash)}
+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|
+  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