nitro 0.26.0 → 0.27.0

data/lib/nitro/helper/layout.rb

@@ -0,0 +1,42 @@
+require 'nano/string/camelize'
+
+require 'nitro/element'
+
+module Nitro
+
+# This helper uses Nitro's powerfull Elements mechanism to
+# implement a simple Rails style Layout helper. Perhaps this
+# may be useful for people coming over from Rails.
+#
+# WARNING: This is not enabled by default. You have to insert
+# the LayoutCompiler before the ElementsCompiler for layout to
+# work.
+
+module LayoutHelper
+
+  def self.included(base)
+    base.module_eval do    
+      # Enclose all templates of this controller with the
+      # given element.
+      
+      def self.layout(name = nil)
+        klass = name.to_s.camelize
+        
+        unless klass
+          if defined? 'Nitro::Element::Layout'
+            klass = Nitro::Element::Layout
+          end
+        end
+        
+        if klass
+          ann self, :layout => klass
+        end
+      end
+    end
+  end
+
+end
+
+end
+
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/helper/table.rb

@@ -1,3 +1,6 @@
+require 'glue/uri'
+require 'glue/configuration'
+
 module Nitro
 
 # The TableBuilder is a helper class that automates the creation
@@ -14,11 +17,37 @@ module Nitro
 # <div class="custom-table-class">
 #   #{table :values => users, :headers => header}
 # </div>
+# 
+# 
+# === Extended Example
+# 
+#  <?r
+#  users = User.all.map { |u| [u.name, u.first_name, u.last_name, u.email] }
+#  headers = ['Username', 'First name', 'Last name', 'Email']
+#  order_opts = { :right => true, # right align the order controls
+#       :values => [nil, 'first_name', 'last_name'], # column names from DB
+#       :asc_pic => "/images/asc.png", 
+#       :desc_pic => "/images/desc.png" }
+#  ?>
+#  
+#  <div class="custom-table-class">
+#    #{table :values => users, :headers => header, 
+#     :order => order_opts, :alternating_rows => true }
+#  </div>
+# 
 #--
-# TODO: sorting, thead/tbody/legend etc, verbose...
+# TODO: legend, verbose... ?
 #++
 
 module TableHelper
+  
+  # The order by key.
+  
+  setting :order_by_key, :default => '_order_by', :doc => 'The order key'
+  
+  # The order by key.
+  
+  setting :order_direction_key, :default => '_order_direction', :doc => 'The order direction key'
 
   # [+options+]
   #    A hash of options.
@@ -26,55 +55,189 @@ module TableHelper
   # :id = id of the component.
   # :headers = an array of the header values
   # :values = an array of arrays.
-
+  # :order = options hash (:left, :right, :asc_pic, :desc_pic, :values)
+  # :alternating_rows = alternating rows, use css to color row_even / row_odd
+  # :footers = an array of tfooter values
+  
   def table(options)
-    c = options
-
     str = '<table'
-    str << %| id="#{c[:id]}"| if c[:id]
+    str << %| id="#{options[:id]}"| if options[:id]
     str << '>'
-
+    
     str << table_rows(options)
     
     str << '</table>'
   end
   alias_method :build_table, :table
-
+  
   # [+options+]
   #    A hash of options.
   # 
   # :id = id of the component.
   # :headers = an array of the header values
   # :values = an array of arrays.
-
+  # :order = options hash (:left, :right, :asc_pic, :desc_pic, :values)
+  # :alternating_rows = alternating rows, use css to color row_even / row_odd
+  # :footers = an array of tfooter values
+  
   def table_rows(options)
