mrflip-pickle 0.1.13

data/History.txt

@@ -0,0 +1,147 @@
+== 0.1.13 - 16 June 2009
+
+* 2 minor enhancements
+  * model! and created_model! raise an error if pickle name can't be found
+  * path_to_pickle uses the above to give back a better error message
+
+
+== 0.1.12 - 7 Apr 2009
+
+* 2 minor enhancements
+  * rationalised Rakefile
+  * update World extensions for latest cucumber changes
+
+
+== 0.1.11 - 22 Feb 2009
+
+* 2 minor enhancements
+  * Pickle now supports multiple machinist blueprints
+  * Fix confusing adapter/adaptor comment generator comment 
+
+
+== 0.1.10 - 13 Feb 2009
+
+* 2 minor enhancements
+  * Made pickle paths generator compatible with latest cucumber
+  * Simplified and Rakefile, including auto push api docs to gh-pages on ci build
+
+
+== 0.1.9 - 29 Jan 2009
+
+* 1 minor enhancement
+  * Pickle::Adapter.model_classes excludes those without tables
+
+
+== 0.1.8 - 29 Jan 2009
+
+* API change
+  * pickle_path becomes path_to_pickle, to avoid named route clashes
+
+* 2 minor enhancements
+  * Updated features for cucumber 0.2 compat
+  * Made paths allow for optional possesives
+
+
+== 0,1,7
+
+* 2 API changes
+  * script/generate pickle path[s] now amends the features/support/paths.rb file
+    instead of creating pge_to_path and path_steps.
+    
+  * pickle_email_steps is renamed email_steps
+
+
+== 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
+  * 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/README.rdoc

