ramaze 0.1.1 → 0.1.2

data/lib/ramaze/helper/cgi.rb

@@ -10,14 +10,32 @@ module Ramaze
 
     # shortcut for CGI.escape
 
-    def escape(*args)
+    def url_encode(*args)
       CGI.escape(*args)
     end
 
     # shortcut for CGI.unescape
 
-    def unescape(*args)
-      CGI.escape(*args)
+    def url_decode(*args)
+      CGI.unescape(*args)
+    end
+
+    # shortcut for GCI.escapeHTML
+
+    def html_escape(string)
+      CGI.escapeHTML(string)
     end
+
+    # shortcut for GCI.unescapeHTML
+    
+    def html_unescape(string)
+      CGI.unescapeHTML(string)
+    end
+
+    # one-letter versions help in case like #{h foo.inspect}
+    # ERb/ERuby/Rails compatible 
+    alias h html_escape
+    alias u url_encode
+
   end
 end

data/lib/ramaze/helper/identity.rb

@@ -6,6 +6,9 @@ require 'openid'
 
 module Ramaze
 
+  openid_store_file = File.join(Dir.tmpdir, 'openid-store')
+  OpenIDStore = OpenID::FilesystemStore.new(openid_store_file)
+
   # This is called Identity to avoid collisions with the original openid.rb
 
   module IdentityHelper
@@ -61,12 +64,7 @@ module Ramaze
     private
 
     def openid_consumer
-      OpenID::Consumer.new(session, Ramaze::Global.openid_store)
+      OpenID::Consumer.new(session, Ramaze::OpenIDStore)
     end
   end
 end
-
-
-openid_store_file = File.join(Dir.tmpdir, 'openid-store')
-
-Ramaze::Global.openid_store ||= OpenID::FilesystemStore.new(openid_store_file)

data/lib/ramaze/helper/link.rb

@@ -22,7 +22,7 @@ module Ramaze
     # Usage:
     #   A('title')                  #=> <a href="/title">title</a>
     #   A('foo/bar')                #=> <a href="/foo/bar">foo/bar</a>
-    #   A('Home' :href => Rs(:/))   #=> <a href="/foo/bar">foo/bar</a>
+    #   A('Home', :href => Rs(:/))  #=> <a href="/foo/bar">Home</a>
 
     def A(title, hash = {})
       hash[:href] ||= Rs(title)
@@ -52,7 +52,7 @@ module Ramaze
     #   R(MC, :foo, :bar => :x) #=> '/foo?bar=x'
 
     def R(*atoms)
-      args, atoms = atoms.partition{|a| a.is_a?(Hash) }
+      args, atoms = atoms.flatten.partition{|a| a.is_a?(Hash) }
       args = args.flatten.inject{|s,v| s.merge!(v) }
 
       map = Global.mapping.invert
@@ -74,10 +74,10 @@ module Ramaze
       end
     end
 
-    # Uses R with self as first element.
+    # Uses R with Controller.current as first element.
 
     def Rs(*atoms)
-      R(self, *atoms)
+      R(Controller.current, *atoms)
     end
   end
 end

data/lib/ramaze/helper/pager.rb

