mholling-paged_scopes 0.0.3 → 0.0.4

data/VERSION.yml

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

data/lib/paged_scopes/controller.rb

@@ -1,24 +1,40 @@
 module PagedScopes
   module Controller
-    def get_page_for(collection_name, options = {})
-      callback_method = "get_page_for_#{collection_name}"
-      define_method callback_method do
-        collection = instance_variable_get("@#{collection_name.to_s.pluralize}")
-        raise RuntimeError, "no @#{collection_name.to_s.pluralize} collection was set" unless collection
-        object = instance_variable_get("@#{collection_name.to_s.singularize}")
-        collection.per_page = options[:per_page] if options[:per_page]
-        collection.page_name = options[:name] if options[:name]
-        page = collection.pages.from_params!(params) || (object && collection.pages.find_by_object(object)) || collection.pages.first
-        page.paginator.set_path { |pg| send(options[:path], pg) } if options[:path]
-        instance_variable_set("@#{collection.pages.name.underscore}", page)
+    module ClassMethods
+      def get_page_for(collection_name, options = {})
+        callback_method = "get_page_for_#{collection_name}"
+        define_method callback_method do
+          collection = instance_variable_get("@#{collection_name.to_s.pluralize}")
+          raise RuntimeError, "no @#{collection_name.to_s.pluralize} collection was set" unless collection
+          object = instance_variable_get("@#{collection_name.to_s.singularize}")
+          instance_variable_set("@#{collection.pages.name.underscore}", page_for(collection, object, options))
+        end
+        protected callback_method
+        before_filter callback_method, options.except(:per_page, :name, :path)
+      end
+    end
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.rescue_responses.update('PagedScopes::PageNotFound' => :not_found)
+    end
+    
+    def page_for(collection, *args, &block)
+      options = args.extract_options!
+      collection.per_page = options[:per_page] if options[:per_page]
+      collection.page_name = options[:name] if options[:name]
+      object = args.first
+      returning collection.pages.find_by_object(object) || collection.pages.from_params!(params) || collection.pages.first do |page|
+        if options[:path]
+          page.paginator.set_path { |pg| send(options[:path], pg) }
+        elsif block_given?
+          page.paginator.set_path(&block)
+        end
       end
-      protected callback_method
-      before_filter callback_method, options.except(:per_page, :name, :path)
     end
   end
 end
 
 if defined? ActionController::Base
-  ActionController::Base.extend PagedScopes::Controller
-  ActionController::Base.rescue_responses.update('PagedScopes::PageNotFound' => :not_found)
+  ActionController::Base.send :include, PagedScopes::Controller
 end

data/lib/paged_scopes/index.rb

@@ -1,62 +1,39 @@
 module PagedScopes
   module Index
     def index_of(object)
-      find_scope = scope(:find) || {}
-      primary_key_attribute = "#{table_name}.#{primary_key}"
-      
-      order_attributes = find_scope[:order].to_s.split(',').map(&:strip)
-      order_operators = order_attributes.inject({}) do |hash, order_attribute|
-        operator = order_attribute.slice!(/\s+(desc|DESC)$/) ? ">" : "<"
-        order_attribute.slice!(/\s+(asc|ASC)$/)
-        hash.merge(order_attribute => operator)
-      end
-      unless order_attributes.include? primary_key_attribute
-        order_operators[primary_key_attribute] = "<"
-        order_attributes << primary_key_attribute
+      columns = scope(:find, :order).to_s.split(',').map(&:strip) << "#{table_name}.#{primary_key}"
+      operators = columns.map do |column|
+        column.slice!(/\s+(asc|ASC)$/)
+        column.slice!(/\s+(desc|DESC)$/) ? ">" : "<"
       end
       
-      attribute_selects = returning([]) do |selects|
-        order_attributes.each_with_index do |order_attribute, n|
-          selects << "#{order_attribute} AS order_attribute_#{n}"
-        end
-      end.join(', ')
+      attributes = (1..columns.size).map { |n| "attribute_#{n}" }
       
