mholling-paged_scopes 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Matthew Hollingworth
+
+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,7 @@
+= paged_scopes
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 Matthew Hollingworth. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "paged_scopes"
+    gem.summary = <<-EOF
+PagedScopes is an ActiveRecord pagination gem. It lets you easily paginate collection associations and
+named scopes. It also paginates collections which already have :limit and :offset scopes in place. You
+can also find the page containing a given object in a collection, and find the next and previous objects
+for each object in the collection.
+EOF
+    gem.email = "mdholling@gmail.com"
+    gem.homepage = "http://github.com/mholling/paged_scopes"
+    gem.authors = ["Matthew Hollingworth"]
+    gem.add_dependency 'activerecord', ">= 2.2.1"
+    gem.has_rdoc = false
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "paged_scopes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

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

data/lib/paged_scopes/collection.rb

@@ -0,0 +1,45 @@
+module PagedScopes  
+  module Collection
+    module Attributes
+      attr_writer :per_page
+    
+      def per_page
+        @per_page || case self
+        when ActiveRecord::NamedScope::Scope
+          @proxy_scope.per_page
+        when ActiveRecord::Associations::AssociationCollection
+          @reflection.klass.per_page
+        end
+      end
+    
+      attr_writer :page_name
+    
+      def page_name
+        @page_name || case self
+        when ActiveRecord::NamedScope::Scope
+          @proxy_scope.page_name
+        when ActiveRecord::Associations::AssociationCollection
+          @reflection.klass.page_name
+        else
+          "Page"
+        end
+      end
+    end
+    
+    include Attributes
+  
+    def pages
+      @pages ||= returning(Class.new) do |klass|
+        klass.send :include, Page
+        klass.proxy = self
+        klass.class_eval "alias :#{name.tableize} :page_scope"
+        klass.instance_eval "alias :find_by_#{name.underscore} :find_by_object"
+        klass.instance_eval "alias :find_by_#{name.underscore}! :find_by_object!"
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend PagedScopes::Collection::Attributes
+ActiveRecord::Associations::AssociationCollection.send :include, PagedScopes::Collection
+ActiveRecord::NamedScope::Scope.send :include, PagedScopes::Collection

data/lib/paged_scopes/context.rb

@@ -0,0 +1,36 @@
+module PagedScopes
+  module Context
+    extend ActiveSupport::Memoizable
+    
+    def self.included(base)
+      base.extend ClassMethods
+      class << base
+        alias_method_chain :find, :context
+      end
+    end
+    
+    module ClassMethods
+      def find_with_context(*args)
+        returning find_without_context(*args) do |results|
+          found_scope, found_options = scope(:find), args.extract_options!
+          [ results ].flatten.each do |result|
+            result.instance_variable_set "@found_scope", found_scope
+            result.instance_variable_set "@found_options", found_options
+          end
+        end
+      end
+    end
+    
+    def previous
+      self.class.scoped(@found_scope).scoped(@found_options).before(self)
+    end
+    
+    def next
+      self.class.scoped(@found_scope).scoped(@found_options).after(self)
+    end
+    
+    memoize :previous, :next
+  end
+end
+
+ActiveRecord::Base.send :include, PagedScopes::Context

data/lib/paged_scopes/controller.rb

@@ -0,0 +1,22 @@
+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.name = options[:name] if options[:name]
+        page = collection.pages.from_params(params) || (object && collection.pages.find_by_object(object)) || collection.pages.first
+        instance_variable_set("@#{collection.pages.name.underscore}", page)
+      end
+      protected callback_method
+      before_filter callback_method
+    end
+  end
+end
+
+if defined? ActionController::Base
+  ActionController::Base.extend PagedScopes::Controller
+end

data/lib/paged_scopes/index.rb

@@ -0,0 +1,89 @@
+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
+      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(', ')
+      
+      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
+
+      order_conditions = order_attributes.reverse.inject([ "", {}, 0 ]) do |args, order_attribute|
+        string, hash, n = args
+        symbol = "s#{n}".to_sym
+        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 ]
+      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]
+      end
+      
+      before_count
+    end
+
+    def after(object)
+      after_index = index_of(object) + 1
+      find_scope = scope(:find) || {}
+      if find_scope[:limit]
+        offset = (find_scope[:offset] || 0).to_i
+        after_index >= find_scope[:limit] ? nil : first(:offset => after_index + offset)
+      else
+        first(:offset => after_index)
+      end
+    end
+
+    def before(object)
+      before_index = index_of(object) - 1
+      find_scope = scope(:find) || {}
+      if find_scope[:limit]
+        offset = find_scope[:offset].to_i
+        before_index < 0 ? nil : first(:offset => before_index + offset)
+      else
+        before_index < 0 ? nil : first(:offset => before_index)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend, PagedScopes::Index

