ptomato-ramaze 2009.02

data/lib/ramaze/helper/gestalt.rb

@@ -0,0 +1,15 @@
+require 'gestalt'
+
+module Ramaze
+  module Helper
+    module Gestalt
+      def gestalt(&block)
+        Ramaze::Gestalt.new(&block)
+      end
+
+      def build(&block)
+        Ramaze::Gestalt.build(&block)
+      end
+    end
+  end
+end

data/lib/ramaze/helper/gravatar.rb

@@ -0,0 +1,32 @@
+module Ramaze
+  module Helper
+    module Gravatar
+
+      # fetches a gravatar from http//www.gravatar.com based on 'email'
+      # and 'size'. Falls back to 'fallback_path' if no gravatar is found.
+      # default 'fallback_path' is "/images/gravatar_default.jpg".
+      # example:
+      #
+      # class GravatarController < Ramaze::Controller
+      #    helper :gravatar
+      #
+      #    def index
+      #      @gravatar_thumbnail_src = gravatar(session[:email] || 'riku@helloit.fi')
+      #    end
+      # end
+      #
+      #  /view/gravatar/index.html:
+      #  <img src="#{@gravatar_thumbnail_src}" />
+
+      def gravatar(email, size = 32, fallback_path = "/images/gravatar_default.jpg")
+        emailhash = Digest::MD5.hexdigest(email)
+
+        fallback = Request.current.domain
+        fallback.path = fallback_path
+        default = Rack::Utils.escape(fallback.to_s)
+
+        return "http://www.gravatar.com/avatar.php?gravatar_id=#{emailhash}&default=#{default}&size=#{size}"
+      end
+    end
+  end
+end

data/lib/ramaze/helper/httpdigest.rb

@@ -0,0 +1,88 @@
+require 'uuid'
+require 'md5'
+
+module Ramaze
+  module Helper
+    module HttpDigest
+
+      UUID_GENERATOR = UUID.new
+
+      SESSION_NONCE = 'httpdigest_authentication_nonce'
+      SESSION_OPAQUE = 'httpdigest_authentication_opaque'
+
+      def httpdigest_logout
+        session.delete( SESSION_NONCE )
+        session.delete( SESSION_OPAQUE )
+      end
+
+      def httpdigest_headers uid, realm
+        session[ SESSION_NONCE ] = UUID_GENERATOR.generate
+        session[ SESSION_OPAQUE ][ realm ][ uid ] = UUID_GENERATOR.generate
+        response['WWW-Authenticate'] =
+          %|Digest realm="#{realm}",| +
+          %|qop="auth,auth-int",| +
+          %|nonce="#{session[SESSION_NONCE]}",| +
+          %|opaque="#{session[SESSION_OPAQUE][realm][uid]}"|
+      end
+
+      def httpdigest(uid, realm)
+        session[ SESSION_OPAQUE ] ||= {}
+        session[ SESSION_OPAQUE ][ realm ] ||= {}
+
+        if request.env['HTTP_AUTHORIZATION']
+
+          authorized = false
+
+          if session[ SESSION_NONCE ] and session[ SESSION_OPAQUE ][ realm ][ uid ]
+
+            auth_split = request.env['HTTP_AUTHORIZATION'].split
+            authentication_type = auth_split[0]
+            authorization = Rack::Auth::Digest::Params.parse( auth_split[1..-1].join(' ') )
+
+            digest_response, username, nonce, nc, cnonce, qop, opaque =
+              authorization.values_at(*%w[response username nonce nc cnonce qop opaque])
+
+            if authentication_type == 'Digest'
+              if nonce == session[SESSION_NONCE] and opaque == session[SESSION_OPAQUE][realm][uid]
+                h1 = nil
+                if respond_to?( :httpdigest_lookup_password )  
+                  ha1 = httpdigest_lookup_password( username )
+                else
+                  if respond_to?( :httpdigest_lookup_plaintext_password )
+                    ha1 = MD5.hexdigest( "#{username}:#{realm}:#{httpdigest_lookup_plaintext_password( username )}" )
+                  else
+                    if block_given?
+                      ha1 = yield( username )
+                    else
+                      raise "No password lookup handler found"
+                    end
+                  end
+                end
+                ha2 = MD5.hexdigest([request.request_method,request.fullpath].join(':'))
+                md5 = MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
+
+                authorized = digest_response == md5
+              end
+            end
+
+          end
+
+          unless authorized
+            httpdigest_headers( uid, realm )
+            respond('Unauthorized', 401)
+          end
+
+        else
+
+          httpdigest_headers( uid, realm )
+          httpdigest_failure if respond_to?( :httpdigest_failure )
+          respond('Unauthorized', 401)
+
+        end
+
+        authorization["username"]
+      end
+
+    end
+  end
+end

