schlick-pickle 0.1.5.1

data/History.txt

@@ -0,0 +1,71 @@
+== edge
+
+* 1 major enhancement
+  * generate page steps with script/generate pickle page
+    page 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
+
+* 3 minor enhancements
+  * Improved documentation
+  * absract models no longer kill pickle
+  * Actually test that the generators work
+
+== 0.1.5
+
+* API change
+  * CaptureModel, etc are now 'capture_model' methods
+
+* 3 major enhancements
+  * Steps for asserting that <n> models exist, matching certain criteria
+  * Steps for asserting associations added to generated pickle steps
+      'Then the user should be in the post's commenters'
+      'Then the forum: "awesome" should be the 2nd post's forum'
+  * configuration can now occur any time before a step is defined, which makes
+    for much more intuitive env.rb
+
+* 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
+  * You can create multiple models with ease, for eg.
+      'Given 10 users exist with role: "admin"'
+
+* 1 minor enhancement
+  * You can do Pickle.configure (just like Webrat.configure)
+
+
+== 0.1.3 - Bugfix release
+
+* 1 minor enhancement
+  * make generated steps compatible with Rails 2.1
+
+
+== 0.1.2
+
+* 2 major enhancements
+  * create your pickle steps with script/generate pickle
+  * Adapter based architecture, supports Machinist, FactoryGirl, and vanilla ActiveRecord
+  
+* 1 minor enhancement
+  * model_names now defaults to subclasses of AR::Base
+  * #original_model => #created_model
+
+
+== 0.1.1
+
+* 1 major enhancement:
+  * made pickle a github gem
+
+* 1 minor enhancement:
+  * Added intentions for pickle in README.textile
+
+
+== Prior to gems
+
+* Initial release: everything is subject to sweeping change

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2009 Ian White - ian.w.white@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/pickle/adapter.rb

@@ -0,0 +1,85 @@
+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
+      @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).reject do |klass|
+        klass.abstract_class? || [CGI::Session::ActiveRecordStore::Session].include?(klass)
+      end
+    end
+  
+    # machinist adapter
+    class Machinist < Adapter
+      def self.factories
+        factories = []
+        model_classes.each do |klass|
+          factories << new(klass, "make") if klass.instance_variable_get('@blueprint')
+          # if there are make_<special> methods, add blueprints for them
+          klass.methods.select{|m| m =~ /^make_/ && m !~ /_unsaved$/}.each do |method|
+            factories << new(klass, method)
+          end
+        end
+        factories
+      end
+      
+      def initialize(klass, method)
+        @klass, @method = klass, method
+        @name = (@method =~ /make_/ ? "#{@method.sub('make_','')}_" : "") + @klass.name.underscore.gsub('/','_')
+      end
+      
+      def create(attrs = {})
+        @klass.send(@method, 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, :replace => options[:to])
+      end
+    end
+  end
+end

data/lib/pickle/injector.rb

@@ -0,0 +1,18 @@
+module Pickle
+  module Injector
+    def self.inject(delegate_class, options = {})
+      target_class  = options[:into] || raise('inject requires a target class specified with :into')
+      delegate_name = options[:name] || delegate_class.name.underscore.gsub('/','_')
+      init_delegate = options[:init] || lambda { new }
+      
+      # create a session object on demand (in target)
+      target_class.send(:define_method, delegate_name) do
+        instance_variable_get("@#{delegate_name}") || instance_variable_set("@#{delegate_name}", delegate_class.instance_eval(&init_delegate))
+      end
+      
+      # in the target, delegate the public instance methods of delegate_class to the delegate_name method
+      delegate_methods = delegate_class.public_instance_methods - Object.instance_methods
+      target_class.delegate *(delegate_methods + [{:to => delegate_name}])
+    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
+        '(?:(?:1|a|an|another|the|that) )'
+      end
+  
+      def match_quoted
+        '(?:[^\\"]|\\.)*'
+      end
+  
+      def match_label
+        "(?::? \"#{match_quoted}\")"
+      end
+
+      def match_value
+        "(?:\"#{match_quoted}\"|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.sub(/\?$/,'').gsub('_','[_ ]')}.join('|')})"
+      end
+      
+      # create capture analogues of match methods
+      instance_methods.select{|m| m =~ /^match_/}.each do |method|
+        eval <<-end_eval                   
+          def #{method.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/with_session.rb

@@ -0,0 +1,24 @@
+module Pickle
+  class Parser
+    # add ability to parse model names as fields, using a session
+    module WithSession
+      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    
+    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 '', /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.replace
+      end
+    end
+  end
+end

data/lib/pickle/session.rb

@@ -0,0 +1,109 @@
+module Pickle
+  class Session
+    def initialize(options = {})
+      self.parser = options[:parser] || Pickle.parser
+      @config = parser.config
+    end
+
+    def create_model(a_model_name, fields = nil)
+      factory, label = *parser.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))
+      store_model(factory, label, record)
+    end
+
+    def find_model(a_model_name, fields = nil)
+      factory, name = *parser.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)))
+        store_model(factory, name, record)
+      end
+    end
+    
+    def find_models(factory, fields = nil)
+      models_by_index(factory).clear
+      model_class = config.factories[factory].klass
+      records = model_class.find(:all, :conditions => convert_models_to_attributes(model_class, parser.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 = *parser.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 "model: #{name} does not refer to known model 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
+    
+    # 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
+    
+  protected
+    attr_reader :parser, :config
+    delegate :canonical, :to => :parser
+  
+    def parser=(parser)
+      parser.session = self
+      @parser = parser
+    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[canonical(factory)] ||= {}
+    end
+    
+    def models_by_index(factory)
+      @models_by_index ||= {}
+      @models_by_index[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 canonical(factory) == 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,9 @@
+module Pickle
+  module Version
+    Major = 0
+    Minor = 1
+    Tiny  = 5
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+end

data/lib/pickle.rb

@@ -0,0 +1,39 @@
+require 'active_support'
+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/page'
+
+# make the parser aware of models in the session (for fields refering to models)
+Pickle::Parser.send :include, Pickle::Parser::WithSession
+
+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
+
+# shortcuts to regexps for use in step definition regexps, *and* in steps
+delegations = %w(capture_model capture_fields capture_factory capture_plural_factory capture_predicate)
+(class << self; self; end).delegate *(delegations + [{:to => 'Pickle.parser'}])
+Pickle::Session.delegate *(delegations + [{:to => :parser}])
+
+# 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
+  ActionController::Integration::Session.send :include, Pickle::Page
+end

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,23 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    @generate_page_steps = args.include?('page')
+    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')
+      
+      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
+      end
+      
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', "pickle_steps.rb")
+      m.template 'page_steps.rb', File.join('features/step_definitions', "page_steps.rb") if @generate_page_steps
+    end
+  end
+end

data/rails_generators/pickle/templates/env.rb

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

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