merb_paginate-gogolok 0.0.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008
+
+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

@@ -0,0 +1,64 @@
+########################################
+# There have been significant changes. #
+# Read below before upgrading.         #
+########################################
+
+merb_paginate
+=============
+
+Pagination that relies on the awesomeness that is the will_paginate gem.
+http://errtheblog.com/posts/56-im-paginating-again
+
+Lots of credit goes to those dudes. It's a fantastic plugin, it just is too 
+rails centric to use with merb out of the box. A lot of things had to be 
+changed to not rely on the magicness of rails (which is why it's not a fork 
+of the project).
+
+This merb plugin is very incomplete and has no specs (Hint: contribute!).
+
+Install
+=======
+
+git clone git://github.com/myobie/merb_paginate.git
+cd merb_paginate
+sudo rake install
+
+Example App
+===========
+
+An example app is now included in the example folder. It comes with a sqlite3
+database that has some posts already in it. I am not sure if the db is cross-
+platform, let me know.
+
+Usage
+=====
+
+Using this plugin is like so in init.rb:
+
+Merb::BootLoader.after_app_loads do 
+  dependency 'merb_paginate'
+end
+
+Right now, DataMapper and ActiveRecord work (Sequel might work, let me know). 
+I hope to have a fully speced paginate finder for each orm evenutally. 
+(Hint: contribute!)
+
+Using the view helper is like so:
+
+  <%= merb_paginate @posts %>
+  
+If you need to generate a more complex url you will need to do:
+
+  <%= merb_paginate @comments, :named_route => :post_comments %>
+
+It is almost exactly like will_paginate, except not as smart about the current collection.
+
+There are also:
+
+  <% paginated_section @posts do %>
+    ...
+  <% end %>
+
+and:
+
+  <%= page_entries_info @posts %>

