kaminari-rails4 0.15.0

data/lib/kaminari/models/data_mapper_collection_methods.rb

@@ -0,0 +1,15 @@
+module Kaminari
+  module DataMapperCollectionMethods
+    def limit_value #:nodoc:
+      query.options[:limit] || 0
+    end
+
+    def offset_value #:nodoc:
+      query.options[:offset] || 0
+    end
+
+    def total_count #:nodoc:
+      model.count(query.options.except(:limit, :offset, :order))
+    end
+  end
+end

data/lib/kaminari/models/data_mapper_extension.rb

@@ -0,0 +1,48 @@
+require 'kaminari/models/data_mapper_collection_methods'
+
+module Kaminari
+  module DataMapperExtension
+    module Paginatable
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{Kaminari.config.page_method_name}(num = 1)
+          num = [num.to_i, 1].max - 1
+          all(:limit => default_per_page, :offset => default_per_page * num).extend Paginating
+        end
+      RUBY
+    end
+
+    module Paginating
+      include Kaminari::PageScopeMethods
+
+      def all(options={})
+        super.extend Paginating
+      end
+
+      def per(num)
+        super.extend Paginating
+      end
+    end
+
+    module Collection
+      extend ActiveSupport::Concern
+      included do
+        include Kaminari::ConfigurationMethods::ClassMethods
+        include Kaminari::DataMapperCollectionMethods
+        include Paginatable
+      end
+    end
+
+    module Model
+      include Kaminari::ConfigurationMethods::ClassMethods
+      include Paginatable
+
+      def limit(val)
+        all(:limit => val)
+      end
+
+      def offset(val)
+        all(:offset => val)
+      end
+    end
+  end
+end

data/lib/kaminari/models/mongo_mapper_extension.rb

@@ -0,0 +1,18 @@
+require 'kaminari/models/plucky_criteria_methods'
+
+module Kaminari
+  module MongoMapperExtension
+    module Document
+      extend ActiveSupport::Concern
+      include Kaminari::ConfigurationMethods
+
+      included do
+        # Fetch the values at the specified page number
+        #   Model.page(5)
+        scope Kaminari.config.page_method_name, Proc.new {|num|
+          limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
+        }
+      end
+    end
+  end
+end

data/lib/kaminari/models/mongoid_criteria_methods.rb

@@ -0,0 +1,23 @@
+module Kaminari
+  module MongoidCriteriaMethods
+    def limit_value #:nodoc:
+      options[:limit]
+    end
+
+    def offset_value #:nodoc:
+      options[:skip]
+    end
+
+    def total_count #:nodoc:
+      embedded? ? unpage.count : count
+    end
+
+    private
+    def unpage
+      clone.tap do |crit|
+        crit.options.delete :limit
+        crit.options.delete :skip
+      end
+    end
+  end
+end

data/lib/kaminari/models/mongoid_extension.rb

@@ -0,0 +1,33 @@
+require 'kaminari/models/mongoid_criteria_methods'
+
+module Kaminari
+  module MongoidExtension
+    module Criteria
+      extend ActiveSupport::Concern
+
+      included do
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{Kaminari.config.page_method_name}(*args)
+            super(*args).criteria.merge(self)
+          end
+        RUBY
+      end
+    end
+
+    module Document
+      extend ActiveSupport::Concern
+      include Kaminari::ConfigurationMethods
+
+      included do
+        # Fetch the values at the specified page number
+        #   Model.page(5)
+        scope Kaminari.config.page_method_name, Proc.new {|num|
+          limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
+        } do
+          include Kaminari::MongoidCriteriaMethods
+          include Kaminari::PageScopeMethods
+        end
+      end
+    end
+  end
+end

data/lib/kaminari/models/page_scope_methods.rb

@@ -0,0 +1,70 @@
+module Kaminari
+  module PageScopeMethods
+    # Specify the <tt>per_page</tt> value for the preceding <tt>page</tt> scope
+    #   Model.page(3).per(10)
+    def per(num)
+      if (n = num.to_i) <= 0
+        self
+      elsif max_per_page && max_per_page < n
+        limit(max_per_page).offset(offset_value / limit_value * max_per_page)
+      else
+        limit(n).offset(offset_value / limit_value * n)
+      end
+    end
+
+    def padding(num)
+      @_padding = num
+      offset(offset_value + num.to_i)
+    end
+
+    # Total number of pages
+    def total_pages
+      count_without_padding = total_count
+      count_without_padding -= @_padding if defined?(@_padding) && @_padding
+      count_without_padding = 0 if count_without_padding < 0
+
+      total_pages_count = (count_without_padding.to_f / limit_value).ceil
+      if max_pages.present? && max_pages < total_pages_count
+        max_pages
+      else
+        total_pages_count
+      end
+    end
+    #FIXME for compatibility. remove num_pages at some time in the future
+    alias num_pages total_pages
+
+    # Current page number
+    def current_page
+      offset_without_padding = offset_value
+      offset_without_padding -= @_padding if defined?(@_padding) && @_padding
+      offset_without_padding = 0 if offset_without_padding < 0
+
+      (offset_without_padding / limit_value) + 1
+    end
+
+    # Next page number in the collection
+    def next_page
+      current_page + 1 unless last_page?
+    end
+
+    # Previous page number in the collection
+    def prev_page
+      current_page - 1 unless first_page?
+    end
+
+    # First page of the collection?
+    def first_page?
+      current_page == 1
+    end
+
+    # Last page of the collection?
+    def last_page?
+      current_page >= total_pages
+    end
+
+    # Out of range of the collection?
+    def out_of_range?
+      current_page > total_pages
+    end
+  end
+end