-    c = options
-
-    str = '<tr>'
-
-    for h in c[:headers]
-      str << %|<th>#{h}</th>|
+    # also accept :items, :rows
+    options[:values] = options[:values] || options[:items] || options[:rows]
+    
+    str = ''
+    str << table_header(options)
+    str << table_footer(options) if options[:footers]
+    
+    items = options[:values]
+    
+    row_state = 'odd' if options[:alternating_rows]
+    
+    # when items is an array of arrays of arrays (meaning, several
+    # arrays deviding the table into several table parts (tbodys))
+    
+    if create_tbody?(options)
+      for body in items
+        str << '<tbody>'
+        
+        for row in body
+          str << '<tr'
+          
+          if options[:alternating_rows]
+            str << %| class="row_#{row_state}"|
+            row_state = (row_state == "odd" ? "even" : "odd")
+          end
+          
+          str << '>'
+          
+          for value in row
+            str << %|<td>#{value}</td>|
+          end
+          
+          str << '</tr>'
+        end
+        
+        str << '</tbody>'
+      end
+    else
+      for row in items
+        str << '<tr'
+        
+        if options[:alternating_rows]
+          str << %| class="row_#{row_state}"|
+          row_state = (row_state == "odd" ? "even" : "odd")
+        end
+        
+        str << '>'
+        
+        for value in row
+          str << %|<td>#{value}</td>|
+        end
+        
+        str << '</tr>'
+      end
     end
-
-    str << "</tr>"
-
-    items = c[:values] || c[:items] || c[:rows]
-
-    for row in c[:values]
-      str << "<tr>"
-      
-      for v in row
-        str << %|<td>#{v}</td>|
+    
+    return str
+  end
+  
+  private
+  
+  # [+options+]
+  #    A hash of options.
+  # 
+  # :id = id of the component.
+  # :headers = an array of the header values
+  # :values = an array of arrays.
+  # :order = options hash (:left, :right, :asc_pic, :desc_pic, :values)
+  # :alternating_rows = alternating rows, use css to color row_even / row_odd
+  # :footers = an array of tfooter values
+  
+  def table_header(options)
+    str = ''
+    str << '<thead>' if create_tbody?(options) || options[:footers]
+    str << '<tr>'
+    
+    options[:headers].each_with_index do |header, index|
+      if (options[:order] && options[:order][:values] &&
+                            options[:order][:values][index])
+        order_by = options[:order][:values][index]
+        
+        asc_val = if options[:order][:asc_pic]
+           %|<img src="#{options[:order][:asc_pic]}" alt="asc" />|
+        else
+          '^'
+        end
+        desc_val = if options[:order][:desc_pic]
+           %|<img src="#{options[:order][:desc_pic]}" alt="desc" />|
+        else
+          'v'
+        end
+        
+        order_asc = "<a href='#{target_uri(order_by, 'ASC')}'>#{asc_val}</a>"
+        order_desc = "<a href='#{target_uri(order_by, 'DESC')}'>#{desc_val}</a>"
+        
+        str << '<th><table width="100%" cellspacing="0" cellpadding="0"><tr>'
+        
+        if options[:order][:left] || !options[:order][:right]
+          str << "<th>#{order_asc}<br />#{order_desc}</th>"
+        end
+        
+        str << %|<th>#{header}</th>|
+        
+        if options[:order][:right]
+          str << "<th>#{order_asc}<br />#{order_desc}</th>"
+        end
+        
+        str << '</tr></table></th>'
+      else
+        str << %|<th>#{header}</th>|
       end
-      
-      str << "</tr>"
     end
-
+    
+    str << '</tr>'
+    str << '</thead>' if create_tbody?(options) || options[:footers]
+    
     return str
   end
+  
+  # [+options+]
+  #    A hash of options.
+  # 
+  # :id = id of the component.
+  # :headers = an array of the header values
+  # :values = an array of arrays.
+  # :order = options hash (:left, :right, :asc_pic, :desc_pic, :values)
+  # :alternating_rows = alternating rows, use css to color row_even / row_odd
+  # :footers = an array of tfooter values
+  
+  def table_footer(options)
+    str = '<tfoot><tr>'
+    
+    for footer in options[:footers]
+      str << %|<td>#{footer}</td>|
+    end
+    
+    str << '</tr></tfoot>'
+    
+    return str
+  end
+  
+  # Generate the target URI.
+  
+  def target_uri(order_by, direction)
+    params = { TableHelper.order_by_key => order_by, 
+              TableHelper.order_direction_key => direction }
+    
+    return UriUtils.update_query_string(request.uri.to_s, params)
+  end
+  
+  def create_tbody?(options)
+    options[:values][0][0].respond_to?(:to_ary)
+  end
 
 end
 
 end 
 
 # * George Moschovitis <gm@navel.gr>
+# * Kashia Buch <kashia@vfemail.net>

data/lib/nitro/{adapter → helper}/wee.rb

