hobo 0.5.3 → 0.6

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

@@ -0,0 +1,37 @@
+module Hobo::Dryml
+  
+  class ScopedVariables
+    
+    def initialize
+      @scopes = [{}]
+    end
+    
+    def [](key)
+      @scopes.reverse_each do |s|
+        return s[key] if s.has_key?(key)
+      end 
+      nil
+    end
+    
+    def []=(key, val)
+      @scopes.last[key] = val
+    end
+    
+    def new_scope
+      @scopes << {}
+      res = yield
+      @scopes.pop
+      res
+    end
+    
+    def method_missing(name, *args)
+      if name.to_s =~ /=$/
+        self[name.to_s[0..-2].to_sym] = args.first
+      else
+        self[name]
+      end
+    end
+    
+  end
+  
+end

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

@@ -36,20 +36,42 @@ module Hobo::Dryml
     end
 
     def load
-      @module = Module.new
+      @module = Module.new do
+        @tag_attrs = {}
+        def self._register_tag_attrs(tag_name, attrs)
+          @tag_attrs[tag_name] = attrs
+        end
+        class << self
+          attr_reader :tag_attrs
+        end
+      end
       @file.rewind
       template = Template.new(@file.read, @module, @file.path)
-      template.compile([], false)
+      template.compile([], [])
       @last_load_time = @file.mtime
     end
 
     def import_into(class_or_module, as)
       if as
-        raise NotImplementedError
-        as_class = Class.new(TemplateEnvironment) { include @module }
-        class_or_module.send(:define_method, as) { @module }
+        # Define a method on class_or_module named whatever 'as'
+        # is. The first time the method is called it creates and
+        # returns an object that provides the taglib's tags as
+        # methods. On subsequent calls the object is cached in an
+        # instance variable "@_#{as}_taglib"
+        
+        taglib_module = @module
+        ivar = "@_#{as}_taglib"
+        class_or_module.send(:define_method, as) do 
+          instance_variable_get(ivar) or begin
+                                           as_class = Class.new(TemplateEnvironment) { include taglib_module }
+                                           as_object = as_class.new
+                                           as_object.copy_instance_variables_from(self)
+                                           instance_variable_set(ivar, as_object)
+                                         end
+        end
       else
         class_or_module.send(:include, @module)
+        class_or_module.tag_attrs.update(@module.tag_attrs) if @module.respond_to?(:tag_attrs)
       end
     end
 

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

@@ -5,6 +5,11 @@ module Hobo::Dryml
   class Template
 
     DRYML_NAME = "[a-zA-Z_][a-zA-Z0-9_]*"
+    DRYML_NAME_RX = /^#{DRYML_NAME}$/
+    
+    CODE_ATTRIBUTE_CHAR = "&"
+    
+    SPECIAL_ATTRIBUTES = %w(param merge_attrs for_type if unless repeat part restore)
 
     @build_cache = {}
     
@@ -20,7 +25,6 @@ module Hobo::Dryml
       @src = src
 
       @environment = environment # a class or a module
