judit-pickle 0.4.2

data/features/support/env.rb

@@ -0,0 +1,52 @@
+# 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__) + '/../../cucumber_test_app/config/environment')
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/world'
+require 'cucumber/rails/active_record'
+require 'cucumber/web/tableish'
+
+require 'webrat'
+require 'webrat/core/matchers'
+
+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,47 @@
+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/
+      '/'
+
+    # the following are examples using path_to_pickle
+
+    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
+
+    # 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))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    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/lib/generators/pickle_generator.rb

@@ -0,0 +1,69 @@
+require 'rails/generators'
+
+class PickleGenerator < Rails::Generators::Base
+  desc "Generates Pickle step files."
+
+  # Use the same templates as Rails 2 generator
+  source_root File.expand_path("../../../rails_generators/pickle/templates", __FILE__)
+
+  class_option :paths, :desc => "Generate features/support/paths.rb file.", :type => :boolean
+  class_option :email, :desc => "Generate features/step_definitions/email_steps.rb file", :type => :boolean
+
+  def initialize(args = [], options = {}, config = {})
+    super
+
+    if self.options.paths? && !File.exists?("features/support/paths.rb")
+      say "features/support/paths.rb not found, is your cucumber up to date?", :red
+      exit
+    end
+  end
+
+  def create_directories
+    empty_directory "features/step_definitions"
+    empty_directory "features/support"
+  end
+
+  def copy_pickle_steps_file
+    template "pickle_steps.rb", "features/step_definitions/pickle_steps.rb"
+    template "pickle.rb", "features/support/pickle.rb"
+  end
+
+  def copy_paths_file
+    return unless options.paths?
+
+    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
+        @current_paths_header = $1
+        @current_paths_footer = $2
+      end
+      template "paths.rb", "features/support/paths.rb"
+    end
+  end
+
+  def copy_email_steps_file
+    return unless options.email?
+    template "email_steps.rb", "features/step_definitions/email_steps.rb"
+    template "email.rb", "features/support/email.rb"
+  end
+
+
+  private
+
+  # Compatibility methods for Rails 2 templates
+  def pickle_path
+    options.paths?
+  end
+
+  def pickle_email
+    options.email?
+  end
+
+  def current_paths_header
+    @current_paths_header
+  end
+
+  def current_paths_footer
+    @current_paths_footer
+  end
+end

data/lib/pickle/adapter.rb

@@ -0,0 +1,137 @@
+require 'active_support/core_ext'
+
+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 create(attrs = {})
+      raise NotImplementedError, "create and return an object with the given attributes"
+    end
+
+    if respond_to?(:class_attribute)
+      class_attribute :model_classes
+    else
+      cattr_writer :model_classes
+    end
+
+    self.model_classes = nil
+
+    # Include this module into your ORM adapter
+    # this will register the adapter with pickle and it will be picked up for you
+    # To create an adapter you should create an inner constant "PickleAdapter"
+    #
+    # e.g. ActiveRecord::Base::PickleAdapter
+    #
+    # @see pickle/adapters/active_record
+    # @see pickle/adapters/datamapper
+    # @see pickle/adapters/mongoid
+    module Base
+      def self.included(base)
+        adapters << base
+      end
+
+      # A collection of registered adapters
+      def self.adapters
+        @@adapters ||= []
+      end
+    end
+
+    class << self
+      def factories
+        raise NotImplementedError, "return an array of factory adapter objects"
+      end
+
+      def model_classes
+        @@model_classes ||= self::Base.adapters.map{ |a| a.model_classes }.flatten
+      end
+
+      # Returns the column names for the given ORM model class.
+      def column_names(klass)
+        klass.const_get(:PickleAdapter).column_names(klass)
+      end
+
+      def get_model(klass, id)
+        klass.const_get(:PickleAdapter).get_model(klass, id)
+      end
+
+      def find_first_model(klass, conditions)
+        klass.const_get(:PickleAdapter).find_first_model(klass, conditions)
+      end
+
+      def find_all_models(klass, conditions)
+        klass.const_get(:PickleAdapter).find_all_models(klass, conditions)
+      end
+      
+      def create_model(klass, attributes)
+        klass.const_get(:PickleAdapter).create_model(klass, attributes)
+      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 = {})
+        if @klass.respond_to?('make!')
+          @klass.send(:make!, @blueprint, attrs)
+        else
+          @klass.send(:make, @blueprint, attrs)
+        end
+      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(@name, attrs)
+      end
+    end
+
+    # ORM adapter.  If you have no factory adapter, you can use this adapter to
+    # use your orm as 'factory' - ie create objects
+    class Orm < Adapter
+      def self.factories
+        model_classes.map{|k| new(k)}
+      end
+
+      def initialize(klass)
+        @klass, @name = klass, klass.name.underscore.gsub('/','_')
+      end
+
+      def create(attrs = {})
+        Pickle::Adapter.create_model(@klass, attrs)
+      end
+    end
+  end
+end