@@ -5,7 +5,10 @@ require 'wee/adaptors/nitro'
 
 module Nitro
 
-module WeeMixin
+# Include this mixin to the standard Controller to have easy 
+# access to Wee Components.
+
+module WeeHelper
   include Wee::Nitro::ControllerMixin
 
   # Returns the output of the component.
@@ -38,11 +41,14 @@ module WeeMixin
   end  
 end
 
-# Add Wee-related helper methods to published objects.
+#--
+# Add Wee-related helper methods to the default Nitro 
+# controller.
+#++
 
 class Controller
   include Wee::Nitro::ControllerMixin
-  include WeeMixin
+  include WeeHelper
 end
 
 end

data/lib/nitro/render.rb

@@ -27,7 +27,9 @@ class ActionExit < Exception; end
 
 class RenderExit < Exception; end
 
-# The output buffer. 
+# The output buffer. The output of a contoller action is
+# accumulated in this buffer before sending this to the client
+# as a HTTP Response.
 #--
 # TODO: Implement a FAST string (maybe in C)
 #++
@@ -125,18 +127,19 @@ module Render
       klass.new(@context, base).send(action)
     end
 
-  rescue RenderExit, ActionExit => e
+  rescue NoActionError => e1
+    log_error(e1, path, false)
+    print '(error)'
 
-    # Just stop rendering.
-    # For example called by redirects.
-    
-  rescue Exception, StandardError => e
-    log_error(e, path)
+  rescue RenderExit, ActionExit => e2
 
-    # More fault tolerant, only flags the erroneous box with 
-    # error not the full page.
+    # Just stop rendering. For example called by redirects.
     
-    @out << '(error)'
+  rescue Exception, StandardError => e3
+    # More fault tolerant, only flags the erroneous box with 
+    # error not the full page.    
+    log_error(e3, path)
+    print '(error)'
   end
 
 private
@@ -191,15 +194,18 @@ private
 
   # Log a rendering error.
 
-  def log_error(error, path)
-    @rendering_errors ||= []
-    @rendering_errors << [error, path]
+  def log_error(error, path, full = true)
+    (@rendering_errors ||= []) << [error, path]
 
-    # gmosx: Hmm perhaps this should not be logged 
-    # to avoid DOS attacks.
+    if full
+      # gmosx: Hmm perhaps this should not be logged 
+      # to avoid DOS attacks.
 
-    Logger.error "Error while handling '#{path}'."
-    Logger.error pp_exception(error)
+      Logger.error "Error while handling '#{path}'."
+      Logger.error pp_exception(error)
+    else
+      Logger.error error.to_s
+    end
   end
 
   # Convenience method to lookup the session.

data/lib/nitro/scaffolding.rb

@@ -4,6 +4,11 @@ require 'nitro/helper/pager'
 
 module Nitro
 
+# Scaffolding is a feature of Nitro that automatically generates
+# maintenance methods for you. It is typically used in the 
+# early stages of development or by the auto administration 
+# part.
+#
 # This module is applied to controllers to provide 
 # automatically generated CRUD methods.
 #--
@@ -60,6 +65,10 @@ module Scaffolding
       klass.to_s.demodulize.underscore.downcase
     end
 
+    #--
+    # A helper that defines a class method.
+    #++
+
     def define_class_method(meth, code)
       unless @klass.instance_methods.include?(meth.to_s) 
         @klass.module_eval %{
@@ -69,10 +78,18 @@ module Scaffolding
         } 
       end
     end
-    
+
+    #--
+    # A helper that defines a controller action.
+    #++
+        
     def define_controller_action(definition, code, template = nil)
       sym, args = definition.to_s.split(/\(|\)/)
       
+      # Access Namespace::Klass.action as namespace/klass/action.
+      
+      sym.gsub!(/::/, '__')
+      
       if sym == 'index'
         action = "#{@base__}index"
       else
@@ -167,7 +184,7 @@ module Scaffolding
       # FIXME: investigate save, improve.
       
       define_controller_action 'save', %{
-        if oid = request['#@oid']
+        if oid = request.fetch('#@oid', nil)
           oid = oid.to_s # fix StringIO (post).
           obj = request.fill(@klass[oid], :assign_relations => true, :force_boolean => true, :preprocess => true)
         else