data/lib/ramaze/helper/identity.rb

@@ -0,0 +1,119 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'openid'
+require 'openid/store/filesystem'
+require 'openid/extensions/pape'
+require 'openid/extensions/sreg'
+
+module Ramaze
+
+  openid_store_file = ::File.join(Dir.tmpdir, 'openid-store')
+
+  # Constant for storing meta-information persistent
+  OpenIDStore = OpenID::Store::Filesystem.new(openid_store_file)
+
+  # This is called Identity to avoid collisions with the original openid.rb
+  # It provides a nice and simple way to provide and control access over the
+  # OpenID authentication model.
+
+  module Helper
+    module Identity
+      LOOKUP << self
+
+      # Simple form for use or overwriting.
+      # Has to provide the same functionality when overwritten or directly
+      # embedded into a page.
+      def openid_login_form(caption="login")
+        %{
+<form method="GET" action="#{Rs(:openid_begin)}">
+  Identity URL: <input type="text" name="url" />
+  <input type="submit" value="#{caption}"/>
+</form>
+        }
+      end
+
+      # We land here from the openid_login_form and if we can find a matching
+      # OpenID server we redirect the user to it, the browser will return to
+      # openid_complete when the authentication is complete.
+      def openid_begin
+        # The OpenID URL pointing to a user's OpenID page,
+        # for example: http://username.myopenid.com)
+        url = request['url']
+        redirect_referrer if url.to_s.empty?
+        session[:openid] ||= {}
+        session[:openid][:entry] = request.referrer
+
+        openid_request = openid_consumer.begin(url)
+
+        # We want these communications to be a secure as the server can
+        # support!
+        papereq = OpenID::PAPE::Request.new
+        papereq.add_policy_uri(OpenID::PAPE::AUTH_PHISHING_RESISTANT)
+        papereq.max_auth_age = 2*60*60
+        openid_request.add_extension(papereq)
+
+        # Request information about the person
+        sregreq = OpenID::SReg::Request.new
+        sregreq.request_fields(['fullname', 'nickname', 'dob', 'email',
+                               'gender', 'postcode', 'country', 'language',
+                               'timezone'])
+        openid_request.add_extension(sregreq)
+        openid_request.return_to_args['did_pape'] = 'y'
+
+        root      = "http://#{request.http_host}/"
+        return_to = request.domain(Rs(:openid_complete)).to_s
+        immediate = false
+
+        if openid_request.send_redirect?(root, return_to, immediate)
+          redirect_url =
+            openid_request.redirect_url(root, return_to, immediate)
+          raw_redirect redirect_url
+        else
+          # what the hell is @form_text ?
+        end
+
+      rescue OpenID::OpenIDError => ex
+        flash[:error] = "Discovery failed for #{url}: #{ex}"
+        raw_redirect Rs(:/)
+      end
+
+      # After having authenticated at the OpenID server browsers are redirected
+      # back here and on success we set the session[:openid][:identity] and a little
+      # default flash message. Then we redirect to wherever session[:openid][:entry]
+      # points us to, which was set on openid_begin to the referrer
+      #
+      # TODO:
+      #   - maybe using StackHelper, but this is a really minimal overlap?
+      def openid_complete
+        openid_response = openid_consumer.complete(request.params, request.url)
+
+        case openid_response.status
+        when OpenID::Consumer::FAILURE
+          flash[:error] = "OpenID - Verification failed: #{openid_response.message}"
+        when OpenID::Consumer::SUCCESS
+          # Backwards compatibility
+          session[:openid][:identity] = openid_response.identity_url
+          session[:openid][:sreg] = OpenID::SReg::Response.from_success_response(openid_response)
+
+          # Forward compatibility :)
+          session[:openid_identity] = openid_response.identity_url
+          session[:openid_sreg] = OpenID::SReg::Response.from_success_response(openid_response)
+
+          flash[:success] = 'OpenID - Verification done.'
+        end
+
+        session.delete(:_openid_consumer_service)
+
+        raw_redirect session[:openid][:entry]
+      end
+
+      private
+
+      # Fetch/Create a OpenID::Consumer for current session.
+      def openid_consumer
+        OpenID::Consumer.new(session, Ramaze::OpenIDStore)
+      end
+    end
+  end
+end

