ptomato-ramaze 2009.02

data/lib/ramaze/helper/paginate.rb

@@ -0,0 +1,233 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module Helper
+
+    # Helper for pagination and pagination-navigation.
+    #
+    # See detailed API docs for Paginator below.
+    # Also have a look at the examples/helpers/paginate.rb
+
+    module Paginate
+
+      # Define default options in your Controller, they are being retrieved by
+      # ancestral_trait, so you can also put it into a common superclass
+
+      trait :paginate => {
+        :limit => 10,
+        :var   => 'pager',
+      }
+
+      # Returns a new Paginator instance.
+      #
+      # Note that the pagination relies on being inside a Ramaze request to
+      # gain necessary metadata about the page it resides on, you cannot use it
+      # outside of Ramaze yet.
+      #
+      # The examples below are meant to be used within your controller or view.
+      #
+      # Usage with Array:
+      #   data = (1..100).to_a
+      #   @pager = paginate(data, :limit => 30, :page => 2)
+      #   @pager.navigation
+      #   @pager.each{|e| puts(e) }
+      #
+      # Usage with Sequel:
+      #   data = Article.filter(:public => true)
+      #   @pager = paginate(data, :limit => 5)
+      #   @pager.navigation
+      #   @pager.each{|e| puts(e)
+      #
+      # +dataset+ may be a Sequel dataset or Array
+      # +options+ Takes precedence to trait[:paginate] and may contain
+      #           following pairs:
+      #   :limit  The number of elements used when you call #each on the
+      #           paginator
+      #   :var    The variable name being used in the request, this is helpful
+      #           if you want to use two or more independent paginations on the
+      #           same page.
+      #   :page   The page you are currently on, if not given it will be
+      #           retrieved from current request variables. Defaults to 1 if
+      #           neither exists.
+
+      def paginate(dataset, options = {})
+        options = ancestral_trait[:paginate].merge(options)
+        limit = options[:limit]
+        var   = options[:var]
+        page  = options[:page] || (request[var] || 1).to_i
+
+        Paginator.new(dataset, page, limit, var)
+      end
+
+      # Provides easy pagination and navigation
+
+      class Paginator
+        include Ramaze::Helper::Link
+        include Ramaze::Helper::CGI
+
+        def initialize(data = [], page = 1, limit = 10, var = 'pager')
+          @data, @page, @limit, @var = data, page, limit, var
+          @pager = pager_for(data)
+          @page = @page > page_count ? page_count : @page
+          @pager = pager_for(data)
+        end
+
+        # Returns String with navigation div.
+        #
+        # This cannot be customized very nicely, but you can style it easily
+        # with CSS.
+        #
+        # Output with 5 elements, page 1, limit 3:
+        #   <div class="pager">
+        #     <span class="first grey">&lt;&lt;</span>
+        #     <span class="previous grey">&lt;</span>
+        #     <a class="current" href="/index?pager=1">1</a>
+        #     <a href="/index?pager=2">2</a>
+        #     <a class="next" href="/index?pager=2">&gt;</a>
+        #     <a class="last" href="/index?pager=2">&gt;&gt;</a>
+        #   </div>
+        #
+        # Output with 5 elements, page 2, limit 3:
+        #   <div class="pager" />
+        #     <a class="first" href="/index?user_page=1">&lt;&lt;</a>
+        #     <a class="previous" href="/index?user_page=1">&lt;</a>
+        #     <a href="/index?user_page=1">1</a>
+        #     <a class="current" href="/index?user_page=2">2</a>
+        #     <span class="next grey">&gt;</span>
+        #     <span class="last grey">&gt;&gt;</span>
+        #   </div>
+
+
+        def navigation(limit = 8)
+          out = [ g.div(:class => :pager) ]
+
+          if first_page?
+            out << g.span(:class => 'first grey'){ h('<<') }
+            out << g.span(:class => 'previous grey'){ h('<') }
+          else
+            out << link(1, '<<', :class => :first)
+            out << link(prev_page, '<', :class => :previous)
+          end
+
+          lower = limit ? (current_page - limit) : 1
+          lower = lower < 1 ? 1 : lower
+
+          (lower...current_page).each do |n|
+            out << link(n)
+          end
+
+          out << link(current_page, current_page, :class => :current)
+
+          if last_page?
+            out << g.span(:class => 'next grey'){ h('>') }
+            out << g.span(:class => 'last grey'){ h('>>') }
+          elsif next_page
+            higher = limit ? (next_page + limit) : page_count
+            higher = [higher, page_count].min
+            (next_page..higher).each do |n|
+              out << link(n)
+            end
+
+            out << link(next_page, '>', :class => :next)
+            out << link(page_count, '>>', :class => :last)
+          end
+
+          out << '</div>'
+          out.map{|e| e.to_s}.join("\n")
+        end
+
+        # Useful to omit pager if it's of no use.
+
+        def needed?
+          @pager.page_count > 1
+        end
+
+        # Forward everything to the inner @pager
+
+        def method_missing(meth, *args, &block)
+          @pager.send(meth, *args, &block)
+        end
+
+        private
+
+        def pager_for(obj)
+          @page = @page < 1 ? 1 : @page
+
+          case obj
+          when Array
+            ArrayPager.new(obj, @page, @limit)
+          else
+            obj.paginate(@page, @limit)
+          end
+        end
+
+        def link(n, text = n, hash = {})
+          text = h(text.to_s)
+
+          params = Ramaze::Request.current.params.merge(@var.to_s => n)
+          name = Ramaze::Request.current.path_info
+          hash[:href] = R(name, params)
+
+          g.a(hash){ text }
+        end
+
+        def g
+          Ramaze::Gestalt.new
+        end
+
+        # Wrapper for Array to behave like the Sequel pagination
+
+        class ArrayPager
+          def initialize(array, page, limit)
+            @array, @page, @limit = array, page, limit
+            @page = page_count if @page > page_count
+          end
+
+          def size
+            @array.size
+          end
+
+          def empty?
+            @array.empty?
+          end
+
+          def page_count
+            pages, rest = @array.size.divmod(@limit)
+            rest == 0 ? pages : pages + 1
+          end
+
+          def current_page
+            @page
+          end
+
+          def next_page
+            page_count == @page ? nil : @page + 1
+          end
+
+          def prev_page
+            @page <= 1 ? nil : @page - 1
+          end
+
+          def first_page?
+            @page <= 1
+          end
+
+          def last_page?
+            page_count == @page
+          end
+
+          def each(&block)
+            from = ((@page - 1) * @limit)
+            to = from + @limit
+
+            a = @array[from...to] || []
+            a.each(&block)
+          end
+
+          include Enumerable
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/helper/partial.rb