data/Rakefile

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+PLUGIN = "merb_paginate"
+NAME = "merb_paginate-gogolok"
+GEM_VERSION = "0.0.4"
+AUTHOR = "Nathan Herald"
+EMAIL = "nathan@myobie.com"
+HOMEPAGE = "http://github.com/gogolok/merb_paginate"
+SUMMARY = "A pagination library for Merb that uses will_paginate internally"
+
+windows = (PLATFORM =~ /win32|cygwin/)
+
+SUDO = windows ? "" : "sudo"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency("merb-core", ">=0.9")
+  s.add_dependency("will_paginate", ">=2.2.0")
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Run :package and install resulting .gem"
+task :install => [:package] do
+  sh %{#{SUDO} gem install pkg/#{NAME}-#{GEM_VERSION} --no-rdoc --no-ri}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+
+Rake::RDocTask.new do |rdoc|
+      files = ['README', 'LICENSE',
+               'lib/**/*.rb']
+      rdoc.rdoc_files.add(files)
+      rdoc.main = 'README'
+      rdoc.title = 'Merb Helper Docs'
+      rdoc.rdoc_dir = 'doc/rdoc'
+      rdoc.options << '--line-numbers' << '--inline-source'
+end
+
+
+Spec::Rake::SpecTask.new do |t|
+   t.warning = true
+   t.spec_opts = ["--format", "specdoc", "--colour"]
+   t.spec_files = Dir['spec/**/*_spec.rb'].sort   
+end
+
+desc "Run all specs and generate an rcov report"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.rcov = true
+  t.rcov_dir = 'coverage'
+  t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
+end
+
+

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+* Add specs!
+* Complete dm_finder!
+* Add finders for other orms
+* Clean up the code

data/lib/merb_paginate.rb

@@ -0,0 +1,23 @@
+require 'will_paginate/collection'
+require 'merb_paginate/finders'
+require 'merb_paginate/view_helpers'
+
+if defined?(Merb::Plugins)
+  Merb::BootLoader.after_app_loads do
+    # Load in the ORM Helpers as needed
+    if Object.const_defined? "DataMapper"
+      require 'merb_paginate/finders/datamapper'
+      DataMapper::Resource.class_eval { include MerbPaginate::Finders::Datamapper }
+    end
+
+    if Object.const_defined? "Sequel"
+      require 'merb_paginate/finders/sequel'
+      SequelModel::Base.class_eval { include MerbPaginate::Finders::Sequel }
+    end
+
+    if Object.const_defined? "ActiveRecord"
+      require 'merb_paginate/finders/activerecord'
+      ActiveRecord::Base.class_eval { include MerbPaginate::Finders::Activerecord }
+    end
+  end
+end

data/lib/merb_paginate/core_ext.rb

@@ -0,0 +1,92 @@
+require 'set'
+require 'will_paginate/array'
+
+# copied from rails
+def mattr_reader(*syms)
+  syms.each do |sym|
+    next if sym.is_a?(Hash)
+    class_eval("unless defined? @@\#{sym}\n@@\#{sym} = nil\nend\n\ndef self.\#{sym}\n@@\#{sym}\nend\n\ndef \#{sym}\n@@\#{sym}\nend\n", __FILE__, __LINE__)
+  end
+end
+
+def returning(value)
+  yield(value)
+  value
+end
+
+# copied from will_paginate
+unless Hash.instance_methods.include? '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? 'reverse_merge'
+  Hash.class_eval do
+    def reverse_merge(other_hash)
+      other_hash.merge(self)
+    end
+  end
+end
+
+unless Hash.instance_methods.include? '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 Hash.instance_methods.include? 'rec_merge!'
+  Hash.class_eval do
+    # Same as Hash#merge!, but recursively merges sub-hashes
+    # (stolen from Haml)
+    def rec_merge!(other)
+      other.each do |key, other_value|
+        value = self[key]
+        if value.is_a?(Hash) and other_value.is_a?(Hash)
+          value.rec_merge! other_value
+        else
+          self[key] = other_value
+        end
+      end
+      self
+    end
+  end
+end
+
+class String
+  
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+  
+  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

data/lib/merb_paginate/finders.rb

@@ -0,0 +1 @@
+require 'merb_paginate/core_ext'

data/lib/merb_paginate/finders/activerecord.rb

@@ -0,0 +1,184 @@
+require 'merb_paginate/finders/generic'
+
+module MerbPaginate
+  module Finders
+    
+    module Activerecord
+      def self.included(base)
+        base.extend ClassMethods
+        class << base
+          alias_method_chain :method_missing, :paginate
+          # alias_method_chain :find_every,     :paginate
+          define_method(:per_page) { 30 } unless respond_to?(:per_page)
+        end
+      end
+
+      # = Paginating finders for ActiveRecord models
+      # 
+      # WillPaginate adds +paginate+ and +per_page+ methods to ActiveRecord::Base
+      # class methods and associations. It also hooks into +method_missing+ to
+      # intercept pagination calls to dynamic finders such as
+      # +paginate_by_user_id+ and translate them to ordinary finders
+      # (+find_all_by_user_id+ in this case).
+      # 
+      # In short, paginating finders are equivalent to ActiveRecord finders; the
+      # only difference is that we start with "paginate" instead of "find" and
+      # that <tt>:page</tt> is required parameter:
+      #
+      #   @posts = Post.paginate :all, :page => params[:page], :order => 'created_at DESC'
+      # 
+      # In paginating finders, "all" is implicit. There is no sense in paginating
+      # a single record, right? So, you can drop the <tt>:all</tt> argument:
+      # 
+      #   Post.paginate(...)              =>  Post.find :all
+      #   Post.paginate_all_by_something  =>  Post.find_all_by_something
+      #   Post.paginate_by_something      =>  Post.find_all_by_something
+      #
+      # == The importance of the <tt>:order</tt> parameter
+      #
+      # In ActiveRecord finders, <tt>:order</tt> parameter specifies columns for the
+      # <tt>ORDER BY</tt> clause in SQL. It is important to have it, since pagination only makes
+      # sense with ordered sets. Without the <tt>ORDER BY</tt> clause, databases aren't required
+      # to do consistent ordering when performing <tt>SELECT</tt> queries; this is especially true
+      # for PostgreSQL.
+      # 
+      module ClassMethods
+        include MerbPaginate::Finders::GenericOrmMethods # include the things that are shared
+        
+        # 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 ActiveRecord finder used (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)
+          finder = (options[:finder] || 'find').to_s
+
+          if finder == 'find'
+            # an array of IDs may have been given:
+            total_entries ||= (Array === args.first and args.first.size)
+            # :all is implicit
+            args.unshift(:all) if args.empty?
+          end
+
+          WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
+            count_options = options.except :page, :per_page, :total_entries, :finder
+            find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+
+            args << find_options
+            # @options_from_last_find = nil
+            pager.replace send(finder, *args, &block)
+
+            # magic counting for user convenience:
+            pager.total_entries = wp_count(count_options, args, finder) unless pager.total_entries
+          end
+        end
+
+        # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string
+        # based on the params otherwise used by paginating finds: +page+ and
+        # +per_page+.
+        #
+        # Example:
+        # 
+        #   @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000],
+        #                          :page => params[:page], :per_page => 3
+        #
+        # A query for counting rows will automatically be generated if you don't
+        # supply <tt>:total_entries</tt>. If you experience problems with this
+        # generated SQL, you might want to perform the count manually in your
+        # application.
+        # 
+        def paginate_by_sql(sql, options)
+          WillPaginate::Collection.create(*wp_parse_options(options)) do |pager|
+            query = sanitize_sql(sql)
+            original_query = query.dup
+            # add limit, offset
+            add_limit! query, :offset => pager.offset, :limit => pager.per_page
+            # perfom the find
+            pager.replace find_by_sql(query)
+
+            unless pager.total_entries
+              count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s]+$/mi, ''
+              count_query = "SELECT COUNT(*) FROM (#{count_query}) AS count_table"
+              # perform the count query
+              pager.total_entries = count_by_sql(count_query)
+            end
+          end
+        end
+
+        # def respond_to?(method, include_priv = false) #:nodoc:
+        #           case method.to_sym
+        #           when :paginate, :paginate_by_sql
+        #             true
+        #           else
+        #             super(method.to_s.sub(/^paginate/, 'find'), include_priv)
+        #           end
+        #         end
+
+      protected
+
+        def method_missing_with_paginate(method, *args, &block) #:nodoc:
+          #did somebody tried to paginate? if not, let them be
+          unless method.to_s.index('paginate') == 0
+            return method_missing_without_paginate(method, *args, &block) 
+          end
+
+          # paginate finders are really just find_* with limit and offset
+          finder = method.to_s.sub('paginate', 'find')
+          finder.sub!('find', 'find_all') if finder.index('find_by_') == 0
+
+          options = args.pop
+          raise ArgumentError, 'parameter hash expected' unless options.respond_to? :symbolize_keys
+          options = options.dup
+          options[:finder] = finder
+          args << options
+
+          paginate(*args, &block)
+        end
+
+        # Does the not-so-trivial job of finding out the total number of entries
+        # in the database. It relies on the ActiveRecord +count+ method.
+        def wp_count(options, args, finder)
+          excludees = [:count, :order, :limit, :offset, :readonly]
+          unless options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
+            excludees << :select # only exclude the select param if it doesn't begin with DISTINCT
+          end
+          # count expects (almost) the same options as find
+          count_options = options.except *excludees
+
+          # merge the hash found in :count
+          # this allows you to specify :select, :order, or anything else just for the count query
+          count_options.update options[:count] if options[:count]
+
+          # we may have to scope ...
+          counter = Proc.new { count(count_options) }
+
+          # we may be in a model or an association proxy!
+          klass = (@owner and @reflection) ? @reflection.klass : self
+
+          count = if finder.index('find_') == 0 and klass.respond_to?(scoper = finder.sub('find', 'with'))
+                    # scope_out adds a 'with_finder' method which acts like with_scope, if it's present
+                    # then execute the count with the scoping provided by the with_finder
+                    send(scoper, &counter)
+                  elsif match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(finder)
+                    # extract conditions from calls like "paginate_by_foo_and_bar"
+                    attribute_names = extract_attribute_names_from_match(match)
+                    conditions = construct_attributes_from_arguments(attribute_names, args)
+                    with_scope(:find => { :conditions => conditions }, &counter)
+                  else
+                    counter.call
+                  end
+
+          count.respond_to?(:length) ? count.length : count
+        end
+      end
+    end
+  end
+end