-      order_attribute_options = { :select => attribute_selects }
-      order_attribute_options.merge!(:offset => 0) if find_scope[:offset]
-      object_with_order_attributes = find(object.id, order_attribute_options)
-
-      object_order_attributes = {}
-      order_attributes.each_with_index do |order_attribute, n|
-        object_order_attributes[order_attribute] = object_with_order_attributes.send("order_attribute_#{n}")
-      end
+      selects = [ columns, attributes ].transpose.map do |column, attribute|
+        "#{column} AS #{attribute}"
+      end.unshift("#{table_name}.*").join(', ')
+      
+      options = { :select => selects }
+      options.merge!(:offset => 0) if scope(:find, :limit) && scope(:find, :offset)
+      object_with_attributes = find(object.id, options)
 
-      order_conditions = order_attributes.reverse.inject([ "", {}, 0 ]) do |args, order_attribute|
-        string, hash, n = args
-        symbol = "s#{n}".to_sym
+      values = attributes.map { |attribute| object_with_attributes.send(attribute) }
+      
+      string, hash = "", {}
+      [ columns, operators, attributes, values ].transpose.reverse.each do |column, operator, attribute, value|
         string = string.blank? ?
-          "#{order_attribute} #{order_operators[order_attribute]} #{symbol.inspect}" :
-          "#{order_attribute} #{order_operators[order_attribute]} #{symbol.inspect} OR (#{order_attribute} = #{symbol.inspect} AND (#{string}))"
-        hash.merge!(symbol => object_order_attributes[order_attribute])
-        [ string, hash, n + 1 ]
+          "#{column} #{operator} :#{attribute}" :
+          "#{column} #{operator} :#{attribute} OR (#{column} = :#{attribute} AND (#{string}))"
+        hash.merge!(attribute.to_sym => value)
       end
-      order_conditions.pop
-
-      # order_conditions = order_attributes.reverse.inject([]) do |conditions, order_attribute|
-      #   if conditions.empty?
-      #     conditions = [ "#{order_attribute} #{order_operators[order_attribute]} ?", object_order_attributes[order_attribute] ]
-      #   else
-      #     conditions[0] = "#{order_attribute} #{order_operators[order_attribute]} ? OR (#{order_attribute} = ? AND (#{conditions[0]}))"
-      #     conditions.insert 1, object_order_attributes[order_attribute]
-      #     conditions.insert 1, object_order_attributes[order_attribute]
-      #   end
-      # end
       
-      count_options = { :conditions => order_conditions, :distinct => true }
-      count_options.merge!(:offset => 0) if find_scope[:offset]
-      before_count = count(primary_key_attribute, count_options)
-      if find_scope[:limit]
-        before_count -= find_scope[:offset] if find_scope[:offset]
-        raise ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{object.id}" if before_count < 0 || before_count >= find_scope[:limit]
+      options = { :conditions => [ string, hash ], :distinct => true }
+      options.merge!(:offset => 0) if scope(:find, :limit) && scope(:find, :offset)
+      before_count = count("#{table_name}.#{primary_key}", options)
+      
+      if scope(:find, :limit)
+        before_count -= scope(:find, :offset) if scope(:find, :limit) && scope(:find, :offset)
+        raise ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{object.id}" if before_count < 0 || before_count >= scope(:find, :limit)
       end
       
       before_count

data/lib/paged_scopes/pages.rb

@@ -138,7 +138,7 @@ module PagedScopes
     end
     
     def ==(other)
-      number == other.number
+      other.is_a?(self.class) && number == other.number
     end
     
     def full?

data/lib/paged_scopes/paginator.rb

@@ -23,27 +23,18 @@ module PagedScopes
     end
 
     def window(options)
-      results = []
       size = options[:size]
       extras = [ options[:extras] ].flatten.compact
       raise ArgumentError, "No window block supplied." unless block_given?
