kaminari 0.16.3 → 1.2.1

data/lib/kaminari/helpers/action_view_extension.rb

@@ -1,132 +0,0 @@
-module Kaminari
-  # = Helpers
-  module ActionViewExtension
-    # A helper that renders the pagination links.
-    #
-    #   <%= 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 (:controller, :action, 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)
-      options[:total_pages] ||= options[:num_pages] || scope.total_pages
-
-      paginator = Kaminari::Helpers::Paginator.new(self, options.reverse_merge(:current_page => scope.current_page, :per_page => scope.limit_value, :remote => false))
-      paginator.to_s
-    end
-
-    # A simple "Twitter like" pagination link that creates a link to the previous page.
-    #
-    # ==== Examples
-    # Basic usage:
-    #
-    #   <%= link_to_previous_page @items, 'Previous Page' %>
-    #
-    # Ajax:
-    #
-    #   <%= link_to_previous_page @items, 'Previous Page', :remote => true %>
-    #
-    # By default, it renders nothing if there are no more results on the previous page.
-    # You can customize this output by passing a block.
-    #
-    #   <%= link_to_previous_page @users, 'Previous Page' do %>
-    #     <span>At the Beginning</span>
-    #   <% end %>
-    def link_to_previous_page(scope, name, options = {}, &block)
-      params = options.delete(:params) || {}
-      param_name = options.delete(:param_name) || Kaminari.config.param_name
-      link_to_unless scope.first_page?, name, params.merge(param_name => scope.prev_page), options.reverse_merge(:rel => 'previous') do
-        block.call if block
-      end
-    end
-
-    # A simple "Twitter like" pagination link that creates a link to the next page.
-    #
-    # ==== 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 block.
-    #
-    #   <%= link_to_next_page @users, 'Next Page' do %>
-    #     <span>No More Pages</span>
-    #   <% end %>
-    def link_to_next_page(scope, name, options = {}, &block)
-      params = options.delete(:params) || {}
-      param_name = options.delete(:param_name) || Kaminari.config.param_name
-      link_to_unless scope.last_page?, name, params.merge(param_name => scope.next_page), options.reverse_merge(:rel => 'next') do
-        block.call if block
-      end
-    end
-
-    # Renders a helpful message with numbers of displayed vs. total entries.
-    # Ported from mislav/will_paginate
-    #
-    # ==== Examples
-    # Basic usage:
-    #
-    #   <%= page_entries_info @posts %>
-    #   #-> Displaying posts 6 - 10 of 26 in total
-    #
-    # By default, the message will use the humanized class name of objects
-    # in collection: for instance, "project types" for ProjectType models.
-    # The namespace will be cutted out and only the last name will be used.
-    # Override this with the <tt>:entry_name</tt> parameter:
-    #
-    #   <%= page_entries_info @posts, :entry_name => 'item' %>
-    #   #-> Displaying items 6 - 10 of 26 in total
-    def page_entries_info(collection, options = {})
-      entry_name = options[:entry_name] || collection.entry_name
-      entry_name = entry_name.pluralize unless collection.total_count == 1
-
-      if collection.total_pages < 2
-        t('helpers.page_entries_info.one_page.display_entries', :entry_name => entry_name, :count => collection.total_count)
-      else
-        first = collection.offset_value + 1
-        last = collection.last_page? ? collection.total_count : collection.offset_value + collection.limit_value
-        t('helpers.page_entries_info.more_pages.display_entries', :entry_name => entry_name, :first => first, :last => last, :total => collection.total_count)
-      end.html_safe
-    end
-
-    # Renders rel="next" and rel="prev" links to be used in the head.
-    #
-    # ==== Examples
-    # Basic usage:
-    #
-    #   In head:
-    #   <head>
-    #     <title>My Website</title>
-    #     <%= yield :head %>
-    #   </head>
-    #
-    #   Somewhere in body:
-    #   <% content_for :head do %>
-    #     <%= rel_next_prev_link_tags @items %>
-    #   <% end %>
-    #
-    #   #-> <link rel="next" href="/items/page/3" /><link rel="prev" href="/items/page/1" />
-    #
-    def rel_next_prev_link_tags(scope, options = {})
-      params = options.delete(:params) || {}
-      param_name = options.delete(:param_name) || Kaminari.config.param_name
-
-      output = ""
-      output << '<link rel="next" href="' + url_for(params.merge(param_name => scope.next_page, :only_path => true)) + '"/>' if scope.next_page
-      output << '<link rel="prev" href="' + url_for(params.merge(param_name => scope.prev_page, :only_path => true)) + '"/>' if scope.prev_page
-
-      output.html_safe
-    end
-  end
-end

