kaminari 0.10.4 → 0.11.0

data/lib/kaminari/helpers/tags.rb

@@ -9,42 +9,19 @@ module Kaminari
     # class, so _tag parital is not needed).
     #   e.g.)  PrevLink  ->  app/views/kaminari/_prev_link.html.erb
     #
-    # If the template file does not exist, it falls back to ancestor classes.
-    #   e.g.)  FirstPageLink  ->  app/views/kaminari/_first_page_link.html.erb
-    #                         ->  app/views/kaminari/_page_link.html.erb
-    #
-    # When no matching template were found in your app, finally the engine's pre
+    # When no matching template were found in your app, the engine's pre
     # installed template will be used.
     #   e.g.)  Paginator  ->  $GEM_HOME/kaminari-x.x.x/app/views/kaminari/_paginator.html.erb
     class Tag
       def initialize(template, options = {}) #:nodoc:
-        @template, @options = template, template.options.merge(options)
-        @param_name = @options.delete :param_name
+        @template, @options = template, options.dup
+        @param_name = @options.delete(:param_name)
+        @theme = @options[:theme] ? "#{@options.delete(:theme)}/" : ''
+        @params = @options[:params] ? template.params.merge(@options.delete :params) : template.params
       end
 
       def to_s(locals = {}) #:nodoc:
-        @template.render :partial => find_template, :locals => @options.merge(locals)
-      end
-
-      private
-      def self.ancestor_renderables
-        arr = []
-        ancestors.each do |klass|
-          return arr if klass == Tag
-          arr << klass if klass != Renderable
-        end
-      end
-
-      # OMG yet another super dirty hack
-      # this method finds
-      #   1. a template for the given class from app/views
-      #   2. a template for its parent class from app/views
-      #   3. the default one inside the engine
-      def find_template
-        self.class.ancestor_renderables.each do |klass|
-          return "kaminari/#{klass.template_filename}" if @template.partial_exists? klass.template_filename
-        end
-        "kaminari/#{self.class.template_filename}"
+        @template.render :partial => "kaminari/#{@theme}#{self.class.name.demodulize.underscore}", :locals => @options.merge(locals)
       end
 
       def page_url_for(page)
@@ -52,129 +29,12 @@ module Kaminari
       end
     end
 
-    module Renderable #:nodoc:
-      def self.included(base) #:nodoc:
-        base.extend ClassMethods
-      end
-      module ClassMethods #:nodoc:
-        def template_filename #:nodoc:
-          name.demodulize.underscore
-        end
-        def included(base) #:nodoc:
-          base.extend Renderable::ClassMethods
-        end
-      end
-    end
-
-    # The container tag
-    class Paginator < Tag
-      include Renderable
-      attr_reader :options
-
-      def initialize(template, window_options) #:nodoc:
-        @template, @options = template, window_options.reverse_merge(template.options)
-        # so that this instance can actually "render". Black magic?
-        @output_buffer = ActionView::OutputBuffer.new
-      end
-
-      # render given block as a view template
-      def render(&block)
-        instance_eval &block if @options[:num_pages] > 1
-        @output_buffer
-      end
-
-      # enumerate each page providing PageProxy object as the block parameter
-      def each_page
-        1.upto(@options[:num_pages]) do |i|
-          @page = i
-          yield PageProxy.new(options, i, @last)
-        end
-      end
-
-      %w[current_page first_page_link last_page_link page_link].each do |tag|
-        eval <<-DEF
-          def #{tag}_tag
-            @last = #{tag.classify}.new @template, :page => @page
-          end
-        DEF
-      end
-
-      %w[prev_link prev_span next_link next_span truncated_span].each do |tag|
-        eval <<-DEF
-          def #{tag}_tag
-            @last = #{tag.classify}.new @template
-          end
-        DEF
-      end
-
-      def to_s(window_options = {}) #:nodoc:
-        super window_options.merge :paginator => self
-      end
-
-      # Wraps a "page number" and provides some utility methods
-      class PageProxy
-        def initialize(options, page, last) #:nodoc:
-          @options, @page, @last = options, page, last
-        end
-
-        # the page number
-        def number
-          @page
-        end
-
-        # current page or not
-        def current?
-          @page == @options[:current_page]
-        end
-
-        # the first page or not
-        def first?
-          @page == 1
-        end
-
-        # the last page or not
-        def last?
-          @page == @options[:num_pages]
-        end
-
-        # within the left outer window or not
-        def left_outer?
-          @page <= @options[:left] + 1
-        end
-
-        # within the right outer window or not
-        def right_outer?
-          @options[:num_pages] - @page <= @options[:right]
-        end
-
-        # inside the inner window or not
-        def inside_window?
-          (@page - @options[:current_page]).abs <= @options[:window]
-        end
-
-        # The last rendered tag was "truncated" or not
-        def was_truncated?
-          @last.is_a? TruncatedSpan
-        end
-      end
-    end
-
-    # A page
-    module Page
-      include Renderable
+    # Tag that contains a link
+    module Link
       # target page number
       def page
         raise 'Override page with the actual page value to be a Page.'
       end