data/lib/merb_paginate/finders/datamapper.rb

@@ -0,0 +1,138 @@
+require 'merb_paginate/finders/generic'
+
+module MerbPaginate
+  module Finders
+    module Datamapper
+    
+    def self.included(base)
+      base.extend ClassMethods
+      class << base
+        define_method(:per_page) { 30 } unless respond_to?(:per_page)
+      end
+    end
+    
+    module ClassMethods
+      include MerbPaginate::Finders::GenericOrmMethods # include the things that are shared
+      
+      define_method(:per_page) { 30 } unless respond_to?(:per_page)
+      
+      # 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+
+      #
+      # All other options (+conditions+, +order+, ...) are forwarded to +all+
+      # and +count+ calls.
+      def paginate(options = {})
+        page, per_page, total_entries = wp_parse_options(options)
+
+        WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
+          count_options = options.except :page, :per_page, :total_entries
+          find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+    
+          pager.replace all(find_options)
+    
+          # magic counting for user convenience:
+          pager.total_entries = wp_count(count_options) unless pager.total_entries
+        end
+      end
+      
+    end
+    
+    end
+  end
+end
+
+# module MerbPaginate
+#   module Finders
+#     
+#     module Datamapper
+#       def self.included(base)
+#         base.extend ClassMethods
+#         class << base
+#           define_method(:per_page) { 30 } unless respond_to?(:per_page)
+#         end
+#       end
+# 
+#       module ClassMethods
+#         include MerbPaginate::Finders::GenericOrmMethods # include the things that are shared
+#         
+#         # 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+
+#         #
+#         # All other options (+conditions+, +order+, ...) are forwarded to +all+
+#         # and +count+ calls.
+#         def paginate(options = {})
+#           page, per_page, total_entries = wp_parse_options(options)
+# 
+#           WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
+#             count_options = options.except :page, :per_page, :total_entries
+#             find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+#       
+#             pager.replace all(find_options)
+#       
+#             # magic counting for user convenience:
+#             pager.total_entries = wp_count(count_options) unless pager.total_entries
+#           end
+#         end
+#   
+#         # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string
+#         # based on the params otherwise used by paginating finds: +page+ and
+#         # +per_page+.
+#         #
+#         # Example:
+#         # 
+#         #   @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000],
+#         #                          :page => params[:page], :per_page => 3
+#         #
+#         # A query for counting rows will automatically be generated if you don't
+#         # supply <tt>:total_entries</tt>. If you experience problems with this
+#         # generated SQL, you might want to perform the count manually in your
+#         # application.
+#         # 
+#         # def paginate_by_sql(sql, options)
+#         #   WillPaginate::Collection.create(*wp_parse_options(options)) do |pager|
+#         #     query = sanitize_sql(sql)
+#         #     original_query = query.dup
+#         #     # add limit, offset
+#         #     add_limit! query, :offset => pager.offset, :limit => pager.per_page
+#         #     # perfom the find
+#         #     pager.replace find_by_sql(query)
+#         #     
+#         #     unless pager.total_entries
+#         #       count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s]+$/mi, ''
+#         #       count_query = "SELECT COUNT(*) FROM (#{count_query}) AS count_table"
+#         #       # perform the count query
+#         #       pager.total_entries = count_by_sql(count_query)
+#         #     end
+#         #   end
+#         # end
+#   
+#         # ^^^^^
+#         # FIXME: Too busy to do this right now, someone help me out
+# 
+#         # def respond_to?(method, include_priv = false) #:nodoc:
+#         #   case method.to_sym
+#         #   when :paginate, :paginate_by_sql
+#         #     true
+#         #   else
+#         #     super(method, include_priv)
+#         #   end
+#         # end
+#   
+#         # ^^^^^
+#         # FIXME: Probly don't need this?
+# 
+#       end
+#     end
+#     
+#   end
+# end

