leaf 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010 Peter Hellberg
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,4 @@
+# Leaf
+
+A _really_ simple pagination library, heavily based on the agnostic branch 
+of [will_paginate](http://github.com/mislav/will_paginate/tree/agnostic)

data/Rakefile

@@ -0,0 +1 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')

data/lib/leaf.rb

@@ -0,0 +1,10 @@
+# = Leafing through the pages!
+#
+# First read about Leaf::Finders::Base, then see
+# Leaf::ViewHelpers. The magical array you're handling in-between is
+# Leaf::Collection.
+#
+# Happy paginating!
+module Leaf
+  require 'leaf/view_helpers/sinatra'
+end

data/lib/leaf/array.rb

@@ -0,0 +1,31 @@
+require 'leaf/collection'
+
+class Array
+  # Paginates a static array (extracting a subset of it). The result is a
+  # Leaf::Collection instance, which is an array with a few more
+  # properties about its paginated state.
+  #
+  # Parameters:
+  # * <tt>:page</tt> - current page, defaults to 1
+  # * <tt>:per_page</tt> - limit of items per page, defaults to 30
+  # * <tt>:total_entries</tt> - total number of items in the array, defaults to
+  #   <tt>array.length</tt> (obviously)
+  #
+  # Example:
+  #   arr = ['a', 'b', 'c', 'd', 'e']
+  #   paged = arr.paginate(:per_page => 2)      #->  ['a', 'b']
+  #   paged.total_entries                       #->  5
+  #   arr.paginate(:page => 2, :per_page => 2)  #->  ['c', 'd']
+  #   arr.paginate(:page => 3, :per_page => 2)  #->  ['e']
+  #
+  # This method was originally {suggested by Desi
+  # McAdam}[http://www.desimcadam.com/archives/8]
+  def paginate(options = {})
+    raise ArgumentError, "parameter hash expected (got #{options.inspect})" unless Hash === options
+      Leaf::Collection.create options[:page] || 1,
+                              options[:per_page] || 30,
+                              options[:total_entries] || self.length do |pager|
+      pager.replace self[pager.offset, pager.per_page].to_a
+    end
+  end
+end

data/lib/leaf/collection.rb

@@ -0,0 +1,100 @@
+module Leaf
+  # = Invalid page number error
+  # This is an ArgumentError raised in case a page was requested that is either
+  # zero or negative number. You should decide how do deal with such errors in
+  # the controller.
+  class InvalidPage < ArgumentError
+    def initialize(page, page_num)
+      super "#{page.inspect} given as value, which translates to '#{page_num}' as page number"
+    end
+  end
+  
+  # = The key to pagination
+  # Arrays returned from paginating finds are, in fact, instances of this little
+  # class. You may think of Leaf::Collection as an ordinary array with
+  # some extra properties. Those properties are used by view helpers to generate
+  # correct page links.
+  #
+  #   gem 'leaf'
+  #   require 'leaf/collection'
+  #   
+  #   # now use Leaf::Collection directly or subclass it
+  class Collection < Array
+    attr_reader :current_page, :per_page, :total_entries, :total_pages
+
+    # Arguments to the constructor are the current page number, per-page limit
+    # and the total number of entries. The last argument is optional because it
+    # is best to do lazy counting; in other words, count *conditionally* after
+    # populating the collection using the +replace+ method.
+    def initialize(page, per_page, total = nil)
+      @current_page = page.to_i
+      raise InvalidPage.new(page, @current_page) if @current_page < 1
+      @per_page = per_page.to_i
+      raise ArgumentError, "`per_page` setting cannot be less than 1 (#{@per_page} given)" if @per_page < 1
+      
+      self.total_entries = total if total
+    end
+
+    # Just like +new+, but yields the object after instantiation and returns it
+    # afterwards. This is very useful for manual pagination:
+    def self.create(page, per_page, total = nil, &block)
+      pager = new(page, per_page, total)
+      yield pager
+      pager
+    end
+
+    # Helper method that is true when someone tries to fetch a page with a
+    # larger number than the last page. Can be used in combination with flashes
+    # and redirecting.
+    def out_of_bounds?
+      current_page > total_pages
+    end
+
+    # Current offset of the paginated collection. If we're on the first page,
+    # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+    # the offset is 30. This property is useful if you want to render ordinals
+    # besides your records: simply start with offset + 1.
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    # current_page - 1 or nil if there is no previous page
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    # current_page + 1 or nil if there is no next page
+    def next_page
+      current_page < total_pages ? (current_page + 1) : nil
+    end
+
+    def total_entries=(number)
+      @total_entries = number.to_i
+      @total_pages   = (@total_entries / per_page.to_f).ceil
+    end
+
+    # This is a magic wrapper for the original Array#replace method. It serves
+    # for populating the paginated collection after initialization.
+    #
+    # Why magic? Because it tries to guess the total number of entries judging
+    # by the size of given array. If it is shorter than +per_page+ limit, then we
+    # know we're on the last page. This trick is very useful for avoiding
+    # unnecessary hits to the database to do the counting after we fetched the
+    # data for the current page.
+    #
+    # However, after using +replace+ you should always test the value of
+    # +total_entries+ and set it to a proper value if it's +nil+. See the example
+    # in +create+.
+    def replace(array)
+      result = super
+      
+      # The collection is shorter then page limit? Rejoice, because
+      # then we know that we are on the last page!
+      if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+        self.total_entries = offset + length
+      end
+
+      result
+    end
+  end
+end

data/lib/leaf/core_ext.rb

@@ -0,0 +1,69 @@
+require 'set'
+require 'leaf/array'
+
+# helper to check for method existance in ruby 1.8- and 1.9-compatible way
+# because `methods`, `instance_methods` and others return strings in 1.8 and symbols in 1.9
+#
+#   ['foo', 'bar'].include_method?(:foo) # => true
+class Array
+  def include_method?(name)
+    name = name.to_sym
+    !!(find { |item| item.to_sym == name })
+  end
+end
+
+## everything below copied from ActiveSupport so we don't depend on it ##
+
+unless Hash.instance_methods.include_method? :except
+  Hash.class_eval do
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+  end
+end
+
+unless Hash.instance_methods.include_method? :slice
+  Hash.class_eval do
+    # Returns a new hash with only the given keys.
+    def slice(*keys)
+      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| !allowed.include?(key) }
+    end
+
+    # Replaces the hash with only the given keys.
+    def slice!(*keys)
+      replace(slice(*keys))
+    end
+  end
+end
+
+unless String.instance_methods.include_method? :constantize
+  String.class_eval do
+    def constantize
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+  end
+end
+
+unless String.instance_methods.include_method? :underscore
+  String.class_eval do
+    def underscore
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/leaf/finders.rb