data/lib/kaminari/helpers/paginator.rb

@@ -1,195 +0,0 @@
-require 'active_support/inflector'
-require 'action_view'
-require 'action_view/log_subscriber'
-require 'action_view/context'
-require 'kaminari/helpers/tags'
-
-module Kaminari
-  module Helpers
-    # The main container tag
-    class Paginator < Tag
-      # so that this instance can actually "render"
-      include ::ActionView::Context
-
-      def initialize(template, options) #:nodoc:
-        #FIXME for compatibility. remove num_pages at some time in the future
-        options[:num_pages] ||= options[:total_pages]
-
-        @window_options = {}.tap do |h|
-          h[:window] = options.delete(:window) || options.delete(:inner_window) || Kaminari.config.window
-          outer_window = options.delete(:outer_window) || Kaminari.config.outer_window
-          h[:left] = options.delete(:left) || Kaminari.config.left
-          h[:left] = outer_window if h[:left] == 0
-          h[:right] = options.delete(:right) || Kaminari.config.right
-          h[:right] = outer_window if h[:right] == 0
-        end
-        @template, @options = template, options
-        @theme = @options[:theme]
-        @views_prefix = @options[:views_prefix]
-        @window_options.merge! @options
-        @window_options[:current_page] = @options[:current_page] = PageProxy.new(@window_options, @options[:current_page], nil)
-
-        @last = nil
-        # initialize the output_buffer for Context
-        @output_buffer = ActionView::OutputBuffer.new
-      end
-
-      # render given block as a view template
-      def render(&block)
-        instance_eval(&block) if @options[:total_pages] > 1
-        @output_buffer
-      end
-
-      # enumerate each page providing PageProxy object as the block parameter
-      # Because of performance reason, this doesn't actually enumerate all pages but pages that are seemingly relevant to the paginator.
-      # "Relevant" pages are:
-      # * pages inside the left outer window plus one for showing the gap tag
-      # * pages inside the inner window plus one on the left plus one on the right for showing the gap tags
-      # * pages inside the right outer window plus one for showing the gap tag
-      def each_relevant_page
-        return to_enum(:each_relevant_page) unless block_given?
-
-        relevant_pages(@window_options).each do |page|
-          yield PageProxy.new(@window_options, page, @last)
-        end
-      end
-      alias each_page each_relevant_page
-
-      def relevant_pages(options)
-        left_window_plus_one = 1.upto(options[:left] + 1).to_a
-        right_window_plus_one = (options[:total_pages] - options[:right]).upto(options[:total_pages]).to_a
-        inside_window_plus_each_sides = (options[:current_page] - options[:window] - 1).upto(options[:current_page] + options[:window] + 1).to_a
-
-        (left_window_plus_one + inside_window_plus_each_sides + right_window_plus_one).uniq.sort.reject {|x| (x < 1) || (x > options[:total_pages])}
-      end
-      private :relevant_pages
-
-      def page_tag(page)
-        @last = Page.new @template, @options.merge(:page => page)
-      end
-
-      %w[first_page prev_page next_page last_page gap].each do |tag|
-        eval <<-DEF
-          def #{tag}_tag
-            @last = #{tag.classify}.new @template, @options
-          end
-        DEF
-      end
-
-      def to_s #:nodoc:
-        subscriber = ActionView::LogSubscriber.log_subscribers.detect {|ls| ls.is_a? ActionView::LogSubscriber}
-
-        # There is a logging subscriber
-        # and we don't want it to log render_partial
-        # It is threadsafe, but might not repress logging
-        # consistently in a high-load environment
-        if subscriber
-          unless defined? subscriber.render_partial_with_logging
-            class << subscriber
-              alias_method :render_partial_with_logging, :render_partial
-              attr_accessor :render_without_logging
-              # ugly hack to make a renderer where
-              # we can turn logging on or off
-              def render_partial(event)
-                render_partial_with_logging(event) unless render_without_logging
-              end
-            end
-          end
-
-          subscriber.render_without_logging = true
-          ret = super @window_options.merge :paginator => self
-          subscriber.render_without_logging = false
-
-          ret
-        else
-          super @window_options.merge :paginator => self
-        end
-      end
-
-      # delegates view helper methods to @template
-      def method_missing(name, *args, &block)
-        @template.respond_to?(name) ? @template.send(name, *args, &block) : super
-      end
-      private :method_missing
-
-      # Wraps a "page number" and provides some utility methods
-      class PageProxy
-        include Comparable
-
-        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[:total_pages]
-        end
-
-        # the previous page or not
-        def prev?
-          @page == @options[:current_page] - 1
-        end
-
-        # the next page or not
-        def next?
-          @page == @options[:current_page] + 1
-        end
-
-        # within the left outer window or not
-        def left_outer?
-          @page <= @options[:left]
-        end
-
-        # within the right outer window or not
-        def right_outer?
-          @options[:total_pages] - @page < @options[:right]
-        end
-
-        # inside the inner window or not
-        def inside_window?
-          (@options[:current_page] - @page).abs <= @options[:window]
-        end
-
-        # The last rendered tag was "truncated" or not
-        def was_truncated?
-          @last.is_a? Gap
-        end
-
-        def to_i
-          number
-        end
-
-        def to_s
-          number.to_s
-        end
-
-        def +(other)
-          to_i + other.to_i
-        end
-
-        def -(other)
-          to_i - other.to_i
-        end
-
-        def <=>(other)
-          to_i <=> other.to_i
-        end
-      end
-    end
-  end
-end