-      def to_s(locals = {}) #:nodoc:
-        super locals.merge(:page => page)
-      end
-    end
-
-    # Tag that contains a link
-    module Link
-      include Renderable
-      include Page
       # the link's href
       def url
         page_url_for page
@@ -184,80 +44,52 @@ module Kaminari
       end
     end
 
-    # Tag that doesn't contain a link
-    module NonLink
-      include Renderable
-    end
-
-    # The "previous" page of the current page
-    module Prev
-      include Renderable
-    end
-
-    # "Previous" without link
-    class PrevSpan < Tag
-      include NonLink
-      include Prev
+    # A page
+    class Page < Tag
+      include Link
+      # target page number
+      def page
+        @options[:page]
+      end
+      def to_s(locals = {}) #:nodoc:
+        super locals.merge(:page => page)
+      end
     end
 
-    # "Previous" with link
-    class PrevLink < Tag
+    # Link with page number that appears at the leftmost
+    class FirstPage < Tag
       include Link
-      include Prev
       def page #:nodoc:
-        @options[:current_page] - 1
+        1
       end
     end
 
-    # The "next" page of the current page
-    module Next
-      include Renderable
-    end
-
-    # "Next" without link
-    class NextSpan < Tag
-      include NonLink
-      include Next
-    end
-
-    # "Next" with link
-    class NextLink < Tag
+    # Link with page number that appears at the rightmost
+    class LastPage < Tag
       include Link
-      include Next
       def page #:nodoc:
-        @options[:current_page] + 1
+        @options[:num_pages]
       end
     end
 
-    # Link showing page number
-    class PageLink < Tag
-      include Page
+    # The "previous" page of the current page
+    class PrevPage < Tag
       include Link
       def page #:nodoc:
-        @options[:page]
+        @options[:current_page] - 1
       end
     end
 
-    # Non-link tag showing the current page number
-    class CurrentPage < Tag
-      include Page
-      include NonLink
+    # The "next" page of the current page
+    class NextPage < Tag
+      include Link
       def page #:nodoc:
-        @options[:page]
+        @options[:current_page] + 1
       end
     end
 
-    # Link with page number that appears at the leftmost
-    class FirstPageLink < PageLink
-    end
-
-    # Link with page number that appears at the rightmost
-    class LastPageLink < PageLink
-    end
-
     # Non-link tag that stands for skipped pages...
-    class TruncatedSpan < Tag
-      include NonLink
+    class Gap < Tag
     end
   end
 end

data/lib/kaminari/models/active_record_extension.rb

@@ -1,17 +1,10 @@
 require File.join(File.dirname(__FILE__), 'active_record_relation_methods')
+
 module Kaminari
   module ActiveRecordExtension
     extend ActiveSupport::Concern
     included do
       def self.inherited(kls) #:nodoc:
-        # TERRIBLE HORRIBLE NO GOOD VERY BAD HACK: inheritable_attributes is not yet set here on AR 3.0
-        unless kls.default_scoping
-          new_inheritable_attributes = Hash[inheritable_attributes.map do |key, value|
-            [key, value.duplicable? ? value.dup : value]
-          end]
-          kls.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-        end
-
         kls.class_eval do
           include Kaminari::ConfigurationMethods
 

data/lib/kaminari/models/active_record_relation_methods.rb

@@ -2,8 +2,15 @@ module Kaminari
   module ActiveRecordRelationMethods
     extend ActiveSupport::Concern
     module InstanceMethods
+      if Rails.version < '3.1'
+        def count #:nodoc:
+          limit_value == 0 ? 0 : length
+        end
+      end
+
       def total_count #:nodoc:
-        c = except(:offset, :limit).count
+        # #count overrides the #select which could include generated columns referenced in #order, so skip #order here, where it's irrelevant to the result anyway
+        c = except(:offset, :limit, :includes, :order).count
         # .group returns an OrderdHash that responds to #count
         c.respond_to?(:count) ? c.count : c
       end

data/lib/kaminari/models/mongoid_extension.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(__FILE__), 'mongoid_criteria_methods')
+
 module Kaminari
   module MongoidExtension
     module Criteria

data/lib/kaminari/railtie.rb

@@ -3,7 +3,7 @@ require 'rails'
 begin; require 'mongoid'; rescue LoadError; end
 
 require File.join(File.dirname(__FILE__), 'helpers/action_view_extension')
