pagify 0.6.1

data/lib/pagify.rb

@@ -0,0 +1,14 @@
+
+module Pagify
+  autoload         :ArrayPager, 'pagify/array'
+  autoload    :DataMapperPager, 'pagify/data_mapper'
+  autoload  :ActiveRecordPager, 'pagify/active_record'
+end
+
+require 'pagify/pager/basic'
+require 'pagify/page/basic'
+
+require 'singleton'
+
+require 'pagify/pager/null'
+require 'pagify/page/null'

data/lib/pagify/active_record.rb

@@ -0,0 +1,17 @@
+
+# anything for active_record
+
+require 'pagify'
+require 'pagify/pager/detail/page_accept_string_or_blank'
+
+require 'pagify/pager/active_record'
+require 'pagify/pagifier/active_record'
+
+require 'pagify/array' # this was needed for active_record...
+
+# workaround for active_record...
+module Pagify
+  class ArrayPager < BasicPager
+    include PageAcceptStringOrBlank
+  end
+end

data/lib/pagify/array.rb

@@ -0,0 +1,6 @@
+
+# anything for array
+
+require 'pagify'
+require 'pagify/pager/array'
+require 'pagify/pagifier/array'

data/lib/pagify/data_mapper.rb

@@ -0,0 +1,8 @@
+
+# anything for data_mapper
+
+require 'pagify'
+require 'pagify/pager/detail/page_accept_string_or_blank'
+
+require 'pagify/pager/data_mapper'
+require 'pagify/pagifier/data_mapper'

data/lib/pagify/helper/abstract.rb

@@ -0,0 +1,112 @@
+
+module Pagify
+  module Helper
+    class Abstract
+      def self.default_attributes
+        {}
+      end
+
+      def self.setting
+        @setting ||= Setting.new(self)
+      end
+
+      attr_reader :pager
+      def initialize pager
+        @pager = pager
+      end
+
+      def setting
+        @setting ||= Setting.new(self, self.class.setting)
+      end
+
+      protected
+      def prepare_links page
+        size = pager.size
+        return [] if page < 1 || page > size
+
+        links_prev, links_post = caculate_2_parts(*caculate_4_parts(page, size))
+
+        current = links_prev.empty? && links_post.empty? ? [] : [page]
+
+        links_prev + current + links_post
+      end
+
+      private
+      def caculate_2_parts outer_prev, inner_prev, inner_post, outer_post
+        [ caculate_part(outer_prev, inner_prev),
+          caculate_part(inner_post, outer_post)  ]
+      end
+
+      # concat outer and inner, remove overlap
+      def caculate_part left, right
+        # don't use ellipsis if there's no spaces between them
+        ellipsis = !left.empty? && (left.last + 1) == right.first ?
+          [] : [setting[:ellipsis]]
+
+        part = left + ellipsis + right
+
+        # clean up overlap and remove '...' if
+        part.delete(setting[:ellipsis]) if
+          part.uniq!     || # there's overlap
+          part.size == 1    # no pages there
+
+        part
+      end
+
+      def caculate_4_parts page, size
+        inner_prev, inner_post = caculate_inner(setting[:inner_links], page, size)
+        outer_prev, outer_post = caculate_outer(setting[:outer_links], page, size,
+                                                inner_prev, inner_post)
+
+        [outer_prev, inner_prev, inner_post, outer_post]
+      end
+
+      def caculate_inner limit, page, size
+        prev, post = page - limit, page + limit
+
+        left   = extract_pages(  prev      ... page, size )
+        right  = extract_pages( (page + 1) ..  post, size )
+
+        # adding more right pages if left pages were not enough.
+        right.push(
+          *extract_pages(
+            (post + 1) .. (post + limit - left.size),  size )) if left.size < limit
+
+        # ditto
+        left.unshift(
+          *extract_pages(
+            (prev - limit - right.size) .. (prev - 1), size )) if right.size < limit
+
+        [left, right]
+      end
+
+      def caculate_outer limit, page, size, inner_prev, inner_post
+        # caculate index
+        prev_last  = [limit,            (inner_prev.first || 1)   ].min
+        post_first = [size - limit + 1, (inner_post.last  || size)].max
+
+        # create outer
+        outer_prev, outer_post = [ (          1 .. prev_last ).to_a,
+                                   ( post_first .. size      ).to_a  ]
+
+        # remove current page
+        outer_prev.delete(page)
+        outer_post.delete(page)
+
+        [outer_prev, outer_post]
+      end
+
+      def extract_pages range, size
+        range.map{ |i| page_exists?(i, size) }.compact
+      end
+
+      def page_exists? page, size
+        if page >= 1 && page <= size
+          page
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pagify/helper/detail/setting.rb

