kaminari-rails4 0.15.0

data/lib/kaminari/helpers/sinatra_helpers.rb

@@ -0,0 +1,144 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/string'
+
+begin
+
+require 'padrino-helpers'
+module Kaminari::Helpers
+  module SinatraHelpers
+    class << self
+      def registered(app)
+        app.register Padrino::Helpers
+        app.helpers  HelperMethods
+        @app = app
+      end
+
+      def view_paths
+        @app.views
+      end
+
+      alias included registered
+    end
+
+    class ActionViewTemplateProxy
+      include Padrino::Helpers::OutputHelpers
+      include Padrino::Helpers::TagHelpers
+      include Padrino::Helpers::AssetTagHelpers
+      include Padrino::Helpers::FormatHelpers
+      include Padrino::Helpers::TranslationHelpers
+
+      def initialize(opts={})
+        @current_path = opts[:current_path]
+        @param_name = (opts[:param_name] || :page).to_sym
+        @current_params = opts[:current_params]
+        @current_params.delete(@param_name)
+      end
+
+      def render(*args)
+        base = ActionView::Base.new.tap do |a|
+          a.view_paths << SinatraHelpers.view_paths
+          a.view_paths << File.expand_path('../../../../app/views', __FILE__)
+        end
+        base.render(*args)
+      end
+
+      def url_for(params)
+        extra_params = {}
+        if page = params[@param_name] and page != 1
+          extra_params[@param_name] = page
+        end
+        query = @current_params.merge(extra_params)
+        @current_path + (query.empty? ? '' : "?#{query.to_query}")
+      end
+
+      def link_to_unless(condition, name, options = {}, html_options = {}, &block)
+        options = url_for(options) if options.is_a? Hash
+        if condition
+          if block_given?
+            block.arity <= 1 ? capture(name, &block) : capture(name, options, html_options, &block)
+          else
+            name
+          end
+        else
+          link_to(name, options, html_options)
+        end
+      end
+
+      def params
+        @current_params
+      end
+    end
+
+    module HelperMethods
+      # A helper that renders the pagination links - for Sinatra.
+      #
+      #   <%= paginate @articles %>
+      #
+      # ==== Options
+      # * <tt>:window</tt> - The "inner window" size (4 by default).
+      # * <tt>:outer_window</tt> - The "outer window" size (0 by default).
+      # * <tt>:left</tt> - The "left outer window" size (0 by default).
+      # * <tt>:right</tt> - The "right outer window" size (0 by default).
+      # * <tt>:params</tt> - url_for parameters for the links (:id, :locale, etc.)
+      # * <tt>:param_name</tt> - parameter name for page number in the links (:page by default)
+      # * <tt>:remote</tt> - Ajax? (false by default)
+      # * <tt>:ANY_OTHER_VALUES</tt> - Any other hash key & values would be directly passed into each tag as :locals value.
+      def paginate(scope, options = {}, &block)
+        current_path = env['PATH_INFO'] rescue nil
+        current_params = Rack::Utils.parse_query(env['QUERY_STRING']).symbolize_keys rescue {}
+        paginator = Kaminari::Helpers::Paginator.new(
+          ActionViewTemplateProxy.new(:current_params => current_params, :current_path => current_path, :param_name => options[:param_name] || Kaminari.config.param_name),
+          options.reverse_merge(:current_page => scope.current_page, :total_pages => scope.total_pages, :per_page => scope.limit_value, :param_name => Kaminari.config.param_name, :remote => false)
+        )
+        paginator.to_s
+      end
+
+      # A simple "Twitter like" pagination link that creates a link to the next page.
+      # Works on Sinatra.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= link_to_next_page @items, 'Next Page' %>
+      #
+      # Ajax:
+      #
+      #   <%= link_to_next_page @items, 'Next Page', :remote => true %>
+      #
+      # By default, it renders nothing if there are no more results on the next page.
+      # You can customize this output by passing a parameter <tt>:placeholder</tt>.
+      #
+      #   <%= link_to_next_page @items, 'Next Page', :placeholder => %{<span>No More Pages</span>} %>
+      #
+      def link_to_next_page(scope, name, options = {})
+        params = options.delete(:params) || (Rack::Utils.parse_query(env['QUERY_STRING']).symbolize_keys rescue {})
+        param_name = options.delete(:param_name) || Kaminari.config.param_name
+        placeholder = options.delete(:placeholder)
+        query = params.merge(param_name => (scope.current_page + 1))
+        unless scope.last_page?
+          link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.reverse_merge(:rel => 'next')
+        else
+          placeholder
+        end
+      end
+    end
+  end
+end
+
+if defined? I18n
+  I18n.load_path += Dir.glob(File.expand_path('../../../../config/locales/*.yml', __FILE__))
+end
+
+rescue LoadError
+
+$stderr.puts "[!]You should install `padrino-helpers' gem if you want to use kaminari's pagination helpers with Sinatra."
+$stderr.puts "[!]Kaminari::Helpers::SinatraHelper does nothing now..."
+
+module Kaminari::Helpers
+  module SinatraHelper
+    def self.registered(*)
+    end
+  end
+end
+
+end

