hobo 0.7.3 → 0.7.4

data/hobo_files/plugin/lib/hobo/dryml/parser/document.rb

@@ -0,0 +1,26 @@
+module Hobo::Dryml::Parser
+  
+  class Document < REXML::Document        
+    
+    attr_accessor :default_attribute_value
+    
+    def initialize(source=nil, context={})
+      super(nil, context)
+      @elements = Hobo::Dryml::Parser::Elements.new(self)
+      if source.kind_of? Document
+        @context = source.context
+        super source
+      else
+        build(  source )
+      end 
+    end
+    
+
+    private
+    def build( source )
+      Hobo::Dryml::Parser::TreeParser.new( source, self ).parse
+    end
+    
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/dryml/parser/element.rb

@@ -0,0 +1,27 @@
+module Hobo::Dryml::Parser
+
+  class Element < REXML::Element
+    
+    def initialize(*args)
+      super
+      @elements = Hobo::Dryml::Parser::Elements.new(self)
+    end
+    
+    def dryml_name
+      expanded_name.sub(/:.*/, "")
+    end
+    
+    attr_accessor :start_tag_source, :source_offset
+    
+    attr_writer :has_end_tag
+    def has_end_tag?
+      @has_end_tag
+    end
+    
+    def parameter_tag?
+      expanded_name =~ /:$/
+    end
+    
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/dryml/parser/elements.rb

@@ -0,0 +1,45 @@
+module Hobo::Dryml::Parser
+
+  class Element < REXML::Element
+    
+    def initialize(*args)
+      super
+      @elements = Hobo::Dryml::Parser::Elements.new(self)
+    end
+    
+    def dryml_name
+      expanded_name.sub(/:.*/, "")
+    end
+    
+    attr_accessor :start_tag_source, :source_offset
+    
+    attr_writer :has_end_tag
+    def has_end_tag?
+      @has_end_tag
+    end
+    
+    def parameter_tag?
+      expanded_name =~ /:$/
+    end
+    
+  end
+  
+  class Elements < REXML::Elements
+    
+    # Override to ensure DRYML elements are created
+    def add(element=nil)
+      rv = nil
+      if element.nil?
+        Hobo::Dryml::Parser::Element.new("", self, @element.context)
+      elsif not element.kind_of?(Element)
+        Hobo::Dryml::Parser::Element.new(element, self, @element.context)
+      else
+        @element << element
+        element.context = @element.context
+        element
+      end
+    end
+    
+  end
+
+end

data/hobo_files/plugin/lib/hobo/dryml/parser/source.rb

@@ -0,0 +1,58 @@
+module Hobo::Dryml::Parser
+  
+  # A REXML source that keeps track of where in the buffer it is
+  class Source < REXML::Source
+    
+    def initialize(src)
+      super(src)
+      @buffer_offset = 0
+    end
+
+    attr_reader :last_match_offset
+
+    def remember_match(m)
+      if m
+        @last_match = m
+        @last_match_offset = @buffer_offset + m.begin(0)
+        @orig[@last_match_offset..@last_match_offset+m[0].length] == @buffer[m.begin(0)..m.end(0)]
+      end
+      m
+    end
+
+    def advance_buffer(md)
+      @buffer = md.post_match
+      @buffer_offset += md.end(0)
+    end
+
+    def scan(pattern, cons=false)
+      raise '!'
+      return nil if @buffer.nil?
+      rv = @buffer.scan(pattern)
+      if cons and rv.size > 0
+        advance_buffer(Regexp.last_match)
+      end
+      rv
+    end
+
+    def consume(pattern)
+      md = remember_match(pattern.match(@buffer))
+      if md
+        advance_buffer(md)
+        @buffer
+      end
+    end
+
+    def match(pattern, cons=false)
+      md = remember_match(pattern.match(@buffer))
+      advance_buffer(md) if cons and md
+      return md
+    end
+
+    def current_line
+      pos = last_match_offset || 0
+      [0, 0, @orig[0..pos].count("\n") + 1] 
+    end
+
+  end
+
+end

data/hobo_files/plugin/lib/hobo/dryml/parser/text.rb

@@ -0,0 +1,13 @@
+module Hobo::Dryml::Parser
+  
+  class Text < REXML::Text
+    
+    def parent=(parent)
+      # Bypass immediate super
+      REXML::Child.instance_method(:parent=).bind(self).call(parent)
+      Text.check(@string, /</, nil) if @raw and @parent && Text.respond_to?(:check)
+    end
+
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/dryml/parser/tree_parser.rb

