ianwhite-pickle 0.1.5 → 0.1.6

data/History.txt

@@ -1,3 +1,39 @@
+== 0.1.6
+
+* 1 API change
+  * to use pickle env.rb should contain "require 'pickle/world'".  You should remove all trace of
+    pickle from features/support/env.rb and re run script/generate pickle
+
+* 2 major enhancements
+
+  * generate email steps with `script/generate pickle email`
+    email steps allow you to do things like this:
+    
+      Then 2 emails should be delivered
+      And the first email should be delivered to fred@gmail.com
+      And the 2nd email should be delivered to the user: "ethel"
+      
+      Then 1 email should be delivered with subject: "Activate your account"
+      And the email should link to the user's page
+    
+    take a look at features/step_definitions/pickle_email_steps.rb
+      
+  * generate path steps with `script/generate pickle path`
+    path steps allow you to do things like this
+    
+      When I go to the comment's page
+      Then I should be at the user's new comment page
+    
+    take a look at features/step_definitions/pickle_path_steps.rb, and modify page_to_path to suit your needs
+
+* 4 minor enhancements
+  * Improved documentation
+  * abstract models no longer kill pickle
+  * Actually test that the generators work
+  * Made Pickle::Session a plain ole mixin, as a separate class was unnecessary
+  * Pickle uses the cucumber World API
+
+
 == 0.1.5
 
 * API change
@@ -11,11 +47,12 @@
   * configuration can now occur any time before a step is defined, which makes
     for much more intuitive env.rb
 
-* 1 minor enhancement
+* 2 minor enhancement
   * predicate matching is less prone to step conflicts because we preload a 
     big list of all the predicate and column methods
   * field values now handle booleans and numerics
 
+
 == 0.1.4
 
 * 1 major enhancement

data/Todo.txt

@@ -0,0 +1,2 @@
+* Translations
+* Investigate using Treetop for pre-parsing

data/lib/pickle/adapter.rb

@@ -23,8 +23,11 @@ module Pickle
     self.model_classes = nil
     
     def self.model_classes
-      @@model_classes ||= returning(::ActiveRecord::Base.send(:subclasses)) do |classes|
-        defined?(CGI::Session::ActiveRecordStore::Session) && classes.delete(CGI::Session::ActiveRecordStore::Session)
+      # remove abstract and framework classes
+      @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).reject do |klass|
+        klass.abstract_class? ||
+         (defined?(CGI::Session::ActiveRecordStore::Session) && klass == CGI::Session::ActiveRecordStore::Session) ||
+         (defined?(::ActiveRecord::SessionStore::Session) && klass == ::ActiveRecord::SessionStore::Session)
       end
     end
   

data/lib/pickle/config.rb

@@ -25,14 +25,10 @@ module Pickle
         factories.merge(adapter.factories.inject({}){|h, f| h.merge(f.name => f)})
       end
     end
-
-    def factory_names
-      factories.keys
-    end
     
     def predicates
-      @predicates ||= Pickle::Adapter.model_classes.map do |klass|
-        klass.public_instance_methods.select{|m| m =~ /\?$/} + klass.column_names
+      @predicates ||= Pickle::Adapter.model_classes.map do |k|
+        k.public_instance_methods.select{|m| m =~ /\?$/} + k.column_names
       end.flatten.uniq
     end
     
@@ -44,8 +40,9 @@ module Pickle
     def map(*args)
       options = args.extract_options!
       raise ArgumentError, "Usage: map 'search' [, 'search2', ...] :to => 'replace'" unless args.any? && options[:to].is_a?(String)