data/lib/kaminari/helpers/tags.rb

@@ -0,0 +1,95 @@
+module Kaminari
+  module Helpers
+    # A tag stands for an HTML tag inside the paginator.
+    # Basically, a tag has its own partial template file, so every tag can be
+    # rendered into String using its partial template.
+    #
+    # The template file should be placed in your app/views/kaminari/ directory
+    # with underscored class name (besides the "Tag" class. Tag is an abstract
+    # class, so _tag parital is not needed).
+    #   e.g.)  PrevLink  ->  app/views/kaminari/_prev_link.html.erb
+    #
+    # 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, 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 => "kaminari/#{@theme}#{self.class.name.demodulize.underscore}", :locals => @options.merge(locals), :formats => [:html]
+      end
+
+      def page_url_for(page)
+        @template.url_for @params.merge(@param_name => (page <= 1 ? nil : page))
+      end
+    end
+
+    # 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
+      # the link's href
+      def url
+        page_url_for page
+      end
+      def to_s(locals = {}) #:nodoc:
+        super locals.merge(:url => url)
+      end
+    end
+
+    # 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
+
+    # Link with page number that appears at the leftmost
+    class FirstPage < Tag
+      include Link
+      def page #:nodoc:
+        1
+      end
+    end
+
+    # Link with page number that appears at the rightmost
+    class LastPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:total_pages]
+      end
+    end
+
+    # The "previous" page of the current page
+    class PrevPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:current_page] - 1
+      end
+    end
+
+    # The "next" page of the current page
+    class NextPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:current_page] + 1
+      end
+    end
+
+    # Non-link tag that stands for skipped pages...
+    class Gap < Tag
+    end
+  end
+end

data/lib/kaminari/hooks.rb

@@ -0,0 +1,33 @@
+module Kaminari
+  class Hooks
+    def self.init
+      ActiveSupport.on_load(:active_record) do
+        require 'kaminari/models/active_record_extension'
+        ::ActiveRecord::Base.send :include, Kaminari::ActiveRecordExtension
+      end
+
+      begin; require 'data_mapper'; rescue LoadError; end
+      if defined? ::DataMapper
+        require 'dm-aggregates'
+        require 'kaminari/models/data_mapper_extension'
+        ::DataMapper::Collection.send :include, Kaminari::DataMapperExtension::Collection
+        ::DataMapper::Model.append_extensions Kaminari::DataMapperExtension::Model
+        # ::DataMapper::Model.send :extend, Kaminari::DataMapperExtension::Model
+      end
+
+      begin; require 'mongoid'; rescue LoadError; end
+      if defined? ::Mongoid
+        require 'kaminari/models/mongoid_extension'
+        ::Mongoid::Criteria.send :include, Kaminari::MongoidExtension::Criteria
+        ::Mongoid::Document.send :include, Kaminari::MongoidExtension::Document
+      end
+
+      ActiveSupport.on_load(:mongo_mapper) do
+        require 'kaminari/models/mongo_mapper_extension'
+        ::MongoMapper::Document.send :include, Kaminari::MongoMapperExtension::Document
+        ::Plucky::Query.send :include, Kaminari::PluckyCriteriaMethods
+      end
+      require 'kaminari/models/array_extension'
+    end
+  end
+end

data/lib/kaminari/models/active_record_extension.rb

