nitro 0.31.0 → 0.40.0

data/lib/nitro/helper/form.rb

@@ -1,153 +1,283 @@
-require 'facet/inflect'
+require 'glue/builder/xml'
 
-require 'nitro/helper/form/controls'
-require 'nitro/helper/form/builder'
+require 'nitro/control'
+require 'nitro/control/none'
 
-module Nitro
+require 'nitro/control/attribute/fixnum'
+require 'nitro/control/attribute/float'
+require 'nitro/control/attribute/text'
+require 'nitro/control/attribute/password'
+require 'nitro/control/attribute/textarea'
+require 'nitro/control/attribute/checkbox'
+require 'nitro/control/attribute/options'
+require 'nitro/control/attribute/file'
 
-# A collection of useful helpers for creating and manipulating
-# Forms.
-#--
-# This helper may by applied at run time so try to optimize 
-# this.
-#++
+require 'nitro/control/relation/refers_to'
+require 'nitro/control/relation/has_many'
 
-module FormHelper
+module Nitro
 
-  def self.included(base)
-    super
-    base.send :include, XhtmlHelper
-  end
+module FormHelper
 
-  # Override these methods to customize the rendering.
-  #
-  # An alternative schema could be:
-  # 
-  # <dl>
-  #   <dt class="#{prop.symbol}">#{label(prop)}</dt>
-  #   <dd class="#{prop.symbol}">#{html}</dd>
-  # </dl>
+  # A specialized Builder for dynamically building of forms.
+  # Provides extra support for forms backed by managed objects
+  # (entities).
+  #--
+  # TODO: allow multiple objects per form.
+  # TODO: use more generalized controls.
+  #++
   
-  module FormBuilder
-    class << self
-      # Emit form prologue.
-      
-      def prologue
-        ''
-      end
-      
-      # Emit form epilogue.
+  class FormXmlBuilder < ::Glue::XmlBuilder
+
+    # Mappings of control names to controls.
+    
+    setting :control_map, :doc => 'Mappings of control names to controls', :default => {
+      :fixnum => FixnumControl,
+      :integer => FixnumControl,
+      :float => FloatControl,
+      :true_class => CheckboxControl,
+      :boolean => CheckboxControl,
+      :checkbox => CheckboxControl,
+      :string => TextControl,
+      :password => PasswordControl,
+      :textarea => TextareaControl,
+      :file => FileControl,
+      :webfile => FileControl,
+=begin
+      :array => ArrayControl,
+=end
+      :options => OptionsControl,
+      :refers_to => RefersToControl,
+      :has_one => RefersToControl,
+      :belongs_to => RefersToControl,
+      :has_many => HasManyControl,
+      :many_to_many => HasManyControl,
+      :joins_many => HasManyControl
+    }
+
+    # Returns a control for the given objects attribute.
+    
+    def self.control_for(obj, a, anno, options)
+      name = anno[:control] || anno[:class].to_s.demodulize.underscore.to_sym
+      control_class = self.control_map.fetch(name, NoneControl)
+      return control_class.new(obj, a, options) 
+    end
+
+    # Returns a control for the given objects relation.
+
+    def self.control_for_relation(obj, rel, options)
+      name = rel[:control] || rel.class.to_s.demodulize.underscore.to_sym
+      control_class = self.control_map.fetch(name, NoneControl)
+      return control_class.new(obj, rel, options) 
+    end
       
-      def epilogue
-        ''
+    def initialize(buffer = '', options = {})
+      super
+      @obj = options[:object]
+      @errors = options[:errors]
+    end
+    
+    # Render a control+label for the given property of the form
+    # object.
+    
+    def attribute(a, options = {})
+      if anno = @obj.class.ann[a]
+        control = self.class.control_for(@obj, a, anno, options)
+        print element(a, anno, control.render)
+      else
+        raise "Undefined attribute '#{a}' for class '#{@obj.class}'."
       end
+    end
+    alias attr attribute
 