-      return if @page.page_count < 2
-      if @page.number - size > 1
-        results << yield(:first, @path.call(@page.class.first)) if extras.include? :first
-        if extras.include?(:previous) && offset_page = @page.offset(-2 * size - 1)
-          results << yield(:previous, @path.call(offset_page))
+      returning [] do |results|
+        results << yield(:first, @page.first? ? nil : @path.call(@page.class.first)) if extras.include?(:first)
+        results << yield(:previous, @page.first? ? nil : @path.call(@page.previous)) if extras.include?(:previous)
+        (-size..size).map { |offset| @page.offset(offset) }.compact.each do |page|
+          results << yield(page, @path.call(page))
         end
-      end
-      (-size..size).map { |offset| @page.offset(offset) }.compact.each do |page|
-        results << yield( page, @path.call(page))
-      end
-      if @page.number + size < @page.page_count
-        if extras.include?(:next) && offset_page = @page.offset(2 * size + 1)
-          results << yield(:next, @path.call(offset_page))
-        end
-        results << yield(:last, @path.call(@page.class.last)) if extras.include? :last
-      end
-      results.join("\n")
+        results << yield(:next, @page.last? ? nil : @path.call(@page.next)) if extras.include?(:next)
+        results << yield(:last, @page.last? ? nil : @path.call(@page.class.last)) if extras.include?(:last)
+      end.join("\n")
     end
   end
 end

data/spec/controller_spec.rb

@@ -3,12 +3,76 @@ require 'spec_helper'
 describe "Controller" do
   
   context "class" do
+    it "should raise 404 on PagedScopes::PageNotFound" do
+      Class.new(ActionController::Base).rescue_responses['PagedScopes::PageNotFound'].should == :not_found
+    end
+  end
+    
+  context "instance using #page_for" do
     before(:each) do
       @class = Class.new(ActionController::Base)
+      @controller = @class.new
+      @articles = User.first.articles
+      @articles.per_page = 3
     end
 
-    it "should raise 404 on PagedScopes::PageNotFound" do
-      @class.rescue_responses['PagedScopes::PageNotFound'].should == :not_found
+    it "should default to the first page of the collection" do
+      in_controller @controller do
+        page_for(@articles).should == @articles.pages.first
+      end
+    end
+    
+    it "should find the page from a page id in the params" do
+      in_controller @controller do
+        @articles.pages.each do |page|
+          stub!(:params).and_return(:page_id => page.id)
+          page_for(@articles).should == page
+        end
+      end
+    end
+    
+    it "should find the page containing an object if specified" do
+      in_controller @controller do
+        @articles.each do |article|
+          # page_for(@articles, article).should == @articles.pages.find_by_article(article)
+          page_for(@articles, article).articles.all.should include(article)
+        end
+      end
+    end
+    
+    it "should set per_page on the collection if specified" do
+      in_controller @controller do
+        page_for(@articles, :per_page => 4)
+        @articles.per_page.should == 4
+      end
+    end
+    
+    it "should set the page model name on the collection if specified" do
+      in_controller @controller do
+        page_for(@articles, :name => "Group")
+        @articles.page_name.should == "Group"
+      end
+    end
+    
+    it "should set the pagination path proc if specified using a :path option" do
+      in_controller @controller do
+        @page = page_for(@articles, :path => :page_articles_path)
+        self.should_receive(:page_articles_path).with(@page.next)
+        @page.paginator.next
+      end
+    end
+    
+    it "should set the pagination path proc if specified with a block" do
+      in_controller @controller do
+        @page = page_for(@articles) { |page| "path/to/page/#{page.to_param}" }
+        @page.paginator.next.should == "path/to/page/#{@page.next.to_param}"
+      end
+    end
+  end
+  
+  context "class using #get_page_for" do
+    before(:each) do
+      @class = Class.new(ActionController::Base)
     end
     
     it "should add a protected get_page_for callback as a before filter when get_page_for is called" do
@@ -24,54 +88,69 @@ describe "Controller" do
       @filter.options.keys.should_not include(:per_page, :name, :path)
       @filter.options.keys.should include(:only, :if)
     end
-    
   end
-    
-  context "instance" do
+  
+  context "instance using get_page_for in the controller class" do
     before(:each) do
