ianwhite-pickle 0.1.6 → 0.1.8

data/History.txt

@@ -1,3 +1,22 @@
+== 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

data/lib/pickle/path.rb

@@ -3,15 +3,15 @@ module Pickle
     # 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
+    #   path_to_pickle 'the user', :action => 'edit'       # => /users/3/edit
+    #   path_to_pickle 'the user', 'the comment'           # => /users/3/comments/1
+    #   path_to_pickle '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)
+    #   path_to_pickle 'the user', :extra => 'new comment' # => /users/3/comments/new
+    def path_to_pickle(*pickle_names)
       options = pickle_names.extract_options!
       models = pickle_names.map{|m| model(m)}
       if options[:extra]

data/lib/pickle/version.rb

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

data/rails_generators/pickle/pickle_generator.rb

@@ -1,9 +1,11 @@
 class PickleGenerator < Rails::Generator::Base
   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"
+    @generate_email_steps = args.include?('email')
+    if @generate_path_steps = args.include?('path') || args.include?('paths')
+      File.exists?('features/support/paths.rb') or raise "features/support/paths.rb not found, is your cucumber up to date?"
+    end
   end
   
   def manifest
@@ -15,12 +17,19 @@ class PickleGenerator < Rails::Generator::Base
       
       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") 
+        current_paths = File.read('features/support/paths.rb')
+        unless current_paths.include?('#{capture_model}')
+          if current_paths =~ /^(.*)(\n\s+else\n\s+raise ".*"\n\s+end\nend\s*)$/m
+            env_assigns[:current_paths_header] = $1
+            env_assigns[:current_paths_footer] = $2
+            m.template 'paths.rb', File.join('features/support', "paths.rb"), :assigns => env_assigns, :collision => :force
+          end
+        end
       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") 
+        m.template 'email_steps.rb', File.join('features/step_definitions', "email_steps.rb") 
       end
       
       env_assigns[:pickle] = true unless current_env.include?("require 'pickle/world'")

data/rails_generators/pickle/templates/{pickle_email_steps.rb → email_steps.rb}

@@ -41,8 +41,8 @@ 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)}/
+Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
+  email(email_ref).body.should =~ /#{path_to(page)}/
 end
 
 Then(/^show me the emails?$/) do

data/rails_generators/pickle/templates/env.rb

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

data/rails_generators/pickle/templates/paths.rb

@@ -0,0 +1,20 @@
+<%= current_paths_header %>
+  # added by script/generate pickle path
+  
+  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
+
+  when /^the (.+?) page$/                                         # translate to named route
+    send "#{$1.downcase.gsub(' ','_')}_path"
+  
+  # end added by pickle path
+<%= current_paths_footer %>

data/spec/lib/pickle_path_spec.rb

@@ -7,52 +7,52 @@ describe Pickle::Path do
     stub!(:model).and_return(@user = mock_model(User))
   end
   
-  describe "#pickle_path" do
+  describe "#path_to_pickle" do
     it "('a user', 'the user: \"fred\"') should retrieve 'a user', and 'the user: \"fred\"' models" do
       should_receive(:model).with('a user')
       should_receive(:model).with('the user: "fred"')
       stub!(:user_user_path).and_return('the path')
-      pickle_path 'a user', 'the user: "fred"'
+      path_to_pickle 'a user', 'the user: "fred"'
     end
     
     it "('a user', :action => 'foo') should return foo_user_path(<user>)" do
       should_receive(:foo_user_path).with(@user).and_return('the path')
-      pickle_path('a user', :action => 'foo').should == 'the path'
+      path_to_pickle('a user', :action => 'foo').should == 'the path'
     end
     
     it "('a user', :action => 'foo') should raise informative error if foo_user_path not defined" do
       should_receive(:foo_user_path).with(@user).and_raise(NoMethodError)
-      lambda { pickle_path('a user', :action => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+      lambda { path_to_pickle('a user', :action => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
     end
     
     it "('a user', :segment => 'foo') should return user_foo_path(<user>)" do
       should_receive(:user_foo_path).with(@user).and_return('the path')
-      pickle_path('a user', :segment => 'foo').should == 'the path'
+      path_to_pickle('a user', :segment => 'foo').should == 'the path'
     end
     
     it "('a user', :segment => 'foo') should raise informative error if foo_user_path not defined" do
       should_receive(:user_foo_path).with(@user).and_raise(NoMethodError)
-      lambda { pickle_path('a user', :segment => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+      lambda { path_to_pickle('a user', :segment => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
     end
     
     it "('a user', :action => 'new', :segment => 'comment') should return new_user_comment_path(<user>)" do
       should_receive(:new_user_comment_path).with(@user).and_return('the path')
-      pickle_path('a user', :segment => 'comment', :action => 'new').should == 'the path'
+      path_to_pickle('a user', :segment => 'comment', :action => 'new').should == 'the path'
     end
     
     it "('a user', :action => 'new', :segment => 'comment') should raise informative error if new_user_comment_path not defined" do
       should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
-      lambda { pickle_path('a user', :action => 'new', :segment => 'comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      lambda { path_to_pickle('a user', :action => 'new', :segment => 'comment') }.should raise_error(Exception, /Could not figure out a path for/)
     end
     
     it "('a user', :extra => 'new comment') should return new_user_comment_path(<user>)" do
       should_receive(:new_user_comment_path).with(@user).and_return('the path')
-      pickle_path('a user', :extra => 'new comment').should == 'the path'
+      path_to_pickle('a user', :extra => 'new comment').should == 'the path'
     end
     
     it "('a user', :extra => 'new comment') should raise informative error if new_user_comment_path not defined" do
       should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
-      lambda { pickle_path('a user', :extra => 'new comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      lambda { path_to_pickle('a user', :extra => 'new comment') }.should raise_error(Exception, /Could not figure out a path for/)
     end
     
     describe "(private API)" do
@@ -61,7 +61,7 @@ describe Pickle::Path do
         should_receive(:pickle_path_for_models_action_segment).with([@user], 'new', 'ish_comment').once
         should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish', 'comment').once
         should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish_comment', '').once
-        lambda { pickle_path('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
+        lambda { path_to_pickle('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ianwhite-pickle
 version: !ruby/object:Gem::Version 
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors: 
 - Ian White
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-24 00:00:00 -08:00
+date: 2009-01-29 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -37,9 +37,9 @@ files:
 - lib/pickle/world.rb
 - lib/pickle.rb
 - rails_generators/pickle/pickle_generator.rb
+- rails_generators/pickle/templates/email_steps.rb
 - rails_generators/pickle/templates/env.rb
-- rails_generators/pickle/templates/pickle_email_steps.rb
-- rails_generators/pickle/templates/pickle_path_steps.rb
+- rails_generators/pickle/templates/paths.rb
 - rails_generators/pickle/templates/pickle_steps.rb
 - License.txt
 - README.textile

data/rails_generators/pickle/templates/pickle_path_steps.rb

@@ -1,53 +0,0 @@
-# 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