-      # Emit a label.
-            
-      def label(prop)
-        %{<label for="#{prop.name}">#{prop[:title] || prop.name.to_s.humanize}</label>}
+    # Render controls for all attributes of the form object.
+    # It only considers serializable attributes.
+    
+    def all_attributes(options = {})
+      for a in @obj.class.serializable_attributes
+        prop = @obj.class.ann(a)
+        unless options[:all]
+          next if a == @obj.class.primary_key or prop[:control] == :none or prop[:relation] or [options[:exclude]].flatten.include?(a)
+        end
+        attribute a, options
       end
+    end
+    alias attributes all_attributes
+    alias serializable_attributes all_attributes
+
+    # === Input
+    #
+    # * rel = The relation name as symbol, or the actual 
+    #   relation object.
+    #--
+    # FIXME: Fix the mismatch with the attributes.
+    #++
+    
+    def relation(rel, options = {})
+      # If the relation name is passed, lookup the actual
+      # relation.
       
-      # Emit a form element.
-      
-      def element(prop, html)
-        %{
-          <p class="form_#{prop.symbol}">
-            <div>#{label(prop)}</div>
-            #{html}
-          </p>
-        }        
+      if rel.is_a? Symbol
+        rel = @obj.class.relation(rel)    
       end
+
+      control = self.class.control_for_relation(@obj, rel, options)
+      print element(rel[:symbol], rel, control.render)
     end
-  end
+    alias rel relation
 
-  # Render a standard form for the given object.
-  #--
-  # RETHINK this method.
-  #++
+    # Render controls for all relations of the form object.
+        
+    def all_relations(options = {})
+      for rel in @obj.class.relations
+        unless options[:all]
+          # Ignore polymorphic_marker relations.
+          #--
+          # gmosx: should revisit the handling of polymorphic
+          # relations, feels hacky.
+          #++
+          next if (rel[:control] == :none) or rel.polymorphic_marker? 
+        end
+        relation rel, options
+      end
+    end    
+    alias relations all_relations
     
-  def form_for(obj, options = {})
-    str = ''
+    # Renders a control to select a file for upload.
     
-    name = obj.class.name.underscore
-  
-    method = options.fetch(:method, 'post')
-    action = options.fetch(:action, "save_#{obj.class.name.underscore}")
-    submit = options.fetch(:submit, 'Save')
-    cancel = options.fetch(:cancel, "#@base/#{Scaffolding.class_to_list(obj.class)}")  
+    def select_file(name, options = {})
+      print %|<input type="file" name="#{name}" />|
+    end
+
+    # If flash[:ERRORS] is filled with errors structured as 
+    # name/message pairs the method creates a div containing them, 
+    # otherwise it returns an empty string. 
+    #
+    # So you can write code like
+    #  #{form_errors}
+    #  <form>... </form>
+    #
+    # and redirect the user to the form in case of errors, thus 
+    # allowing him to see what was wrong. 
     
-    if enctype = options.fetch(:enctype, nil) 
-      enctype_attribute = " enctype=\"#{enctype}\""
-    else
-      enctype_attribute = ''
-      for prop in obj.class.properties.values
-        if prop.klass.ancestors.include? Og::Blob                
-          enctype_attribute = ' enctype="multipart/form-data"'
+    def form_errors
+      res = ''
+
+      unless @errors.empty?
+        res << %{<div class="error">\n<ul>\n}
+        for err in @errors
+          if err.is_a? Array
+            res << "<li><strong>#{err[0].to_s.humanize}</strong>: #{err[1]}</li>\n"
+          else
+            res << "<li>#{err}</li>\n"
+          end
         end
+        res << %{</ul>\n</div>\n}
       end
+
+      print(res)
     end
+
+  private
+  
+    # Emit a form element. Override this method to customize the
+    # rendering for your application needs.
     
-    if action == :self
-      str << %{<form method="post"#{enctype_attribute}>}    
-    else
-      action = "#{@base}/#{action}" unless action =~ /\//
-      str << %{<form action="#{action}" method="post"#{enctype_attribute}>}    
+    def element(a, anno, html)
+      # TODO: give better form id!
+      %{
+        <p id="form_#{a}">
+          #{html}
+        </p>
+      }        
     end
-    
-    str << %{<input type="hidden" name="oid" value="#{obj.oid}" />} if obj.oid
-    str << controls_for(obj, options)
-    str << %{<input type="submit" value="#{submit}" />}
-    str << %{ or <a href="#{cancel}">Cancel</a>} if cancel
-    str << %{</form>}
-    
-    return str  
+  
   end
 
-  # Render the controls for the given object.
+private
+
+  # A sophisticated form generation helper method.
+  # If no block is provided, render all attributes.
+  #
+  # === Options
+  #
+  # * :object, :entity, :class = The object that acts as model
+  #   for this form. If you pass a class an empty object is 
+  #   instantiated.
+  #
+  # * :action = The action of this form. The parameter is 
+  #   passed through the R operator (encode_url) to support
+  #   advanced url encoding.
+  #
+  # * :errors = An optional collection of errors.
+  #
+  # === Example
+  #   
+  # #{form(:object => @owner, :action => :save_profile) do |f|
+  #   f.property :name, :editable => false
+  #   f.property :password
+  #   f.br
+  #   f.submit 'Update'
+  # end}
+  
+  def form(options = {}, &block)
+    obj = (options[:object] ||= options[:entity] || options[:class])
     
-  def controls_for(obj, options = {})
-    str = FormBuilder.prologue
-        
-    controls_for_properties(str, obj, options)
+    # If the passed obj is a Class instantiate an empty object
+    # of this class.
     
-    unless options[:no_relations]
-     controls_for_relations(str, obj, options)
+    if obj.is_a? Class
+      obj = options[:object] = obj.allocate
     end
+
+    # Convert virtual :multipart method to method="post",
+    # enctype="multipart/form-data"
     
-    str << FormBuilder.epilogue
-    
-    return str
-  end
+    if options[:method] == :multipart
+      options[:method] = 'POST'
+      options[:enctype] = 'multipart/form-data'
+    end    
 
-  # Render the controls for the properties of the given object.
-  
-  def controls_for_properties(str, obj, options = {})
-    for prop in obj.class.properties.values
-      unless options[:all]
-        next if prop.symbol == obj.class.primary_key.symbol or prop[:control] == :none or prop[:relation]
+    options[:errors] ||= []
+
+    if errors = flash[:ERRORS]
+      if errors.is_a? Array
+        options[:errors].concat(errors)
+      elsif errors.is_a? Glue::Validation::Errors
+        options[:errors].concat(errors.to_a)
+      else
+        options[:errors] << errors
       end
-      control = Form::Control.fetch(obj, prop, options).render
-      str << FormBuilder.element(prop, control)
     end
+    
+    if obj and errors = obj.errors
+      options[:errors].concat(errors.to_a)
+    end
+        
+    b = FormXmlBuilder.new('', options)
+
+    b << '<form'
+    b << %| action="#{R options[:action]}"| if options[:action]
+    b << %| method="#{options[:method]}"| if options[:method]
+    b << %| accept-charset="#{options[:charset]}"| if options[:charset]
+    b << %| enctype="#{options[:enctype]}"| if options[:enctype]
+    b << '>'
+    
+    b.hidden(:oid, obj.oid) if obj and obj.saved?
+
+    # If no block is provided, render all attributes.
+    
+    if block_given?
+      yield b
+    else
+      b.all_attributes
+    end
+    
+    b << '</form>'
+    
+    return b
   end
   
-  # Render the controls for the relations of the given object.
-  
-  def controls_for_relations(str, obj, options = {})
-    for rel in obj.class.relations        
-      unless options[:all]
-        next if rel[:control] == :none
-      end
-      control = Form::Control.fetch(obj, rel, options).render
-      str << FormBuilder.element(rel, control)      
-    end  
-  end
-
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>
-# * Chris Farmiloe <chris.farmiloe@farmiloe.com>
-# * Rob Pitt <rob@motionpath.co.uk>
-  

data/lib/nitro/helper/javascript.rb

@@ -1,11 +1,31 @@
+#--
+# WARNING: most of the code here is deprecated and will be 
+# replaced. Use with caution.
+#++
+
 require 'facet/inflect'
 
 module Nitro
 
+# Javascript code manager.
+#--
+# TODO: Add support for synthesizing compound Javascript files from
+# multiple smaller files.
+#++
+
 module Javascript
+  
   # The javascript files to auto include.
   
   setting :required_files, :default => [], :doc => 'The javascript files to auto include'
+
+  # The root directory where javascript files reside.
+  
+  setting :root_dir, :default => 'public/js', :doc => 'The root directory where javascript files reside'
+
+  def self.require path
+  end
+
 end
 
 # Javascript utilities.
@@ -17,6 +37,7 @@ private
   def escape_javascript(js)
     (js || '').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
   end
+  alias escape escape_javascript
 
   # Converts a Ruby hash to a Javascript hash.
   
@@ -30,6 +51,13 @@ private
   def name_to_jsfile(name)  
     "/js/#{name}.js"
   end  
+
+  # Generate javascript confirm code for links.
+
+  def confirm(text = 'Are you sure?')
+    %|onclick="return confirm('#{text}')"|
+  end
+
 end
 
 # Generates cliend side javascript.
@@ -404,5 +432,3 @@ module JavascriptHelper
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>