kaminari 0.17.0 → 1.0.0.beta2

data/lib/kaminari/models/configuration_methods.rb

@@ -1,48 +0,0 @@
-module Kaminari
-  module ConfigurationMethods
-    extend ActiveSupport::Concern
-    module ClassMethods
-      # Overrides the default +per_page+ value per model
-      #   class Article < ActiveRecord::Base
-      #     paginates_per 10
-      #   end
-      def paginates_per(val)
-        @_default_per_page = val
-      end
-
-      # This model's default +per_page+ value
-      # returns +default_per_page+ value unless explicitly overridden via <tt>paginates_per</tt>
-      def default_per_page
-        (defined?(@_default_per_page) && @_default_per_page) || Kaminari.config.default_per_page
-      end
-
-      # Overrides the max +per_page+ value per model
-      #   class Article < ActiveRecord::Base
-      #     max_paginates_per 100
-      #   end
-      def max_paginates_per(val)
-        @_max_per_page = val
-      end
-
-      # This model's max +per_page+ value
-      # returns +max_per_page+ value unless explicitly overridden via <tt>max_paginates_per</tt>
-      def max_per_page
-        (defined?(@_max_per_page) && @_max_per_page) || Kaminari.config.max_per_page
-      end
-
-      # Overrides the max_pages value per model
-      #   class Article < ActiveRecord::Base
-      #     max_pages_per 100
-      #   end
-      def max_pages_per(val)
-        @_max_pages = val
-      end
-
-      # This model's max_pages value
-      # returns max_pages value unless explicitly overridden via <tt>max_pages_per</tt>
-      def max_pages
-        (defined?(@_max_pages) && @_max_pages) || Kaminari.config.max_pages
-      end
-    end
-  end
-end

data/lib/kaminari/models/data_mapper_collection_methods.rb

@@ -1,19 +0,0 @@
-module Kaminari
-  module DataMapperCollectionMethods
-    def entry_name
-      model.model_name.human.downcase
-    end
-
-    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

@@ -1,51 +0,0 @@
-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)
-          model = self
-          model = self.model if self.is_a? DataMapper::Collection
-          num = [num.to_i, 1].max - 1
-          all(:limit => model.default_per_page, :offset => model.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::DataMapperCollectionMethods
-        include Paginatable
-
-        delegate :default_per_page, :max_per_page, :max_pages, :to => :model
-      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

@@ -1,18 +0,0 @@
-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

@@ -1,40 +0,0 @@
-module Kaminari
-  module MongoidCriteriaMethods
-    def initialize_copy(other) #:nodoc:
-      @total_count = nil
-      super
-    end
-
-    def entry_name
-      model_name.human.downcase
-    end
-
-    def limit_value #:nodoc:
-      options[:limit]
-    end
-
-    def offset_value #:nodoc:
-      options[:skip]
-    end
-
-    def total_count #:nodoc:
-      @total_count ||= if embedded?
-        unpage.count
-      else
-        if options[:max_scan] && options[:max_scan] < count
-          options[:max_scan]
-        else
-          count
-        end
-      end
-    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

@@ -1,26 +0,0 @@
-require 'kaminari/models/mongoid_criteria_methods'
-
-module Kaminari
-  module MongoidExtension
-    module Document
-      extend ActiveSupport::Concern
-      include Kaminari::ConfigurationMethods
-
-      included do
-        scope Kaminari.config.page_method_name, Proc.new {|num|
-          limit(default_per_page).offset(default_per_page * ((num = num.to_i - 1) < 0 ? 0 : num))
-        } do
-          include Kaminari::MongoidCriteriaMethods
-          include Kaminari::PageScopeMethods
-        end
-      end
-
-      module ClassMethods
-        def inherited(kls)
-          super
-          kls.send(:include, Kaminari::MongoidExtension::Document.dup)
-        end
-      end if Mongoid::VERSION < '5.0.0'
-    end
-  end
-end

data/lib/kaminari/models/page_scope_methods.rb

@@ -1,73 +0,0 @@
-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
-
-    def num_pages
-      ActiveSupport::Deprecation.warn 'num_pages is deprecated and will be removed in Kaminari 1.0. Please use total_pages instead.'
-      total_pages
-    end
-
-    # 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

@@ -1,23 +0,0 @@
-module Kaminari
-  module PluckyCriteriaMethods
-    include Kaminari::PageScopeMethods
-
-    delegate :default_per_page, :max_per_page, :max_pages, :to => :model
-
-    def entry_name
-      model.model_name.human.downcase
-    end
-
-    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

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

data/lib/kaminari/sinatra.rb

@@ -1,7 +0,0 @@
-require 'sinatra/base'
-require 'kaminari'
-require 'kaminari/helpers/sinatra_helpers'
-
-ActiveSupport::Deprecation.warn 'Kaminari Sinatra support has been extracted to a separate gem, and will be removed in the next 1.0 release. Please bundle kaminari-sinatra gem.'
-
-Kaminari::Hooks.init

data/spec/config/config_spec.rb

@@ -1,91 +0,0 @@
-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

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

data/spec/fake_app/active_record/models.rb

@@ -1,65 +0,0 @@
-# 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, lambda { 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
-
-# a class that uses abstract class
-class Product < ActiveRecord::Base
-  self.abstract_class = true
-end
-class Device < Product
-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 }
-    create_table(:devices) {|t| t.string :name; t.integer :age}
-  end
-end
-ActiveRecord::Migration.verbose = false
-CreateAllTables.up