data/lib/kaminari/models/plucky_criteria_methods.rb

@@ -0,0 +1,18 @@
+module Kaminari
+  module PluckyCriteriaMethods
+    include Kaminari::PageScopeMethods
+    include Kaminari::ConfigurationMethods::ClassMethods
+
+    def limit_value #:nodoc:
+      options[:limit]
+    end
+
+    def offset_value #:nodoc:
+      options[:skip]
+    end
+
+    def total_count #:nodoc:
+      count
+    end
+  end
+end

data/lib/kaminari/railtie.rb

@@ -0,0 +1,7 @@
+module Kaminari
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'kaminari' do |_app|
+      Kaminari::Hooks.init
+    end
+  end
+end

data/lib/kaminari/sinatra.rb

@@ -0,0 +1,5 @@
+require 'sinatra/base'
+require 'kaminari'
+require 'kaminari/helpers/sinatra_helpers'
+
+Kaminari::Hooks.init

data/lib/kaminari/version.rb

@@ -0,0 +1,3 @@
+module Kaminari
+  VERSION = '0.15.0'
+end

data/spec/config/config_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Kaminari::Configuration do
+  subject { Kaminari.config }
+  describe 'default_per_page' do
+    context 'by default' do
+      its(:default_per_page) { should == 25 }
+    end
+    context 'configured via config block' do
+      before do
+        Kaminari.configure {|c| c.default_per_page = 17}
+      end
+      its(:default_per_page) { should == 17 }
+      after do
+        Kaminari.configure {|c| c.default_per_page = 25}
+      end
+    end
+  end
+
+  describe 'max_per_page' do
+    context 'by default' do
+      its(:max_per_page) { should == nil }
+    end
+    context 'configure via config block' do
+      before do
+        Kaminari.configure {|c| c.max_per_page = 100}
+      end
+      its(:max_per_page) { should == 100 }
+      after do
+        Kaminari.configure {|c| c.max_per_page = nil}
+      end
+    end
+  end
+
+  describe 'window' do
+    context 'by default' do
+      its(:window) { should == 4 }
+    end
+  end
+
+  describe 'outer_window' do
+    context 'by default' do
+      its(:outer_window) { should == 0 }
+    end
+  end
+
+  describe 'left' do
+    context 'by default' do
+      its(:left) { should == 0 }
+    end
+  end
+
+  describe 'right' do
+    context 'by default' do
+      its(:right) { should == 0 }
+    end
+  end
+
+  describe 'param_name' do
+    context 'by default' do
+      its(:param_name) { should == :page }
+    end
+
+    context 'configured via config block' do
+      before do
+        Kaminari.configure {|c| c.param_name = lambda { :test } }
+      end
+
+      its(:param_name) { should == :test }
+
+      after do
+        Kaminari.configure {|c| c.param_name = :page }
+      end
+    end
+  end
+
+  describe 'max_pages' do
+    context 'by default' do
+      its(:max_pages) { should == nil }
+    end
+    context 'configure via config block' do
+      before do
+        Kaminari.configure {|c| c.max_pages = 5}
+      end
+      its(:max_pages) { should == 5 }
+      after do
+        Kaminari.configure {|c| c.max_pages = nil}
+      end
+    end
+  end
+end

data/spec/fake_app/active_record/config.rb

@@ -0,0 +1,3 @@
+# database
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('test')

data/spec/fake_app/active_record/models.rb

@@ -0,0 +1,57 @@
+# models
+class User < ActiveRecord::Base
+  has_many :authorships
+  has_many :readerships
+  has_many :books_authored, :through => :authorships, :source => :book
+  has_many :books_read, :through => :readerships, :source => :book
+  has_many :addresses, :class_name => 'User::Address'
+
+  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
+# a model that is a descendant of AR::Base but doesn't directly inherit AR::Base
+class Admin < User
+end
+# a model with namespace
+class User::Address < ActiveRecord::Base
+  belongs_to :user
+end
+
+#migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:gem_defined_models) { |t| t.string :name; t.integer :age }
+    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 }
+    create_table(:user_addresses) {|t| t.string :street; t.integer :user_id }
+  end
+end
+ActiveRecord::Migration.verbose = false
+CreateAllTables.up

data/spec/fake_app/data_mapper/config.rb

@@ -0,0 +1 @@
+DataMapper.setup(:default, 'sqlite::memory:')

data/spec/fake_app/data_mapper/models.rb

@@ -0,0 +1,27 @@
+class User
+  include ::DataMapper::Resource
+
+  property :id, Serial
+  property :name, String, :required => true
+  property :age, Integer
+
+  has n, :projects, :through => Resource
+end
+
+class User::Address
+  include ::DataMapper::Resource
+
+  property :id, Serial
+end
+
+class Project
+  include ::DataMapper::Resource
+
+  property :id, Serial
+  property :name, String, :required => true
+
+  has n, :users, :through => Resource
+end
+
+DataMapper.finalize
+DataMapper.auto_migrate!

data/spec/fake_app/mongo_mapper/config.rb

@@ -0,0 +1,2 @@
+MongoMapper.connection = Mongo::Connection.new 'localhost', 27017
+MongoMapper.database = 'kaminari_test'

data/spec/fake_app/mongo_mapper/models.rb

@@ -0,0 +1,9 @@
+class User
+  include ::MongoMapper::Document
+  key :name, String
+  key :age, Integer
+end
+
+class User::Address
+  include ::MongoMapper::Document
+end