@@ -0,0 +1,316 @@
+# 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.
+#
+
+module Ramaze
+
+# 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.
+
+class Pager
+  include Ramaze::LinkHelper
+
+  # Items per page.
+
+  trait :limit => 10
+
+  # The request key.
+
+  trait :key => '_page'
+
+  # The current page.
+
+  attr_accessor :page
+
+  # Items per page.
+
+  attr_accessor :limit
+
+  # The total number of pages.
+
+  attr_accessor :page_count
+
+  # Total count of items.
+
+  attr_accessor :total_count
+
+  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
+
+  def set_count(total_count)
+    @total_count = total_count
+    @page_count = (@total_count.to_f / @limit).ceil
+  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 previous_page
+    [@page - 1, 1].max
+  end
+
+  # Return the index of the next page.
+
+  def next_page
+    [@page + 1, @page_count].min
+  end
+
+  # A set of helpers to create links to common pages.
+
+  for target in [:first, :last, :previous, :next]
+    eval %{
+      def link_#{target}_page
+        target_uri(#{target}_page)
+      end
+      alias_method :#{target}_page_uri, :link_#{target}_page
+      alias_method :#{target}_page_href, :link_#{target}_page
+    }
+  end
+
+  # Iterator
+
+  def each(&block)
+    @page_items.each(&block)
+  end
+
+  # Iterator
+  # Returns 1-based index.
+
+  def each_with_index
+    idx = @start_idx
+    for item in @page_items
+      yield(idx + 1, item)
+      idx += 1
+    end
+  end
+
+  # Is the pager empty, ie has one page only?
+
+  def empty?
+    @page_count < 1
+  end
+
+  # The items count.
+
+  def size
+    @total_count
+  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
+
+  # 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
+
+  # To be used with Og queries.
+
+  def limit
+    if @start_idx > 0
+      { :limit => @limit, :offset => @start_idx }
+    else
+      { :limit => @limit }
+    end
+  end
+
+  def offset
+    @start_idx
+  end
+
+  # Override this method in your application if needed.
+  #--
+  # TODO: better markup.
+  #++
+
+  def navigation
+    nav = ""
+
+    unless first_page?
+      nav << %{
+        <div class="first"><a href="#{first_page_href}">First</a></div>
+        <div class="previous"><a href="#{previous_page_href}">Previous</a></div>
+      }
+    end
+
+    unless last_page?
+      nav << %{
+        <div class="last"><a href="#{last_page_href}">Last</a></div>
+        <div class="next"><a href="#{next_page_href}">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
+
+  def navigation?
+    @page_count > 1
+  end
+
+private
+
+  # Generate the target URI.
+
+  def target_uri(page)
+    params = Request.current.params.dup.update(@key => page)
+    Rs(Controller.current.action.method, params)
+  end
+
+end
+
+# Pager related helper methods.
+
+module PagerHelper
+
+private
+
+  # Helper method that generates a collection of items and the
+  # associated pager object.
+  #
+  # === Example
+  #
+  # entries, pager = paginate(Article, :where => 'title LIKE..', :limit => 10)
+  #
+  # or
+  #
+  # items = [ 'item1', 'item2', ... ]
+  # entries, pager = paginate(items, :limit => 10)
+  #
+  # or
+  #
+  # entries, pager = paginate(article.comments, :limit => 10)
+  #
+  # <ul>
+  # <?r for entry in entries ?>
+  #    <li>#{entry.to_link}</li>
+  # <?r end ?>
+  # </ul>
+  # #{pager.navigation}
+
+  def paginate(items, options = {})
+    limit = options.delete(:limit) || options[: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)
+      case items
+      when Og::Collection
+        pager = Pager.new(request, limit, items.count, pager_key)
+        options.update(pager.limit)
+        items = items.reload(options)
+        return items, pager
+
+      when Og::Mixin
+        pager = Pager.new(request, limit, items.count(options), pager_key)
+        options.update(pager.limit)
+        items = items.all(options)
+        return items, pager
+      end
+    end
+  end
+
+end
+
+end

data/lib/ramaze/helper/partial.rb

@@ -0,0 +1,37 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module PartialHelper
+
+    private
+    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 = {})
+      saved = {}
+      options.keys.each {|x| saved[x] = request.params[x] }
+
+      request.params.update(options)
+
+      Controller.handle(url)
+    ensure
+      options.keys.each {|x| request.params[x] = saved[x] }
+    end
+
+    def render_template(file, options = {})
+      current = Action.current
+      options[:binding]     ||= current.binding
+      options[:controller]  ||= current.controller
+      options[:instance]    ||= current.instance
+      options[:template] = (options[:controller].template_root/file)
+
+      action = Ramaze::Action(options)
+      action.render
+    end
+  end
+end

data/lib/ramaze/helper/stack.rb

@@ -47,7 +47,7 @@ module Ramaze
 
     def call this
       (session[:STACK] ||= []) << request.fullpath
-      redirect(R(this))
+      redirect this
     end
 
     # return to the last location on session[:STACK]