data/lib/merb_paginate/finders/generic.rb

@@ -0,0 +1,50 @@
+module MerbPaginate
+  module Finders
+    
+    # A mixin for ORMs. Provides +per_page+ class method
+    module GenericOrmMethods
+      protected
+      
+      # Count it up!
+      def wp_count(options)
+        excludees = [:count, :order, :limit, :offset, :readonly]
+      
+        # unless options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
+        #   excludees << :select # only exclude the select param if it doesn't begin with DISTINCT
+        # end
+      
+        # ^^^^^^
+        # FIXME: Don't need select right now and I'm not even sure how it works in datamapper to be honest
+      
+        # count expects the same options as find
+        count_options = options.except *excludees
+        
+        # merge the hash found in :count
+        # this allows you to specify :select, :order, or anything else just for the count query
+        count_options.update options[:count] if options[:count]
+        
+        # !IMPORTANT!: this assumes all ORMs will have a count method
+        # if this assumtion turns out to be false, I will move this into the specific ORM finders
+        counter = count_options.empty? ? count : count(count_options) # don't pass in nothing (helps datamapper 0.2.5 and maybe others)
+        counter.respond_to?(:length) ? counter.length : counter # send back the length of the resulting count (either the length of the array or the number returned)
+      end
+      
+      def wp_parse_options(options) #:nodoc:
+        raise ArgumentError, 'parameter hash expected' unless options.is_a? Hash
+        options = options.to_mash # FIXME: where is this defined? I don't want to use anything that is not part of core_ext.rb
+        raise ArgumentError, ':page parameter required' unless options.key? :page # TODO: it's set as a default below, why is it needed here?
+      
+        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]
+        [page, per_page, total]
+      end
+
+    end
+  
+  end
+end