@@ -0,0 +1,22 @@
+require 'kaminari/models/active_record_model_extension'
+
+module Kaminari
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+    included do
+      # Future subclasses will pick up the model extension
+      class << self
+        def inherited_with_kaminari(kls) #:nodoc:
+          inherited_without_kaminari kls
+          kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ActiveRecord::Base
+        end
+        alias_method_chain :inherited, :kaminari
+      end
+
+      # Existing subclasses pick up the model extension as well
+      self.descendants.each do |kls|
+        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ActiveRecord::Base
+      end
+    end
+  end
+end

data/lib/kaminari/models/active_record_model_extension.rb

@@ -0,0 +1,20 @@
+require 'kaminari/models/active_record_relation_methods'
+
+module Kaminari
+  module ActiveRecordModelExtension
+    extend ActiveSupport::Concern
+
+    included do
+      self.send(:include, Kaminari::ConfigurationMethods)
+
+      # Fetch the values at the specified page number
+      #   Model.page(5)
+      self.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::ActiveRecordRelationMethods
+        include Kaminari::PageScopeMethods
+      end
+    end
+  end
+end

data/lib/kaminari/models/active_record_relation_methods.rb

@@ -0,0 +1,29 @@
+module Kaminari
+  module ActiveRecordRelationMethods
+    # a workaround for AR 3.0.x that returns 0 for #count when page > 1
+    # if +limit_value+ is specified, load all the records and count them
+    if ActiveRecord::VERSION::STRING < '3.1'
+      def count(column_name = nil, options = {}) #:nodoc:
+        limit_value ? length : super(column_name, options)
+      end
+    end
+
+    def total_count(column_name = nil, options = {}) #:nodoc:
+      # #count overrides the #select which could include generated columns referenced in #order, so skip #order here, where it's irrelevant to the result anyway
+      @total_count ||= begin
+        c = except(:offset, :limit, :order)
+
+        # Remove includes only if they are irrelevant
+        c = c.except(:includes) unless references_eager_loaded_tables?
+
+        # .group returns an OrderdHash that responds to #count
+        c = c.count(column_name, options)
+        if c.is_a?(Hash) || c.is_a?(ActiveSupport::OrderedHash)
+          c.count
+        else
+          c.respond_to?(:count) ? c.count(column_name, options) : c
+        end
+      end
+    end
+  end
+end

data/lib/kaminari/models/array_extension.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/module'
+module Kaminari
+  # Kind of Array that can paginate
+  class PaginatableArray < Array
+    include Kaminari::ConfigurationMethods::ClassMethods
+
+    attr_internal_accessor :limit_value, :offset_value
+
+    # ==== Options
+    # * <tt>:limit</tt> - limit
+    # * <tt>:offset</tt> - offset
+    # * <tt>:total_count</tt> - total_count
+    def initialize(original_array = [], options = {})
+      @_original_array, @_limit_value, @_offset_value, @_total_count, @_padding = original_array, (options[:limit] || default_per_page).to_i, options[:offset].to_i, options[:total_count], options[:padding].to_i
+
+      if options[:limit] && options[:offset]
+        extend Kaminari::PageScopeMethods
+      end
+
+      if options[:total_count]
+        super original_array
+      else
+        super(original_array[@_offset_value, @_limit_value] || [])
+      end
+    end
+
+    # items at the specified "page"
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{Kaminari.config.page_method_name}(num = 1)
+        offset(limit_value * ([num.to_i, 1].max - 1))
+      end
+    RUBY
+
+    # returns another chunk of the original array
+    def limit(num)
+      self.class.new @_original_array, :limit => num, :offset => @_offset_value, :total_count => @_total_count, :padding => @_padding
+    end
+
+    # total item numbers of the original array
+    def total_count
+      @_total_count || @_original_array.count
+    end
+
+    # returns another chunk of the original array
+    def offset(num)
+      self.class.new @_original_array, :limit => @_limit_value, :offset => num, :total_count => @_total_count, :padding => @_padding
+    end
+  end
+
+  # Wrap an Array object to make it paginatable
+  # ==== Options
+  # * <tt>:limit</tt> - limit
+  # * <tt>:offset</tt> - offset
+  # * <tt>:total_count</tt> - total_count
+  def self.paginate_array(array, options = {})
+    PaginatableArray.new array, options
+  end
+end

data/lib/kaminari/models/configuration_methods.rb

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