-      @environment.send(:include, Hobo::PredicateDispatch)
 
       @template_path = template_path.sub(/^#{Regexp.escape(RAILS_ROOT)}/, "")
 
@@ -32,12 +36,12 @@ module Hobo::Dryml
 
     attr_reader :tags, :template_path
     
-    def compile(local_names=[], auto_taglibs=true)
+    def compile(local_names=[], auto_taglibs=[])
       now = Time.now
 
       unless @template_path == EMPTY_PAGE
         filename = RAILS_ROOT + (@template_path.starts_with?("/") ? @template_path : "/" + @template_path)
-        mtime = File.stat(filename).mtime
+        mtime = File.stat(filename).mtime rescue nil
       end
         
       if mtime.nil? || !@builder.ready?(mtime)
@@ -61,12 +65,10 @@ module Hobo::Dryml
       logger.info("  DRYML: Compiled#{from_cache} #{template_path} in %.2fs" % (Time.now - now))
     end
       
+
     def create_render_page_method
       erb_src = process_src
-      
-      src = ERB.new(erb_src).src[("_erbout = '';").length..-1]
-      
-      @builder.add_build_instruction(:type => :render_page, :src => src, :line_num => 1)
+      @builder.add_build_instruction(:render_page, :src => erb_src, :line_num => 1)
     end
 
     
@@ -87,29 +89,26 @@ module Hobo::Dryml
       end
 
       @xmlsrc = "<dryml_page>" + src + "</dryml_page>"
-
-      @doc = REXML::Document.new(RexSource.new(@xmlsrc))
-
-      erb_src = restore_erb_scriptlets(children_to_erb(@doc.root))
+      begin
+        @doc = REXML::Document.new(RexSource.new(@xmlsrc), :dryml_mode => true)
+      rescue REXML::ParseException => e
+        raise DrymlSyntaxError, "File: #{@template_path}\n#{e}"
+      end
+      @doc.default_attribute_value = "&true"
       
-      erb_src
+      restore_erb_scriptlets(children_to_erb(@doc.root))
     end
 
 
     def restore_erb_scriptlets(src)
-      src.gsub(/\[!\[HOBO-ERB(\d+)\s*\]!\]/m) { "<%#{@scriptlets[Regexp.last_match[1].to_i]}%>" }
-    end
-
-
-    def erb_process(src)
-      ERB.new(restore_erb_scriptlets(src)).src
+      src.gsub(/\[!\[HOBO-ERB(\d+)\s*\]!\]/m) {|s| "<%#{@scriptlets[$1.to_i]}%>" }
     end
 
-
+    
     def children_to_erb(nodes)
       nodes.map{|x| node_to_erb(x)}.join
     end
-
+ 
 
     def node_to_erb(node)
       case node
@@ -131,50 +130,62 @@ module Hobo::Dryml
 
 
     def element_to_erb(el)
-      dryml_exception("badly placed parameter tag <#{el.name}>", el) if
+      dryml_exception("parameter tags (<#{el.name}>) are no more, wake up and smell the coffee", el) if
         el.name.starts_with?(":")
 
       @last_element = el
-      case el.name
+      case el.dryml_name
 
-      when "taglib"
-        taglib_element(el)
-        # return nothing - the import has no presence in the erb source
+      when "include"
+        include_element(el)
+        # return nothing - the include has no presence in the erb source
         tag_newlines(el)
         
       when "set_theme"
         require_attribute(el, "name", /^#{DRYML_NAME}$/)
-        @builder.add_build_instruction(:type => :set_theme, :name => el.attributes['name'])
+        @builder.add_build_instruction(:set_theme, :name => el.attributes['name'])
 
         # return nothing - set_theme has no presence in the erb source
         tag_newlines(el)
 
       when "def"
         def_element(el)
-
+        
       when "tagbody"
         tagbody_element(el)
-
+        
+      when "set"
+        set_element(el)
+        
+      when "set_scoped"
+        set_scoped_element(el)
+        
+      when "default_tagbody"
+        default_tagbody_element(el)
+        
       else
-        if el.name.not_in?(Hobo.static_tags) or
-            el.attributes['replace_option'] or el.attributes['content_option']
-          tag_call(el)
+        if el.dryml_name.not_in?(Hobo.static_tags) || el.attributes['param'] || el.attributes['restore']
+          if el.dryml_name =~ /^[A-Z]/
+            template_call(el)
+          else
+            tag_call(el)
+          end
         else
-          html_element_to_erb(el)
+          static_element_to_erb(el)
         end
       end
     end
 
 
-    def taglib_element(el)
+    def include_element(el)
       require_toplevel(el)
       require_attribute(el, "as", /^#{DRYML_NAME}$/, true)
       if el.attributes["src"]
-        @builder.add_build_instruction(:type => :taglib, 
+        @builder.add_build_instruction(:include, 
                                        :name => el.attributes["src"], 
                                        :as => el.attributes["as"])
       elsif el.attributes["module"]
-        @builder.add_build_instruction(:type => :module, 
+        @builder.add_build_instruction(:module, 
                                        :name => el.attributes["module"], 
                                        :as => el.attributes["as"])
       end
@@ -186,353 +197,578 @@ module Hobo::Dryml
     end
 
 
+    def set_element(el)
+      assigns = el.attributes.map do |name, value|
+        dryml_exception(el, "invalid name in set") unless name =~ DRYML_NAME_RX
+        "#{name} = #{attribute_to_ruby(value)}; "
+      end.join
+      "<% #{assigns}#{tag_newlines(el)} %>"
+    end
+    
+    
+    def set_scoped_element(el)
+      assigns = el.attributes.map do |name, value|
+        dryml_exception(el, "invalid name in set_scoped") unless name =~ DRYML_NAME_RX
+        "scope[:#{name}] = #{attribute_to_ruby(value)}; "
+      end.join
+      "<% scope.new_scope { #{assigns}#{tag_newlines(el)} %>#{children_to_erb(el)}<% } %>"
+    end
+    
+    
+    def declared_attributes(def_element)
+      attrspec = def_element.attributes["attrs"]
+      attr_names = attrspec ? attrspec.split(/\s*,\s*/).every(:to_sym) : []
+      invalids = attr_names & ([:with, :field, :this] + SPECIAL_ATTRIBUTES.every(:to_sym))
+      dryml_exception("invalid attrs in def: #{invalids * ', '}", def_element) unless invalids.empty?
+      attr_names
+    end
+
+
     def def_element(el)
       require_toplevel(el)
-      require_attribute(el, "tag", /^#{DRYML_NAME}$/)
+      require_attribute(el, "tag", DRYML_NAME_RX)
       require_attribute(el, "attrs", /^\s*#{DRYML_NAME}(\s*,\s*#{DRYML_NAME})*\s*$/, true)
-      require_attribute(el, "alias_of", /^#{DRYML_NAME}$/, true)
-      require_attribute(el, "alias_current", /^#{DRYML_NAME}$/, true)
-      require_attribute(el, "if", /^#{DRYML_NAME}$/, true)
-
-      name = el.attributes["tag"]
+      require_attribute(el, "alias_of", DRYML_NAME_RX, true)
+      require_attribute(el, "alias_current_as", DRYML_NAME_RX, true)
+      
+      unsafe_name = el.attributes["tag"]
+      name = Hobo::Dryml.unreserve(unsafe_name)
+      if (for_type = el.attributes['for'])
+        type_name = if for_type =~ /^[a-z]/
+                      # It's a symbolic type name - look up the Ruby type name
+                      Hobo.field_types[for_type].name
+                    else
+                      for_type
+                    end.underscore.gsub('/', '__')
+        suffix = "__for_#{type_name}"
+        name        += suffix
+        unsafe_name += suffix
+      end
+      
+      # While processing this def, @def_name contains
+      # the names of all nested defs join with '_'. It's used to
+      # disambiguate local variables as a workaround for the broken
+      # scope semantics of Ruby 1.8.
+      old_def_name = @def_name
+      @def_name = @def_name ? "#{@def_name}_#{unsafe_name}" : unsafe_name
 
       alias_of = el.attributes['alias_of']
-      alias_current = el.attributes['alias_current']
+      alias_current = el.attributes['alias_current_as']
 
-      dryml_exception("def cannot have both alias_of and alias_current", el) if alias_of && alias_current
+      dryml_exception("def cannot have both alias_of and alias_current_as", el) if alias_of && alias_current
       dryml_exception("def with alias_of must be empty", el) if alias_of and el.size > 0
-
+      
+      # If we're redefining, we need a statement in the method body
+      # that does the alias_method on the fly.
+      re_alias = ""
+      
       if alias_of || alias_current
         old_name = alias_current ? name : alias_of
         new_name = alias_current ? alias_current : name
 
-        @builder.add_build_instruction(:type => :alias_method, :new => new_name.to_sym, :old => old_name.to_sym)
+        @builder.add_build_instruction(:alias_method, :new => new_name.to_sym, :old => old_name.to_sym)
       end
-
-      if alias_of
-        "<% #{tag_newlines(el)} %>"
-      else
-        attrspec = el.attributes["attrs"]
-        attr_names = attrspec ? attrspec.split(/\s*,\s*/) : []
-
-        invalids = attr_names & %w{obj attr this}
-        dryml_exception("invalid attrs in def: #{invalids * ', '}", el) unless invalids.empty?
-
-        create_tag_method(el, name.to_sym, attr_names.omap{to_sym})
-      end
-    end
-
-
-    def create_tag_method(el, name, attrs)
-      name = Hobo::Dryml.unreserve(name)
       
-      inner_tags = find_inner_tags(el)
-
-      # A statement to assign values to local variables named after the tag's attrs.
-      setup_locals = ( (attrs.map{|a| "#{Hobo::Dryml.unreserve(a)}, "} + ['options, inner_tag_options']).join +
-                       " = _tag_locals(__options__, #{attrs.inspect}, #{inner_tags.inspect})" )
-
-      start = "_tag_context(__options__, __block__) do |tagbody| #{setup_locals}"
+      res = if alias_of
+              "#{re_alias}<% #{tag_newlines(el)} %>"
+            else
+              src = if template_name?(name)
+                      template_method(name, re_alias, el)
+                    else
+                      tag_method(name, re_alias, el)
+                    end
+              src << "<% _register_tag_attrs(:#{name}, #{declared_attributes(el).inspect}) %>"
+              
+              logger.debug(restore_erb_scriptlets(src)) if el.attributes["debug_source"]
+              
+              @builder.add_build_instruction(:def,
+                                             :src => restore_erb_scriptlets(src),
+                                             :line_num => element_line_num(el))
+              # keep line numbers matching up
+              "<% #{"\n" * src.count("\n")} %>"
+            end
+      @def_name = old_def_name
+      res
+    end
+    
+    
+    def template_call?(el)
+      template_name?(el.name)
+    end
+    
+    
+    def template_name?(name)
+      name =~ /^[A-Z]/
+    end
+    
+    
+    def param_names_in_template(el)
+      REXML::XPath.match(el, ".//*[@param]").map do |e|
+        name = get_param_name(e)
+        dryml_exception("invalid param name: #{name.inspect}", e) unless 
+          is_code_attribute?(name) || name =~ DRYML_NAME_RX || name =~ /#\{/
+        name.to_sym unless is_code_attribute?(name)
+      end.compact
+    end
+    
+    
+    def template_method(name, re_alias, el)
+      param_names = param_names_in_template(el)
       
-      pred = el.attributes["if"]
-      pred = pred[1..-1] if pred && pred.starts_with?('#')
+      "<% def #{name}(all_attributes={}, all_parameters={}, &__block__); " +
+        "parameters = all_parameters - #{param_names.inspect}; " +
+        tag_method_body(el) +
+        "; end %>"
+    end
+    
+    
+    def tag_method(name, re_alias, el)
+      "<% def #{name}(all_attributes={}, &__block__); " +
+        "parameters = nil; " +
+        tag_method_body(el) + 
+        "; end %>"
+    end
+              
+    
+    def tag_method_body(el, attributes_var="all_attributes", block_var="__block__")
+      attrs = declared_attributes(el)
       
-      def_line = if pred
-                   "defp :#{name}, (proc {|options| #{pred}}) do |__options__, __block__|"
-                 elsif @environment.predicate_method?(name)
-                   # be sure not to overwrite the predicate dispatch method
-                   "defp :#{name} do |__options__, __block__|"
-                 else
-                   "def #{name}(__options__={}, &__block__)"
-                 end
+      # A statement to assign values to local variables named after the tag's attrs
+      # The trailing comma on `attributes` is supposed to be there!
+      setup_locals = attrs.map{|a| "#{Hobo::Dryml.unreserve(a)}, "}.join + "attributes, = " +
+        "_tag_locals(#{attributes_var}, #{attrs.inspect})"
 
-      method_src = ( "<% #{def_line}; #{start} " +
-                     # reproduce any line breaks in the start-tag so that line numbers are preserved
-                     tag_newlines(el) + "%>" +
-                     children_to_erb(el) +
-                     "<% @output; end; end %>" )
+      start = "_tag_context(#{attributes_var}, #{block_var}) do |tagbody| #{setup_locals}"
       
-      logger.debug(restore_erb_scriptlets(method_src)) if el.attributes["hobo_debug_source"]
-      
-        @builder.add_build_instruction(:type => :def, :src => erb_process(method_src), :line_num => element_line_num(el))
-
-      # keep line numbers matching up
-      "<% #{"\n" * method_src.count("\n")} %>"
+      "#{start} " +
+        # reproduce any line breaks in the start-tag so that line numbers are preserved
+        tag_newlines(el) + "%>" +
+        children_to_erb(el) +
+        "<% _erbout; end"
     end
     
     
-    def find_inner_tags(el)
-      el.map do |e|
-        if e.is_a?(REXML::Element)
-          name = e.attributes["content_option"] || e.attributes["replace_option"]
-          [(name if name && !is_code_attribute?(name))] + find_inner_tags(e)
-        else
-          []
-        end
-      end.flatten.compact
-    end
-
-
     def tagbody_element(el)
       dryml_exception("tagbody can only appear inside a <def>", el) unless
         find_ancestor(el) {|e| e.name == 'def'}
       dryml_exception("tagbody cannot appear inside a part", el) if
-        find_ancestor(el) {|e| e.attributes['part_id']}
+        find_ancestor(el) {|e| e.attributes['part']}
       tagbody_call(el)
     end
-
+    
 
     def tagbody_call(el)
-      options = []
-      obj = el.attributes['obj']
-      attr = el.attributes['attr']
-      options << ":obj => #{attribute_to_ruby(obj)}" if obj
-      options << ":attr => #{attribute_to_ruby(attr)}" if attr
-      else_ = attribute_to_ruby(el.attributes['else'])
-      "<%= tagbody ? tagbody.call({ #{options * ', '} }) : #{else_} %>"
+      attributes = []
+      with = el.attributes['with']
+      field = el.attributes['field']
+      attributes << ":with => #{attribute_to_ruby(with)}" if with
+      attributes << ":field => #{attribute_to_ruby(field)}" if field
+      
+      default_body = if el.children.empty?
+                       "nil"
+                     else
+                       "proc { %>#{children_to_erb(el)}<% }"
+                     end
+      
+      call = apply_control_attributes("do_tagbody(tagbody, {#{attributes * ', '}}, #{default_body})", el)
+      "<% _output(#{call}) %>"
+    end
+
+    
+    def default_tagbody_element(el)
+      name = el.attributes['for'] || @containing_tag_name
+      "<% #{name}_default_tagbody && #{name}_default_tagbody.call %>"
     end
 
 
     def part_element(el, content)
-      require_attribute(el, "part_id", /^#{DRYML_NAME}$/)
-      part_name  = el.attributes['part_id']
+      require_attribute(el, "part", DRYML_NAME_RX)
+      part_name  = el.attributes['part']
       dom_id = el.attributes['id'] || part_name
       
-      dryml_exception("dupplicate part name: #{part_name}", el) if
-        (part_name + "_part").in?(@environment.instance_methods)
-
       part_src = "<% def #{part_name}_part #{tag_newlines(el)}; new_context do %>" +
         content +
         "<% end; end %>"
-      create_part(part_src, element_line_num(el))
+      @builder.add_part(part_name, restore_erb_scriptlets(part_src), element_line_num(el))
 
       newlines = "\n" * part_src.count("\n")
-      res = "<%= call_part(#{attribute_to_ruby(dom_id)}, :#{part_name}) #{newlines} %>"
+      "<%= call_part(#{attribute_to_ruby(dom_id)}, :#{part_name}) #{newlines} %>"
+    end
+    
+    
+    def get_param_name(el)
+      param_name = el.attributes["param"]
+      
+      if param_name
+        def_tag = find_ancestor(el) {|e| e.name == "def"}
+        dryml_exception("param is not allowed outside of template definitions", el) if
+          def_tag.nil? || !template_name?(def_tag.attributes["tag"])
+      end
+      
+      res = param_name == "&true" ? el.dryml_name : param_name
+
+      dryml_exception("param name for a template call must be capitalised", el) if
+        res && template_call?(el) && !template_name?(res)
+      dryml_exception("param name for a block-tag call must not be capitalised", el) if
+        res && !template_call?(el) && template_name?(res)
+      
       res
     end
+    
+    
+    def call_name(el)
+      Hobo::Dryml.unreserve(el.dryml_name)
+    end
+
+   
+    def polymorphic_call_type(el)
+      t = el.attributes['for_type']
+      if t.nil?
+        nil
+      elsif t == "&true"
+        'this_type'
+      elsif t =~ /^[A-Z]/
+        t
+      elsif t =~ /^[a-z]/
+        "Hobo.field_types[:#{t}]"
+      elsif is_code_attribute?(t)
+        t[1..-1]
+      else
+        dryml_exception("invalid for_type attribute", el)
+      end
+    end
+    
+    
+    def template_call(el)
+      name = call_name(el)
+      param_name = get_param_name(el)
+      attributes = tag_attributes(el)
+      newlines = tag_newlines(el)
+      
+      parameters = tag_newlines(el) + tag_parameters(el)
+      
+      is_param_default_call = el.attributes['restore']
+      
+      call = if param_name
+               param_name = attribute_to_ruby(param_name, :symbolize => true)
+               args = "#{attributes}, #{parameters}, all_parameters[#{param_name}]"
+               to_call = if is_param_default_call
+                           # The tag is available in a local variable
+                           # holding a proc
+                           el.dryml_name
+                         elsif (call_type = polymorphic_call_type(el))
+                           "find_polymorphic_template(:#{name}, #{call_type})"
+                         else
+                           ":#{name}"
+                         end
+               "call_template_parameter(#{to_call}, #{args})"
+             else
+               if is_param_default_call
+                 # The tag is a proc available in a local variable
+                 "#{name}__default.call(#{attributes}, #{parameters})"
+               elsif (call_type = polymorphic_call_type(el))
+                 "send(find_polymorphic_template(:#{name}, #{call_type}), #{attributes}, #{parameters})"
+               else
+                 "#{name}(#{attributes}, #{parameters})"
+               end
+             end
 
+      call = apply_control_attributes(call, el)
+      maybe_make_part_call(el, "<% _output(#{call}) %>")
+    end
+    
+    
+    def merge_attribute(el)
+      merge = el.attributes['merge']
+      dryml_exception("merge cannot have a RHS", el) if merge && merge != "&true"
+      merge
+    end
+    
 
-    def create_part(erb_src, line_num)
-      # Add a method to the part module for this template
+    # Tag parameters are parameters to templates.
+    def tag_parameters(el)
+      dryml_exception("content is not allowed directly inside template calls", el) if 
+        el.children.find { |e| e.is_a?(REXML::Text) && !e.to_s.blank? }
 
-        @builder.add_build_instruction(:type => :part, :src => erb_process(erb_src), :line_num => line_num)
+      param_items = el.map do |node|
+        case node
+        when REXML::Text
+          # Just whitespace
+          node.to_s
+        when REXML::Element
+          e = node
+          param_name = get_param_name(e)
+          if param_name
+            if template_call?(e)
+              ":#{e.name} => merge_template_parameter_procs(#{template_proc(e)}, all_parameters[:#{param_name}]), "
+            else
+              ":#{e.name} => merge_option_procs(#{template_proc(e)}, all_parameters[:#{param_name}]), "
+            end
+          else
+            ":#{e.name} => #{template_proc(e)}, "
+          end
+        end
+      end.join
+      
+      
+      merge_params = el.attributes['merge_params'] || merge_attribute(el)
+      if merge_params
+        extra_params = if merge_params == "&true"
+                         "parameters"
+                        elsif is_code_attribute?(merge_params)
+                          merge_params[1..-1]
+                        else
+                          dryml_exception("invalid merge_params", el)
+                        end
+        "{#{param_items}}.merge((#{extra_params}) || {})"
+      else
+        "{#{param_items}}"
+      end
     end
 
     
-    def tag_call(el)
-      require_attribute(el, "content_option", /#{DRYML_NAME}/, true)
-      require_attribute(el, "replace_option", /#{DRYML_NAME}/, true)
-      
-      # find out if it's empty before removing any <:param_tags>
-      empty_el = el.size == 0
-
-      # gather <:param_tags>, and remove them from the dom
-      compiled_param_tags = compile_parameter_tags(el)
+    def template_proc(el)
+      nl = tag_newlines(el)
+      if (repl = el.attribute("replace"))
+        dryml_exception("replace attribute must not have a value", el) if repl.has_rhs?
+        dryml_exception("replace parameters must not have attributes", el) if el.attributes.length > 1
         
-      name = Hobo::Dryml.unreserve(el.name)
-      options = tag_options(el, compiled_param_tags)
-      newlines = tag_newlines(el)
-      replace_option = el.attributes["replace_option"]
-      content_option = el.attributes["content_option"]
-      dryml_exception("both replace_option and content_option given") if replace_option && content_option
-      call = if replace_option
-               replace_option = attribute_to_ruby(replace_option)
-               "call_replaceable_tag(:#{name}, #{options}, inner_tag_options[#{replace_option}.to_sym])"
-             elsif content_option
-               content_option = attribute_to_ruby(content_option)
-               "call_replaceable_content_tag(:#{name}, #{options}, inner_tag_options[#{content_option}.to_sym])"
-             else
-               "#{name}(#{options})"
-             end
+        default_tag_name = "#{el.dryml_name}__default"
 
-      part_id = el.attributes['part_id']
-      if empty_el
-        if part_id
-          "<span id='#{part_id}'>" + part_element(el, "<%= #{call} %>") + "</span>"
-        else
-          "<%= #{call} #{newlines}%>"
-        end
+        "proc {|#{default_tag_name}| new_context { %>#{children_to_erb(el)}<% } #{nl}}"
       else
-        children = children_to_erb(el)
-        if part_id
-          id = el.attributes['id'] || part_id
-          "<span id='<%= #{attribute_to_ruby(id)} %>'>" +
-            part_element(el, "<% _erbout.concat(#{call} do %>#{children}<% end) %>") +
-            "</span>"
+        attributes = el.attributes.map do 
+          |name, value| ":#{name} => #{attribute_to_ruby(value, el)}" unless name.in?(SPECIAL_ATTRIBUTES)
+        end.compact
+      
+        if template_call?(el || modifiers.first)
+          parameters = el ? tag_parameters(el) : "{}"
+          "proc { [{#{attributes * ', '}}, #{parameters}] #{nl}}"
         else
-          "<% _erbout.concat(#{call} do #{newlines}%>#{children}<% end) %>"
+          if el && el.has_end_tag?
+            old = @containing_tag_name
+            @containing_tag_name = el.dryml_name
+            body = children_to_erb(el)
+            @containing_tag_name = old
+
+            attributes << ":tagbody => proc {|#{el.dryml_name}_default_tagbody| new_context { %>#{body}<% } } " 
+          end
+          "proc { {#{attributes * ', '}} #{nl}}"
         end
       end
     end
     
     
-    def compile_parameter_tags(el)
-      # The implementation of parameter tags is greatly complicated
-      # by the need to maintain line-number parity between the dryml source
-      # and generated erb source
-      
-      last = el.children.reverse.ofind{is_a?(REXML::Element) && name.starts_with?(":")}
-      return "" if last.nil?
-      param_section = el.children[0..el.index(last)]
-      
-      dryml_exception("invalid content before parameter tag", el) unless param_section.all? do |e|
-        (e.is_a?(REXML::Element) && e.name.starts_with?(":")) || 
-          (e.is_a?(REXML::Text) && e.to_s.blank?) ||
-          e.is_a?(REXML::Comment) 
+    def default_tag_name(el)
+      if template_call?(el)
+        "Default#{el.dryml_name}"
+      else
+        "default_#{el.dryml_name}"
       end
+    end
+    
+    
+    def tag_call(el)
+      name = call_name(el)
+      param_name = get_param_name(el)
+      attributes = tag_attributes(el)
+      newlines = tag_newlines(el)
       
-      last = param_section.last
-      compiled = param_section.map do |e|
-        # REXML Bug - don't use el.remove (also removes other children that are == )
-        el.delete_at(el.index(e))
-        case e
-        when REXML::Element
-          array_index = begin
-                          # If there are other param-tags with this
-                          # name, the index of this one, else nil
-                          same_name_params = param_section.select {|x| x.is_a?(REXML::Element) and x.name == e.name}
-                          same_name_params.length > 1 && same_name_params.index(e)
-                        end
-          
-          param_name = attr_name_to_option_key(e.name[1..-1], array_index)
-          
-          dryml_exception("duplicate attribute/parameter-tag #{param}", el) if
-            param_name.in?(el.attributes.keys)
-          
-          param_value = 
-            if e.has_attributes?
-              pairs = e.attributes.map do |n,v|
-                "#{attr_name_to_option_key(n)} => " + "#{attribute_to_ruby(v)}"
-              end
-              # If there is content to, that goes in the hash under the key :content
-              if e.size > 0
-                pairs << "#{tag_newlines(el)}:content => (capture do %>#{children_to_erb(e)}<%; end)"
-              end
-              "{" + pairs.join(",") + "}"
-            elsif e.size > 0
-              "#{tag_newlines(el)}(capture do %>#{children_to_erb(e)}<%; end)"
-            else
-              "''"
-            end
-          pair = "#{param_name} => #{param_value}"
-          pair << ", " unless e == last
-          pair
-          
-        when REXML::Text
-          e.to_s
-          
-        when REXML::Comment
-          REXML::Comment::START + node.to_s + REXML::Comment::STOP
-          
-        end
-      end
+      is_param_default_call = el.attributes['restore']
+
+      call = if param_name
+               to_call = if is_param_default_call
+                           # The tag is available in a local variable
+                           # holding a proc
+                           el.dryml_name
+                         elsif (call_type = polymorphic_call_type(el))
+                           "find_polymorphic_tag(:#{name}, #{call_type})"
+                         else
+                           ":#{name}"
+                         end
+               param_name = attribute_to_ruby(param_name, :symbolize => true)
+               "call_block_tag_parameter(#{to_call}, #{attributes}, all_parameters[#{param_name}])"
+             else
+               if is_param_default_call
+                 "#{name}__default.call_with_block(#{attributes})"
+               elsif (call_type = polymorphic_call_type(el))
+                 "send(find_polymorphic_tag(:#{name}, #{call_type}), #{attributes})"
+               else
+                 "#{name}(#{attributes unless attributes == '{}'})"
+               end
+             end
       
-      compiled.join
+      if el.children.empty?
+        call = apply_control_attributes(call, el)
+        maybe_make_part_call(el, "<%= #{call} #{newlines}%>")
+      else
+        old = @containing_tag_name
+        @containing_tag_name = el.dryml_name
+        children = children_to_erb(el)
+        @containing_tag_name = old
+        
+        call_statement = "#{call} do |#{el.dryml_name}_default_tagbody| #{newlines}%>#{children}<% end"
+        call = "<% _output(" + apply_control_attributes(call_statement, el) + ") %>"
+        maybe_make_part_call(el, call)
+      end
     end
-      
     
-    def attr_name_to_option_key(name, array_index=nil)
-      parts = name.split(".").map { |p| ":#{p}" }
-      parts << array_index if array_index
-      if parts.length == 1
-        parts.first
+    def maybe_make_part_call(el, call)
+      part_name = el.attributes['part']
+      if part_name
+        part_id = part_name && "<%= #{attribute_to_ruby(el.attributes['id'] || part_name)} %>"
+        "<span class='part_wrapper' id='#{part_id}'>" + part_element(el, call) + "</span>"
       else
-        "[" + parts.join(', ') + "]"
+        call
       end
     end
     
     
-    def tag_options(el, param_tags_compiled)
+    def tag_attributes(el)
       attributes = el.attributes
-
-      options = attributes.map do |n,v|
-        param_name = attr_name_to_option_key(n)
-        param_value = attribute_to_ruby(v)
-        "#{param_name} => #{param_value}"
-      end
+      items = attributes.map do |n,v|
+        ":#{n} => #{attribute_to_ruby(v)}" unless n.in?(SPECIAL_ATTRIBUTES)
+      end.compact
       
-      options << param_tags_compiled unless param_tags_compiled.blank?
-      all = options.join(', ')
+      # if there's a ':' el.name is just the part after the ':'
+      items << ":field => \"#{el.name}\"" if el.name != el.expanded_name
       
-      xattrs = attributes['xattrs']
-      if xattrs
-        extra_options = if xattrs.blank?
-                          "options"
-                        elsif xattrs.starts_with?("#")
-                          xattrs[1..-1]
+      items = items.join(", ")
+      
+      merge_attrs = attributes['merge_attrs'] || merge_attribute(el)
+      if merge_attrs
+        extra_attributes = if merge_attrs == "&true"
+                          "attributes"
+                        elsif is_code_attribute?(merge_attrs)
+                          merge_attrs[1..-1]
                         else
-                          dryml_exception("invalid xattrs", el)
+                          dryml_exception("invalid merge_attrs", el)
                         end
-        "{#{all}}.merge((#{extra_options}) || {})"
+        "{#{items}}.merge((#{extra_attributes}) || {})"
       else
-        "{#{all}}"
+        "{#{items}}"
       end
     end
 
-    
-    def html_element_to_erb(el)
-      start_tag_src = el.instance_variable_get("@start_tag_source").
-        gsub(REXML::CData::START, "").gsub(REXML::CData::STOP, "")
-
-      xattrs = el.attributes["xattrs"]
-      if xattrs
-        attr_args = if xattrs.starts_with?('#')
-                      xattrs[1..-1]
-                    elsif xattrs.blank?
-                      "options"
-                    else
-                      dryml_exception("invalid xattrs", el)
-                    end
-        class_attr = el.attributes["class"]
-        if class_attr
-          raise HoboError.new("invalid class attribute with xattrs: '#{class_attr}'") if
-            class_attr =~ /'|\[!\[HOBO-ERB/
-
-          attr_args.concat(", '#{class_attr}'")
-          start_tag_src.sub!(/\s*class\s*=\s*('[^']*?'|"[^"]*?")/, "")
-        end
-        start_tag_src.sub!(/\s*xattrs\s*=\s*('[^']*?'|"[^"]*?")/, " <%= xattrs(#{attr_args}) %>")
+    def static_tag_to_method_call(el)
+      part = el.attributes["part"]
+      attrs = el.attributes.map do |n, v|
+        next if n.in? SPECIAL_ATTRIBUTES
+        val = restore_erb_scriptlets(v).gsub('"', '\"').gsub(/<%=(.*?)%>/, '#{\1}')
+        %(:#{n} => "#{val}")
+      end.compact
+      
+      # If there's a part but no id, the id defaults to the part name
+      if part && !el.attributes["id"]
+        attrs << ":id => '#{part}'"
       end
+      
+      # Convert the attributes hash to a call to merge_attrs if
+      # there's a merge_attrs attribute
+      attrs = if (merge_attrs = el.attributes['merge_attrs'])
+                dryml_exception("merge_attrs was given a string", el) unless is_code_attribute?(merge_attrs)
+        
+                "merge_attrs({#{attrs * ', '}}, " +
+                  "((__merge_attrs__ = (#{merge_attrs[1..-1]})) == true ? attributes : __merge_attrs__))"
+              else
+                "{" + attrs.join(', ') + "}"
+              end
+      
+      if el.children.empty?
+        dryml_exception("part attribute on empty static tag", el) if part
 
-      if start_tag_src.ends_with?("/>")
-        start_tag_src
+        "<%= " + apply_control_attributes("tag(:#{el.name}, #{attrs} #{tag_newlines(el)})", el) + " %>"
       else
-        if el.attributes['part_id']
+        if part
           body = part_element(el, children_to_erb(el))
-          if el.attributes["id"]
-            # remove part_id, and eval the id attribute with an erb scriptlet
-            start_tag_src.sub!(/\s*part_id\s*=\s*('[^']*?'|"[^"]*?")/, "")
-            id_expr = attribute_to_ruby(el.attributes['id'])
-            start_tag_src.sub!(/id\s*=\s*('[^']*?'|"[^"]*?")/, "id='<%= #{id_expr} %>'")
-          else
-            # rename part_id to id
-            start_tag_src.sub!(/part_id\s*=\s*('[^']*?'|"[^"]*?")/, "id=\\1")
-          end
-          dryml_exception("multiple part ids", el) if start_tag_src.index("part_id=")
+        else
+          body = children_to_erb(el)               
+        end
 
+        output_tag = "tag(:#{el.name}, #{attrs}, true) + new_context { %>#{body}</#{el.name}><% }"
+        "<% _output(" + apply_control_attributes(output_tag, el) + ") %>"
+      end
+    end
+    
+    
+    def static_element_to_erb(el)
+      if %w(part merge_attrs if unless repeat).any? {|x| el.attributes[x]}
+        static_tag_to_method_call(el)
+      else
+        start_tag_src = el.start_tag_source.gsub(REXML::CData::START, "").gsub(REXML::CData::STOP, "")
+        
+        # Allow #{...} as an alternate to <%= ... %>
+        start_tag_src.gsub!(/=\s*('.*?'|".*?")/) do |s|
+          s.gsub(/#\{(.*?)\}/, '<%= \1 %>')
+        end
 
-          start_tag_src + body + "</#{el.name}>"
-        else
+        if el.has_end_tag?
           start_tag_src + children_to_erb(el) + "</#{el.name}>"
+        else
+          start_tag_src
         end
       end
     end
+    
+    
+    def apply_control_attributes(expression, el)
+      if_, unless_, repeat = controls = %w(if unless repeat).map {|x| el.attributes[x]}
+      controls.compact!
+      
+      dryml_exception("You can't have multiple control attributes on the same element", el) if
+        controls.length > 1
+      
+      val = controls.first
+      if val.nil?
+        expression
+      else
+        control = if repeat && val == "&true"
+                    "this"
+                  elsif is_code_attribute?(val)
+                    "#{val[1..-1]}"
+                  else
+                    "this.#{val}"
+                  end
+        
+        x = gensym
+        if if_
+          "(if !(#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " +
+            "else (Hobo::Dryml.last_if = false; ''); end)"
+        elsif unless_
+          "(if (#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " +
+            "else (Hobo::Dryml.last_if = false; ''); end)"
+        elsif repeat
+          "repeat_attribute(#{control}) { #{expression} }"
+        end
+      end
+    end
+    
+
+    def attribute_to_ruby(*args)
+      options = extract_options_from_args!(args)
+      attr, el = args
+      
+      dryml_exception('erb scriptlet not allowed in this attribute (use #{ ... } instead)', el) if
+        attr.is_a?(String) && attr.index("[![HOBO-ERB")
 
-    def attribute_to_ruby(attr)
-      dryml_exception("erb scriptlet in attribute of defined tag") if attr && attr.index("[![HOBO-ERB")
-      if attr.nil?
-        "nil"
-      elsif is_code_attribute?(attr)
-        "(#{attr[1..-1]})"
+      if options[:symbolize] && attr =~ /^[a-zA-Z_][^a-zA-Z0-9_]*[\?!]?/
+        ":#{attr}"
       else
-        str = if not attr =~ /"/
-                '"' + attr + '"'
-              elsif not attr =~ /'/
-                "'#{attr}'"
+        res = if attr.nil?
+                "nil"
+              elsif is_code_attribute?(attr)
+                "(#{attr[1..-1]})"
               else
-                dryml_exception("invalid quote(s) in attribute value")
-              end
-        attr.starts_with?("++") ? "attr_extension(#{str})" : str
+                if attr !~ /"/
+                  '"' + attr + '"'
+                elsif attr !~ /'/
+                  "'#{attr}'"
+                else
+                  dryml_exception("invalid quote(s) in attribute value")
+                end
+                #attr.starts_with?("++") ? "attr_extension(#{str})" : str
+              end 
+        options[:symbolize] ? (res + ".to_sym") : res
       end
     end
 
@@ -545,41 +781,48 @@ module Hobo::Dryml
       return nil
     end
 
-    def require_toplevel(el)
-      dryml_exception("<#{el.name}> can only be at the top level", el) if el.parent != @doc.root
+    def require_toplevel(el, message=nil)
+      message ||= "can only be at the top level"
+      dryml_exception("<#{el.dryml_name}> #{message}", el) if el.parent != @doc.root
     end
 
     def require_attribute(el, name, rx=nil, optional=false)
       val = el.attributes[name]
       if val
-        dryml_exception("invalid #{name}=\"#{val}\" attribute on <#{el.name}>", el) unless val =~ rx
+        dryml_exception("invalid #{name}=\"#{val}\" attribute on <#{el.dryml_name}>", el) unless rx && val =~ rx
       else
-        dryml_exception("missing #{name} attribute on <#{el.name}>", el) unless optional
+        dryml_exception("missing #{name} attribute on <#{el.dryml_name}>", el) unless optional
       end
     end
 
     def dryml_exception(message, el=nil)
       el ||= @last_element
-      raise DrymlException.new(message + " -- at #{template_path}:#{element_line_num(el)}")
+      raise DrymlException.new(message, template_path, element_line_num(el))
     end
 
     def element_line_num(el)
-      offset = el.instance_variable_get("@source_offset")
+      offset = el.source_offset
       line_no = @xmlsrc[0..offset].count("\n") + 1
     end
 
     def tag_newlines(el)
-      src = el.instance_variable_get("@start_tag_source")
+      src = el.start_tag_source
       "\n" * src.count("\n")
     end
 
     def is_code_attribute?(attr_value)
-      attr_value.starts_with?("#")
+      attr_value =~ /^\&/ && attr_value !~ /^\&\S+;/
     end
 
     def logger
       ActionController::Base.logger rescue nil
     end
+    
+    def gensym(name="__tmp")
+      @gensym_counter ||= 0
+      @gensym_counter += 1
+      "#{name}_#{@gensym_counter}"
+    end
 
   end