kaminari 0.17.0 → 1.0.0.beta2

data/gemfiles/sinatra_14.gemfile

@@ -1,33 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'sinatra', '~> 1.4.0'
-gem 'rspec', '~> 2.14.1'
-
-gem 'activerecord', '>= 4.0.0', :require => 'active_record'
-gem 'padrino-helpers', '~> 0.12.0'
-
-gem 'rack-test', '>= 0'
-gem 'sinatra-contrib', '~> 1.4.0'
-
-if RUBY_VERSION == '1.9.3'
-  gem 'mime-types', '2.99'
-end
-
-platforms :ruby do
-  if RUBY_VERSION > "2.1.0"
-    gem 'sqlite3'
-  else
-    gem 'sqlite3', '1.3.8'
-  end
-end
-platforms :jruby do
-  gem 'activerecord-jdbcsqlite3-adapter', '>= 1.3.0'
-end
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-  gem 'racc'
-  gem 'rubysl-test-unit'
-  gem 'rubinius-developer_tools'
-end
-
-gemspec :path => '../'

data/lib/generators/kaminari/config_generator.rb

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

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

@@ -1,119 +0,0 @@
-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'
-
-        if theme = self.class.themes.detect {|t| t.name == file_name}
-          if download_templates(theme).empty?
-            say %Q[template_engine: #{template_engine} is not available for theme: #{file_name}]
-          end
-        else
-          say %Q[no such theme: #{file_name}\n  avaliable themes: #{self.class.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.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.read)['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.read)['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.read)['content'])
-        end
-      end
-      module_function :get_content_for
-    end
-  end
-end

data/lib/kaminari/config.rb

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

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

data/lib/kaminari/grape.rb

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

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 = (sum = collection.offset_value + collection.limit_value) > collection.total_count ? collection.total_count : sum
-        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:
-        ActiveSupport::Deprecation.warn 'num_pages is deprecated and will be removed in Kaminari 1.0. Please use total_pages instead.' if options.has_key? :num_pages
-        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