@@ -0,0 +1,9 @@
+require 'leaf/core_ext'
+
+module Lead
+  # Database logic for different ORMs
+  #
+  # See Leaf::Finders::Base
+  module Finders
+  end
+end

data/lib/leaf/finders/base.rb

@@ -0,0 +1,82 @@
+require 'leaf/core_ext'
+
+module Leaf
+  module Finders
+    # = Database-agnostic finder module
+    # 
+    # Out of the box, leaf supports hooking in the Sequel ORM
+    module Base
+      def per_page
+        @per_page ||= 30
+      end
+      
+      def per_page=(limit)
+        @per_page = limit.to_i
+      end
+      
+      # This is the main paginating finder.
+      #
+      # == Special parameters for paginating finders
+      # * <tt>:page</tt> -- REQUIRED, but defaults to 1 if false or nil
+      # * <tt>:per_page</tt> -- defaults to <tt>CurrentModel.per_page</tt> (which is 30 if not overridden)
+      # * <tt>:total_entries</tt> -- use only if you manually count total entries
+      # * <tt>:count</tt> -- additional options that are passed on to +count+
+      # * <tt>:finder</tt> -- name of the finder method to use (default: "find")
+      #
+      # All other options (+conditions+, +order+, ...) are forwarded to +find+
+      # and +count+ calls.
+      def paginate(*args, &block)
+        options = args.pop
+        page, per_page, total_entries = wp_parse_options(options)
+
+        Leaf::Collection.create(page, per_page, total_entries) do |pager|
+          query_options = options.except :page, :per_page, :total_entries
+          wp_query(query_options, pager, args, &block)
+        end
+      end
+
+      # Iterates through all records by loading one page at a time. This is useful
+      # for migrations or any other use case where you don't want to load all the
+      # records in memory at once.
+      #
+      # It uses +paginate+ internally; therefore it accepts all of its options.
+      # You can specify a starting page with <tt>:page</tt> (default is 1). Default
+      # <tt>:order</tt> is <tt>"id"</tt>, override if necessary.
+      #
+      # {Jamis Buck describes this}[http://weblog.jamisbuck.org/2007/4/6/faking-cursors-in-activerecord]
+      # and also uses a more efficient way for MySQL.
+      def paginated_each(options = {}, &block)
+        options = { :order => 'id', :page => 1 }.merge options
+        options[:page] = options[:page].to_i
+        options[:total_entries] = 0 # skip the individual count queries
+        total = 0
+        
+        begin 
+          collection = paginate(options)
+          total += collection.each(&block).size
+          options[:page] += 1
+        end until collection.size < collection.per_page
+        
+        total
+      end
+      
+      protected
+        
+        def wp_parse_options(options)
+          raise ArgumentError, 'parameter hash expected' unless Hash === options
+          raise ArgumentError, ':page parameter required' unless options.key? :page
+          
+          if options[:count] and options[:total_entries]
+            raise ArgumentError, ':count and :total_entries are mutually exclusive'
+          end
+
+          page     = options[:page] || 1
+          per_page = options[:per_page] || self.per_page
+          total    = options[:total_entries]
+          
+          return [page, per_page, total]
+        end
+        
+    end
+  end
+end