data/lib/kaminari/helpers/sinatra_helpers.rb

@@ -1,176 +0,0 @@
-require 'active_support/core_ext/object'
-require 'active_support/core_ext/string'
-require 'action_dispatch/http/mime_type'
-
-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 previous page.
-      # Works on Sinatra.
-      #
-      # ==== Examples
-      # Basic usage:
-      #
-      #   <%= link_to_previous_page @items, 'Previous Page' %>
-      #
-      # Ajax:
-      #
-      #   <%= link_to_previous_page @items, 'Previous Page', :remote => true %>
-      #
-      # By default, it renders nothing if there are no more results on the previous page.
-      # You can customize this output by passing a parameter <tt>:placeholder</tt>.
-      #
-      #   <%= link_to_previous_page @users, 'Previous Page', :placeholder => %{<span>At the Beginning</span>} %>
-      #
-      def link_to_previous_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)
-
-        unless scope.first_page?
-          query = params.merge(param_name => scope.prev_page)
-          link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.reverse_merge(:rel => 'previous')
-        else
-          placeholder.to_s.html_safe
-        end
-      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)
-
-        unless scope.last_page?
-          query = params.merge(param_name => scope.next_page)
-          link_to name, env['PATH_INFO'] + (query.empty? ? '' : "?#{query.to_query}"), options.reverse_merge(:rel => 'next')
-        else
-          placeholder.to_s.html_safe
-        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

@@ -1,105 +0,0 @@
-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) || Kaminari.config.param_name
-        @theme = @options.delete(:theme)
-        @views_prefix = @options.delete(:views_prefix)
-        @params = @options[:params] ? template.params.merge(@options.delete :params) : template.params
-      end
-
-      def to_s(locals = {}) #:nodoc:
-        @template.render :partial => partial_path, :locals => @options.merge(locals), :formats => [:html]
-      end
-
-      def page_url_for(page)
-        @template.url_for @params.merge(@param_name => (page <= 1 ? nil : page), :only_path => true)
-      end
-
-      def partial_path
-        [
-         @views_prefix,
-         "kaminari",
-         @theme,
-         self.class.name.demodulize.underscore
-        ].compact.join("/")
-      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

@@ -1,36 +0,0 @@
-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::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'
-
-      ActiveSupport.on_load(:action_view) do
-        ::ActionView::Base.send :include, Kaminari::ActionViewExtension
-      end
-    end
-  end
-end

data/lib/kaminari/models/active_record_extension.rb

@@ -1,22 +0,0 @@
-require 'kaminari/models/active_record_model_extension'
-
-module Kaminari
-  module ActiveRecordExtension
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      # Future subclasses will pick up the model extension
-      def inherited(kls) #:nodoc:
-        super
-        kls.send(:include, Kaminari::ActiveRecordModelExtension) if kls.superclass == ::ActiveRecord::Base
-      end
-    end
-
-    included do
-      # 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

@@ -1,22 +0,0 @@
-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)
-      eval <<-RUBY
-        def self.#{Kaminari.config.page_method_name}(num = nil)
-          limit(default_per_page).offset(default_per_page * ((num = num.to_i - 1) < 0 ? 0 : num)).extending do
-            include Kaminari::ActiveRecordRelationMethods
-            include Kaminari::PageScopeMethods
-          end
-        end
-      RUBY
-    end
-  end
-end