@@ -0,0 +1,67 @@
+module Hobo::Dryml::Parser
+
+  class TreeParser < REXML::Parsers::TreeParser
+    def initialize( source, build_context = Document.new )
+      @build_context = build_context
+      @parser = Hobo::Dryml::Parser::BaseParser.new(source)
+    end
+
+    
+    def parse
+      tag_stack = []
+      in_doctype = false
+      entities = nil
+      begin
+        while true
+          event = @parser.pull
+          #STDERR.puts "TREEPARSER GOT #{event.inspect}"
+          case event[0]
+          when :end_document
+            unless tag_stack.empty?
+              #raise ParseException.new("No close tag for #{tag_stack.inspect}")
+              raise ParseException.new("No close tag for #{@build_context.xpath}")
+            end
+            return
+          when :start_element
+            tag_stack.push(event[1])
+            el = @build_context = @build_context.add_element( event[1] )
+            event[2].each do |key, value|
+              el.attributes[key]=Hobo::Dryml::Parser::Attribute.new(key,value,self)
+            end
+            @build_context.start_tag_source = event[3]
+            @build_context.source_offset = event[4]
+          when :end_element
+            tag_stack.pop
+            @build_context.has_end_tag = event[2]
+            @build_context = @build_context.parent
+          when :text
+            if not in_doctype
+              if @build_context[-1].instance_of? Text
+                @build_context[-1] << event[1]
+              else
+                @build_context.add( 
+                                   Hobo::Dryml::Parser::Text.new(event[1], @build_context.whitespace, nil, true) 
+                                   ) unless (
+                                             @build_context.ignore_whitespace_nodes and
+                                             event[1].strip.size==0
+                                             )
+              end
+            end
+          when :comment
+            c = REXML::Comment.new( event[1] )
+            @build_context.add( c )
+          when :cdata
+            c = REXML::CData.new( event[1] )
+            @build_context.add( c )
+          when :processing_instruction
+            @build_context.add( Instruction.new( event[1], event[2] ) )
+          end
+        end
+      rescue REXML::Validation::ValidationException
+        raise
+      rescue
+        raise REXML::ParseException.new( $!.message, @parser.source, @parser, $! )
+      end
+    end
+  end
+end

data/hobo_files/plugin/lib/hobo/dryml/scoped_variables.rb

@@ -7,14 +7,12 @@ module Hobo::Dryml
     end
     
     def [](key)
-      @scopes.reverse_each do |s|
-        return s[key] if s.has_key?(key)
-      end 
-      nil
+     s = scope_with_key(key) and s[key]
     end
     
     def []=(key, val)
-      @scopes.last[key] = val
+      s = scope_with_key(key) || @scopes.last
+      s[key] = val
     end
     
     def new_scope
@@ -24,6 +22,13 @@ module Hobo::Dryml
       res
     end
     
+    def scope_with_key(key)
+      @scopes.reverse_each do |s|
+        return s if s.has_key?(key)
+      end 
+      nil
+    end
+    
     def method_missing(name, *args)
       if name.to_s =~ /=$/
         self[name.to_s[0..-2].to_sym] = args.first

data/hobo_files/plugin/lib/hobo/dryml/template.rb

@@ -19,6 +19,8 @@ module Hobo::Dryml
                             if unless repeat 
                             part part-locals
                             restore)
+    
+    VALID_PARAMETER_TAG_ATTRIBUTES = %w(param replace)
 
     @build_cache = {}
     
@@ -99,7 +101,7 @@ module Hobo::Dryml
 
       @xmlsrc = "<dryml_page>" + src + "</dryml_page>"
       begin
-        @doc = REXML::Document.new(RexSource.new(@xmlsrc), :dryml_mode => true)
+        @doc = Hobo::Dryml::Parser::Document.new(Hobo::Dryml::Parser::Source.new(@xmlsrc))
       rescue REXML::ParseException => e
         raise DrymlSyntaxError, "File: #{@template_path}\n#{e}"
       end
@@ -253,7 +255,9 @@ module Hobo::Dryml
       if (for_type = el.attributes['for'])
         type_name = if defined?(HoboFields) && for_type =~ /^[a-z]/
                       # It's a symbolic type name - look up the Ruby type name
-                      HoboFields.to_class(for_type).name
+                      klass = HoboFields.to_class(for_type)
+                      dryml_exception("No such type in polymorphic tag definition: '#{for_type}'", el) unless klass
+                      klass.name
                     elsif for_type =~ /^_.*_$/
                       rename_class(for_type)
                     else
@@ -581,50 +585,51 @@ module Hobo::Dryml
     
 
     def parameter_tag_hash_item(el, metadata_name)
