kaminari-rails4 0.15.0

data/kaminari.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "kaminari/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'kaminari-rails4'
+  s.version     = Kaminari::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Akira Matsuda']
+  s.email       = ['ronnie@dio.jp']
+  s.homepage    = 'https://github.com/amatsuda/kaminari'
+  s.summary     = 'A pagination engine plugin for Rails 3+ or other modern frameworks'
+  s.description = 'Kaminari is a Scope & Engine based, clean, powerful, agnostic, customizable and sophisticated paginator for Rails 3+'
+
+  s.rubyforge_project = 'kaminari-rails4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extra_rdoc_files = ['README.rdoc']
+  s.require_paths = ['lib']
+
+  s.licenses = ['MIT']
+
+  s.add_dependency 'activesupport', ['>= 3.0.0']
+  s.add_dependency 'actionpack', ['>= 3.0.0']
+
+  s.add_development_dependency 'bundler', ['>= 1.0.0']
+  s.add_development_dependency 'rake', ['>= 0']
+  s.add_development_dependency 'sqlite3', ['>= 0']
+  s.add_development_dependency 'tzinfo', ['>= 0']
+  s.add_development_dependency 'rspec', ['>= 0']
+  s.add_development_dependency 'rr', ['>= 0']
+  s.add_development_dependency 'capybara', ['>= 1.0']
+  s.add_development_dependency 'database_cleaner', ['>= 0']
+  s.add_development_dependency 'rdoc', ['>= 0']
+end

data/lib/generators/kaminari/config_generator.rb

@@ -0,0 +1,16 @@
+module Kaminari
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+
+      desc <<DESC
+Description:
+    Copies Kaminari configuration file to your application's initializer directory.
+DESC
+
+      def copy_config_file
+        template 'kaminari_config.rb', 'config/initializers/kaminari_config.rb'
+      end
+    end
+  end
+end

data/lib/generators/kaminari/templates/kaminari_config.rb

@@ -0,0 +1,10 @@
+Kaminari.configure do |config|
+  # config.default_per_page = 25
+  # config.max_per_page = nil
+  # config.window = 4
+  # config.outer_window = 0
+  # config.left = 0
+  # config.right = 0
+  # config.page_method_name = :page
+  # config.param_name = :page
+end

data/lib/generators/kaminari/views_generator.rb