data/lib/merb_paginate/finders/sequel.rb

@@ -0,0 +1,38 @@
+# someone please show me some love :(
+
+require 'merb_paginate/finders/generic'
+
+module MerbPaginate
+  module Finders
+    
+    module Datamapper
+      def self.included(base)
+        base.extend ClassMethods
+        class << base
+          define_method(:per_page) { 30 } unless respond_to?(:per_page)
+        end
+      end
+
+      module ClassMethods
+        include MerbPaginate::Finders::GenericOrmMethods # include the things that are shared
+        
+        def paginate(options = {})
+          Merb.logger.info(" $$$ Sequel support in merb_paginate has not been tested at all. Please let me know if it works.")
+          page, per_page, total_entries = wp_parse_options(options)
+
+          WillPaginate::Collection.create(page, per_page, total_entries) do |pager|
+            count_options = options.except :page, :per_page, :total_entries
+            find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+      
+            pager.replace all(find_options)
+      
+            # magic counting for user convenience:
+            pager.total_entries = wp_count(count_options) unless pager.total_entries
+          end
+        end
+
+      end
+    end
+    
+  end
+end

data/lib/merb_paginate/view_helpers.rb

@@ -0,0 +1,267 @@
+# This file is very merb specific, but it only includes the ViewHelpers module if merb is already loaded
+
+require 'merb_paginate/core_ext'
+
+module MerbPaginate
+  # = MerbPaginate view helpers
+  #
+  # Currently there is only one view helper: +merb_paginate+. It renders the
+  # pagination links for the given collection. The helper itself is lightweight
+  # and serves only as a wrapper around link renderer instantiation; the
+  # renderer then does all the hard work of generating the HTML.
+  # 
+  # == Global options for helpers
+  #
+  # Options for pagination helpers are optional and get their default values from the
+  # MerbPaginate::ViewHelpers.pagination_options hash. You can write to this hash to
+  # override default options on the global level:
+  #
+  #   MerbPaginate::ViewHelpers.pagination_options[:prev_label] = 'Previous page'
+  #
+  # By putting this into your init.rb you can easily translate link texts to previous
+  # and next pages, as well as override some other defaults to your liking.
+  module ViewHelpers
+    # default options that can be overridden on the global level
+    @@pagination_options = {
+      :class        => 'pagination',
+      :prev_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     => 'MerbPaginate::LinkRenderer',
+      :page_links   => true,
+      :container    => true,
+      :namespace    => nil
+    }
+    
+    # there is not mattr_accessor here and it's not a big deal to just make these two getter/setter methods for now
+    
+    def self.pagination_options
+      @@pagination_options
+    end
+    
+    def self.pagination_options=(options)
+      @@pagination_options = options
+    end
+
+    # Renders Digg/Flickr-style pagination for a MerbPaginate::Collection
+    # object. Nil is returned if there is only one page in total; no point in
+    # rendering the pagination in that case...
+    # 
+    # ==== Options
+    # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
+    # * <tt>:prev_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 of the link renderer (default: WillPaginate::LinkRenderer)
+    # * <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:
+    # 
+    #   <%= merb_paginate @posts, :id => 'wp_posts' %>
+    #
+    # ... will result in:
+    #
+    #   <div class="pagination" id="wp_posts"> ... </div>
+    #
+    # There is not magic controller inference anynmore. Pass in the variable lazy.
+    #
+    def merb_paginate(collection, options = {}) # collection is required now! Booya!
+      # early exit if there is nothing to render
+      return nil unless collection.total_pages > 1
+      
+      options = options.to_mash.reverse_merge MerbPaginate::ViewHelpers.pagination_options.to_mash
+      # create the renderer instance
+      renderer_class = options[:renderer].to_s.constantize
+      renderer = renderer_class.new collection, options, self
+      # render HTML for pagination
+      renderer.to_html
+    end
+    
+    # Wrapper for rendering pagination links at both top and bottom of a block
+    # of content.
+    # 
+    #   <% paginated_section @posts do %>
+    #     <ol id="posts">
+    #       <% for post in @posts %>
+    #         <li> ... </li>
+    #       <% end %>
+    #     </ol>
+    #   <% end %>
+    #
+    # will result in:
+    #
+    #   <div class="pagination"> ... </div>
+    #   <ol id="posts">
+    #     ...
+    #   </ol>
+    #   <div class="pagination"> ... </div>
+    #
+    # Arguments are passed to a <tt>will_paginate</tt> call, so the same options
+    # apply. Don't use the <tt>:id</tt> option; otherwise you'll finish with two
+    # blocks of pagination links sharing the same ID (which is invalid HTML).
+    def paginated_section(*args, &block)
+      pagination = merb_paginate(*args).to_s
+      content = pagination + capture(&block) + pagination
+      #concat content, block.binding
+      content
+    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 entries 6 - 10 of 26 in total
+    def page_entries_info(collection)
+      if collection.total_pages < 2
+        case collection.size
+        when 0; 'No entries found'
+        when 1; 'Displaying <b>1</b> entry'
+        else;   "Displaying <b>all #{collection.size}</b> entries"
+        end
+      else
+        %{Displaying entries <b>%d&nbsp;-&nbsp;%d</b> of <b>%d</b> in total} % [
+          collection.offset + 1,
+          collection.offset + collection.length,
+          collection.total_entries
+        ]
+      end
+    end
+    
+  end
+
+  # Copied mostly from will_paginate, but changed to work with the merb url helpers
+  class LinkRenderer
+
+    def initialize(collection, options, template)
+      @collection = collection
+      @options    = options
+      @template   = template
+    end
+
+    def to_html
+      links = @options[:page_links] ? windowed_links : []
+      # previous/next buttons
+      links.unshift page_link_or_span(@collection.previous_page, 'disabled', @options[:prev_label])
+      links.push    page_link_or_span(@collection.next_page,     'disabled', @options[:next_label])
+      
+      html = links.join(@options[:separator])
+      @options[:container] ? "<div#{html_attributes_string}>#{html}</div>" : html
+    end
+
+    def html_attributes
+      return @html_attributes if @html_attributes
+      @html_attributes = @options.except *(MerbPaginate::ViewHelpers.pagination_options.keys - [:class])
+      # pagination of Post models will have the ID of "posts_pagination"
+      if @options[:container] and @options[:id] === true
+        @html_attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
+      end
+      @html_attributes
+    end
+    
+    def html_attributes_string
+      string = ""
+      if html_attributes
+        html_attributes.each do |key, value|
+          string << " #{key}='#{value}'"
+        end
+      end
+      string
+    end
+    
+  protected
+
+    def gap_marker; '...'; end
+    
+    def windowed_links
+      prev = nil
+
+      visible_page_numbers.inject [] do |links, n|
+        # detect gaps:
+        links << gap_marker if prev and n > prev + 1
+        links << page_link_or_span(n)
+        prev = n
+        links
+      end
+    end
+
+    def visible_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
+      elsif window_from < 1
+        window_to += 1 - window_from
+        window_from = 1
+      end
+      
+      visible   = (1..total_pages).to_a
+      left_gap  = (2 + outer_window)...window_from
+      right_gap = (window_to + 1)...(total_pages - outer_window)
+      visible  -= left_gap.to_a  if left_gap.last - left_gap.first > 1
+      visible  -= right_gap.to_a if right_gap.last - right_gap.first > 1
+
+      visible
+    end
+    
+    def page_link_or_span(page, span_class = 'current', text = nil)
+      text ||= page.to_s
+      if page and page != current_page
+        "<a href=\"#{url_for_page(page)}\">#{text}</a>"
+      else
+        "<span class=\"#{span_class}\">#{text}</span>"
+      end
+    end
+
+    def url_for_page(page)
+      # Include all query params when constructing new paging URL
+      params = @template.params.to_a.reject{|i| ['namespace', 'controller', 'action', 'format'].include?(i[0]) }
+      params << [param_name, page]
+      params = params.map{|i| i.join('=')}.join('&')
+
+      @template.request.path + "?" + params
+    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_sym
+    end
+
+    def params
+      @params ||= @template.params.to_mash
+    end
+  end
+end
+
+if Object.const_defined? "Merb"
+  Merb::Controller.class_eval do
+    include MerbPaginate::ViewHelpers
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: merb_paginate-gogolok
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Nathan Herald
+autorequire: merb_paginate
+bindir: bin
+cert_chain: []
+
+date: 2009-11-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: will_paginate
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.0
+    version: 
+description: A pagination library for Merb that uses will_paginate internally
+email: nathan@myobie.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb_paginate.rb
+- lib/merb_paginate/core_ext.rb
+- lib/merb_paginate/finders.rb
+- lib/merb_paginate/finders/activerecord.rb
+- lib/merb_paginate/finders/datamapper.rb
+- lib/merb_paginate/finders/generic.rb
+- lib/merb_paginate/finders/sequel.rb
+- lib/merb_paginate/view_helpers.rb
+has_rdoc: true
+homepage: http://github.com/gogolok/merb_paginate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A pagination library for Merb that uses will_paginate internally
+test_files: []
+