-      if el.name =~ /^before-/
-        before_parameter_tag_hash_item(el, metadata_name)
-      elsif el.name =~ /^after-/
-        after_parameter_tag_hash_item(el, metadata_name)
-      elsif el.name =~ /^prepend-/
-        prepend_parameter_tag_hash_item(el, metadata_name)
-      elsif el.name =~ /^append-/
-        append_parameter_tag_hash_item(el, metadata_name)
-      elsif (param_name = get_param_name(el))
-        ":#{ruby_name el.name} => merge_tag_parameter(#{param_proc(el, metadata_name)}, all_parameters[:#{param_name}])"
+      name = el.name.dup
+      if name.sub!(/^before-/, "")
+        before_parameter_tag_hash_item(name, el, metadata_name)
+      elsif name.sub!(/^after-/, "")
+        after_parameter_tag_hash_item(name, el, metadata_name)
+      elsif name.sub!(/^prepend-/, "")
+        prepend_parameter_tag_hash_item(name, el, metadata_name)
+      elsif name.sub!(/^append-/, "")
+        append_parameter_tag_hash_item(name, el, metadata_name)
       else
-        ":#{ruby_name el.name} => #{param_proc(el, metadata_name)}"
+        hash_key = ruby_name name
+        hash_key += "_replacement" if el.attribute("replace")
+        if (param_name = get_param_name(el))
+          ":#{hash_key} => merge_tag_parameter(#{param_proc(el, metadata_name)}, all_parameters[:#{param_name}])"
+        else
+          ":#{hash_key} => #{param_proc(el, metadata_name)}"
+        end
       end
     end
     
     
-    def before_parameter_tag_hash_item(el, metadata_name)
+    def before_parameter_tag_hash_item(name, el, metadata_name)
       param_name = get_param_name(el)
       dryml_exception("param declaration not allowed on 'before' parameters", el) if param_name
-      name = el.name.sub(/^before-/, "")
       content = children_to_erb(el) + "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>"
-      ":#{ruby_name name} => #{replace_parameter_proc(el, metadata_name, content)}"
+      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
     end
 
     
-    def after_parameter_tag_hash_item(el, metadata_name)
+    def after_parameter_tag_hash_item(name, el, metadata_name)
       param_name = get_param_name(el)
       dryml_exception("param declaration not allowed on 'after' parameters", el) if param_name
-      name = el.name.sub(/^after-/, "")
       content = "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>" + children_to_erb(el) 
-      ":#{ruby_name name} => #{replace_parameter_proc(el, metadata_name, content)}"
+      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
     end
     
     
-    def append_parameter_tag_hash_item(el, metadata_name)
-      name = el.name.sub(/^append-/, "")
+    def append_parameter_tag_hash_item(name, el, metadata_name)
       ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + 
         param_content_element(name) + children_to_erb(el) +
         "<% } } } ] }"
     end
     
     
-    def prepend_parameter_tag_hash_item(el, metadata_name)
-      name = el.name.sub(/^prepend-/, "")
+    def prepend_parameter_tag_hash_item(name, el, metadata_name)
       ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + 
         children_to_erb(el) + param_content_element(name) +
         "<% } } } ] }"
@@ -660,8 +665,14 @@ module Hobo::Dryml
         
         replace_parameter_proc(el, metadata_name)
       else
-        attributes = el.attributes.map do 
-          |name, value| ":#{ruby_name name} => #{attribute_to_ruby(value, el)}" unless name.in?(SPECIAL_ATTRIBUTES)
+        attributes = el.attributes.map do |name, value| 
+          if name.in?(VALID_PARAMETER_TAG_ATTRIBUTES)
+            # just ignore
+          elsif name.in?(SPECIAL_ATTRIBUTES)
+            dryml_exception("attribute '#{name}' is not allowed on parameter tags (<#{el.name}:>)", el)
+          else
+            ":#{ruby_name name} => #{attribute_to_ruby(value, el)}"
+          end
         end.compact
         
         nested_parameters_hash = parameter_tags_hash(el, metadata_name)
@@ -693,6 +704,11 @@ module Hobo::Dryml
     end
     
     
+    def field_shorthand_element?(el)
+      el.expanded_name =~ /:./
+    end
+    
+    
     def tag_attributes(el)
       attributes = el.attributes
       items = attributes.map do |n,v|
@@ -704,7 +720,7 @@ module Hobo::Dryml
       end.compact
       
       # if there's a ':' el.name is just the part after the ':'
-      items << ":field => \"#{ruby_name el.name}\"" if el.expanded_name =~ /:./
+      items << ":field => \"#{ruby_name el.name}\"" if field_shorthand_element?(el)
       
       items = items.join(", ")
       
@@ -765,7 +781,7 @@ module Hobo::Dryml
     
     
     def static_element_to_erb(el)