data/lib/paged_scopes/pages.rb

@@ -0,0 +1,188 @@
+module PagedScopes
+  class PageNotFound < ActiveRecord::RecordNotFound
+    attr_reader :substitute
+    def initialize(message, substitute = nil)
+      super(message)
+      @substitute = substitute
+    end
+  end
+  
+  module Page
+    extend ActiveSupport::Memoizable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      extend ActiveSupport::Memoizable
+      include Enumerable
+      
+      attr_accessor :proxy
+      
+      def per_page
+        proxy.per_page || raise(RuntimeError, "please specify per_page in your collection")
+      end
+      
+      def name
+        proxy.page_name
+      end
+        
+      def find(id)
+        new(id.to_i)
+      end
+      
+      memoize :find
+
+      def find_by_object!(object)
+        raise PageNotFound, "#{object.inspect} is not an ActiveRecord instance" unless object.is_a?(ActiveRecord::Base)
+        find(1 + proxy.index_of(object) / per_page)
+      rescue ActiveRecord::RecordNotFound
+        raise PageNotFound, "#{object.inspect} not found in scope"
+      end
+            
+      def find_by_object(object)
+        find_by_object!(object)
+      rescue PageNotFound
+        nil
+      end
+      
+      def from_params!(params)
+        find(params[name.underscore.foreign_key.to_sym])
+      end
+      
+      def from_params(params)
+        from_params!(params)
+      rescue PageNotFound
+        nil
+      end
+
+      def count
+        collection_count = if proxy_scoped?(:limit)
+          count_options = { :distinct => true, :limit => 1 }
+          count_options.merge!(:offset => 0) if proxy_scoped?(:offset)
+          proxy_count = proxy.count("#{proxy.table_name}.#{proxy.primary_key}", count_options)
+          proxy_count -= proxy_options[:offset] if proxy_scoped?(:offset)
+          [ proxy_count, proxy_options[:limit] ].min
+        else
+          proxy.count("#{proxy.table_name}.#{proxy.primary_key}", :distinct => true)
+        end
+        (collection_count - 1)/per_page + 1
+      end
+      
+      memoize :count
+
+      def first
+        find(1)
+      end
+
+      def last
+        find(count)
+      end
+
+      def each(&block)
+        (1..count).each { |number| yield find(number) }
+      end
+
+      def all
+        collect { |page| page }
+      end
+      
+      def closest_to(number)
+        find([ [ 1, number ].max, count ].min)
+      end
+      
+      private
+      
+      def proxy_options
+        proxy.send(:scope, :find) || {}
+      end
+                  
+      def proxy_scoped?(key = nil)
+        proxy.send(:scoped?, :find, key)
+      end
+    end
+    
+    attr_reader :number, :paginator
+    delegate :per_page, :proxy, :proxy_options, :proxy_scoped?, :to => "self.class"
+    private :proxy, :proxy_options, :proxy_scoped?
+
+    def initialize(number)
+      unless number > 0 && number <= self.class.count
+        raise PageNotFound.new("couldn't find page number #{number}", self.class.closest_to(number))
+      end
+      @number = number
+      @paginator = PagedScopes::Paginator.new(self)
+    end
+    
+    def page_count
+      self.class.count
+    end
+    
+    def first?
+      number == 1
+    end
+    
+    def last?
+      number == page_count
+    end
+    
+    def <=>(other)
+      number <=> other.number
+    end
+    
+    def ==(other)
+      number == other.number
+    end
+    
+    def full?
+      !last? || page_scope.all.length == per_page
+    end
+    
+    def to_param
+      number.to_s
+    end
+    
+    def id
+      number
+    end
+    
+    def previous
+      self.class.find(number - 1) unless first?
+    end
+
+    def next
+      self.class.find(number + 1) unless last?
+    end
+    
+    def offset(n)
+      self.class.find(number + n)
+    rescue PageNotFound
+      nil
+    end
+        
+    def inspect
+      "#<#{self.class.name}, for: #{proxy.name}, number: #{number}>"
+    end
+    
+    def page_scope
+      if proxy_scoped?(:limit)
+        subquery_sql = proxy.name.constantize.send(:construct_finder_sql, proxy_options.merge(:select => "#{proxy.table_name}.#{proxy.primary_key}"))
+        paged_conditions = "#{proxy.table_name}.#{proxy.primary_key} IN (#{subquery_sql})"
+        paged_options = { :conditions => paged_conditions, :limit => per_page, :offset => (number - 1) * per_page }
+        proxy.name.constantize.scoped(proxy_options.except(:limit, :offset)).scoped(paged_options)
+        # can't exclude :conditions since it won't work for has_many :through associations (multiple identical records returned)
+      else
+        proxy.scoped(:limit => per_page, :offset => (number - 1) * per_page)      
+      end
+    end
+    
+    private
+    
+    def subquery_sql
+      proxy.name.constantize.send(:construct_finder_sql, proxy_options.merge(:select => "#{proxy.table_name}.#{proxy.primary_key}"))
+    end
+    
+    memoize :subquery_sql
+  end
+end