-      @controller = Class.new(ActionController::Base) do
-        get_page_for :articles
-      end.new
+      @class = Class.new(ActionController::Base)
+      @class.get_page_for :articles, :per_page => 3
+      @controller = @class.new
     end
-
+    
     it "should raise an error if no collection is set" do
       in_controller @controller do
         lambda { get_page_for_articles }.should raise_error(RuntimeError)
       end      
     end
+    
+    it "should pass :per_page, :name and :path options on to the call to #page_for" do
+      @options = { :per_page => 3, :name => "Group", :path => :page_articles_path }
+      @class.get_page_for :articles, @options
+      @controller = @class.new
+      in_controller @controller do
+        @articles = User.first.articles
+        self.should_receive(:page_for).with(@articles, nil, @options)
+        get_page_for_articles
+      end
+    end
 
-    context "when the collection is set" do
+    context "when the collection is set before the filter is run" do
       before(:each) do
         in_controller @controller do
           @articles = User.first.articles
-          @articles.per_page = 3
         end
       end
     
-      it "should get the page from a page id in the params" do
+      it "should get the page from the collection object if set as an instance variable" do
         in_controller @controller do
+          @articles.each do |article|
+            @article = article
+            get_page_for_articles
+            @page.articles.should include(@article)
+          end
+        end
+      end
+      
+      it "should get the page from the params if a collection object is not set or is a new record" do
+        in_controller @controller do
+          @articles.per_page = 3
           stub!(:params).and_return(:page_id => @articles.pages.last.id)
-          get_page_for_articles
-          @page.should == @articles.pages.last
+          [ nil, Article.new ].each do |article|
+            @article = article
+            get_page_for_articles
+            @page.should == @articles.pages.last
+          end
         end
       end
 
       it "should raise PageNotFound if the page id in the params is not in range" do
         in_controller @controller do
+          @articles.per_page = 3
           stub!(:params).and_return(:page_id => @articles.pages.last.id + 1)
           lambda { get_page_for_articles }.should raise_error(PagedScopes::PageNotFound)
         end
       end
-  
-      it "should otherwise get the page from the current object if no page id is present in the params" do 
-        in_controller @controller do
-          @article = @articles.last
-          get_page_for_articles
-          @page.should == @articles.pages.find_by_article(@article)
-          @page.articles.should include(@article)
-        end
-      end
-          
+                
       it "should get the first page if the current object is a new record" do
         in_controller @controller do
           @article = @articles.new
@@ -80,7 +159,7 @@ describe "Controller" do
         end
       end
           
-      it "should otherwise get the first page" do
+      it "should otherwise default to the first page" do
         in_controller @controller do
           get_page_for_articles
           @page.should == @articles.pages.first
@@ -88,48 +167,159 @@ describe "Controller" do
       end
     end
   end
-  
-  context "instance when :per_page is specified in the call to #get_page_for" do
-    it "should set per_page on the collection" do
-      @controller = Class.new(ActionController::Base) do
-        get_page_for :articles, :per_page => 3
-      end.new
-      in_controller @controller do
-        @articles = User.first.articles
-        @articles.per_page = nil
-        get_page_for_articles
-        @articles.per_page.should == 3
-        @articles.pages.per_page.should == 3
-      end
-    end
-  end
-  
-  context "instance when :name is specified in the call to #get_page_for" do
-    it "should set page_name on the collection" do
-      @controller = Class.new(ActionController::Base) do
-        get_page_for :articles, :per_page => 3, :name => "Group"
-      end.new
-      in_controller @controller do
-        @articles = User.first.articles
-        get_page_for_articles
-        @articles.page_name.should == "Group"
-        @articles.pages.name.should == "Group"
-      end
-    end
-  end
-    
-  context "instance when :path is specified in the call to #get_page_for" do
-    it "should set page's pagination path to the specified controller method" do
-      @controller = Class.new(ActionController::Base) do
-        get_page_for :articles, :per_page => 3, :path => :page_articles_path
-      end.new
-      in_controller @controller do
-        @articles = User.first.articles
-        @article = @articles.first
-        get_page_for_articles
-        self.should_receive(:page_articles_path).with(@page.next)
-        @page.paginator.next
-      end
-    end
-  end
 end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# require 'spec_helper'