-require File.join(File.dirname(__FILE__), 'helpers/helpers')
+require File.join(File.dirname(__FILE__), 'helpers/paginator')
 require File.join(File.dirname(__FILE__), 'models/page_scope_methods')
 require File.join(File.dirname(__FILE__), 'models/configuration_methods')
 

data/lib/kaminari/version.rb

@@ -0,0 +1,3 @@
+module Kaminari
+  VERSION = File.read File.join(File.dirname(__FILE__), '../../VERSION')
+end

data/spec/acceptance/users_spec.rb

@@ -13,7 +13,7 @@ feature 'Users' do
         page.should have_content '1'
       end
       within 'span.next' do
-        click_link 'Next »'
+        click_link 'Next ›'
       end
     end
 
@@ -21,8 +21,8 @@ feature 'Users' do
       within 'span.page.current' do
         page.should have_content '2'
       end
-      within 'span.page.last' do
-        click_link '4'
+      within 'span.last' do
+        click_link 'Last »'
       end
     end
 
@@ -31,7 +31,7 @@ feature 'Users' do
         page.should have_content '4'
       end
       within 'span.prev' do
-        click_link '« Prev'
+        click_link '‹ Prev'
       end
     end
 
@@ -39,6 +39,15 @@ feature 'Users' do
       within 'span.page.current' do
         page.should have_content '3'
       end
+      within 'span.first' do
+        click_link '« First'
+      end
+    end
+
+    within 'nav.pagination' do
+      within 'span.page.current' do
+        page.should have_content '1'
+      end
     end
   end
 end

data/spec/fake_app.rb

@@ -20,9 +20,39 @@ end
 
 # models
 class User < ActiveRecord::Base
-  default_scope order(:name)
+  has_many :authorships
+  has_many :readerships
+  has_many :books_authored, :through => :authorships, :source => :book
+  has_many :books_read, :through => :readerships, :source => :book
+
+  def readers
+    User.joins(:books_read => :authors).where(:authors_books => {:id => self})
+  end
+
+  scope :by_name, order(:name)
+  scope :by_read_count, lambda {
+    cols = if connection.adapter_name == "PostgreSQL"
+      column_names.map { |column| %{"users"."#{column}"} }.join(", ")
+    else
+      '"users"."id"'
+    end
+    group(cols).select("count(readerships.id) AS read_count, #{cols}").order('read_count DESC')
+  }
+end
+class Authorship < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :book
+end
+class Readership < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :book
+end
+class Book < ActiveRecord::Base
+  has_many :authorships
+  has_many :readerships
+  has_many :authors, :through => :authorships, :source => :user
+  has_many :readers, :through => :readerships, :source => :user
 end
-class Book < ActiveRecord::Base; end
 
 # controllers
 class ApplicationController < ActionController::Base; end
@@ -44,5 +74,7 @@ class CreateAllTables < ActiveRecord::Migration
   def self.up
     create_table(:users) {|t| t.string :name; t.integer :age}
     create_table(:books) {|t| t.string :title}
+    create_table(:readerships) {|t| t.integer :user_id; t.integer :book_id }
+    create_table(:authorships) {|t| t.integer :user_id; t.integer :book_id }
   end
 end

data/spec/helpers/helpers_spec.rb

@@ -1,11 +1,12 @@
 require File.expand_path('../spec_helper', File.dirname(__FILE__))
 include Kaminari::Helpers
 
-describe 'Kaminari::Helpers::PaginationRenderer' do
+describe 'Kaminari::Helpers::Paginator' do
   let :template do
     stub(r = Object.new) do
       render.with_any_args
       params { {} }
+      options { {} }
       url_for {|h| "/foo?page=#{h[:page]}"}
     end
     r
@@ -13,10 +14,18 @@ describe 'Kaminari::Helpers::PaginationRenderer' do
 
   describe '#params' do
     before do
-      @renderer = PaginationRenderer.new(template, :params => {:controller => 'foo', :action => 'bar'})
+      @paginator = Paginator.new(template, :params => {:controller => 'foo', :action => 'bar'})
     end
-    subject { @renderer.instance_variable_get '@template' }
-    its(:params) { should == {:controller => 'foo', :action => 'bar'} }
+    subject { @paginator.page_tag(template).instance_variable_get('@params') }
+    it { should == {:controller => 'foo', :action => 'bar'} }
+  end
+
+  describe '#param_name' do
+    before do
+      @paginator = Paginator.new(template, :param_name => :pagina)
+    end
+    subject { @paginator.page_tag(template).instance_variable_get('@param_name') }
+    it { should == :pagina }
   end
 
   #TODO test somehow...