@@ -0,0 +1,202 @@
+= pickle
+
+Pickle gives you cucumber steps that create your models easily from factory-girl or
+machinist factories/blueprints.  You can also just use ActiveRecord but it's not as cool.
+
+References to the models are stored, not necessarily for the purpose of checking the db
+(although you could use it for that), but for enabling easy reference to urls, and for
+building complex givens which require a bunch of models collaborating
+
+== CI
+
+It's tested against all stable branches of 2.x rails, and edge, with the latest versions of rspec, cucumber, factory_girl, machinist.
+
+== Install
+
+Install pickle either as a rails plugin, or a gem
+
+  # plugin
+  script/plugin install git://github.com/ianwhite/pickle.git
+  
+  # or, plugin as submodule
+  git submodule add git://github.com/ianwhite/pickle.git vendor/plugins/pickle
+
+  # or, gem
+  sudo gem install ianwhite-pickle
+  
+== Get Started
+
+(you'd better install cucumber)
+
+  script/generate pickle [paths] [email]
+
+Now have a look at <tt>features/step_definitions/pickle_steps.rb</tt>
+
+If you want path steps and email steps then just add 'paths' and/or 'email'.  The code/steps will be
+written to <tt>features/env/paths.rb</tt> and
+<tt>features/step_definitions/email_steps.rb</tt> respectively.
+
+=== Using with plain ole Active Record
+
+If you have an AR called 'Post', with required fields 'title', and 'body', then you can now write 
+steps like this
+
+  Given a post exists with title: "My Post", body: "My body"
+
+=== Using with factory-girl or machinist
+
+But you're using Machinist or FactoryGirl right?!  To leverage all of the factories/blueprints
+you've written, you can just do stuff like
+
+  Given a user exists
+  And another user exists with role: "admin"
+
+  # later
+  Then a user should exist with name: "Fred"
+  And that user should be activated # this uses rspec predicate matchers
+
+==== Machinst: require your blueprints and reset Shams
+
+(The latest version of pickle supports {multiple blueprints}[http://github.com/notahat/machinist/commit/d6492e6927a8aa1819926e48b22377171fd20496], for 
+earlier versions of machinist use pickle <= 0.1.10)
+
+In your <tt>features/support/env.rb</tt> add the following lines at the bottom
+
+  require "#{Rails.root}/spec/blueprints" # or wherever they live
+  Before { Sham.reset } # reset Shams in between scenarios
+
+=== Configuring Pickle
+
+You can tell pickle to use another factory adapter (see Pickle::Adapter), or
+create mappings from english expressions to pickle model names.  You can also
+override many of the options on the Pickle::Config object if you so choose 
+
+  require 'pickle/world'
+
+  Pickle.configure do |config|
+    config.adapters = [:machinist, YourOwnAdapterClass]
+    config.map 'me', 'myself', 'my', 'I', :to => 'user: "me"'
+  end
+
+== API
+
+=== Steps
+
+When you run <tt>script/generate pickle</tt> you get the following steps
+
+==== Given steps
+
+"Given <b>a model</b> exists",  e.g.
+
+  Given a user exists
+  Given a user: "fred" exists
+  Given the user exists
+  
+"Given <b>a model</b> exists with <b>fields</b>",  e.g.
+
+  Given a user exists with name: "Fred"
+  Given a user exists with name: "Fred", activated: false
+  
+You can refer to other models in the fields
+
+  Given a user exists
+  And a post exists with author: the user
+  
+  Given a person: "fred" exists
+  And a person: "ethel" exists
+  And a fatherhood exists with parent: user "fred", child: user "ethel"
+  
+"Given <b>n</b> models exist", e.g.
+  
+  Given 10 users exist
+  
+"Given <b>n</b> <b>models</b> exist with <b>fields</b>", examples:
+
+  Given 10 users exist with activated: false
+
+==== Then steps
+
+===== Asserting existence of models
+
+"Then <b>a model</b> should exist",  e.g.
+
+  Then a user should exist
+
+"Then <b>a model</b> should exist with <b>fields</b>", e.g.
+
+  Then a user: "fred" should exist with name: "Fred" # we can label the found user for later use
+  
+You can use other models, booleans, numerics, and strings as fields
+
+  Then a person should exist with child: person "ethel"
+  Then a user should exist with activated: false
+  Then a user should exist with activated: true, email: "fred@gmail.com"
+  
+"Then <b>n</b> <b>models</b> should exist", e.g.
+
+  Then 10 events should exist
+  
+"Then <b>n</b> <b>models</b> should exist with <b>fields</b>", e.g.
+
+  Then 2 people should exist with father: person "fred"
+  
+===== Asserting associations
+
+One-to-one assocs: "Then <b>a model</b> should be <b>other model</b>'s <b>association</b>", e.g.
+
+  Then the person: "fred" should be person: "ethel"'s father
+  
+Many-to-one assocs: "Then <b>a model</b> should be [in|one of] <b>other model</b>'s <b>association</b>", e.g.
+
+  Then the person: "ethel" should be one of person: "fred"'s children
+  Then the comment should be in the post's comments
+  
+===== Asserting predicate methods
+
+"Then <b>a model</b> should [be|have] [a|an] <b>predicate</b>", e.g.
+
+  Then the user should have a status # => user.status?.should == true
+  Then the car: "batmobile" should be fast # => car.fast?.should == true
+  
+"Then <b>a model</b> should [be|have] [a|an] <b>predicate</b>", e.g.
+
+  Then person: "fred" should not be childless # => fred.childless?.should == false
+  
+=== Regexps for use in your own steps
+
+By default you get some regexps available in the main namespace for use
+in creating your own steps: `capture_model`, `capture_fields`, and others (see lib/pickle.rb)
+
+(You can use any of the regexps that Pickle uses by using the Pickle.parser namespace, see
+Pickle::Parser::Matchers for the methods available)
+
+*capture_model*
+
+  Given /^#{capture_model} exists$/ do |model_name|
+    model(model_name).should_not == nil
+  end
+
+  Then /^I should be at the (.*?) page$/ |page|
+    if page =~ /#{capture_model}'s/
+      url_for(model($1))
+    else
+      # ...
+    end
+  end
+
+  Then /^#{capture_model} should be one of #{capture_model}'s posts$/ do |post, forum|
+    model(forum).posts.should include(post)
+  end 
+
+*capture_fields*
+
+This is useful for setting attributes, and knows about pickle model names so that you
+can build up composite objects with ease
+
+  Given /^#{capture_model} exists with #{capture_fields}$/ do |model_name, fields|
+    create_model(model_name, fields)
+  end
+
+  # example of use
+  Given a user exists
+  And a post exists with author: the user # this step will assign the above user as :author on the post

data/Todo.txt

@@ -0,0 +1,4 @@
+* Add email_for (same concept as path_to)
+* fix problem with save_and_open_emails
+* Translations
+* Investigate using Treetop for pre-parsing

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

@@ -0,0 +1,87 @@
+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
+      # remove abstract, framework, and non-table classes
+      @@model_classes ||= ::ActiveRecord::Base.send(:subclasses).reject do |klass|
+        klass.abstract_class? || !klass.table_exists? ||
+         (defined?(CGI::Session::ActiveRecordStore::Session) && klass == CGI::Session::ActiveRecordStore::Session) ||
+         (defined?(::ActiveRecord::SessionStore::Session) && klass == ::ActiveRecord::SessionStore::Session)
+      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
+        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