+# 
+# describe "Controller" do
+#   
+#   context "class" do
+#     before(:each) do
+#       @class = Class.new(ActionController::Base)
+#     end
+# 
+#     it "should raise 404 on PagedScopes::PageNotFound" do
+#       @class.rescue_responses['PagedScopes::PageNotFound'].should == :not_found
+#     end
+#     
+#     it "should add a protected get_page_for callback as a before filter when get_page_for is called" do
+#       @class.get_page_for :articles
+#       @class.before_filters.map(&:to_s).should include("get_page_for_articles")
+#       @class.protected_instance_methods.map(&:to_s).should include("get_page_for_articles")
+#     end
+#     
+#     it "should pass filter options except for :per_page, :name and :path on to the before filter" do
+#       @options = { :per_page => 3, :name => "Group", :path => :page_articles_path, :only => [ :index, :show ], :if => :test }
+#       @class.get_page_for :articles, @options
+#       @filter = @class.filter_chain.detect { |filter| filter.method.to_s == "get_page_for_articles" }
+#       @filter.options.keys.should_not include(:per_page, :name, :path)
+#       @filter.options.keys.should include(:only, :if)
+#     end
+#     
+#   end
+#     
+#   context "instance" do
+#     before(:each) do
+#       @controller = Class.new(ActionController::Base) do
+#         get_page_for :articles
+#       end.new
+#     end
+# 
+#     it "should raise an error if no collection is set" do
+#       in_controller @controller do
+#         lambda { get_page_for_articles }.should raise_error(RuntimeError)
+#       end      
+#     end
+# 
+#     context "when the collection is set" do
+#       before(:each) do
+#         in_controller @controller do
+#           @articles = User.first.articles
+#           @articles.per_page = 3
+#         end
+#       end
+#     
+#       it "should get the page from a page id in the params" do
+#         in_controller @controller do
+#           stub!(:params).and_return(:page_id => @articles.pages.last.id)
+#           get_page_for_articles
+#           @page.should == @articles.pages.last
+#         end
+#       end
+# 
+#       it "should raise PageNotFound if the page id in the params is not in range" do
+#         in_controller @controller do
+#           stub!(:params).and_return(:page_id => @articles.pages.last.id + 1)
+#           lambda { get_page_for_articles }.should raise_error(PagedScopes::PageNotFound)
+#         end
+#       end
+#   
+#       it "should otherwise get the page from the current object if no page id is present in the params" do 
+#         in_controller @controller do
+#           @article = @articles.last
+#           get_page_for_articles
+#           @page.should == @articles.pages.find_by_article(@article)
+#           @page.articles.should include(@article)
+#         end
+#       end
+#           
+#       it "should get the first page if the current object is a new record" do
+#         in_controller @controller do
+#           @article = @articles.new
+#           get_page_for_articles
+#           @page.should == @articles.pages.first
+#         end
+#       end
+#           
+#       it "should otherwise get the first page" do
+#         in_controller @controller do
+#           get_page_for_articles
+#           @page.should == @articles.pages.first
+#         end
+#       end
+#     end
+#   end
+#   
+#   context "instance when :per_page is specified in the call to #get_page_for" do
+#     it "should set per_page on the collection" do
+#       @controller = Class.new(ActionController::Base) do
+#         get_page_for :articles, :per_page => 3
+#       end.new
+#       in_controller @controller do
+#         @articles = User.first.articles
+#         @articles.per_page = nil
+#         get_page_for_articles
+#         @articles.per_page.should == 3
+#         @articles.pages.per_page.should == 3
+#       end
+#     end
+#   end
+#   
+#   context "instance when :name is specified in the call to #get_page_for" do
+#     it "should set page_name on the collection" do
+#       @controller = Class.new(ActionController::Base) do
+#         get_page_for :articles, :per_page => 3, :name => "Group"
+#       end.new
+#       in_controller @controller do
+#         @articles = User.first.articles
+#         get_page_for_articles
+#         @articles.page_name.should == "Group"
+#         @articles.pages.name.should == "Group"
+#       end
+#     end
+#   end
+#     
+#   context "instance when :path is specified in the call to #get_page_for" do
+#     it "should set page's pagination path to the specified controller method" do
+#       @controller = Class.new(ActionController::Base) do
+#         get_page_for :articles, :per_page => 3, :path => :page_articles_path
+#       end.new
+#       in_controller @controller do
+#         @articles = User.first.articles
+#         @article = @articles.first
+#         get_page_for_articles
+#         self.should_receive(:page_articles_path).with(@page.next)
+#         @page.paginator.next
+#       end
+#     end
+#   end
+# end