data/lib/leaf/finders/sequel.rb

@@ -0,0 +1,22 @@
+require 'sequel'
+require 'sequel/extensions/pagination'
+
+existing_methods = Sequel::Dataset::Pagination.instance_methods
+
+Sequel::Dataset::Pagination.module_eval do
+  # it should quack like a Leaf::Collection
+  
+  alias :total_pages   :page_count  unless existing_methods.include_method? :total_pages
+  alias :per_page      :page_size   unless existing_methods.include_method? :per_page
+  alias :previous_page :prev_page   unless existing_methods.include_method? :previous_page
+  alias :total_entries :pagination_record_count unless existing_methods.include_method? :total_entries
+  
+  def out_of_bounds?
+    current_page > total_pages
+  end
+
+  # Current offset of the paginated collection
+  def offset
+    (current_page - 1) * per_page
+  end
+end

data/lib/leaf/version.rb

@@ -0,0 +1,9 @@
+module Leaf
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/leaf/view_helpers.rb

@@ -0,0 +1,34 @@
+module Leaf
+  # = Leaf view helpers
+  #
+  # The main view helper is +leaf+. It renders the pagination links
+  # for the given collection.
+  #
+  # Read more in Leaf::ViewHelpers::Base
+  module ViewHelpers
+    # ==== Global options for helpers
+    #
+    # Options for pagination helpers are optional and get their default values
+    # from the Leaf::ViewHelpers.pagination_options hash. You can write
+    # to this hash to override default options on the global level:
+    #
+    # Leaf::ViewHelpers.pagination_options[:previous_label] = 'Previous page'
+    def self.pagination_options() @pagination_options; end
+    # Overrides the default +pagination_options+
+    def self.pagination_options=(value) @pagination_options = value; end
+    
+    self.pagination_options = {
+      :class => 'pagination',
+      :previous_label => '← Previous',
+      :next_label => 'Next →',
+      :inner_window => 4, # links around the current page
+      :outer_window => 1, # links around beginning and end
+      :separator => ' ', # single space is friendly to spiders and non-graphic browsers
+      :param_name => :page,
+      :params => nil,
+      :renderer => 'Leaf::ViewHelpers::LinkRenderer',
+      :page_links => true,
+      :container => true
+    }
+  end
+end