@@ -0,0 +1,54 @@
+
+require 'pagify/helper/abstract'
+
+module Pagify
+  module Helper
+    # TODO: refactor me!!
+    class Setting
+      def initialize helper, parent = {}
+        @helper = helper
+        @parent = parent
+        @attributes = extract_default_attributes helper
+      end
+
+      def [] key
+        if @attributes[key]
+           @attributes[key]
+        else
+          @parent[key]
+        end
+      end
+
+      def []= key, value
+        @attributes[key] = value
+      end
+
+      def to_hash
+        @attributes.dup
+      end
+
+      def restore_default!
+        @attributes = extract_default_attributes @helper
+      end
+
+      def additional_attributes
+        defaults = extract_default_attributes(
+                     @helper.kind_of?(Abstract) ? @helper.class : @helper).keys
+
+        @parent.to_hash.merge(@attributes).reject{ |key, value| defaults.member?(key) }
+      end
+
+      private
+      def extract_default_attributes helper
+        if helper.respond_to? :default_attributes
+          helper.default_attributes
+        else
+          {}
+        end
+      rescue NotImplementedError
+        {}
+      end
+
+    end # of Setting
+  end # of Helper
+end # of Pagify

data/lib/pagify/helper/detail/setup.rb

@@ -0,0 +1,23 @@
+
+module Pagify
+  module Helper
+    def self.setup helper_class
+      Pagify::BasicPager.module_eval do
+        helper_name = helper_class.to_s.downcase[/::?(\w+)$/, 1]
+        define_method helper_name do
+          variable_name = "@helper_#{helper_name}"
+          instance_variable_get(variable_name) or
+          instance_variable_set(variable_name, helper_class.new(self))
+        end
+      end
+
+      # hmm.... how should i define this method?
+      # Pagify::BasicPage.module_eval do
+      #   helper_name = helper_class.to_s.downcase[/::?(\w+)$/, 1]
+      #   define_method helper_name do
+      #     pager.__send__ helper_name
+      #   end
+      # end
+    end
+  end
+end

data/lib/pagify/helper/html.rb

@@ -0,0 +1,86 @@
+
+require 'pagify/helper/abstract'
+
+require 'pagify/helper/detail/setting'
+require 'pagify/helper/detail/setup'
+
+module Pagify
+  module Helper
+    class HTML < Abstract
+      def self.default_attributes
+        super.merge(
+        {  :first_text => '&laquo; First',
+            :last_text =>          'Last &raquo;',
+            :prev_text => '&lt; Previous',
+            :next_text =>          'Next &gt;',
+          :inner_links => 4,
+          :outer_links => 2,
+        #        :step => 3,
+          :separator   => ' ',
+          :ellipsis    => '...' })
+      end
+
+      def links_full page, &block
+        page = normalize_page(page)
+        "#{links_navigate(page, &block)}<br />#{links(page, &block)}"
+      end
+
+      def links_navigate page
+        page = normalize_page(page)
+        size = pager.size
+        attrs = extract_html_attributes
+
+        prev = if page > 1 && page_exists?(page - 1, size)
+                 "<a href=\"#{yield(page - 1)}\"#{attrs}>#{setting[:prev_text]}</a>"
+               else
+                 nil
+               end
+
+        post = if page < size && page_exists?(page + 1, size)
+                 "<a href=\"#{yield(page + 1)}\"#{attrs}>#{setting[:next_text]}</a>"
+               else
+                 nil
+               end
+
+        [prev, post].compact.join(setting[:separator])
+      end
+
+      def links page
+        page = normalize_page(page)
+        size = pager.size
+        attrs = extract_html_attributes
+
+        prepare_links(page).map{ |i|
+          if i == page
+            case page
+              when 1;    setting[:first_text]
+              when size; setting[ :last_text]
+              else;      page
+            end
+          else
+            case i
+              when 1;      "<a href=\"#{yield(i)}\"#{attrs}>#{setting[:first_text]}</a>"
+              when size;   "<a href=\"#{yield(i)}\"#{attrs}>#{setting[ :last_text]}</a>"
+              when Fixnum; "<a href=\"#{yield(i)}\"#{attrs}>#{i}</a>"
+              else;        i.to_s
+            end
+          end
+        }.join(setting[:separator])
+      end
+
+      private
+      def extract_html_attributes
+        attrs = setting.additional_attributes.
+                  map{ |key, value| "#{key}=\"#{value}\"" }.join(' ')
+
+        attrs = ' ' + attrs if attrs != ''
+        attrs
+      end
+
+      def normalize_page page
+        pager.__send__(:normalize_page, page)
+      end
+    end # of HTML
+    setup HTML
+  end # of Helper
+end # of Pagify

data/lib/pagify/helper/rails.rb

@@ -0,0 +1,23 @@
+
+require 'pagify/helper/html'
+
+module Pagify::Helper::Rails
+  def default_attributes
+    super.merge(:query_name => :page, :wrapper_class => 'pagination')
+  end
+end
+
+class Pagify::Helper::HTML
+  extend Pagify::Helper::Rails
+end
+
+module ApplicationHelper
+  def would_paginate objs, &path
+    path = lambda{ request.path } unless block_given?
+    html = objs.pager.html
+    name = html.setting[:query_name]
+    "<div class=\"#{html.setting[:wrapper_class]}\">" +
+    html.links_full(params[name]){ |p| path.call + "?#{name}=#{p}" } +
+    '</div>'
+  end
+end

data/lib/pagify/page/basic.rb

@@ -0,0 +1,56 @@
+
+module Pagify
+  # which was produced by Paginator#page / Paginator#[],
+  # representing page that contained target data.
+  # it would use lazy fetching, whenever you need the data,
+  # the fetcher would be invoked that time. whenever the data
+  # was fetched, it won't fetch again. it you need refetch,
+  # call Page#fetch
+  class BasicPage
+    # prvent Page#to_a return [#<Page:0x12345>]
+    undef_method :to_a if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9.0')
+
+    # pager to get the original pager; page to get the number of this page
+    attr_reader :pager, :page
+
+    # don't create a page instance yourself unless you have to
+    def initialize pager, page; @pager, @page = pager, page; end
+
+    # return the page instance next to this page
+    def next; pager.page(page + 1); end
+
+    # return the page instance prev to this page
+    def prev; pager.page(page - 1); end
+
+    # if the page numbers and the pagers are equal,
+    # then the pages are equal.
+    def == rhs
+      rhs.kind_of?(BasicPage) &&
+      page  == rhs.page       &&
+      pager == rhs.pager
+    end
+
+    # explicitly fetch the data from pager
+    def fetch; @data = pager.fetcher[self.begin, pager.per_page]; end
+
+    # get the data fetched from pager
+    def data; @data ||= fetch; end
+
+    # the real beginning index
+    def begin; pager.offset page; end
+
+    # the real ending index (need fetch, because we don't know the size)
+    def end; self.begin + self.size - 1; end
+
+    # any other method call would delegate to the data,
+    # e.g., each, to_a, map, first, method_you_defined, etc.
+    def method_missing msg, *args, &block
+      if data.respond_to?(msg)
+        data.__send__(msg, *args, &block)
+      else
+        super(msg, *args, &block)
+      end
+    end
+
+  end # of BasicPage
+end # of Pagify

data/lib/pagify/page/null.rb

@@ -0,0 +1,10 @@
+
+module Pagify
+  # a null page that stubs anything to 0 or [], etc.
+  class NullPage < BasicPage
+    def initialize pager = NullPager.instance, page = 0
+      super(pager, page)
+      @data = []
+    end
+  end
+end

data/lib/pagify/pager/active_record.rb

@@ -0,0 +1,30 @@
+
+# you'll need activerecord to use ActiveRecordPager
+
+module Pagify
+  # active_record paginator was provided for convenience,
+  # it wraps Paginator for you, and you can just pass the model class to it.
+  # you don't have to care about the fetcher and counter.
+  # additionally, you can pass other options to rails paginator,
+  # they would be used in find options. e.g.,
+  #  ActiveRecordPaginator.new Model, :order => 'created_at DESC'
+  # would invoke Model.find :all, :offset => ?, :limit => ?, order => 'created_at DESC'
+  class ActiveRecordPager < BasicPager
+    include PageAcceptStringOrBlank
+    # the model class that you passed in this paginator
+    attr_reader :model
+
+    def initialize model_class, opts = {}
+      @model = model_class
+      query_opts = reject_pager_opts(opts)
+
+      super(opts.merge(
+        :fetcher => lambda{ |offset, per_page|
+          model.find(:all, query_opts.merge(:offset => offset, :limit => per_page))
+        },
+        :counter => lambda{
+          model.count(query_opts)
+        }))
+    end
+  end # of ActiveRecordPager
+end # of Pagify