data/spec/page_spec.rb

@@ -4,7 +4,7 @@ describe "Pages" do
   in_contexts do
     before(:each) do
       @pages = @articles.pages
-      @per_page = 3
+      @per_page = 2
       @articles.stub!(:per_page).and_return(@per_page)
       @articles.stub!(:page_name).and_return("Page")
     end
@@ -128,7 +128,7 @@ describe "Pages" do
     before(:each) do
       @articles = Article.scoped(:conditions => { :title => "Supercalifragilisticexpialidocious" })
       @articles.all.should be_empty
-      @articles.per_page = 3
+      @articles.per_page = 2
     end
     
     it "should have one page" do
@@ -149,7 +149,7 @@ describe "Page instance" do
   in_contexts do
     before(:each) do
       @pages = @articles.pages
-      @per_page = 3
+      @per_page = 2
       @articles.stub!(:per_page).and_return(@per_page)
     end
     

data/spec/paginator_spec.rb

@@ -70,6 +70,10 @@ describe "Paginator" do
   end
   
   describe "window generator" do
+    before(:each) do
+      @args = []
+    end
+    
     it "should raise an error if no block is provided" do
       lambda { @pages.first.paginator.window({}) }.should raise_error(ArgumentError)
     end
@@ -89,55 +93,54 @@ describe "Paginator" do
         range.map { |nearby_number| @pages.find(nearby_number) }.each do |nearby_page|
           expected_args << [ nearby_page, @path.call(nearby_page) ]
         end
-        actual_args = []
         page.paginator.window(:size => @size) do |*args|
-          actual_args << args
+          expected_args.shift.should == args
         end
-        actual_args.should == expected_args
+        expected_args.should be_empty
       end
     end
     
-    [ :first, :last ].each do |extra|
+    [ [ :previous, 2, 1 ], [ :next, 1, 2 ] ].each do |extra, number, new_number|
       it "should call the block with #{extra.inspect} and the path for the #{extra} page if #{extra.inspect} is specified as an extra" do
-        page = @pages.find(6)
+        page = @pages.find(number)
         page.paginator.set_path(&@path)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
-          @received = true if extra == page && path == @path.call(@pages.send(extra))
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
+          @args << args
         end
-        @received.should be_true
+        @args.should include([ extra, @path.call(@pages.find(new_number)) ])
       end
     end
 
-    [ [ :first, "1+@size" ], [ :last, "@page_count-@size" ] ].each do |extra, number|
-      it "should not call the block with #{extra.inspect} if #{extra.inspect} is specified as an extra but the #{extra} page is within the window" do
+    [ [ :previous, "1" ], [ :next, "@page_count" ] ].each do |extra, number|
+      it "should call the block with #{extra.inspect} and a nil path if #{extra.inspect} is specified as an extra but there is no #{extra} page" do
         page = @pages.find(eval(number))
         page.paginator.set_path(&@path)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
-          @received = true if extra == page
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
+          @args << args
         end
-        @received.should be_nil
+        @args.should include([ extra, nil ])
       end
     end
     
-    [ [ :previous, 8, "8-2*@size-1" ], [ :next, 4, "4+2*@size+1" ] ].each do |extra, number, new_number|
+    [ :first, :last ].each do |extra|
       it "should call the block with #{extra.inspect} and the path for the #{extra} page if #{extra.inspect} is specified as an extra" do