-      if %w(part merge-attrs if unless repeat).any? {|x| el.attributes[x]}
+      if promote_static_tag_to_method_call?(el)
         static_tag_to_method_call(el)
       else
         start_tag_src = el.start_tag_source.gsub(REXML::CData::START, "").gsub(REXML::CData::STOP, "")
@@ -784,6 +800,11 @@ module Hobo::Dryml
     end
     
     
+    def promote_static_tag_to_method_call?(el)
+      %w(part merge-attrs if unless repeat).any? {|x| el.attributes[x]}
+    end
+    
+    
     def apply_control_attributes(expression, el)
       controls = %w(if unless repeat).map_hash { |x| el.attributes[x] }.compact
       

data/hobo_files/plugin/lib/hobo/dryml/template_environment.rb

@@ -49,14 +49,17 @@ module Hobo::Dryml
       end
     end
 
-    attr_accessor 
 
     for attr in [:erb_binding, :part_contexts, :view_name,
-                 :this, :this_parent, :this_field,
+                 :this, :this_parent, :this_field, :this_key,
                  :form_field_path, :form_this, :form_field_names]
       class_eval "def #{attr}; @_#{attr}; end"
     end
     
+    def this_key=(key)
+      @_this_key = key
+    end
+    
     
     # The type of this, or when this is nil, the type that would be expected in the current field
     def this_type
@@ -87,7 +90,8 @@ module Hobo::Dryml
     
     
     def this_field_reflection
-      this_parent && this_field && this_parent.class.respond_to?(:reflections) && this_parent.class.reflections[this_field.to_sym]
+      this.try.proxy_reflection ||
+        (this_parent && this_field && this_parent.class.respond_to?(:reflections) && this_parent.class.reflections[this_field.to_sym])
     end
     
     
@@ -179,15 +183,17 @@ module Hobo::Dryml
 
     
     def find_polymorphic_tag(name, call_type=nil)
-      call_type ||= (this.is_a?(Array) && this.respond_to?(:member_class) && this.try.member_class) || this_type
+      call_type ||= (this.is_a?(Array) && this.respond_to?(:member_class) && this.member_class) || this_type
 
       while true
-        if call_type == ActiveRecord::Base || call_type == Object
-          return name
-        elsif respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}")
+        if respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}")
           return poly_name
         else
-          call_type = call_type.superclass
+          if call_type == ActiveRecord::Base || call_type == Object
+            return name
+          else
+            call_type = call_type.superclass
+          end
         end
       end
     end
@@ -315,13 +321,14 @@ module Hobo::Dryml
     
     def call_tag_parameter(the_tag, attributes, parameters, caller_parameters, param_name)
       overriding_proc = caller_parameters[param_name]
+      replacing_proc  = caller_parameters[:"#{param_name}_replacement"]
       
       if param_name == :default && overriding_proc
         # :default content is handled specially
         
         call_tag_parameter_with_default_content(the_tag, attributes, parameters[:default], overriding_proc)
-        
-      elsif overriding_proc && overriding_proc.arity == 1
+
+      elsif replacing_proc
         # The caller is replacing this parameter. Don't call the tag
         # at all, just the overriding proc, but pass the restorable
         # tag as a parameter to the overriding proc
@@ -330,9 +337,17 @@ module Hobo::Dryml
           # Call the replaced tag with the attributes and parameters
           # as given in the original tag definition, and with the
           # specialisation given on the 'restore' call
+          
+          if overriding_proc
+            overriding_attributes, overriding_parameters = overriding_proc.call
+            restore_attrs  = overriding_attributes.merge(restore_attrs)
+            restore_params = overriding_parameters.merge(restore_params)
+          end
+          
           override_and_call_tag(the_tag, attributes, parameters, restore_attrs, restore_params)
         end
-        overriding_proc.call(tag_restore)
+        replacing_proc.call(tag_restore)
+        
         
       else
         overriding_attributes, overriding_parameters = overriding_proc._?.call
@@ -423,7 +438,7 @@ module Hobo::Dryml
     end
     
 
-    def part_contexts_storage_tag
+    def part_contexts_javascripts
       storage = part_contexts_storage
       storage.blank? ? "" : "<script>\n#{storage}</script>\n"
     end
@@ -437,7 +452,7 @@ module Hobo::Dryml
     def render_tag(tag_name, attributes)
       method_name = tag_name.gsub('-', '_')
       if respond_to?(method_name)
-        res = (send(method_name, attributes) + part_contexts_storage_tag).strip
+        res = (send(method_name, attributes) + part_contexts_javascripts).strip
 
         # TODO: Temporary hack to get the dryml metadata comments in the right place
         if RAILS_ENV == "development"