data/lib/ramaze/helper/link.rb

@@ -0,0 +1,122 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  # Helper::Link is included into the Controller by default
+  #
+  # Usage is shown in spec/ramaze/helper/link.rb and the rdocs below.
+
+  module Helper::Link
+    # Builds a basic <a> tag.
+    #
+    # `text` is mandatory, the second hash of options will be transformed into
+    # arguments of the tag, :href is a special case and its segments will be
+    # escaped.
+    #
+    # If you pass no :href, the text will be run through Rs and its result is
+    # used instead. If you really want an empty href, use :href => ''
+    #
+    # Usage:
+    #   A('text')                       #> <a href="/text">text</a>
+    #   A('foo/bar')                    #> <a href="/foo/bar">foo/bar</a>
+    #   A('/foo?x=y')                   #> <a href="/foo?x=y">/foo?x=y</a>
+    #   A('text', :href => '/foo?x=y')  #> <a href="/foo?x=y">text</a>
+    #   A('Home', :href => Rs(:/))      #> <a href="/foo/bar">Home</a>
+
+    def A(*args)
+      hash = args.last.respond_to?(:to_hash) ? args.pop : {}
+
+      hash[:href] ||= Rs(*args)
+      text = hash.delete(:text) || args.last || hash[:title] || hash[:href]
+      hash[:href] = hash[:href].to_s.gsub(/[^\/?;=]+/){|m| Rack::Utils.escape(m) }
+
+      args = ['']
+      hash.each {|k,v| args << %(#{k}="#{v}") if k and v }
+
+      %(<a#{args.join(' ')}>#{text}</a>)
+    end
+
+    # Builds links out of segments.
+    #
+    # Pass it strings, symbols, controllers and it will produce a link out of
+    # it. Paths to Controllers are obtained from Global.mapping.
+    #
+    # For brevity, the mapping for the example below is following:
+    #   { MC => '/', OC => '/o', ODC => '/od' }
+    #
+    # Usage:
+    #   R(MC) #=> '/'
+    #   R(OC) #=> '/o'
+    #   R(ODC) #=> '/od'
+    #   R(MC, :foo) #=> '/foo'
+    #   R(OC, :foo) #=> '/o/foo'
+    #   R(ODC, :foo) #=> '/od/foo'
+    #   R(MC, :foo, :bar => :x) #=> '/foo?bar=x'
+
+    def R(*atoms)
+      args, atoms = atoms.flatten.partition{|a| a.is_a?(Hash) }
+      args = args.flatten.inject{|s,v| s.merge!(v) }
+
+      map = Global.mapping.invert
+
+      atoms.map! do |atom|
+        if atom.is_a?(Ramaze::Controller)
+          map[atom.class]
+        else
+          map[atom]
+        end or atom.to_s
+      end
+
+      front = [Global.prefix, *atoms].join('/').squeeze('/')
+
+      if args
+        rear = args.inject('?'){|s,(k,v)| s << "#{Rack::Utils.escape(k)}=#{Rack::Utils.escape(v)};"}[0..-2]
+        front + rear
+      else
+        front
+      end
+    end
+
+    # Uses R with Controller.current as first element.
+
+    def Rs(*atoms)
+      atoms.unshift Controller.current unless atoms.first.is_a?(Controller)
+      R(*atoms)
+    end
+
+    # Give it a path with character to split at and one to join the crumbs with.
+    # It will generate a list of links that act as pointers to previous pages on
+    # this path.
+    #
+    # Example:
+    #   breadcrumbs('/path/to/somewhere')
+    #
+    #   # results in this, newlines added for readability:
+    #
+    #   <a href="/path">path</a>/
+    #   <a href="/path/to">to</a>/
+    #   <a href="/path/to/somewhere">somewhere</a>
+    #
+    # Optionally a href prefix can be specified which generate link
+    # names a above, but with the prefix prepended to the href path.
+    #
+    # Example:
+    #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
+    #
+    #   # results in this, newlines added for readability:
+    #
+    #   <a href="/mycontroller/action/path">path</a>/
+    #   <a href="/mycontroller/action/path/to">to</a>/
+    #   <a href="/mycontroller/action/path/to/somewhere">somewhere</a>
+
+    def breadcrumbs(path, split = '/', join = '/', href_prefix = '')
+      atoms = path.split(split).reject{|a| a.empty?}
+      crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
+      bread = crumbs.map do |a|
+        href_path = href_prefix + a*'/'
+        A(a[-1], :href=>(href_path))
+      end
+      bread.join(join)
+    end
+  end
+end

data/lib/ramaze/helper/markaby.rb

@@ -0,0 +1,31 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Allows you to use some shortcuts for markaby in your Controller.
+
+  module Helper::Markaby
+    # use this inside your controller to directly build Markaby
+    # Refer to the Markaby-documentation and testsuite for more examples.
+    # Usage:
+    #   mab { h1 "Apples & Oranges"}                    #=> "<h1>Apples &amp; Oranges</h1>"
+    #   mab { h1 'Apples', :class => 'fruits&floots' }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
+
+    def markaby(ivs = {}, helpers = nil, &block)
+      builder = ::Markaby::Builder
+      builder.extend(Ramaze::Helper::Methods)
+      builder.send(:helper, :redirect, :link, :sendfile, :flash, :cgi, :partial)
+
+      iv_hash = {}
+      instance_variables.each do |iv|
+        key, value = iv.gsub('@', '').to_sym, instance_variable_get(iv)
+        iv_hash[key] = value
+      end
+
+      builder.new(iv_hash.merge(ivs), helpers, &block).to_s
+    end
+
+    alias mab markaby
+  end
+end

data/lib/ramaze/helper/maruku.rb

@@ -0,0 +1,9 @@
+require 'maruku'
+
+module Ramaze
+  module Helper::Maruku
+    def maruku(text)
+      Maruku.new(text).to_html
+    end
+  end
+end

data/lib/ramaze/helper/nitroform.rb

@@ -0,0 +1,14 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'nitro/helper/form'
+
+module Ramaze
+  module Helper
+
+    # This helper simply includes the Nitro::FormHelper so you can use its methods
+    # in your Controller.
+
+    Nitroform = ::Nitro::FormHelper
+  end
+end

data/lib/ramaze/helper/pager.rb

@@ -0,0 +1,366 @@
+module Ramaze
+
+# The BSD License
+#
+# Copyright (c) 2004-2007, George K. Moschovitis. (http://www.gmosx.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Nitro nor the names of its contributors may be
+# used to endorse or promote products derived from this software
+# without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# Displays a collection of entitities in multiple pages.
+#
+# === Design
+#
+# This pager is carefully designed for scaleability. It stores only the items
+# for one page. The key parameter is needed, multiple pagers can coexist in a
+# single page. The pager leverages the SQL LIMIT option to optimize database
+# interaction.
+#
+#
+# === Example
+#
+#   class MyController
+#     def index
+#       objs = (0..200).to_a
+#       @entries, @pager = paginate(objs, :limit => 20)
+#     end
+#   end
+#
+#
+#   <html>
+#     <head><title>Pager</title></head>
+#     <body>
+#       <?r if pager.navigation? ?>
+#         <div class="pager">#{@pager.navigation}</div>
+#       <?r end ?>
+#       <ul>
+#       <?r @entries.each do |entry| ?>
+#         <li>#{entry}</li>
+#       <?r end ?>
+#       </ul>
+#     </body>
+#   </html>
+#
+# === Styling
+#
+# The following classes can be used for styling with CSS (provided you put the
+# pager in a element with class 'pager' like shown above):
+#
+#   .pager {}
+#   .pager .first {}
+#   .pager .previous {}
+#   .pager .next {}
+#   .pager .last {}
+#   .pager ul {}
+#   .pager li {}
+#   .pager li.active {}
+
+class Pager
+  include Ramaze::Helper::Link
+
+  # Items per page.
+
+  trait :limit => 10
+
+  # The request key.
+
+  trait :key => '_page'
+
+  # The current page.
+
+  attr_reader :page
+
+  # Items per page.
+
+  attr_reader :limit
+
+  # The total number of pages.
+
+  attr_reader :page_count
+
+  # Total count of items.
+
+  attr_reader :total_count
+
+  # Create a new Pager object.
+  #
+  # request:: Ramaze::Request object providing access to GET parameters
+  # limit:: how many elements go to one page
+  # total_count:: total element count
+  # key:: key used for getting the current page from GET paramaters
+  #
+  # Note:  You never have to create this class yourself, use the `paginate()`
+  # convenience method from the Helper::Pager.
+
+  def initialize(request, limit, total_count, key = trait[:key])
+    raise 'limit should be > 0' unless limit > 0
+
+    @request, @key = request, key
+    @page = (request.params[key] || 1).to_i
+    @limit = limit
+    set_count(total_count)
+    @start_idx = (@page - 1) * limit
+  end
+
+  # Return the first page index.
+
+  def first_page
+    1
+  end
+
+  # Is the first page displayed?
+
+  def first_page?
+    @page == 1
+  end
+
+  # Return the last page index.
+
+  def last_page
+    return @page_count
+  end
+
+  # Is the last page displayed?
+
+  def last_page?
+    @page == @page_count
+  end
+
+  # Return the index of the previous page.
+
+  def prev_page
+    [@page - 1, 1].max
+  end
+
+  # Return the index of the next page.
+
+  def next_page
+    [@page + 1, @page_count].min
+  end
+
+  # Returns each element for the current page
+
+  def each(&block)
+    @page_items.each(&block)
+  end
+
+  # Iterator
+  # Returns 1-based index.
+
+  def each_with_index(&block)
+    @page_items.each_with_index(&block)
+  end
+
+  # Is the pager empty, ie has one page only?
+
+  def empty?
+    @page_count < 2
+  end
+
+  # Returns true if a navigation is necessary (meaning there is more than one
+  # page)
+
+  def navigation?
+    !empty?
+  end
+
+  # Returns the amount of all elements in all pages.
+
+  def size
+    @total_count
+  end
+
+  # Override this method in your application if needed.
+  #--
+  # TODO: better markup.
+  #++
+
+  def navigation
+    nav = ""
+
+    unless first_page?
+      nav << %{
+        <div class="first"><a href="#{link_first_page}">First</a></div>
+        <div class="previous"><a href="#{link_prev_page}">Previous</a></div>
+      }
+    end
+
+    unless last_page?
+      nav << %{
+        <div class="last"><a href="#{link_last_page}">Last</a></div>
+        <div class="next"><a href="#{link_next_page}">Next</a></div>
+      }
+    end
+
+    nav << %{<ul>}
+
+    for i in nav_range()
+      if i == @page
+        nav << %{<li class="active">#{i}</li>}
+      else
+        nav << %{<li><a href="#{target_uri(i)}">#{i}</a></li>}
+      end
+    end
+
+    nav << %{</ul>}
+
+    return nav
+  end
+
+  # To be used with Og queries.
+
+  def limit
+    if @start_idx > 0
+      { :limit => @limit, :offset => @start_idx }
+    else
+      { :limit => @limit }
+    end
+  end
+
+  # Returns the index of the first element to go into the current page
+
+  def offset
+    @start_idx
+  end
+
+private
+
+  # Generate the target URI.
+
+  def target_uri(page)
+    params = @request.params.merge(@key => page)
+    Rs(Action.current.name, params)
+  end
+
+  # Generate link for the first page.
+
+  def link_first_page; target_uri(first_page); end
+
+  # Generate link for the last page.
+
+  def link_last_page; target_uri(last_page); end
+
+  # Generate link for the previous page.
+
+  def link_prev_page; target_uri(prev_page); end
+
+  # Generate link for the next page.
+
+  def link_next_page; target_uri(next_page); end
+
+
+  # Returns the range of the current page.
+
+  def page_range
+    s = @idx
+    e = [@idx + @items_limit - 1, all_total_count].min
+
+    return [s, e]
+  end
+
+  # Returns the range of
+  # Override if needed.
+
+  def nav_range
+    # effective range = 10 pages.
+    s = [@page - 5, 1].max
+    e = [@page + 9, @page_count].min
+
+    d = 9 - (e - s)
+    e += d if d < 0
+
+    return (s..e)
+  end
+
+  # generates total and page count of the pager.
+
+  def set_count(total_count)
+    @total_count = total_count
+    @page_count = (@total_count.to_f / @limit).ceil
+  end
+
+end
+
+# Pager related helper methods.
+
+module Helper::Pager
+
+  # Helper method that generates a collection of items and the
+  # associated pager object.
+  #
+  # === Example
+  #
+  # items = [ 'item1', 'item2', ... ]
+  # entries, pager = paginate(items, :limit => 10)
+  #
+  # <ul>
+  # <?r for entry in entries ?>
+  #    <li>#{entry.to_link}</li>
+  # <?r end ?>
+  # </ul>
+  # #{pager.navigation}
+  #
+  # === Og Example
+  #
+  # entries, pager = paginate(Article, :where => 'title LIKE..', :limit => 10)
+  #
+  # or
+  #
+  # entries, pager = paginate(article.comments, :limit => 10)
+
+  def paginate(items, options = {})
+    limit = options.delete(:limit) || Pager.trait[:limit]
+    pager_key = options.delete(:pager_key) || Pager.trait[:key]
+
+    case items
+    when Array
+      pager = Pager.new(request, limit, items.size, pager_key)
+      items = items.slice(pager.offset, pager.limit[:limit])
+      return items, pager
+    end
+
+    if defined?(Og) && items.is_a?(Og::Collection)
+      pager = Pager.new(request, limit, items.count, pager_key)
+      options.update(pager.limit)
+      items = items.reload(options)
+      return items, pager
+    elsif defined?(Og::EntityMixin) && items.is_a?(Og::EntityMixin) ||
+          defined?(Og::Mixin) && items.is_a?(Og::Mixin) # Og <= 0.41
+      pager = Pager.new(request, limit, items.count(options), pager_key)
+      options.update(pager.limit)
+      items = items.all(options)
+      return items, pager
+    end
+
+    raise "No suitable pagination method for #{items.inspect}"
+  end
+
+end
+
+end