@@ -0,0 +1,105 @@
+#          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::Partial
+  #
+  # === Example Usage
+  #
+  #   class MyController
+  #     def index
+  #     end
+  #     def list
+  #       plain = request['plain']
+  #       "Hello World from List!  Plain List == #{plain}"
+  #     end
+  #   end
+  #
+  #
+  #   <html>
+  #     <head><title>Partial Render Index</title></head>
+  #     <body>
+  #       #{render_partial(Rs(:list), 'plain' => true)}
+  #     </body>
+  #   </html>
+
+  module Helper::Partial
+    module_function
+
+    # Renders a url 'inline'.
+    #
+    # url:      normal URL, like you'd use for redirecting.
+    # options:  optional, will be used as request parameters.
+
+    def render_partial(url, options = {})
+      # Save any request params that clash with the ones we're about to add in.
+      saved = {}
+      options.keys.each {|x| saved[x] = Request.current.params[x] }
+
+      # Add/overwrite with the specified params. Ensure keys are strings since
+      # request[:foo] converts key to string when performing lookup.
+      options.each do |key, value|
+        Request.current.params[key.to_s] = value
+      end
+
+      Controller.handle(url)
+    ensure
+      # Always reinstate the original
+      options.keys.each {|x| Request.current.params[x] = saved[x] }
+    end
+
+    # Render the template file in view_root of the
+    # current controller.
+
+    def render_template(file, vars = {})
+      current = Action.current
+      options = { :controller => current.controller,
+                  :instance => current.instance.dup }
+
+      file = file.to_s
+
+      if Pathname(file).absolute?
+        file = file.squeeze '/'
+        unless File.exist?(file)
+          Log.warn "render_template: #{file} does not exist."
+          return ''
+        end
+        options[:template] = file
+      else
+        roots = [options[:controller].template_paths].flatten
+
+        if (files = Dir[File.join("{#{roots.join(',')}}","{#{file},#{file}.*}")]).any?
+          options[:template] = files.first.squeeze '/'
+        else
+          Log.warn "render_template: #{file} does not exist in the following directories: #{roots.join(',')}."
+          return ''
+        end
+      end
+
+      binding = options[:instance].scope
+      
+      # For Ruby 1.9/1.8.7
+      binding = binding.binding if binding.respond_to?(:binding)
+
+      vars.each do |name, value|
+        options[:instance].instance_variable_set("@#{name}", value)
+
+        value = "ObjectSpace._id2ref(#{ value.object_id })"
+        eval "#{ name } = #{ value }", binding
+      end
+
+      options[:binding] = binding
+
+      Ramaze::Action(options).render
+    end
+
+    # shortcut to render_partial, accepts a method and contructs a link to the
+    # current controller, then calls render_partial on that
+
+    def render_action method, *params
+      render_partial(Rs(method), *params)
+    end
+
+  end
+end