data/lib/pickle/adapters/active_record.rb

@@ -0,0 +1,57 @@
+begin
+  require 'activerecord'
+rescue LoadError
+  require 'active_record'
+end
+
+class ActiveRecord::Base
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= [
+        "CGI::Session::ActiveRecordStore::Session",
+        "ActiveRecord::SessionStore::Session"
+      ]
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      begin
+        klasses = ::ActiveRecord::Base.__send__(:descendants) # Rails 3
+      rescue
+        klasses = ::ActiveRecord::Base.__send__(:subclasses) # Rails 2
+      end
+
+      klasses.select do |klass|
+        !klass.abstract_class? && klass.table_exists? && !except_classes.include?(klass.name)
+      end
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.column_names
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.find(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      klass.find(:first, :conditions => conditions)
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      klass.find(:all, :conditions => conditions)
+    end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create!(attributes)
+    end
+  end
+end

data/lib/pickle/adapters/data_mapper.rb

@@ -0,0 +1,42 @@
+require 'dm-core'
+
+module DataMapper::Resource
+  module PickleAdapter
+    include Pickle::Adapter::Base
+
+    # Do not consider these to be part of the class list
+    def self.except_classes
+      @@except_classes ||= []
+    end
+
+    # Gets a list of the available models for this adapter
+    def self.model_classes
+      ::DataMapper::Model.descendants.to_a.select{|k| !except_classes.include?(k.name)}
+    end
+
+    # get a list of column names for a given class
+    def self.column_names(klass)
+      klass.properties.map(&:name)
+    end
+
+    # Get an instance by id of the model
+    def self.get_model(klass, id)
+      klass.get(id)
+    end
+
+    # Find the first instance matching conditions
+    def self.find_first_model(klass, conditions)
+      klass.first(conditions)
+    end
+
+    # Find all models matching conditions
+    def self.find_all_models(klass, conditions)
+      klass.all(conditions)
+    end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create(attributes)
+    end
+  end
+end

data/lib/pickle/adapters/mongoid.rb

@@ -0,0 +1,44 @@
+require 'mongoid'
+
+module Mongoid
+  module Document
+    module PickleAdapter
+      include Pickle::Adapter::Base
+
+      # Do not consider these to be part of the class list
+      def self.except_classes
+        @@except_classes ||= []
+      end
+
+      # Gets a list of the available models for this adapter
+      def self.model_classes
+        ObjectSpace.each_object(Class).to_a.select {|klass| klass.ancestors.include? Mongoid::Document}
+      end
+
+      # get a list of column names for a given class
+      def self.column_names(klass)
+        klass.fields.keys
+      end
+
+      # Get an instance by id of the model
+      def self.get_model(klass, id)
+        klass.find(id)
+      end
+
+      # Find the first instance matching conditions
+      def self.find_first_model(klass, conditions)
+        klass.first(:conditions => conditions)
+      end
+
+      # Find all models matching conditions
+      def self.find_all_models(klass, conditions)
+        klass.all(:conditions => conditions)
+      end
+
+      # Create a model with given attributes
+      def self.create_model(klass, attributes)
+        klass.create!(attributes)
+      end
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -0,0 +1,49 @@
+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, :orm]
+    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 =~ /\?$/} + Pickle::Adapter.column_names(k)
+      end.flatten.uniq
+    end
+
+    class Mapping < Struct.new(:search, :replacement)
+    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 << Mapping.new(search, 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,77 @@
+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
+
+    def visit_in_email(email, link_text)
+      visit(parse_email_for_link(email, link_text))
+    end
+
+    def click_first_link_in_email(email)
+      link = links_in_email(email).first
+      visit link
+    end
+
+  protected
+    def open_in_browser(path) # :nodoc
+      require "launchy"
+      Launchy::Browser.run(path)
+    rescue LoadError
+      warn "Sorry, you need to install launchy to open emails: `gem install launchy`"
+    end
+
+    # 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 = "pickle-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
+
+    def parse_email_for_link(email, text_or_regex)
+      url = parse_email_for_explicit_link(email, text_or_regex)
+      url ||= parse_email_for_anchor_text_link(email, text_or_regex)
+      raise "No link found matching #{text_or_regex.inspect} in #{email}" unless url
+      url
+    end
+
+    # e.g. confirm in http://confirm
+    def parse_email_for_explicit_link(email, regex)
+      regex = /#{Regexp.escape(regex)}/ unless regex.is_a?(Regexp)
+      links_in_email(email).detect { |link| link =~ regex }
+    end
+
+    # e.g. Click here in  <a href="http://confirm">Click here</a>
+    def parse_email_for_anchor_text_link(email, link_text)
+      if match_data = email.encoded.match(%r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>})
+        match_data[1]
+      end
+    end
+
+    def links_in_email(email, protos=['http', 'https'])
+      URI.extract(email.encoded.to_s, protos)
+    end
+
+  end
+end