Pistos-ramaze 2008.09

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, :link)
+
+      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,7 @@
+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