paged_scopes 0.1.0 → 0.1.1

data/README.textile

@@ -193,6 +193,60 @@ page_articles GET /pagina/:page_id/articles(.:format) {:controller=>"articles",
 
 (This is likely only to be useful in rare situations. One example would be paginating more than one collection in a single view.)
 
+A more complex example:
+
+<pre>
+map.resources :articles, :collection => { :published => :get }, :paged => true
+</pre>
+
+Which would produce these paged routes:
+
+<pre>
+published_page_articles GET /pages/:page_id/articles/published(.:format) {:controller=>"articles", :action=>"published"}
+          page_articles GET /pages/:page_id/articles(.:format)           {:controller=>"articles", :action=>"index"}
+</pre>
+
+By default paged routes are generated for the <code>:index</code> action and any <code>:collection</code> actions that specify the <code>:get</code> method. To override the default behaviour, simply be explicit about which paged routes are required:
+
+<pre>
+map.resources :articles, :collection => { :published => :get }, :paged => { :published => true }   
+</pre>
+
+Which would produce only this paged route:
+
+<pre>
+published_page_articles GET /pages/:page_id/articles/published(.:format) {:controller=>"articles", :action=>"published"}
+</pre>
+
+Another complex example:
+
+<pre>
+map.resources :articles, :collection => { :published => :get }, :paged => { :index => true, :published => { :as => :pagina } }
+</pre>
+
+Which would produce these paged routes:
+
+<pre>
+published_page_articles GET /pagina/:page_id/articles/published(.:format) {:controller=>"articles", :action=>"published"}
+          page_articles GET /pages/:page_id/articles(.:format)            {:controller=>"articles", :action=>"index"}
+</pre>
+
+In fact, the <code>:as</code> and <code>:name</code> options specified in the root of the <code>:paged</code> will be used for all paged routes where an alternative is not specified.
+
+<pre>
+map.resources :users, :collection => { :active => :get, :blocked => :get, :online => :get }, :paged => { :as => "pagina", :index => true, :active => { :name => "group" }, :blocked => { :as => "blacklist" } }
+</pre>
+
+Which would produce these three paged routes:
+
+<pre>
+blocked_page_users GET /blacklist/:page_id/users/blocked(.:format) {:controller=>"users", :action=>"blocked"}
+active_group_users GET /pagina/:group_id/users/active(.:format)    {:controller=>"users", :action=>"active"}
+        page_users GET /pagina/:page_id/users(.:format)            {:controller=>"users", :action=>"index"}
+</pre>
+
+Notice that there is no paged route for the <code>:online</code> collection action.
+
 h2. Controller Methods
 
 OK, so we have our pages represented in our article index route. Let's turn to the articles controller next.
@@ -456,14 +510,14 @@ h2. Get It!
 You can install the PagedScopes gem as follows:
 
 <pre>
-gem sources -a http://gems.github.com # just once
-sudo gem install mholling-paged_scopes
+gem sources -a http://gemcutter.org # just once
+sudo gem install paged_scopes
 </pre>
 
 And in your <code>config/environment.rb</code>, if you're on Rails:
 
 <pre>
-config.gem "mholling-paged_scopes", :lib => "paged_scopes", :source => "http://gems.github.com"
+config.gem "paged_scopes", :source => "http://gemcutter.org"
 </pre>
 
 Peruse the code at "GitHub":http://github.com/mholling/paged_scopes.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 0
 :major: 0
 :minor: 1
+:patch: 1

data/history.txt

@@ -0,0 +1,5 @@
+PagedScopes Revision History
+ 
+Version 0.1.1
+* Added this revision history.
+* Added ability to generate paged routes for other collection actions (Matthew Gibbons, Matthew Hollingworth).

data/lib/paged_scopes/resources.rb

@@ -2,16 +2,36 @@ module PagedScopes
   module Resources
     def resources_with_paged(*entities, &block)
       options = entities.extract_options!
-      if page_options = options.delete(:paged)
-        resources_without_paged(*(entities.dup << options), &block)
-        page_options = {} unless page_options.is_a? Hash
-        page_name = page_options.delete(:name)
-        page_options.slice!(:as, :name)
-        page_options.merge!(:only => :none)
-        preserved_options = ActionController::Resources::INHERITABLE_OPTIONS + [ :name_prefix, :path_prefix ]
-        with_options(options.slice(*preserved_options)) do |map|
-          map.resources_without_paged(page_name || :pages, page_options) do |page|
-            page.resources(*(entities.dup << { :only => :index }))
+
+      if paged_options = options.delete(:paged)
+        resources_without_paged(*(entities.dup << options), &block)        
+        
+        paged_options = {} unless paged_options.is_a? Hash
+        paged_as = paged_options.delete(:as)
+        paged_name = paged_options.delete(:name)
+        
+        if paged_options.empty?
+          unless (options[:only] && ![ options[:only] ].flatten.include?(:index)) || (options[:except] && [ options[:except] ].flatten.include?(:index))
+            paged_options[:index] = true
+          end
+          options[:collection].each { |collection, methods| paged_options[collection] = true if [ methods ].flatten.include? :get } if options[:collection]
+        end
+
+        paged_options.each_pair do |action, page_options|
+          page_options = {} unless page_options.is_a? Hash
+          page_options.reverse_merge! :name => paged_name unless paged_name.blank?
+          page_options.reverse_merge! :as => paged_as unless paged_as.blank?
+          page_options.merge! :only => :none
+          
+          preserved_options = ActionController::Resources::INHERITABLE_OPTIONS + [ :name_prefix, :path_prefix ]
+          
+          with_options(options.slice(*preserved_options)) do |map|
+            map.resources_without_paged(page_options.delete(:name) || :pages, page_options) do |page|
+              entities_options = action == :index ?
+                { :only => :index, :as => options[:as] } :
+                { :only => :none,  :as => options[:as], :collection => { action => :get } }
+              page.resources(*(entities.dup << entities_options))
+            end
           end
         end
       else

data/paged_scopes.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{paged_scopes}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matthew Hollingworth"]
-  s.date = %q{2009-10-10}
+  s.date = %q{2009-10-23}
   s.email = %q{mdholling@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
      "README.textile",
      "Rakefile",
      "VERSION.yml",
+     "history.txt",
      "lib/paged_scopes.rb",
      "lib/paged_scopes/collection.rb",
      "lib/paged_scopes/context.rb",

data/spec/resources_spec.rb

@@ -17,6 +17,16 @@ describe "Resources" do
     drawing_routes { |map| map.resources :articles, :paged => true }.should change { number_of_routes }.by(7+1)
   end
   
+  it "should not add a paged index route if the index action is excluded by an :only option" do
+    drawing_routes { |map| map.resources :articles, :paged => true, :only => :show }.should change { number_of_routes }.by(1+0)
+    drawing_routes { |map| map.resources :memberships, :paged => true, :only => [ :show, :edit ] }.should change { number_of_routes }.by(2+0)
+  end
+  
+  it "should not add a paged index route if the index action is excluded by an :except option" do
+    drawing_routes { |map| map.resources :articles, :paged => true, :except => :index }.should change { number_of_routes }.by(6+0)
+    drawing_routes { |map| map.resources :memberships, :paged => true, :except => [ :index, :new ] }.should change { number_of_routes }.by(5+0)
+  end
+  
   context "with a :paged options" do    
     it "should map a paged index route for GET only" do
       draw_routes { |map| map.resources :articles, :paged => true }
@@ -51,7 +61,7 @@ describe "Resources" do
       recognise_path(:get, "/groups/1/articles").should == { :controller => "articles", :action => "index", :group_id => "1" }
     end
     
-    it "should accept a :path_prefix hash as the :paged option" do
+    it "should accept a :name_prefix option in the paged route" do
       draw_routes { |map| map.resources :articles, :paged => true, :name_prefix => "baz_" }
       named_routes.names.should include(:baz_page_articles)
     end
@@ -69,4 +79,83 @@ describe "Resources" do
       end
     end
   end
+  
+  context "with extra collection routes" do
+    # TODO: test for :index in :except...?
+    context "and an overall :paged option" do
+      it "should map a paged route if the collection action is GET" do
+        drawing_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true }.should change { number_of_routes }.by(8+2)
+      end
+    
+      it "should map a paged route if the collection action includes GET" do
+        drawing_routes { |map| map.resources :memberships, :collection => { :paid => [ :get, :put ] }, :paged => true }.should change { number_of_routes }.by(9+2)
+      end
+    
+      it "should not map a paged route if the collection action is not GET" do
+        drawing_routes { |map| map.resources :memberships, :collection => { :paid => :put }, :paged => true }.should change { number_of_routes }.by(8+1)
+      end
+    
+      it "should not map a paged route if the collection action does not include GET" do
+        drawing_routes { |map| map.resources :memberships, :collection => { :paid => [ :put, :delete ] }, :paged => true }.should change { number_of_routes }.by(9+1)
+      end
+    
+      it "should map a paged collection route for a GET method only" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true }
+        recognise_path(   :get, "/pages/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :page_id => "1" }
+        recognise_path(   :put, "/pages/1/memberships/paid").should be_nil
+        recognise_path(  :post, "/pages/1/memberships/paid").should be_nil
+        recognise_path(:delete, "/pages/1/memberships/paid").should be_nil
+      end
+
+      it "should add a named route for the paged collection route" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true }
+        named_routes.names.should include(:paid_page_memberships)
+        # TODO: this should maybe be page_paid_memberships?
+      end
+
+      it "should observe the :path_prefix option in the paged route" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true, :path_prefix => "foo" }
+        recognise_path(:get, "/foo/pages/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :page_id => "1" }
+      end
+
+      it "should observe a :namespace option in the paged route" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true, :namespace => "bar/" }
+        recognise_path(:get, "/pages/1/memberships/paid").should == { :controller => "bar/memberships", :action => "paid", :page_id => "1" }
+      end
+
+      it "should accept an :as option in the :paged option" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => { :as => "page" } }
+        recognise_path(:get, "/page/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :page_id => "1" }
+      end
+
+      it "should accept a :name option in the :paged option" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => { :name => :groups } }
+        recognise_path(:get, "/groups/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :group_id => "1" }
+      end
+
+      it "should accept a :name_prefix option in the paged route" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => true, :name_prefix => "baz_" }
+        named_routes.names.should include(:paid_baz_page_memberships)
+        # TODO: this should maybe be baz_page_paid_memberships?
+      end
+    end
+    
+    context "and a per-collection :paged options hash" do
+      it "should add a paged route for each :get collection with a corresponding entry in the :paged hash" do
+        drawing_routes { |map| map.resources :memberships, :collection => { :paid => :get, :unpaid => :get }, :paged => { :index => true, :paid => true } }.should change { number_of_routes }.by(9+2)
+      end
+
+      it "should accept an :as option in the :paged options hash" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => { :index => true, :paid => { :as => "page" } } }
+        recognise_path(:get, "/pages/1/memberships").should == { :controller => "memberships", :action => "index", :page_id => "1" }
+        recognise_path(:get, "/page/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :page_id => "1" }
+      end
+
+      it "should accept a :name option in the :paged options hash" do
+        draw_routes { |map| map.resources :memberships, :collection => { :paid => :get }, :paged => { :index => true, :paid => { :name => :groups } } }
+        recognise_path(:get, "/pages/1/memberships").should == { :controller => "memberships", :action => "index", :page_id => "1" }
+        recognise_path(:get, "/groups/1/memberships/paid").should == { :controller => "memberships", :action => "paid", :group_id => "1" }
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: paged_scopes
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Matthew Hollingworth
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-10 00:00:00 +11:00
+date: 2009-10-23 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,6 +38,7 @@ files:
 - README.textile
 - Rakefile
 - VERSION.yml
+- history.txt
 - lib/paged_scopes.rb
 - lib/paged_scopes/collection.rb
 - lib/paged_scopes/context.rb