@@ -0,0 +1,118 @@
+module Kaminari
+  module Generators
+
+    class ViewsGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../../../../app/views/kaminari', __FILE__)
+
+      class_option :template_engine, :type => :string, :aliases => '-e', :desc => 'Template engine for the views. Available options are "erb", "haml", and "slim".'
+
+      def self.banner #:nodoc:
+        <<-BANNER.chomp
+rails g kaminari:views THEME [options]
+
+    Copies all paginator partial templates to your application.
+    You can choose a template THEME by specifying one from the list below:
+
+        - default
+            The default one.
+            This one is used internally while you don't override the partials.
+#{themes.map {|t| "        - #{t.name}\n#{t.description}"}.join("\n")}
+BANNER
+      end
+
+      desc ''
+      def copy_or_fetch #:nodoc:
+        return copy_default_views if file_name == 'default'
+
+        themes = self.class.themes
+        if theme = themes.detect {|t| t.name == file_name}
+          download_templates theme
+        else
+          say %Q[no such theme: #{file_name}\n  avaliable themes: #{themes.map(&:name).join ", "}]
+        end
+      end
+
+      private
+      def self.themes
+        begin
+          @themes ||= GitHubApiHelper.get_files_in_master.group_by {|fn, _| fn[0...(fn.index('/') || 0)]}.delete_if {|fn, _| fn.blank?}.map do |name, files|
+            Theme.new name, files
+          end
+        rescue SocketError
+          []
+        end
+      end
+
+      def download_templates(theme)
+        theme.templates_for(template_engine).each do |template|
+          say "      downloading #{template.name} from kaminari_themes..."
+          create_file template.name, GitHubApiHelper.get_content_for("#{theme.name}/#{template.name}")
+        end
+      end
+
+      def copy_default_views
+        filename_pattern = File.join self.class.source_root, "*.html.#{template_engine}"
+        Dir.glob(filename_pattern).map {|f| File.basename f}.each do |f|
+          copy_file f, "app/views/kaminari/#{f}"
+        end
+      end
+
+      def template_engine
+        options[:template_engine].try(:to_s).try(:downcase) || 'erb'
+      end
+    end
+
+    Template = Struct.new(:name, :sha) do
+      def description?
+        name == 'DESCRIPTION'
+      end
+
+      def view?
+        name =~ /^app\/views\//
+      end
+
+      def engine #:nodoc:
+        File.extname(name).sub /^\./, ''
+      end
+    end
+
+    class Theme
+      attr_accessor :name
+      def initialize(name, templates) #:nodoc:
+        @name, @templates = name, templates.map {|fn, sha| Template.new fn.sub(/^#{name}\//, ''), sha}
+      end
+
+      def description #:nodoc:
+        file = @templates.detect(&:description?)
+        return "#{' ' * 12}#{name}" unless file
+        GitHubApiHelper.get_content_for("#{@name}/#{file.name}").chomp.gsub(/^/, ' ' * 12)
+      end
+
+      def templates_for(template_engine) #:nodoc:
+        @templates.select {|t| !t.description?}.select {|t| !t.view? || (t.engine == template_engine)}
+      end
+    end
+
+    module GitHubApiHelper
+      def get_files_in_master
+        master_tree_sha = open('https://api.github.com/repos/amatsuda/kaminari_themes/git/refs/heads/master') do |json|
+          ActiveSupport::JSON.decode(json)['object']['sha']
+        end
+        open('https://api.github.com/repos/amatsuda/kaminari_themes/git/trees/' + master_tree_sha + '?recursive=1') do |json|
+          blobs = ActiveSupport::JSON.decode(json)['tree'].find_all {|i| i['type'] == 'blob' }
+          blobs.map do |blob|
+            [blob['path'], blob['sha']]
+          end
+        end
+      end
+      module_function :get_files_in_master
+
+      def get_content_for(path)
+        open('https://api.github.com/repos/amatsuda/kaminari_themes/contents/' + path) do |json|
+          Base64.decode64(ActiveSupport::JSON.decode(json)['content'])
+        end
+      end
+      module_function :get_content_for
+    end
+  end
+end

data/lib/kaminari.rb

@@ -0,0 +1,38 @@
+module Kaminari
+end
+
+# load Rails/Railtie
+begin
+  require 'rails'
+rescue LoadError
+  #do nothing
+end
+
+$stderr.puts <<-EOC if !defined?(Rails) && !defined?(Sinatra) && !defined?(Grape)
+warning: no framework detected.
+
+Your Gemfile might not be configured properly.
+---- e.g. ----
+Rails:
+    gem 'kaminari'
+
+Sinatra/Padrino:
+    gem 'kaminari', :require => 'kaminari/sinatra'
+
+Grape:
+    gem 'kaminari', :require => 'kaminari/grape'
+
+EOC
+
+# load Kaminari components
+require 'kaminari/config'
+require 'kaminari/helpers/paginator'
+require 'kaminari/models/page_scope_methods'
+require 'kaminari/models/configuration_methods'
+require 'kaminari/hooks'
+
+# if not using Railtie, call `Kaminari::Hooks.init` directly
+if defined? Rails
+  require 'kaminari/railtie'
+  require 'kaminari/engine'
+end

data/lib/kaminari/config.rb

@@ -0,0 +1,51 @@
+require 'active_support/configurable'
+
+module Kaminari
+  # Configures global settings for Kaminari
+  #   Kaminari.configure do |config|
+  #     config.default_per_page = 10
+  #   end
+  def self.configure(&block)
+    yield @config ||= Kaminari::Configuration.new
+  end
+
+  # Global settings for Kaminari
+  def self.config
+    @config
+  end
+
+  # need a Class for 3.0
+  class Configuration #:nodoc:
+    include ActiveSupport::Configurable
+    config_accessor :default_per_page
+    config_accessor :max_per_page
+    config_accessor :window
+    config_accessor :outer_window
+    config_accessor :left
+    config_accessor :right
+    config_accessor :page_method_name
+    config_accessor :max_pages
+
+    def param_name
+      config.param_name.respond_to?(:call) ? config.param_name.call : config.param_name
+    end
+
+    # define param_name writer (copied from AS::Configurable)
+    writer, line = 'def param_name=(value); config.param_name = value; end', __LINE__
+    singleton_class.class_eval writer, __FILE__, line
+    class_eval writer, __FILE__, line
+  end
+
+  # this is ugly. why can't we pass the default value to config_accessor...?
+  configure do |config|
+    config.default_per_page = 25
+    config.max_per_page = nil
+    config.window = 4
+    config.outer_window = 0
+    config.left = 0
+    config.right = 0
+    config.page_method_name = :page
+    config.param_name = :page
+    config.max_pages = nil
+  end
+end

data/lib/kaminari/engine.rb

@@ -0,0 +1,4 @@
+module Kaminari #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/kaminari/grape.rb

@@ -0,0 +1,4 @@
+require 'grape'
+require 'kaminari'
+
+Kaminari::Hooks.init

data/lib/kaminari/helpers/action_view_extension.rb

@@ -0,0 +1,151 @@
+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)
+      paginator = Kaminari::Helpers::Paginator.new self, 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.
+    #
+    # ==== 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.current_page - 1)), 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.current_page + 1)), 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 = if options[:entry_name]
+        options[:entry_name]
+      elsif collection.empty? || collection.is_a?(::Kaminari::PaginatableArray)
+        'entry'
+      else
+        if collection.respond_to? :model  # DataMapper
+          collection.model.model_name.human.downcase
+        else  # AR
+          collection.model_name.human.downcase
+        end
+      end
+      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 = ""
+
+      if !scope.first_page? && !scope.last_page?
+        # If not first and not last, then output both links.
+        output << '<link rel="next" href="' + url_for(params.merge(param_name => (scope.current_page + 1))) + '"/>'
+        output << '<link rel="prev" href="' + url_for(params.merge(param_name => (scope.current_page - 1))) + '"/>'
+      elsif scope.first_page?
+        # If first page, add next link unless last page.
+        output << '<link rel="next" href="' + url_for(params.merge(param_name => (scope.current_page + 1))) + '"/>' unless scope.last_page?
+      else
+        # If last page, add prev link unless first page.
+        output << '<link rel="prev" href="' + url_for(params.merge(param_name => (scope.current_page - 1))) + '"/>' unless scope.first_page?
+      end
+
+      output.html_safe
+    end
+
+  end
+end

data/lib/kaminari/helpers/paginator.rb

@@ -0,0 +1,186 @@
+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:
+        @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] ? "#{@options[:theme]}/" : ''
+        @options[:current_page] = PageProxy.new @window_options.merge(@options), @options[:current_page], nil
+        #FIXME for compatibility. remove num_pages at some time in the future
+        @options[:total_pages] ||= @options[:num_pages]
+        @options[:num_pages] ||= @options[:total_pages]
+        @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.merge(@options)).each do |i|
+          yield PageProxy.new(@window_options.merge(@options), i, @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(@options).merge :paginator => self
+          subscriber.render_without_logging = false
+
+          ret
+        else
+          super @window_options.merge(@options).merge :paginator => self
+        end
+      end
+
+      # 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