bootstrap_pager 0.9.0

data/lib/bootstrap_pager/helpers/paginator.rb

@@ -0,0 +1,186 @@
+require 'active_support/inflector'
+require 'action_view'
+require 'action_view/log_subscriber'
+require 'action_view/context'
+require 'bootstrap_pager/helpers/tags'
+
+module BootstrapPager
+  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) || BootstrapPager.config.window
+          outer_window = options.delete(:outer_window) || BootstrapPager.config.outer_window
+          h[:left] = options.delete(:left) || BootstrapPager.config.left
+          h[:left] = outer_window if h[:left] == 0
+          h[:right] = options.delete(:right) || BootstrapPager.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

data/lib/bootstrap_pager/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 BootstrapPager::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 = BootstrapPager::Helpers::Paginator.new(
+          ActionViewTemplateProxy.new(:current_params => current_params, :current_path => current_path, :param_name => options[:param_name] || BootstrapPager.config.param_name),
+          options.reverse_merge(:current_page => scope.current_page, :total_pages => scope.total_pages, :per_page => scope.limit_value, :param_name => BootstrapPager.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) || BootstrapPager.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 bootstrap_pager's pagination helpers with Sinatra."
+$stderr.puts "[!]BootstrapPager::Helpers::SinatraHelper does nothing now..."
+
+module BootstrapPager::Helpers
+  module SinatraHelper
+    def self.registered(*)
+    end
+  end
+end
+
+end

data/lib/bootstrap_pager/helpers/tags.rb

@@ -0,0 +1,96 @@
+module BootstrapPager
+  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/bootstrap_pager/ directory
+    # with underscored class name (besides the "Tag" class. Tag is an abstract
+    # class, so _tag partial is not needed).
+    #   e.g.)  PrevLink  ->  app/views/bootstrap_pager/_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/bootstrap_pager-x.x.x/app/views/bootstrap_pager/_paginator.html.erb
+    class Tag
+      def initialize(template, options = {}) #:nodoc:
+        @template, @options = template, options.dup
+        @param_name = @options.delete(:param_name)
+        @engine_namespace = @options.delete(:engine_namespace)
+        @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 => "bootstrap_pager/#{@theme}#{self.class.name.demodulize.underscore}", :locals => @options.merge(locals), :formats => [:html]
+      end
+
+      def page_url_for(page)
+        (@engine_namespace || @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/bootstrap_pager/hooks.rb

@@ -0,0 +1,41 @@
+module BootstrapPager
+  class Hooks
+    def self.init
+      ActiveSupport.on_load(:active_record) do
+        require 'bootstrap_pager/models/active_record_extension'
+        ::ActiveRecord::Base.send :include, BootstrapPager::ActiveRecordExtension
+      end
+
+      begin; require 'data_mapper'; rescue LoadError; end
+      if defined? ::DataMapper
+        require 'dm-aggregates'
+        require 'bootstrap_pager/models/data_mapper_extension'
+        ::DataMapper::Collection.send :include, BootstrapPager::DataMapperExtension::Collection
+        ::DataMapper::Model.append_extensions BootstrapPager::DataMapperExtension::Model
+        # ::DataMapper::Model.send :extend, BootstrapPager::DataMapperExtension::Model
+      end
+
+      begin; require 'mongoid'; rescue LoadError; end
+      if defined? ::Mongoid
+        require 'bootstrap_pager/models/mongoid_extension'
+        ::Mongoid::Criteria.send :include, BootstrapPager::MongoidExtension::Criteria
+        ::Mongoid::Document.send :include, BootstrapPager::MongoidExtension::Document
+      end
+
+      ActiveSupport.on_load(:mongo_mapper) do
+        require 'bootstrap_pager/models/mongo_mapper_extension'
+        ::MongoMapper::Document.send :include, BootstrapPager::MongoMapperExtension::Document
+        ::Plucky::Query.send :include, BootstrapPager::PluckyCriteriaMethods
+      end
+
+      # Rails 3.0.x fails to load helpers in Engines (?)
+      if defined?(::ActionView) && ::ActionPack::VERSION::STRING < '3.1'
+        ActiveSupport.on_load(:action_view) do
+          require 'bootstrap_pager/helpers/action_view_extension'
+          ::ActionView::Base.send :include, BootstrapPager::ActionViewExtension
+        end
+      end
+      require 'bootstrap_pager/models/array_extension'
+    end
+  end
+end

data/lib/bootstrap_pager/models/active_record_extension.rb

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

data/lib/bootstrap_pager/models/active_record_model_extension.rb

@@ -0,0 +1,20 @@
+require 'bootstrap_pager/models/active_record_relation_methods'
+
+module BootstrapPager
+  module ActiveRecordModelExtension
+    extend ActiveSupport::Concern
+
+    included do
+      self.send(:include, BootstrapPager::ConfigurationMethods)
+
+      # Fetch the values at the specified page number
+      #   Model.page(5)
+      self.scope BootstrapPager.config.page_method_name, Proc.new {|num|
+        limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
+      } do
+        include BootstrapPager::ActiveRecordRelationMethods
+        include BootstrapPager::PageScopeMethods
+      end
+    end
+  end
+end

data/lib/bootstrap_pager/models/active_record_relation_methods.rb

@@ -0,0 +1,29 @@
+module BootstrapPager
+  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 OrderedHash 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/bootstrap_pager/models/array_extension.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/module'
+module BootstrapPager
+  # Kind of Array that can paginate
+  class PaginatableArray < Array
+    include BootstrapPager::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 BootstrapPager::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 #{BootstrapPager.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/bootstrap_pager/models/configuration_methods.rb

@@ -0,0 +1,48 @@
+module BootstrapPager
+  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) || BootstrapPager.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) || BootstrapPager.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) || BootstrapPager.config.max_pages
+      end
+    end
+  end
+end

data/lib/bootstrap_pager/models/data_mapper_collection_methods.rb

@@ -0,0 +1,15 @@
+module BootstrapPager
+  module DataMapperCollectionMethods
+    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