data/lib/ramaze/helper/redirect.rb

@@ -0,0 +1,100 @@
+#          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::Redirect actually takes advantage of Helper::Link.link_raw to build the links
+  # it redirects to.
+  # It doesn't do much else than this:
+  #     setting a status-code of 303 and a response['Location'] = link
+  # returning some nice text for visitors who insist on ignoring those hints :P
+  #
+  # Usage:
+  #   redirect Rs()
+  #   redirect R(MainController)
+  #   redirect R(MainController, :foo)
+  #   redirect 'foo/bar'
+  #   redirect 'foo/bar', :status => 301
+  #
+  # TODO:
+  #   - maybe some more options, like a delay
+  #
+
+  module Helper::Redirect
+
+    # render to the browser directly, ignoring any templates
+    #
+    # Usage:
+    #   respond 'Page not found', 404
+    #   respond render_template('forbidden.erb'), 403
+    #   respond File.open('file.jpg'), 200, 'Content-Type' => 'image/jpeg'
+
+    def respond(*args)
+      response.build(*args)
+      throw(:respond)
+    end
+
+    # Usage:
+    #   redirect Rs()
+    #   redirect R(MainController)
+    #   redirect R(MainController, :foo)
+    #   redirect 'foo/bar'
+    #   redirect 'foo/bar', :status => 301
+
+    def redirect(target, opts = {})
+      target = target.to_s
+
+      unless target =~ %r!^https?://!
+        target[0,0] = '/' unless target =~ %r!^/!
+        if host = request.env['HTTP_HOST']
+          target[0,0] = "#{request.protocol}://#{host}"
+        end
+      end
+
+      raw_redirect(target, opts)
+    end
+
+    # Do not perform any mutations on the target like #redirect does.
+    # Suitable if you have to redirect to a different subdomain or host.
+    def raw_redirect(target, opts = {})
+      target = target.to_s
+      header = {'Location' => target}
+      status = opts[:status] || 302 # Found
+      body = %{You are being redirected, please follow <a href="#{target}">this link to: #{target}</a>!}
+
+      Log.info("Redirect to '#{target}'")
+      request[:redirected] = true
+      throw(:redirect, [body, status, header])
+    end
+
+    # Are we being redirected?
+    def redirected?
+      request[:redirected]
+    end
+
+    # Redirect to the location the browser says it's coming from.
+    # If the current address is the same as the referrer or no referrer exists
+    # yet, we will redirect to +fallback+.
+    #
+    # NOTE:
+    #   * In some cases this may result in a double redirect, given that the
+    #     request query parameters may change order. We don't have a nice way
+    #     of handling that yet, but it should be very, very rare
+
+    def redirect_referer(fallback = R(:/))
+      if referer = request.referer and url = request.url
+        referer_uri = URI(referer)
+        request_uri = URI(url)
+
+        if referer_uri == request_uri
+          redirect fallback
+        else
+          redirect referer
+        end
+      else
+        redirect fallback
+      end
+    end
+    alias redirect_referrer redirect_referer
+  end
+end

data/lib/ramaze/helper/rest.rb

@@ -0,0 +1,43 @@
+module Ramaze
+  module Helper
+    module REST
+      def self.included(klass)
+        klass.class_eval do
+          trait :REST => {
+            'GET' => [], 'PUT' => [],
+            'POST' => [], 'DELETE' => [],
+            :any => [],
+          }
+          extend Indicate
+
+          def self.method_added(name)
+            name = name.to_s
+            active = trait[:REST][:active] ||= :any
+            trait[:REST][active] << name
+          end
+        end
+      end
+
+      module Indicate
+        def on(http_method)
+          hm = http_method.to_s.upcase
+          trait[:REST][hm] = []
+          trait[:REST][:active] = hm
+        end
+
+        (%w[GET PUT POST DELETE] << 'any').each do |http_method|
+          define_method("on_#{http_method.downcase}") do |*args|
+            if args.empty?
+              on(http_method)
+            else
+              trait[:REST][http_method] += args.flatten
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# POST /foo/bar
+# methods_on_post[/foo/bar]