-        page = @pages.find(number)
+        page = @pages.find(6)
         page.paginator.set_path(&@path)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
-          @received = true if extra == page && path == @path.call(@pages.find(eval(new_number)))
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
+          @args << args
         end
-        @received.should be_true
+        @args.should include([ extra, @path.call(@pages.send(extra)) ])
       end
     end
 
-    [ [ :previous, "1+2*@size" ], [ :next, "@page_count-2*@size" ] ].each do |extra, number|
-      it "should not call the block with #{extra.inspect} if #{extra.inspect} is specified as an extra but the #{extra} window is out of range" do
+    [ [ :first, "1" ], [ :last, "@page_count" ] ].each do |extra, number|
+      it "should call the block with #{extra.inspect} and a nil path if #{extra.inspect} is specified as an extra but the current page is the #{extra} page" do
         page = @pages.find(eval(number))
         page.paginator.set_path(&@path)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
-          @received = true if extra == page
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
+          @args << args
         end
-        @received.should be_nil
+        @args.should include([ extra, nil ])
       end
     end
     
@@ -151,4 +154,5 @@ describe "Paginator" do
       pages_in_order.should == [ :first, :previous, @pages.find(5), @pages.find(6), @pages.find(7), :next, :last ]
     end
   end
+
 end

data/spec/spec_helper.rb

@@ -18,33 +18,61 @@ ActiveRecord::Schema.define do
   create_table "articles", :force => true do |t|
     t.column "user_id",  :integer
     t.column "title", :text
+    t.column "published_at", :datetime
   end
   create_table "comments", :force => true do |t|
     t.column "article_id", :integer
     t.column "user_id", :integer
   end
+  create_table "contributions", :force => true do |t|
+    t.column "article_id", :integer
+    t.column "user_id", :integer
+  end
 end
 
 class ::User < ActiveRecord::Base
   has_many :articles
-  has_many :comments
-  has_many :commented_articles, :through => :comments, :source => :article
+  has_many :recent_articles, :order => "published_at DESC", :conditions => [ "published_at IS NOT :nil", { :nil => nil } ], :class_name => "Article"
+  has_many :contributions
+  has_many :shared_articles, :through => :contributions, :source => :article
 end
 class ::Article < ActiveRecord::Base
   belongs_to :user
   has_many :comments
+  named_scope :untitled, :conditions => { :title => nil }
+  named_scope :including_user, :include => :user
+  named_scope :with_user, :joins => 'INNER JOIN users ON users.id = articles.user_id'
+  named_scope :with_named_user, :joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ]
+  named_scope :ordered_by_user_name, :joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ], :order => 'users.name'
+  named_scope :with_comments, :joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id'
+  named_scope :first_three_with_comments, :joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id', :limit => 3
+  named_scope :with_multiple_comments, :include => :comments, :joins => 'INNER JOIN (SELECT count(id) AS count, article_id FROM comments GROUP BY article_id) article_comments ON article_comments.article_id = articles.id', :conditions => 'article_comments.count > 1'
+  named_scope :first_three, :limit => 3
+  named_scope :two_through_four, :limit => 3, :offset => 1
+  named_scope :descending_id, :order => 'articles.id DESC'
 end
 class ::Comment < ActiveRecord::Base
   belongs_to :article
+end
+class ::Contribution < ActiveRecord::Base
+  belongs_to :article
   belongs_to :user
 end
 
-[ "first user", nil, "last user" ].each { |name| User.create(:name => name) }
-7.times do
-  User.all.each do |user|
-    user.articles.create.comments << User.first.comments.new
-    user.articles.create(:title => "%03d title" % Article.count).comments << User.first.comments.new << User.last.comments.new
+User.create(:name => "user #1")
+User.create(:name => nil)
+User.create(:name => "user #3")
+9.times do |n|
+  shared_article = User.first.articles.create
+  User.all.each_with_index do |user, i|
+    user.articles.create
+    user.articles.create(:title => "Article #%03d" % Article.count)
+    published_article = user.articles.create(:title => "Article #%03d" % Article.count, :published_at => n.weeks.ago)
+    n.times { published_article.comments << Comment.new }
+    user.articles.create(:published_at => n.weeks.ago)
+    user.shared_articles << shared_article unless user == User.first
   end
