godfat-pagify 0.5.0

data/lib/pagify/array.rb

@@ -0,0 +1,6 @@
+
+# anything for array
+
+require 'pagify'
+require 'pagify/pagers/array'
+require 'pagify/pagifiers/array'

data/lib/pagify/basic.rb

@@ -0,0 +1,3 @@
+
+require 'pagify/pagers/basic'
+require 'pagify/pages/basic'

data/lib/pagify/data_mapper.rb

@@ -0,0 +1,16 @@
+
+# anything for data_mapper
+
+gem 'extlib', '<=0.9.8'
+gem 'dm-core', '<=0.9.7'
+gem 'dm-aggregates', '<=0.9.7'
+
+require 'dm-core'
+require 'dm-aggregates'
+
+require 'pagify'
+require 'pagify/pagers/details/page_accept_string_or_blank'
+
+require 'pagify/pagers/data_mapper'
+require 'pagify/pagifiers/data_mapper'
+

data/lib/pagify/helpers/abstract.rb

@@ -0,0 +1,92 @@
+
+module Pagify
+  module Helpers
+    class Abstract
+      def self.default_attributes
+        raise NotImplementedError
+      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_prev(outer_prev, inner_prev),
+          caculate_post(inner_post, outer_post)  ]
+      end
+      def caculate_prev outer_prev, inner_prev
+        # concat outer and inner, remove overlap
+        links_prev = outer_prev + [setting[:ellipsis]] + inner_prev
+
+        # clean up overlap and remove '...' if there's overlap or no pages there
+        links_prev.delete(setting[:ellipsis]) if links_prev.uniq! || links_prev.size == 1
+
+        links_prev
+      end
+      def caculate_post inner_post, outer_post
+        # concat outer and inner, remove overlap
+        links_post = inner_post + [setting[:ellipsis]] + outer_post
+
+        # clean up overlap and remove '...' if there's overlap or no pages there
+        links_post.delete(setting[:ellipsis]) if links_post.uniq! || links_post.size == 1
+
+        links_post
+      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
+        [ (1..limit).map{ |i| page_exists?(page - i, size) }.reverse.compact,
+          (1..limit).map{ |i| page_exists?(page + i, size) }.compact          ]
+      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 page_exists? page, size
+        if page >= 1 && page <= size
+          page
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pagify/helpers/details/setting.rb

@@ -0,0 +1,54 @@
+
+require 'pagify/helpers/abstract'
+
+module Pagify
+  module Helpers
+    # 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
+  end
+end

data/lib/pagify/helpers/details/setup.rb

@@ -0,0 +1,23 @@
+
+module Pagify
+  module Helpers
+    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/helpers/html.rb

@@ -0,0 +1,85 @@
+
+require 'pagify/helpers/abstract'
+
+require 'pagify/helpers/details/setting'
+require 'pagify/helpers/details/setup'
+
+module Pagify
+  module Helpers
+    class HTML < Abstract
+      def self.default_attributes
+        {  :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 />\n#{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
+    setup HTML
+  end
+end

data/lib/pagify/null.rb

@@ -0,0 +1,5 @@
+
+require 'singleton'
+
+require 'pagify/pagers/null'
+require 'pagify/pages/null'

data/lib/pagify/pagers/active_record.rb

@@ -0,0 +1,32 @@
+
+# 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
+
+end

data/lib/pagify/pagers/array.rb

@@ -0,0 +1,22 @@
+
+module Pagify
+  # array paginator would just simply assume your data is an array,
+  # and create pages simply for your_data[offset, per_page]
+  # if your data is much more complex, use Paginator instead of this
+  class ArrayPager < BasicPager
+    attr_reader :data
+
+    # data that you passed in this paginator
+    def initialize data, opts = {}
+      @data = data
+      super(opts.merge(
+        :fetcher => lambda{ |offset, per_page|
+          data[offset, per_page]
+        },
+        :counter => lambda{
+          data.size
+        }))
+    end
+
+  end
+end

data/lib/pagify/pagers/basic.rb

@@ -0,0 +1,114 @@
+
+module Pagify
+  # pager is something help you paginate the data,
+  # through the fetcher and counter you pass in.
+  # e.g., for a array, the fetcher would be array[offset, per_page],
+  # the counter would be array.size. and for data mapper's resource,
+  # fetcher would be Model.all :offset => offset, :limit => per_page.
+  # see ArrayPager and DataMapperPager, ActiveRecordPager, etc.
+  # if you just simply need them or have a look at the source code
+  # for example usage for Pager.
+  class BasicPager
+    include Enumerable
+    attr_reader :fetcher, :counter
+    attr_accessor :opts
+
+    [:per_page, :null_page].each{ |attr|
+      define_method(attr) do
+        opts[attr]
+      end
+
+      define_method("#{attr}=") do |new_value|
+        opts[attr] = new_value
+      end
+    }
+
+    #  fetcher is function that fetch the data,
+    #  counter is function that count the data,
+    #  null_page indicates that pager sohuld
+    # the default per_page is 20. you can reset per_page property later.
+    def initialize opts = {}
+      raise ArgumentError.new('missing fetcher and/or counter.') if
+        !opts[:fetcher] || !opts[:counter]
+
+      raise ArgumentError.new('fetcher or counter does not respond to call.') if
+        !opts[:fetcher].respond_to?(:call) || !opts[:counter].respond_to?(:call)
+
+      @opts     = {}
+      @fetcher  = opts[:fetcher]
+      @counter  = opts[:counter]
+
+      self.per_page  = opts[:per_page]  || 20
+      self.null_page = opts[:null_page] || true
+    end
+
+    # if two paginators are equal, then the properties of
+    # per_page, fetcher, counter are all equal.
+    def == rhs
+      return false unless rhs
+      self.per_page == rhs.per_page and
+      self.fetcher  == rhs.fetcher  and
+      self.counter  == rhs.counter
+    end
+
+    # for each page...
+    def each; 1.upto(size){ |i| yield page(i) }; end
+
+    # return all pages in an array
+    def to_a; map{ |e| e }; end
+    alias_method :pages, :to_a
+
+    def page_exists? page
+      page = normalize_page(page)
+      offset = (page - 1) * per_page
+      page > 0 && offset < entries_count
+    end
+
+    # create page instance by page number.
+    # if page number you specified was not existed,
+    # nil would be returned. note, page start at 1, not zero.
+    def page page
+      if page_exists?(page)
+        return BasicPage.new(self, normalize_page(page))
+
+      else
+        if null_page
+          return null_page_instance
+        else
+          return nil
+        end
+
+      end
+
+    end
+    alias_method :[], :page
+
+    # return the amount of pages
+    def size; (entries_count / per_page.to_f).ceil; end
+
+    # simply call @counter.call
+    def entries_count; counter.call; end
+
+    # get the offset property about the page.
+    # it is simply (page-1)*@per_page
+    def offset page
+      (normalize_page(page) - 1) * per_page
+    end
+
+    protected
+    def reject_pager_opts opts
+      opts.reject{ |key, value| [:per_page, :null_page].member?(key) }
+    end
+
+    # do nothing for basic pager
+    def normalize_page page
+      page
+    end
+
+    # return a null pager that stubs anything to 0
+    def null_page_instance
+      @null_page_instance ||= NullPage.new(self)
+    end
+
+  end
+end