-      search = args.size == 1 ? args.first.to_s : "(?:#{args.join('|')})"
-      self.mappings << OpenStruct.new(:search => search, :replace => options[:to])
+      args.each do |search|
+        self.mappings << OpenStruct.new(:search => search, :replace => 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,17 @@
+require 'pickle'
+require 'pickle/email'
+require 'pickle/email/parser'
+
+# add email parser expressions
+Pickle::Parser.send :include, Pickle::Email::Parser
+
+# make world pickle/email aware
+World do |world|
+  world.extend Pickle::Email
+  world
+end
+
+# 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

@@ -10,7 +10,7 @@ module Pickle
       end
   
       def match_prefix
-        '(?:(?:1|a|an|another|the|that) )'
+        '(?:(?:a|an|another|the|that) )'
       end
   
       def match_quoted
@@ -34,15 +34,15 @@ module Pickle
       end
   
       def match_mapping
-        config.mappings.any? ? "(?:#{config.mappings.map(&:search).join('|')})" : ""
+        "(?:#{config.mappings.map(&:search).join('|')})"
       end
   
       def match_factory
-        "(?:#{config.factory_names.map{|n| n.gsub('_','[_ ]')}.join('|')})"
+        "(?:#{config.factories.keys.map{|n| n.gsub('_','[_ ]')}.join('|')})"
       end
       
       def match_plural_factory
-        "(?:#{config.factory_names.map{|n| n.pluralize.gsub('_','[_ ]')}.join('|')})"
+        "(?:#{config.factories.keys.map{|n| n.pluralize.gsub('_','[_ ]')}.join('|')})"
       end
       
       def match_indexed_model

data/lib/pickle/parser.rb

@@ -34,7 +34,7 @@ module Pickle
     
     # returns really underscored name
     def canonical(str)
-      str.to_s.gsub(' ','_').underscore
+      str.to_s.underscore.gsub(' ','_').gsub('/','_')
     end
     
     # return [factory_name, name or integer index]
@@ -49,9 +49,9 @@ module Pickle
   
     def parse_index(index)
       case index
-      when '', /last/ then -1
+      when nil, '', 'last' then -1
       when /#{capture_number_in_ordinal}/ then $1.to_i - 1
-      when /first/ then 0
+      when 'first' then 0
       end
     end
 

data/lib/pickle/path/world.rb

@@ -0,0 +1,8 @@
+require 'pickle'
+require 'pickle/path'
+
+# make world pickle/path aware
+World do |world|
+  world.extend Pickle::Path
+  world
+end

data/lib/pickle/path.rb

@@ -0,0 +1,44 @@
+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
+    #
+    #   pickle_path 'the user', :action => 'edit'       # => /users/3/edit
+    #   pickle_path 'the user', 'the comment'           # => /users/3/comments/1
+    #   pickle_path '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
+    #
+    #   pickle_path 'the user', :extra => 'new comment' # => /users/3/comments/new
+    def pickle_path(*pickle_names)
+      options = pickle_names.extract_options!
+      models = pickle_names.map{|m| model(m)}
+      if options[:extra]
+        parts = options[:extra].underscore.gsub(' ','_').split("_")
+        find_pickle_path_using_action_segment_combinations(models, parts)
+      else
+        pickle_path_for_models_action_segment(models, 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(models, 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_models_action_segment(models, action, segment) and break
+      end
+      path
+    end
+    
+    def pickle_path_for_models_action_segment(models, action, segment)
+      action.blank? or action = action.downcase.gsub(' ','_')
+      segment.blank? or segment = segment.downcase.gsub(' ','_')
+      model_names = models.map{|m| m.class.name.underscore}.join("_")
+      parts = [action, model_names, segment].reject(&:blank?)
+      send("#{parts.join('_')}_path", *models) rescue nil
+    end
+  end
+end

data/lib/pickle/{parser/with_session.rb → session/parser.rb}

@@ -1,7 +1,7 @@
 module Pickle
-  class Parser
+  module Session
     # add ability to parse model names as fields, using a session
-    module WithSession
+    module Parser
       def self.included(parser_class)
         parser_class.alias_method_chain :parse_field, :model
       end

data/lib/pickle/session.rb

@@ -1,45 +1,56 @@
 module Pickle
-  class Session
-    def initialize(options = {})
-      self.parser = options[:parser] || Pickle.parser
-      @config = parser.config
+  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 = *parser.parse_model(a_model_name)
+      factory, label = *parse_model(a_model_name)
       raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
-      record = config.factories[factory].create(parser.parse_fields(fields))
+      record = pickle_config.factories[factory].create(parse_fields(fields))
       store_model(factory, label, record)
     end
 
     def find_model(a_model_name, fields = nil)
-      factory, name = *parser.parse_model(a_model_name)
+      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 = config.factories[factory].klass
-      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parser.parse_fields(fields)))
+      model_class = pickle_config.factories[factory].klass
+      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
         store_model(factory, name, record)
       end
     end
     
     def find_models(factory, fields = nil)
-      model_class = config.factories[factory].klass
-      records = model_class.find(:all, :conditions => convert_models_to_attributes(model_class, parser.parse_fields(fields)))
+      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
-    
-    def clear_models(factory)
-      models_by_name(factory).clear
-      models_by_factory(factory).clear
-    end
       
     # return the original model stored by create_model or find_model
     def created_model(name)
-      factory, name_or_index = *parser.parse_model(name)
+      factory, name_or_index = *parse_model(name)
       
       if name_or_index.blank?
-        models_by_factory(factory).last
+        models_by_index(factory).last
       elsif name_or_index.is_a?(Integer)
-        models_by_factory(factory)[name_or_index]
+        models_by_index(factory)[name_or_index]
       else
         models_by_name(factory)[name_or_index] or raise "model: #{name} does not refer to known model in this scenario"
       end
@@ -62,7 +73,7 @@ module Pickle
     
     # return all original models of specified type
     def created_models(factory)
-      models_by_factory(factory)
+      models_by_index(factory)
     end
       
     # return all models of specified type (freshly selected from the database)
@@ -70,14 +81,32 @@ module Pickle
       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
-    attr_reader :parser, :config
-  
-    def parser=(parser)
+    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
-      @parser = parser
+      @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")
@@ -90,23 +119,23 @@ module Pickle
     
     def models_by_name(factory)
       @models_by_name ||= {}
-      @models_by_name[factory] ||= {}
+      @models_by_name[pickle_parser.canonical(factory)] ||= {}
     end
     
-    def models_by_factory(factory)
-      @models_by_factory ||= {}
-      @models_by_factory[factory] ||= []
+    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(parser.canonical(record.class.name), name, record) if parser.canonical(record.class.name) != factory
+      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_factory(factory) << record
+      models_by_index(factory) << record
     end
   end
 end

data/lib/pickle/version.rb

@@ -2,7 +2,7 @@ module Pickle
   module Version
     Major = 0
     Minor = 1
-    Tiny  = 5
+    Tiny  = 6
     
     String = [Major, Minor, Tiny].join('.')
   end

data/lib/pickle/world.rb

@@ -0,0 +1,12 @@
+require 'pickle'
+
+# make cucumber world pickle aware
+World do |world|
+  world.extend Pickle::Session
+  world
+end
+
+# 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

@@ -3,12 +3,11 @@ require 'pickle/version'
 require 'pickle/adapter'
 require 'pickle/config'
 require 'pickle/parser'
-require 'pickle/parser/with_session'
 require 'pickle/session'
-require 'pickle/injector'
+require 'pickle/session/parser'
 
 # make the parser aware of models in the session (for fields refering to models)
-Pickle::Parser.send :include, Pickle::Parser::WithSession
+Pickle::Parser.send :include, Pickle::Session::Parser
 
 module Pickle
   class << self
@@ -24,14 +23,4 @@ module Pickle
       @parser ||= Parser.new({:config => config}.merge(options))
     end
   end
-end
-
-# inject the pickle session into integration session if we have one (TODO: inject into merb etc?)
-if defined?(ActionController::Integration::Session)
-  Pickle::Injector.inject Pickle::Session, :into => ActionController::Integration::Session
-end
-
-# shortcuts to regexps for use in step definitions
-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

@@ -1,19 +1,32 @@
 class PickleGenerator < Rails::Generator::Base
-  def initialize(*args)
-    super(*args)
+  def initialize(args, options)
+    super(args, options)
+    @generate_path_steps = args.include?('page') || args.include?('path')
+    @generate_email_steps = args.include?('email')
     File.exists?('features/support/env.rb') or raise "features/support/env.rb not found, try running script/generate cucumber"
   end
   
   def manifest
     record do |m|
       m.directory File.join('features/step_definitions')
-      m.template 'pickle_steps.rb', File.join('features/step_definitions', "pickle_steps.rb")
+      
       current_env = File.read('features/support/env.rb')
-      if current_env.include?("require 'pickle'")
-        logger.skipped "features/support/env.rb, as it already requires pickle"
-      else
-        m.template 'env.rb', File.join('features/support', "env.rb"), :assigns => {:current_env => current_env}, :collision => :force
+      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'")
+        m.template 'pickle_path_steps.rb', File.join('features/step_definitions', "pickle_path_steps.rb") 
+      end
+      
+      if @generate_email_steps
+        env_assigns[:pickle_email] = true unless current_env.include?("require 'pickle/email/world'")
+        m.template 'pickle_email_steps.rb', File.join('features/step_definitions', "pickle_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/env.rb

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

data/rails_generators/pickle/templates/pickle_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 (.+) page$/) do |email_ref, page|
+  email(email_ref).body.should =~ /#{page_to_path(page)}/
+end
+
+Then(/^show me the emails?$/) do
+   save_and_open_emails
+end

data/rails_generators/pickle/templates/pickle_path_steps.rb

@@ -0,0 +1,53 @@
+# this file generated by script/generate pickle page.
+# You should edit the page_to_path method below for your own app's needs
+
+# When I go to /sessions/new
+When(/^I go to \/(.+?)$/) do |path|
+  visit "/#{path}"
+end
+
+# Then I should be at /sessions/new
+Then(/^I should be at \/(.+?)$/) do |path|
+  request.path.should =~ /^\/#{path}/
+end
+
+# When I go to the posts's new comment page
+When(/^I go to (.+?) page$/) do |page|
+  visit page_to_path(page)
+end
+
+# Then I should be at the posts's new comment page
+Then(/^I should be at (.+?) page$/) do |page|
+  request.path.should =~ /^#{page_to_path(page)}/
+end
+
+# passed a string like 'the home', returns a path
+def page_to_path(page)
+  case page
+  # add your own app-specific mappings, e.g.
+  #
+  # when 'the home'
+  #   '/'
+  #
+  # when /$#{capture_model}'s activation^/
+  #   activation_by_code_path(created_model($1).activation_code)
+    
+  when /^#{capture_model}'s$/                           # the forum's
+    pickle_path $1
+    
+  when /^#{capture_model}'s #{capture_model}'s$/        # the forum's post's
+    pickle_path $1, $2
+
+  when /^#{capture_model}'s #{capture_model}'s (.+?)$/  # the forum's post's comments
+    pickle_path $1, $2, :extra => $3
+
+  when /^#{capture_model}'s (.+?)$/                     # the post's comments
+    pickle_path $1, :extra => $2
+
+  when /^the (.+?)$/                                    # the new session
+    send "#{$1.downcase.gsub(' ','_')}_path"
+    
+  else
+    raise "Could not map '#{page}' page to a path"
+  end
+end