+  n.times { shared_article.comments << Comment.new }
 end
 
 module ControllerHelpers
@@ -56,6 +84,7 @@ module ControllerHelpers
   end
   
   def in_controller(controller, &block)
+    controller.copy_instance_variables_from(self)
     in_instance controller do
       stub!(:params).and_return({})
       instance_eval(&block)
@@ -91,25 +120,31 @@ end
 
 module Contexts
   def in_contexts(&block)
-    [ [ "a scoped ActiveRecord class",      "Article.scoped({})"            ],
-      [ "a has_many association",           "User.last.articles"            ], # not tested for habtm!
-      [ "a has_many, :through association", "User.first.commented_articles" ] ].each do |base_type, base|
-      [ [ "",                                         ""                                          ],
-        [ "scoped with :conditions",                  ".scoped(:conditions => { :title => nil })" ],
-        [ "scoped with :include",                     ".scoped(:include => :comments)"            ],
-        [ "scoped with :joins",                       ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id')" ],
-        [ "scoped with :joins & :conditions",         ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ])" ],
-        [ "scoped with :joins, :conditions & :order", ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ], :order => 'users.name')" ],
-        [ "scoped with :joins & :group",              ".scoped(:joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id')" ],
-        [ "scoped with :joins, :group & :limit",      ".scoped(:joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id', :limit => 4)" ],
-        [ "scoped with :includes, :joins & subquery", ".scoped(:include => :comments, :joins => 'INNER JOIN (SELECT count(id) AS count, article_id FROM comments GROUP BY article_id) article_comments ON article_comments.article_id = articles.id', :conditions => 'article_comments.count > 1')"],
-        [ "scoped with :limit",                       ".scoped(:limit => 5)"                      ],
-        [ "scoped with :limit & :offset",             ".scoped(:limit => 5, :offset => 7)"        ],
-        [ "scoped with :order",                       ".scoped(:order => 'articles.id DESC')"     ] ].each do |scope_type, scope|
+    [
+      [ "a scoped ActiveRecord class",        "Article.scoped({})"           ],
+      [ "a has_many association",             "User.last.articles"           ],
+      [ "an ordered has_many association",    "User.last.recent_articles"    ],
+      [ "a has_many, :through association",   "User.last.shared_articles"    ] # not tested for habtm!
+    ].each do |base_type, base|
+      [ 
+        [ "",                                         "" ],
+        [ "scoped with :conditions",                  ".untitled" ],
+        [ "scoped with :include",                     ".including_user" ],
+        [ "scoped with :joins",                       ".with_user" ],
+        [ "scoped with :joins & :conditions",         ".with_named_user" ],
+        [ "scoped with :joins, :conditions & :order", ".ordered_by_user_name" ],
+        [ "scoped with :joins & :group",              ".with_comments" ],
+        [ "scoped with :joins, :group & :limit",      ".first_three_with_comments" ],
+        [ "scoped with :includes, :joins & subquery", ".with_multiple_comments" ],
+        [ "scoped with :limit",                       ".first_three" ],
+        [ "scoped with :limit & :offset",             ".two_through_four" ],
+        [ "scoped with :order",                       ".descending_id" ]
+      ].each do |scope_type, scope|
         context "for #{base_type} #{scope_type}" do
           before(:each) do
             @articles = eval("#{base}#{scope}")
-            @articles.all.should_not be_empty
+            @articles.all.should_not be_empty # sanity check: make sure our collection actually has some elements!
+            @articles.all.should == @articles.all.uniq # don't want duplicate items in our test collection
           end
           instance_eval(&block)
         end
@@ -123,4 +158,3 @@ Spec::Runner.configure do |config|
   config.include RoutingHelpers
   config.include ControllerHelpers
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mholling-paged_scopes
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Matthew Hollingworth
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -07:00
+date: 2009-06-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency