paged_scopes 0.1.0

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+require 'yaml'
+
+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
+  Jeweler::GemcutterTasks.new
+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: 0
+:major: 0
+:minor: 1

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/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)
+        found_scope, found_options = (scope(:find) || {}).dup, args.dup.extract_options!.dup
+        returning find_without_context(*args) do |results|
+          [ results ].flatten.compact.each do |result|
+            result.instance_variable_set "@found_scope", found_scope.dup
+            result.instance_variable_set "@found_options", found_options.dup
+          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,54 @@
+module PagedScopes
+  module Controller
+    module ClassMethods
+      def paginate(*args)
+        options = args.extract_options!
+        raise ArgumentError, "can't paginate multiple collections with one call" if args.many?
+        collection_name = args.first || default_collection_name
+        callback_method = "paginate_#{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}")
+          page = page_for(collection, object, options)
+          instance_variable_set("@#{collection.pages.name.underscore}", page)
+        end
+        protected callback_method
+        before_filter callback_method, options.except(:per_page, :name, :path)
+      end
+      
+      private
+      
+      def default_collection_name
+        collection_name = name
+        raise RuntimeError, "couldn't find controller name" unless collection_name.slice!(/Controller$/)
+        collection_name.demodulize.tableize
+      end
+    end
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.rescue_responses.update('PagedScopes::PageNotFound' => :not_found)
+    end
+    
+    private
+    
+    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
+    end
+  end
+end
+
+if defined? ActionController::Base
+  ActionController::Base.send :include, PagedScopes::Controller
+end

data/lib/paged_scopes/index.rb

@@ -0,0 +1,62 @@
+module PagedScopes
+  module Index
+    def index_of(object)
+      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
+      
+      attributes = (1..columns.size).map { |n| "attribute_#{n}" }
+      
+      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)
+
+      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? ?
+          "#{column} #{operator} :#{attribute}" :
+          "#{column} #{operator} :#{attribute} OR (#{column} = :#{attribute} AND (#{string}))"
+        hash.merge!(attribute.to_sym => value)
+      end
+      
+      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
+    end
+
+    def after(object)
+      after_index = index_of(object) + 1
+      if limit = scope(:find, :limit)
+        after_index >= limit ? nil : first(:offset => after_index + (scope(:find, :offset) || 0))
+      else
+        first(:offset => after_index)
+      end
+    end
+
+    def before(object)
+      before_index = index_of(object) - 1
+      if scope(:find, :limit)
+        before_index < 0 ? nil : first(:offset => before_index + (scope(:find, :offset) || 0))
+      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,194 @@
+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)
+        number = params[name.underscore.foreign_key.to_sym]
+        number ? find(number) : 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, 1].max
+      end
+      
+      memoize :count
+
+      def first
+        find(1)
+      end
+
+      def last
+        find(count)
+      end
+
+      def each(&block)
+        1.upto(count) { |number| yield find(number) }
+      end
+
+      def all
+        collect { |page| page }
+      end
+      
+      def closest_to(number)
+        closest_number = [ [ 1, number ].max, count ].min
+        closest_number > 0 ? find(closest_number) : nil ## TODO this is unneeded now!
+      end
+      
+      def reload!
+        unmemoize_all
+      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 <= page_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 reload!
+      self.class.reload!
+      self.class.find(number)
+      unmemoize_all
+    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)
+      other.is_a?(self.class) && number == other.number
+    end
+    
+    def full?
+      !last? || page_scope.all.length == per_page # TODO: could improve this to calculate mathematically
+    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