data/lib/leaf/view_helpers/base.rb

@@ -0,0 +1,121 @@
+require 'leaf/core_ext'
+require 'leaf/view_helpers'
+
+module Leaf
+  module ViewHelpers
+    # = The main view helpers module
+    #
+    # This is the base module which provides the +leaf+ view helper.
+    module Base
+      # Renders Digg/Flickr-style pagination for a Leaf::Collection object. Nil is
+      # returned if there is only one page in total; pagination links aren't needed in that case.
+      # 
+      # ==== Options
+      # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
+      # * <tt>:previous_label</tt> -- default: "« Previous"
+      # * <tt>:next_label</tt> -- default: "Next »"
+      # * <tt>:inner_window</tt> -- how many links are shown around the current page (default: 4)
+      # * <tt>:outer_window</tt> -- how many links are around the first and the last page (default: 1)
+      # * <tt>:separator</tt> -- string separator for page HTML elements (default: single space)
+      # * <tt>:param_name</tt> -- parameter name for page number in URLs (default: <tt>:page</tt>)
+      # * <tt>:params</tt> -- additional parameters when generating pagination links
+      #   (eg. <tt>:controller => "foo", :action => nil</tt>)
+      # * <tt>:renderer</tt> -- class name, class or instance of a link renderer (default:
+      #   <tt>Leaf::LinkRenderer</tt>)
+      # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
+      # * <tt>:container</tt> -- toggles rendering of the DIV container for pagination links, set to
+      #   false only when you are rendering your own pagination markup (default: true)
+      # * <tt>:id</tt> -- HTML ID for the container (default: nil). Pass +true+ to have the ID
+      #   automatically generated from the class name of objects in collection: for example, paginating
+      #   ArticleComment models would yield an ID of "article_comments_pagination".
+      #
+      # All options beside listed ones are passed as HTML attributes to the container
+      # element for pagination links (the DIV). For example:
+      # 
+      #   <%= leaf @posts, :id => 'leaf_posts' %>
+      #
+      # ... will result in:
+      #
+      #   <div class="pagination" id="leaf_posts"> ... </div>
+      #
+      def leaf(collection, options = {})
+        # early exit if there is nothing to render
+        return nil unless collection.total_pages > 1
+        
+        options = Leaf::ViewHelpers.pagination_options.merge(options)
+        
+        # get the renderer instance
+        renderer = case options[:renderer]
+        when String
+          options[:renderer].constantize.new
+        when Class
+          options[:renderer].new
+        else
+          options[:renderer]
+        end
+        # render HTML for pagination
+        renderer.prepare collection, options, self
+        renderer.to_html
+      end
+      
+      # Renders a helpful message with numbers of displayed vs. total entries.
+      # You can use this as a blueprint for your own, similar helpers.
+      #
+      #   <%= 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.
+      # Override this to your liking with the <tt>:entry_name</tt> parameter:
+      #
+      #   <%= page_entries_info @posts, :entry_name => 'item' %>
+      #   #-> Displaying items 6 - 10 of 26 in total
+      #
+      # Entry name is entered in singular and pluralized with
+      # <tt>String#pluralize</tt> method from ActiveSupport. If it isn't
+      # loaded, specify plural with <tt>:plural_name</tt> parameter:
+      #
+      #   <%= page_entries_info @posts, :entry_name => 'item', :plural_name => 'items' %>
+      #
+      # By default, this method produces HTML output. You can trigger plain
+      # text output by passing <tt>:html => false</tt> in options.
+      def page_entries_info(collection, options = {})
+        entry_name = options[:entry_name] || (collection.empty?? 'entry' :
+                     collection.first.class.name.underscore.gsub('_', ' '))
+        
+        plural_name = if options[:plural_name]
+          options[:plural_name]
+        elsif entry_name == 'entry'
+          plural_name = 'entries'
+        elsif entry_name.respond_to? :pluralize
+          plural_name = entry_name.pluralize
+        else
+          entry_name + 's'
+        end
+
+        unless options[:html] == false
+          b  = '<b>'
+          eb = '</b>'
+          sp = '&nbsp;'
+        else
+          b  = eb = ''
+          sp = ' '
+        end
+        
+        if collection.total_pages < 2
+          case collection.size
+          when 0; "No #{plural_name} found"
+          when 1; "Displaying #{b}1#{eb} #{entry_name}"
+          else;   "Displaying #{b}all #{collection.size}#{eb} #{plural_name}"
+          end
+        else
+          %{Displaying #{plural_name} #{b}%d#{sp}-#{sp}%d#{eb} of #{b}%d#{eb} in total} % [
+            collection.offset + 1,
+            collection.offset + collection.length,
+            collection.total_entries
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/leaf/view_helpers/link_renderer.rb

@@ -0,0 +1,129 @@
+require 'leaf/core_ext'
+require 'leaf/view_helpers/link_renderer_base'
+
+module Leaf
+  module ViewHelpers
+    # This class does the heavy lifting of actually building the pagination
+    # links. It is used by +leaf+ helper internally.
+    class LinkRenderer < LinkRendererBase
+      
+      # * +collection+ is a Leaf::Collection instance or any other object
+      #   that conforms to that API
+      # * +options+ are forwarded from +leaf+ view helper
+      # * +template+ is the reference to the template being rendered
+      def prepare(collection, options, template)
+        super(collection, options)
+        @template = template
+        @container_attributes = @base_url_params = nil
+      end
+
+      # Process it! This method returns the complete HTML string which contains
+      # pagination links. Feel free to subclass LinkRenderer and change this
+      # method as you see fit.
+      def to_html
+        html = pagination.map do |item|
+          item.is_a?(Fixnum) ?
+            page_number(item) :
+            send(item)
+        end.join(@options[:separator])
+        
+        @options[:container] ? html_container(html) : html
+      end
+
+      # Returns the subset of +options+ this instance was initialized with that
+      # represent HTML attributes for the container element of pagination links.
+      def container_attributes
+        @container_attributes ||= begin
+          attributes = @options.except *(Leaf::ViewHelpers.pagination_options.keys - [:class])
+          # pagination of Post models will have the ID of "posts_pagination"
+          if @options[:container] and @options[:id] === true
+            attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
+          end
+          attributes
+        end
+      end
+      
+    protected
+    
+      def page_number(page)
+        unless page == current_page
+          link(page, page, :rel => rel_value(page))
+        else
+          tag(:em, page)
+        end
+      end
+      
+      def gap
+        '<span class="gap">&hellip;</span>'
+      end
+      
+      def previous_page
+        previous_or_next_page(@collection.previous_page, @options[:previous_label], 'previous_page')
+      end
+      
+      def next_page
+        previous_or_next_page(@collection.next_page, @options[:next_label], 'next_page')
+      end
+      
+      def previous_or_next_page(page, text, classname)
+        if page
+          link(text, page, :class => classname)
+        else
+          tag(:span, text, :class => classname + ' disabled')
+        end
+      end
+      
+      def html_container(html)
+        tag(:div, html, container_attributes)
+      end
+      
+      # Returns URL params for +page_link_or_span+, taking the current GET params
+      # and <tt>:params</tt> option into account.
+      def url(page)
+        raise NotImplementedError
+      end
+      
+    private
+
+      def link(text, target, attributes = {})
+        if target.is_a? Fixnum
+          attributes[:rel] = rel_value(target)
+          target = url(target)
+        end
+        attributes[:href] = target
+        tag(:a, text, attributes)
+      end
+      
+      def tag(name, value, attributes = {})
+        string_attributes = attributes.inject('') do |attrs, pair|
+          unless pair.last.nil?
+            attrs << %( #{pair.first}="#{Rack::Utils.escape_html(pair.last.to_s)}")
+          end
+          attrs
+        end
+        "<#{name}#{string_attributes}>#{value}</#{name}>"
+      end
+
+      def rel_value(page)
+        case page
+        when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
+        when @collection.next_page; 'next'
+        when 1; 'start'
+        end
+      end
+
+      def symbolized_update(target, other)
+        other.each do |key, value|
+          key = key.to_sym
+          existing = target[key]
+          
+          if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
+            symbolized_update(existing || (target[key] = {}), value)
+          else
+            target[key] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leaf/view_helpers/link_renderer_base.rb

@@ -0,0 +1,83 @@
+require 'leaf/view_helpers'
+
+module Leaf
+  module ViewHelpers
+    # This class does the heavy lifting of actually building the pagination
+    # links. It is used by +leaf+ helper internally.
+    class LinkRendererBase
+
+      # * +collection+ is a Leaf::Collection instance or any other object
+      #   that conforms to that API
+      # * +options+ are forwarded from +leaf+ view helper
+      def prepare(collection, options)
+        @collection = collection
+        @options    = options
+
+        # reset values in case we're re-using this instance
+        @total_pages = @param_name = nil
+      end
+      
+      def pagination
+        items = @options[:page_links] ? windowed_page_numbers : []
+        items.unshift :previous_page
+        items.push :next_page
+      end
+
+    protected
+    
+      # Calculates visible page numbers using the <tt>:inner_window</tt> and
+      # <tt>:outer_window</tt> options.
+      def windowed_page_numbers
+        inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
+        window_from = current_page - inner_window
+        window_to = current_page + inner_window
+        
+        # adjust lower or upper limit if other is out of bounds
+        if window_to > total_pages
+          window_from -= window_to - total_pages
+          window_to = total_pages
+        end
+        if window_from < 1
+          window_to += 1 - window_from
+          window_from = 1
+          window_to = total_pages if window_to > total_pages
+        end
+        
+        # these are always visible
+        middle = window_from..window_to
+
+        # left window
+        if outer_window + 3 < middle.first # there's a gap
+          left = (1..(outer_window + 1)).to_a
+          left << :gap
+        else # runs into visible pages
+          left = 1...middle.first
+        end
+
+        # right window
+        if total_pages - outer_window - 2 > middle.last # again, gap
+          right = ((total_pages - outer_window)..total_pages).to_a
+          right.unshift :gap
+        else # runs into visible pages
+          right = (middle.last + 1)..total_pages
+        end
+        
+        left.to_a + middle.to_a + right.to_a
+      end
+
+    private
+
+      def current_page
+        @collection.current_page
+      end
+
+      def total_pages
+        @collection.total_pages
+      end
+
+      def param_name
+        @param_name ||= @options[:param_name].to_s
+      end
+    end
+  end
+end

data/lib/leaf/view_helpers/sinatra.rb

@@ -0,0 +1,19 @@
+require 'leaf/view_helpers/base'
+require 'leaf/view_helpers/link_renderer'
+
+Leaf::ViewHelpers::LinkRenderer.class_eval do
+  protected
+  def url(page)
+    url = @template.request.url
+    if page == 1
+      # strip out page param and trailing ? if it exists
+      url.gsub(/page=[0-9]+/, '').gsub(/\?$/, '')
+    else
+      if url =~ /page=[0-9]+/
+        url.gsub(/page=[0-9]+/, "page=#{page}")
+      else
+        (url =~ /\?/) ? url + "&page=#{page}" : url + "?page=#{page}"
+      end      
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: leaf
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Peter Hellberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-24 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 2
+        - 0
+        version: 1.2.0
+  type: :runtime
+  version_requirements: *id001
+description: A really simple pagination library for Sinatra
+email: peter@c7.se
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/leaf/array.rb
+- lib/leaf/collection.rb
+- lib/leaf/core_ext.rb
+- lib/leaf/finders/base.rb
+- lib/leaf/finders/sequel.rb
+- lib/leaf/finders.rb
+- lib/leaf/version.rb
+- lib/leaf/view_helpers/base.rb
+- lib/leaf/view_helpers/link_renderer.rb
+- lib/leaf/view_helpers/link_renderer_base.rb
+- lib/leaf/view_helpers/sinatra.rb
+- lib/leaf/view_helpers.rb
+- lib/leaf.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/c7/leaf
+licenses: 
+- MIT-LICENSE
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: leaf
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple Sinatra pagination
+test_files: []
+