pickle-has_many_support 0.3.1

data/features/step_definitions/generator_steps.rb

@@ -0,0 +1,46 @@
+Before('@gen') do
+  `mv #{Rails.root}/features/ #{Rails.root}/features.orig/ > /dev/null 2>&1`
+end
+
+After('@gen') do
+  `rm -rf #{Rails.root}/features`
+  `mv #{Rails.root}/features.orig/ #{Rails.root}/features/ > /dev/null 2>&1`
+end
+
+Given(/^cucumber has been freshly generated$/) do
+  `cd #{Rails.root}; script/generate cucumber -f --webrat`
+end
+
+Given(/^pickle path email has been freshly generated$/) do
+  `cd #{Rails.root}; script/generate -f pickle paths email`
+end
+
+Given(/^env\.rb already requires (.+)$/) do |file|
+  File.open("#{Rails.root}/features/support/env.rb", "a") do |env|
+    env << "require '#{file}'\n"
+  end
+end
+
+When(/^I run "(.*)"$/) do |command|
+  @output = `cd #{Rails.root}; #{command}`
+end
+
+Then(/^I should see "(.*)"$/) do |text|
+  @output.should include(text)
+end
+
+Then(/^the file (.+?) should exist$/) do |file|
+  File.exist?("#{Rails.root}/#{file}").should == true
+end
+
+Then(/^the file (.+?) should match \/(.*?)\/$/) do |file, regexp|
+  File.read("#{Rails.root}/#{file}").should match(/#{regexp}/m)
+end
+
+Then(/^the file (.+?) should not match \/(.*?)\/$/) do |file, regexp|
+  File.read("#{Rails.root}/#{file}").should_not match(/#{regexp}/m)
+end
+
+Then /^the file ([^ ]+) should be identical to the local (.+)$/ do |generated_file, source_file|
+  File.read("#{Rails.root}/#{generated_file}").should == File.read("#{File.dirname(__FILE__)}/../#{source_file}")
+end

data/features/step_definitions/path_steps.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+Then(/^(.+?) should match route \/(.+?)$/) do |page, route|
+  regexp = route.gsub(/:(\w*?)id/,'\d+')
+  path_to(page).should =~ /#{regexp}/
+end
+
+When(/^I go to (.+)$/) do |page|
+  visit path_to(page)
+end
+
+Then(/^I should be at (.+)$/) do |page|
+  request.path.should =~ /#{path_to(page)}/
+end

data/features/step_definitions/pickle_steps.rb

@@ -0,0 +1,100 @@
+# 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|
+  create_models_from_table(plural_factory, table)
+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|
+  find_models_from_table(plural_factory, table).should_not be_any(&: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 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|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# model.attribute.should eql(value)
+# model.attribute.should_not eql(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub(' ', '_')
+  
+  case expected
+  when 'nil', 'true', 'false'
+    actual_value.send(expectation, send("be_#{expected}"))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    actual_value.send(expectation, eql(expected.to_f))
+  else
+    actual_value.to_s.send(expectation, eql(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  model!(name).send(association).size.should == size.to_i
+end

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,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/pickle/adapter.rb

@@ -0,0 +1,127 @@
+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 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
+    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
+    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
+        ::ActiveRecord::Base::PickleAdapter.model_classes.map{|k| new(k)}
+      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/adapters/active_record.rb

@@ -0,0 +1,46 @@
+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
+      ::ActiveRecord::Base.__send__(:subclasses).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
+  end
+end

data/lib/pickle/adapters/data_mapper.rb

@@ -0,0 +1,37 @@
+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
+  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 =~ /\?$/} + Pickle::Adapter.column_names(k)
+      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