data/lib/paged_scopes/paginator.rb

@@ -0,0 +1,47 @@
+module PagedScopes
+  class Paginator
+    attr_reader :page
+
+    def initialize(page)
+      @page = page
+    end
+
+    def set_path(&block)
+      @path = block
+    end
+    
+    def path
+      @path || raise(ArgumentError, "No path proc supplied.")
+    end
+
+    def previous
+      path.call(@page.previous) unless @page.first?
+    end
+
+    def next
+      path.call(@page.next) unless @page.last?
+    end
+
+    def window(options)
+      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
+        yield :first, @path.call(@page.class.first) if extras.include? :first
+        if extras.include?(:previous) && offset_page = @page.offset(-2 * size - 1)
+          yield :previous, @path.call(offset_page)
+        end
+      end
+      (-size..size).map { |offset| @page.offset(offset) }.compact.each do |page|
+        yield page, @path.call(page)
+      end
+      if @page.number + size < @page.page_count
+        if extras.include?(:next) && offset_page = @page.offset(2 * size + 1)
+          yield :next, @path.call(offset_page)
+        end
+        yield :last, @path.call(@page.class.last) if extras.include? :last
+      end
+    end
+  end
+end

data/lib/paged_scopes/resources.rb

@@ -0,0 +1,32 @@
+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 }))
+          end
+        end
+      else
+        resources_without_paged(*(entities << options), &block)
+      end
+    end
+    
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :resources, :paged
+      end
+    end
+  end
+end
+
+if defined? ActionController::Resources
+  ActionController::Resources.send :include, PagedScopes::Resources
+end

data/lib/paged_scopes.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Base
+
+require 'paged_scopes/index'
+require 'paged_scopes/context'
+require 'paged_scopes/collection'
+require 'paged_scopes/pages'
+require 'paged_scopes/controller'
+require 'paged_scopes/paginator'
+require 'paged_scopes/resources'

data/rails/init.rb

@@ -0,0 +1 @@
+require 'paged_scopes'

data/spec/collection_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe "Collection" do
+  describe "(ActiveRecord::Base class)" do
+    it "should have a per_page setter and getter" do
+      Article.per_page = 5
+      Article.per_page.should == 5
+    end
+    
+    it "should have a default page name of 'Page'" do
+      Article.page_name.should == "Page"
+    end
+
+    it "should have a page_name setter and getter" do
+      Article.page_name = "Group"
+      Article.page_name.should == "Group"
+    end
+    
+    it "should not have a #pages method" do
+      Article.respond_to?(:pages).should be_false
+    end
+  end
+  
+  [ [ "association", "User.first.articles"                             ],
+    [ "named scope", "Article.scoped(:conditions => 'title IS NULL')" ] ].each do |collection_type, collection|
+    describe "(#{collection_type})" do
+      before(:each) do
+        @collection = eval(collection)
+        Article.stub!(:per_page).and_return(10)
+        Article.page_name = "Page"
+      end
+      
+      it "should have a default per_page of the ActiveRecord::Base class" do
+        @collection.per_page.should == 10
+      end
+    
+      it "should have a per_page setter and getter" do
+        @collection.per_page = 20
+        @collection.per_page.should == 20
+      end
+      
+      it "should not overwrite the ActiveRecord::Base per_page value when per_page is set" do
+        @collection.per_page = 20
+        Article.per_page.should == 10
+      end
+      
+      it "should have a default page_name of the ActiveRecord::Base class" do
+        @collection.page_name.should == "Page"
+      end
+    
+      it "should have a page_name setter and getter" do
+        @collection.page_name = "Group"
+        @collection.page_name.should == "Group"
+      end
+      
+      it "should not overwrite the ActiveRecord::Base page_name value when page_name is set" do
+        @collection.page_name = "Group"
+        Article.page_name.should == "Page"
+      end
+  
+      it "should have a #pages method" do
+        @collection.respond_to?(:pages).should be_true
+      end
+    end
+  end
+end

data/spec/context_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "Context" do
+  in_contexts do
+    it "should know the object after an object in the collection" do
+      articles = @articles.all
+      until articles.empty? do
+        articles.shift.next.should == articles.first
+      end
+    end
+
+    it "should know the object before an object in the collection" do
+      articles = @articles.all
+      until articles.empty? do
+        articles.pop.previous.should == articles.last
+      end
+    end
+  end  
+end