raw 0.49.0

data/lib/raw/helper/form.rb

@@ -0,0 +1,284 @@
+require "glue/builder/xml"
+
+require 'raw/control'
+require 'raw/control/none'
+
+require 'raw/control/attribute/fixnum'
+require 'raw/control/attribute/float'
+require 'raw/control/attribute/text'
+require 'raw/control/attribute/password'
+require 'raw/control/attribute/textarea'
+require 'raw/control/attribute/checkbox'
+require 'raw/control/attribute/options'
+require 'raw/control/attribute/file'
+
+require 'raw/control/relation/refers_to'
+require 'raw/control/relation/has_many'
+
+module Raw
+
+module FormHelper
+
+  # 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.
+  #++
+  
+  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)
+      raise "Invalid attribute '#{a}' for object '#{obj}'" if anno.nil?
+      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 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_method :attr, :attribute
+
+    # 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_method :attributes, :all_attributes
+    alias_method :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.
+      
+      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
+    alias_method :rel, :relation
+
+    # 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_method :relations, :all_relations
+    
+    # Renders a control to select a file for upload.
+    
+    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. 
+    
+    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.
+    
+    def element(a, anno, html)
+      # TODO: give better form id!
+      %{
+        <p id="form_#{a}">
+          #{html}
+        </p>
+      }        
+    end
+  
+  end
+
+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_uri) to support
+  #   advanced uri transformation.
+  #
+  # * :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])
+    
+    # If the passed obj is a Class instantiate an empty object
+    # of this class.
+    
+    if obj.is_a? Class
+      obj = options[:object] = obj.allocate
+    end
+
+    # Convert virtual :multipart method to method="post",
+    # enctype="multipart/form-data"
+    
+    if options[:method] == :multipart
+      options[:method] = 'POST'
+      options[:enctype] = 'multipart/form-data'
+    end    
+
+    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
+    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
+  
+end
+
+end

data/lib/raw/helper/javascript.rb

@@ -0,0 +1,59 @@
+require "facets/core/inflect"
+
+module Raw
+
+# 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.
+
+module JavascriptUtils
+
+private
+  # Escape carrier returns and single and double quotes for JavaScript segments.
+  
+  def escape_javascript(js)
+    (js || '').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
+  end
+  alias_method :escape, :escape_javascript
+
+  # Converts a Ruby hash to a Javascript hash.
+  
+  def hash_to_js(options)
+    '{' + options.map {|k, v| "#{k}:#{v}"}.join(', ') + '}'
+  end
+  
+  # Converts the name of a javascript file to the actual 
+  # filename. Override if you don't like the defaults.
+  
+  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
+
+end

data/lib/raw/helper/layout.rb

@@ -0,0 +1,40 @@
+require "facets/core/inflect"
+
+require "raw/element"
+
+module Raw
+
+# 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

data/lib/raw/helper/navigation.rb

@@ -0,0 +1,87 @@
+module Raw
+
+# A helper mixin for programmatically building Navigation Menus
+# through easy to style XHTML. 
+# The code resulting from these methods is in line with that found in most examples at 
+# listamatic, thus you can use prebuilt CSS and Javascript to create horizontal or vertical menus.
+# Basically it generates something like
+#  <div id="navcontainer">
+#   <ul id="navlist">
+#    <li id="active"> <a href="/foo" id="current"> Current Page </a></li>
+#    <li> <a href="/bar"> Other page </a> </li>
+#   </ul>
+#   </div> 
+#
+# This helper takes care of setting of putting the special CSS
+# identifiers for the current controller automatically.
+# You could override menuitem_active_on(path)
+# to change the behaviour that choose the active item, 
+# for example  to keep the item "Wiki" active both for 
+# /wiki/pageone and /wiki/pagetwo
+#
+# Example of horizontal bar at listamatic:
+# http://css.maxdesign.com.au/listamatic/horizontal26.htm
+# Vertical example 
+# http://css.maxdesign.com.au/listamatic/vertical09.htm
+# 
+# NOTE: No tests were made with Publishable objects which are not 
+# subclass of Nitro::Controller, but it _should_ work. 
+
+module NavigationHelper
+
+TEMPLATE=<<Eof
+<div id="navcontainer">
+ <ul id="navlist">
+LIST
+ </ul>
+</div> 
+Eof
+
+  # Takes a list of controllers and builds a menu 
+  # using #mount_path as the uri and the controller name as text. 
+  # An eventual "Controller" suffix will be stripped, so i.e. for controllers 
+  # named +HomeController+, +Pages+, +FeedCtl+ it will use 
+  # +Home+, +Page+, +FeedCtl+.
+  # 
+  # For more finegrained control you can pass a block to this function, each 
+  # controller will be passed to it and the result will be used as the text 
+  # for the menu item.
+  # 
+  # 
+  # Otherwise you can specify pairs of path/text using #navigation_for_hash
+  
+  def menu_for(*controllers) #:yields:
+    hash= {}
+    controllers.each do |c|
+      hash[c.mount_path] = block_given? ? yield(c) : c.name.gsub(/Controller/,'')
+    end
+    menu_from_hash(hash)
+  end
+  
+  # The argument must be an hash of pairs {'path'=>'text for menu item'},
+  # no control will be applied on these values, they will be used directly.
+  # You can use the method like
+  #  navigation_for_hash '/foo/bar'=>'Page One', '/foo/baz'=>'Page Two'
+  #
+  # The method takes care of setting the CSS values as expected. 
+  #
+  # To avoid specifying everything the method #navigation_menu can be used. 
+  
+  def menu_from_hash(hash)
+    list=hash.map do |path,name|
+      if menuitem_active_on?(path)
+        %{<li id="active"><a href="#{path}" id="current"> #{name} </a></li>}
+      else
+        %{<li><a href="#{path}"> #{name} </a></li>}
+      end
+    end.join("\n")
+    TEMPLATE.gsub("LIST",list)
+  end
+
+  def menuitem_active_on?(path)
+    path == request.path
+  end
+
+end
+
+end