hobo 0.7.5 → 0.8

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/source.rb

@@ -1,8 +1,8 @@
 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
@@ -50,7 +50,7 @@ module Hobo::Dryml::Parser
 
     def current_line
       pos = last_match_offset || 0
-      [0, 0, @orig[0..pos].count("\n") + 1] 
+      [0, 0, @orig[0..pos].count("\n") + 1]
     end
 
   end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/text.rb

@@ -1,7 +1,7 @@
 module Hobo::Dryml::Parser
-  
+
   class Text < REXML::Text
-    
+
     def parent=(parent)
       # Bypass immediate super
       REXML::Child.instance_method(:parent=).bind(self).call(parent)
@@ -9,5 +9,5 @@ module Hobo::Dryml::Parser
     end
 
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/tree_parser.rb

@@ -6,7 +6,7 @@ module Hobo::Dryml::Parser
       @parser = Hobo::Dryml::Parser::BaseParser.new(source)
     end
 
-    
+
     def parse
       tag_stack = []
       in_doctype = false
@@ -39,8 +39,8 @@ module Hobo::Dryml::Parser
               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) 
+                @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

data/{hobo_files/plugin/lib → lib}/hobo/dryml/part_context.rb

@@ -1,20 +1,20 @@
 module Hobo
-  
+
   module Dryml
-    
+
     # Raised when the part context fails its integrity check.
     class PartContext
-      
+
       class TamperedWithPartContext < StandardError; end
-    
+
       class Id < String; end
-      
+
       class << self
         attr_accessor :secret, :digest
       end
       self.digest = 'SHA1'
-      
-      
+
+
       def self.client_side_storage(contexts, session)
         return "" if contexts.empty?
 
@@ -23,15 +23,15 @@ module Hobo
           "hoboParts['#{dom_id}'] = (#{code});\n"
         end.join
       end
-      
-      
+
+
       def initialize(part_name, this_id, locals)
         @part_name = part_name
         @this_id = this_id
         @locals = locals.map { |l| pre_marshal(l) }
       end
-      
-      
+
+
       def pre_marshal(x)
         if x.is_a?(ActiveRecord::Base) && x.respond_to?(:typed_id)
           Id.new(x.typed_id)
@@ -39,26 +39,26 @@ module Hobo
           x
         end
       end
-      
-      
+
+
       def marshal(session)
         context = [@part_name, @this_id, @locals]
         data = Base64.encode64(Marshal.dump(context)).strip
         digest = self.class.generate_digest(data, session)
         "#{data}--#{digest}"
       end
-        
+
 
       class << self
-        
+
         # Generate the HMAC keyed message digest. Uses SHA1 by default.
         def generate_digest(data, session)
           secret = self.secret || ActionController::Base.cached_session_options.first[:secret]
           key = secret.respond_to?(:call) ? secret.call(session) : secret
           OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(digest), key, data)
         end
-        
-        
+
+
         # Unmarshal part context to a hash and verify its integrity.
         def unmarshal(client_store, this, session)
           data, digest = CGI.unescape(client_store).strip.split('--')
@@ -70,7 +70,7 @@ module Hobo
 
           [part_name, restore_part_this(this_id, this), restore_locals(locals)]
         end
-      
+
         def restore_part_this(this_id, this)
           if this_id == "this" or this_id.blank?
             this
@@ -78,10 +78,10 @@ module Hobo
             nil
           else
             Hobo.object_from_dom_id(this_id)
-          end          
+          end
         end
-        
-        
+
+
         def restore_locals(locals)
           locals.map do |l|
             if l.is_a?(Id)
@@ -91,11 +91,11 @@ module Hobo
             end
           end
         end
-        
+
       end
-      
+
     end
-    
-  end 
-  
+
+  end
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/scoped_variables.rb

@@ -1,34 +1,34 @@
 module Hobo::Dryml
-  
+
   class ScopedVariables
-    
-    def initialize
-      @scopes = [{}]
+
+    def initialize(variables=nil)
+      @scopes = variables ? [variables] : []
     end
-    
+
     def [](key)
      s = scope_with_key(key) and s[key]
     end
-    
+
     def []=(key, val)
-      s = scope_with_key(key) || @scopes.last
+      s = scope_with_key(key) or raise ArgumentError, "no such scoped variable: #{key}"
       s[key] = val
     end
-    
-    def new_scope
-      @scopes << {}
+
+    def new_scope(variables)
+      @scopes << variables.dup
       res = yield
       @scopes.pop
       res
     end
-    
+
     def scope_with_key(key)
       @scopes.reverse_each do |s|
         return s if s.has_key?(key)
-      end 
+      end
       nil
     end
-    
+
     def method_missing(name, *args)
       if name.to_s =~ /=$/
         self[name.to_s[0..-2].to_sym] = args.first
@@ -36,7 +36,7 @@ module Hobo::Dryml
         self[name]
       end
     end
-    
+
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/tag_parameters.rb

@@ -1,11 +1,11 @@
 module Hobo
-  
+
   module Dryml
-    
+
     class NoParameterError < RuntimeError; end
-    
+
     class TagParameters < Hash
-      
+
       def initialize(parameters, exclude_names=nil)
         if exclude_names.blank?
           update(parameters)
@@ -13,7 +13,7 @@ module Hobo
           parameters.each_pair { |k, v| self[k] = v unless k.in?(exclude_names) }
         end
       end
-      
+
       def method_missing(name, default_content="")
         if name.to_s =~ /\?$/
           has_key?(name.to_s[0..-2].to_sym)
@@ -21,15 +21,15 @@ module Hobo
           self[name]._?.call(default_content) || ""
         end
       end
-      
+
       undef_method :default
-      
+
       def [](param_name)
         fetch(param_name, nil)
       end
-        
+
     end
-    
+
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/taglib.rb

@@ -1,93 +1,99 @@
 module Hobo
-  
+
   module Dryml
 
     class Taglib
-     
+
       @cache = {}
-     
+
       class << self
-     
+
         def get(options)
-          taglib = @cache[options]
+          cache_key = options.inspect
+          taglib = @cache[cache_key]
           if taglib
             taglib.reload
           else
             src_file = taglib_filename(options)
             bundle = options[:bundle] && Bundle.bundles[options[:bundle]]
-     
+
             taglib = Taglib.new(src_file, bundle)
-            @cache[options] = taglib
+            @cache[cache_key] = taglib
           end
           taglib
         end
-        
+
         def clear_cache
           @cache = {}
         end
-        
+
         private
-        
+
         def taglib_filename(options)
-          base = if (plugin = options[:plugin])
-                   "vendor/plugins/#{plugin}/taglibs"
+          plugin = options[:plugin]
+          base = if plugin == "hobo"
+                   "#{HOBO_ROOT}/taglibs"
+                 elsif plugin
+                   "#{RAILS_ROOT}/vendor/plugins/#{plugin}/taglibs"
                  elsif (bundle_name = options[:bundle])
-                   bundle = Bundle.bundles[bundle_name]
-                   "vendor/plugins/#{bundle.plugin}/taglibs"
+                   bundle = Bundle.bundles[bundle_name] or raise ArgumentError, "No such bundle: #{options[:bundle]}"
+                   "#{RAILS_ROOT}/vendor/plugins/#{bundle.plugin}/taglibs"
                  elsif options[:src] =~ /\//
-                   "app/views"
+                   "#{RAILS_ROOT}/app/views"
+                 elsif options[:template_dir] =~ /^#{HOBO_ROOT}/
+                   options[:template_dir]
                  else
-                   options[:template_dir].gsub(/^\//, "") # remove leading / if there is one
+                   "#{RAILS_ROOT}/#{options[:template_dir].gsub(/^\//, '')}" # remove leading / if there is one
                  end
-          
-          filename = "#{RAILS_ROOT}/#{base}/#{options[:src]}.dryml"
-          raise DrymlException, "No such taglib: #{options.inspect} #{filename}" unless File.exists?(filename)
+
+          filename = "#{base}/#{options[:src]}.dryml"
+          raise DrymlException, "No such taglib: #{base} #{options.inspect} #{filename}" unless File.exists?(filename)
           filename
         end
-     
+
       end
-     
+
       def initialize(src_file, bundle)
         @src_file = src_file
         @bundle = bundle
         load
       end
-     
+
       def reload
         load if File.mtime(@src_file) > @last_load_time
       end
-     
+
       def load
         @module = Module.new do
-          
+
           @tag_attrs = {}
           @tag_aliases = {}
-          
+
           class << self
-            
+
             def included(base)
               @tag_aliases.each do |tag, feature|
                 base.send(:alias_method_chain, tag, feature)
               end
             end
-     
+
             def _register_tag_attrs(tag, attrs)
               @tag_attrs[tag] = attrs
             end
             attr_reader :tag_attrs
-            
-            def delayed_alias_method_chain(tag, feature)
+
+            def alias_method_chain_on_include(tag, feature)
               @tag_aliases[tag] = feature
             end
-            
+
           end
-          
+
         end
         template = Template.new(File.read(@src_file), @module, @src_file, @bundle)
         template.compile([], [])
         @last_load_time = File.mtime(@src_file)
       end
-     
+
       def import_into(class_or_module, as)
         if as
           # Define a method on class_or_module named whatever 'as'
@@ -95,10 +101,10 @@ module Hobo
           # 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 
+          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
@@ -111,9 +117,9 @@ module Hobo
           class_or_module.tag_attrs.update(@module.tag_attrs) if @module.respond_to?(:tag_attrs)
         end
       end
-     
+
     end
-    
+
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/template.rb

@@ -1,4 +1,5 @@
 require 'rexml/document'
+require 'pathname'
 
 module Hobo::Dryml
 
@@ -9,21 +10,21 @@ module Hobo::Dryml
 
     RUBY_NAME = "[a-zA-Z_][a-zA-Z0-9_]*"
     RUBY_NAME_RX = /^#{RUBY_NAME}$/
-    
+
     CODE_ATTRIBUTE_CHAR = "&"
-    
+
     NO_METADATA_TAGS = %w(doctype if else unless repeat do with name type-name)
-    
-    SPECIAL_ATTRIBUTES = %w(param merge merge-params merge-attrs 
-                            for-type 
-                            if unless repeat 
+
+    SPECIAL_ATTRIBUTES = %w(param merge merge-params merge-attrs
+                            for-type
+                            if unless repeat
                             part part-locals
                             restore)
-    
+
     VALID_PARAMETER_TAG_ATTRIBUTES = %w(param replace)
 
     @build_cache = {}
-    
+
     class << self
       attr_reader :build_cache
 
@@ -35,7 +36,7 @@ module Hobo::Dryml
     def initialize(src, environment, template_path, bundle=nil)
       @src = src
       @environment = environment # a class or a module
-      @template_path = template_path.sub(/^#{Regexp.escape(RAILS_ROOT)}/, "")
+      @template_path = template_path.sub(%r(^#{Regexp.escape(RAILS_ROOT)}/), "")
       @bundle = bundle
 
       @builder = Template.build_cache[@template_path] || DRYMLBuilder.new(self)
@@ -45,49 +46,49 @@ module Hobo::Dryml
     end
 
     attr_reader :tags, :template_path, :bundle
-    
+
     def compile(local_names=[], auto_taglibs=[])
       now = Time.now
 
       unless @template_path.ends_with?(EMPTY_PAGE)
-        filename = RAILS_ROOT + (@template_path.starts_with?("/") ? @template_path : "/" + @template_path)
-        mtime = File.stat(filename).mtime rescue nil
-      end
-        
-      if mtime.nil? || !@builder.ready?(mtime)
-        @builder.clear_instructions
-        parsed = true
-        # parse the DRYML file creating a list of build instructions
-        if is_taglib?
-          process_src
-        else
-          create_render_page_method
-        end
+        p = Pathname.new template_path
+        p = Pathname.new(RAILS_ROOT) + p unless p.absolute?
+        mtime = p.mtime
+      
+        if !@builder.ready?(mtime)
+          @builder.start
+          parsed = true
+          # parse the DRYML file creating a list of build instructions
+          if is_taglib?
+            process_src
+          else
+            create_render_page_method
+          end
 
-        # store build instructions in the cache
-        Template.build_cache[@template_path] = @builder
+          # store build instructions in the cache
+          Template.build_cache[@template_path] = @builder
+        end
       end
-
+      
       # compile the build instructions
       @builder.build(local_names, auto_taglibs, mtime)
 
-      from_cache = (parsed ? '' : ' (from cache)')
-      logger.info("  DRYML: Compiled#{from_cache} #{template_path} in %.2fs" % (Time.now - now))
+      logger.info("  DRYML: Compiled #{template_path} in %.2fs" % (Time.now - now)) if parsed
     end
-      
+
 
     def create_render_page_method
       erb_src = process_src
-      
+
       @builder.add_build_instruction(:render_page, :src => erb_src, :line_num => 1)
     end
 
-    
+
     def is_taglib?
       @environment.class == Module
     end
 
-    
+
     def process_src
       @doc = Hobo::Dryml::Parser::Document.new(@src, @template_path)
       result = children_to_erb(@doc.root)
@@ -99,11 +100,11 @@ module Hobo::Dryml
       @doc.restore_erb_scriptlets(src)
     end
 
-    
+
     def children_to_erb(nodes)
       nodes.map{|x| node_to_erb(x)}.join
     end
- 
+
 
     def node_to_erb(node)
       case node
@@ -111,7 +112,7 @@ module Hobo::Dryml
       # v important this comes before REXML::Text, as REXML::CData < REXML::Text
       when REXML::CData
         REXML::CData::START + node.to_s + REXML::CData::STOP
-        
+
       when REXML::Comment
         REXML::Comment::START + node.to_s + REXML::Comment::STOP
 
@@ -127,8 +128,8 @@ module Hobo::Dryml
     def strip_suppressed_whiteaspace(s)
       s # s.gsub(/ -(\s*\n\s*)/, '<% \1 %>')
     end
-    
-    
+
+
     def element_to_erb(el)
       dryml_exception("old-style parameter tag (<#{el.name}>)", el) if el.name.starts_with?(":")
 
@@ -140,7 +141,7 @@ module Hobo::Dryml
         # return just the newlines to keep line-number matching - 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(:set_theme, :name => el.attributes['name'])
@@ -150,16 +151,19 @@ module Hobo::Dryml
 
       when "def"
         def_element(el)
-        
+
+      when "extend"
+        extend_element(el)
+
       when "set"
         set_element(el)
-        
+
       when "set-scoped"
         set_scoped_element(el)
-        
+
       when "param-content"
         param_content_element(el)
-        
+
       else
         if el.dryml_name.not_in?(Hobo.static_tags) || el.attributes['param'] || el.attributes['restore']
           tag_call(el)
@@ -179,7 +183,7 @@ module Hobo::Dryml
       end
       @builder.add_build_instruction(:include, options)
     end
-    
+
 
     def import_module(mod, as=nil)
       @builder.import_module(mod, as)
@@ -188,23 +192,24 @@ module Hobo::Dryml
 
     def set_element(el)
       assigns = el.attributes.map do |name, value|
+        next if name.in?(SPECIAL_ATTRIBUTES)
         dryml_exception("invalid name in <set>", el) unless name =~ /^#{DRYML_NAME}(\.#{DRYML_NAME})*$/
         "#{ruby_name name} = #{attribute_to_ruby(value)}; "
       end.join
       code = apply_control_attributes("begin; #{assigns}; end", el)
-      "<% #{assigns}#{tag_newlines(el)} %>"
+      "<% #{code}#{tag_newlines(el)} %>"
     end
-    
-    
+
+
     def set_scoped_element(el)
-      assigns = el.attributes.map do |name, value|
+      variables = el.attributes.map do |name, value|
         dryml_exception("invalid name in <set-scoped>", el) unless name =~ DRYML_NAME_RX
-        "scope[:#{ruby_name name}] = #{attribute_to_ruby(value)}; "
-      end.join
-      "<% scope.new_scope { #{assigns}#{tag_newlines(el)} %>#{children_to_erb(el)}<% } %>"
+        ":#{ruby_name name} => #{attribute_to_ruby(value)} "
+      end
+      "<% scope.new_scope(#{variables * ', '}) { #{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*/).map{ |n| n.underscore.to_sym } : []
@@ -212,13 +217,13 @@ module Hobo::Dryml
       dryml_exception("invalid attrs in def: #{invalids * ', '}", def_element) unless invalids.empty?
       attr_names
     end
-    
-    
+
+
     def ruby_name(dryml_name)
       dryml_name.gsub('-', '_')
     end
-    
-    
+
+
     def with_containing_tag_name(el)
       old = @containing_tag_name
       @containing_tag_name = el.dryml_name
@@ -227,57 +232,86 @@ module Hobo::Dryml
     end
 
 
-    def def_element(el)
-      require_toplevel(el)
-      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_RX, true)
-      require_attribute(el, "extend-with", DRYML_NAME_RX, true)
-      
-      unsafe_name = el.attributes["tag"]
-      name = Hobo::Dryml.unreserve(unsafe_name)
-      if (for_type = el.attributes['for'])
+    def define_polymorphic_dispatcher(el, name)
+      # FIXME: The new erb context ends up being set-up twice 
+      src = %(
+      def #{name}(attributes={}, parameters={})
+        _tag_context(attributes) do
+          attributes.delete :with
+          attributes.delete :field
+          call_polymorphic_tag('#{name}', attributes, parameters) { #{name}__base(attributes.except, parameters) }
+        end
+      end
+      )
+      @builder.add_build_instruction(:eval, :src => src, :line_num => element_line_num(el))
+    end
+    
+    
+    def extend_element(el)
+      def_element(el, true)
+    end
+    
+    
+    def type_specific_suffix
+      el = @def_element
+      for_type = el.attributes['for']
+      if for_type
         type_name = if defined?(HoboFields) && for_type =~ /^[a-z]/
                       # It's a symbolic type name - look up the Ruby type name
-                      klass = HoboFields.to_class(for_type)
-                      dryml_exception("No such type in polymorphic tag definition: '#{for_type}'", el) unless klass
+                      klass = HoboFields.to_class(for_type) or 
+                        dryml_exception("No such type in polymorphic tag definition: '#{for_type}'", el)
                       klass.name
                     elsif for_type =~ /^_.*_$/
                       rename_class(for_type)
                     else
                       for_type
                     end.underscore.gsub('/', '__')
-        suffix = "__for_#{type_name}"
+        "__for_#{type_name}"
+      end
+    end
+        
+
+    def def_element(el, extend_tag=false)
+      require_toplevel(el)
+      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_RX, true)
+
+      @def_element = el
+
+      unsafe_name = el.attributes["tag"]
+      name = Hobo::Dryml.unreserve(unsafe_name)
+      suffix = type_specific_suffix
+      if suffix
         name        += suffix
         unsafe_name += suffix
       end
       
-      @def_element = el
-      
-      alias_of = el.attributes['alias-of']
-      extend_with = el.attributes['extend-with']
+      if el.attributes['polymorphic']
+        %w(for alias-of).each do |attr|
+          dryml_exception("def cannot have both 'polymorphic' and '#{attr}' attributes") if el.attributes[attr]
+        end
+        
+        define_polymorphic_dispatcher(el, ruby_name(name))
+        name        += "__base"
+        unsafe_name += "__base"
+      end
 
-      dryml_exception("def cannot have both alias-of and extend-with", el) if alias_of && extend_with
+      alias_of = el.attributes['alias-of']
       dryml_exception("def with alias-of must be empty", el) if alias_of and el.size > 0
-      
-      
-      @builder.add_build_instruction(:alias_method,
-                                     :new => ruby_name(name).to_sym, 
-                                     :old => ruby_name(Hobo::Dryml.unreserve(alias_of)).to_sym) if alias_of
-      
+
+      alias_of and @builder.add_build_instruction(:alias_method,
+                                                  :new => ruby_name(name).to_sym,
+                                                  :old => ruby_name(Hobo::Dryml.unreserve(alias_of)).to_sym)
+
       res = if alias_of
               "<% #{tag_newlines(el)} %>"
             else
-              src = ""
-              if extend_with
-                src << "<% delayed_alias_method_chain :#{ruby_name name}, :#{ruby_name extend_with} %>"
-                name = "#{name}-with-#{extend_with}"
-              end
-              src << tag_method(name, el) +
+              src = tag_method(name, el, extend_tag) +
                 "<% _register_tag_attrs(:#{ruby_name name}, #{declared_attributes(el).inspect.underscore}) %>"
-              
+
               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))
@@ -287,47 +321,56 @@ module Hobo::Dryml
       @def_element = nil
       res
     end
-    
-    
+
+
     def param_names_in_definition(el)
       REXML::XPath.match(el, ".//*[@param]").map do |e|
         name = get_param_name(e)
-        dryml_exception("invalid param name: #{name.inspect}", e) unless 
+        dryml_exception("invalid param name: #{name.inspect}", e) unless
           is_code_attribute?(name) || name =~ RUBY_NAME_RX || name =~ /#\{/
         name.to_sym unless is_code_attribute?(name)
       end.compact
     end
-    
-    
-    def tag_method(name, el)
+
+
+    def tag_method(name, el, extend_tag=false)
+      name = ruby_name name
       param_names = param_names_in_definition(el)
       
-      "<% def #{ruby_name name}(all_attributes={}, all_parameters={}); " +
+      if extend_tag
+        @extend_key = 'a' + Digest::SHA1.hexdigest(el.to_s)[0..10]
+        alias_statement = "; alias_method_chain_on_include :#{name}, :#{@extend_key}"
+        name = "#{name}_with_#{@extend_key}"
+      end
+            
+      src = "<% def #{name}(all_attributes={}, all_parameters={}); " +
         "parameters = Hobo::Dryml::TagParameters.new(all_parameters, #{param_names.inspect.underscore}); " +
         "all_parameters = Hobo::Dryml::TagParameters.new(all_parameters); " +
         tag_method_body(el) +
-        "; end %>"
+        "; end#{alias_statement} %>"
+      @extend_key = nil
+      src
     end
-    
-        
+
+
     def tag_method_body(el)
       attrs = declared_attributes(el)
-      
+
       # 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).underscore}, "}.join + "attributes, = " +
         "_tag_locals(all_attributes, #{attrs.inspect})"
 
       start = "_tag_context(all_attributes) do #{setup_locals}"
-      
+
       "#{start} " +
         # reproduce any line breaks in the start-tag so that line numbers are preserved
         tag_newlines(el) + "%>" +
         wrap_tag_method_body_with_metadata(children_to_erb(el)) +
         "<% _erbout; end"
     end
-    
-    
+
+
     def wrap_source_with_metadata(content, kind, name, *args)
       if (!include_source_metadata) || name.in?(NO_METADATA_TAGS)
         content
@@ -336,32 +379,35 @@ module Hobo::Dryml
         "<!--[DRYML|#{metadata * '|'}[-->" + content + "<!--]DRYML]-->"
       end
     end
-    
-    
+
+
     def wrap_tag_method_body_with_metadata(content)
       name   = @def_element.attributes['tag']
-      extend = @def_element.attributes['extend-with']
       for_   = @def_element.attributes['for']
-      name = extend ? "#{name}-with-#{extend}" : name
       name += " for #{for_}" if for_
       wrap_source_with_metadata(content, "def", name, element_line_num(@def_element))
     end
-    
-    
+
+
     def wrap_tag_call_with_metadata(el, content)
       name = el.expanded_name
       param = el.attributes['param']
-        
+
       if param == "&true"
         name += " param"
       elsif param
-        name += " param='#{param}'" 
+        name += " param='#{param}'"
       end
-        
+
       wrap_source_with_metadata(content, "call", name, element_line_num(el))
     end
-    
-       
+
+
+    def param_content_local_name(name)
+      "_#{ruby_name name}__default_content"
+    end
+
+
     def param_content_element(name_or_el)
       name = if name_or_el.is_a?(String)
                name_or_el
@@ -376,7 +422,7 @@ module Hobo::Dryml
 
     def part_element(el, content)
       require_attribute(el, "part", DRYML_NAME_RX)
-      
+
       if contains_param?(el)
         delegated_part_element(el, content)
       else
@@ -384,13 +430,13 @@ module Hobo::Dryml
       end
     end
 
-    
+
     def simple_part_element(el, content)
       part_name  = el.attributes['part']
       dom_id = el.attributes['id'] || part_name
       part_name = ruby_name(part_name)
       part_locals = el.attributes["part-locals"]
-      
+
       part_src = "<% def #{part_name}_part(#{part_locals._?.gsub('@', '')}) #{tag_newlines(el)}; new_context do %>" +
         content +
         "<% end; end %>"
@@ -400,31 +446,36 @@ module Hobo::Dryml
       args = [attribute_to_ruby(dom_id), ":#{part_name}", "nil", part_locals].compact
       "<%= call_part(#{args * ', '}) #{newlines} %>"
     end
-    
-    
+
+
     def delegated_part_element(el, content)
-      # TODO 
+      # TODO
     end
-    
-    
+
+
     def contains_param?(el)
       # TODO
       false
     end
-    
-    
+
+
     def part_delegate_tag_name(el)
       "#{@def_name}_#{el.attributes['part']}__part_delegate"
     end
     
     
+    def current_def_name
+      @def_element && @def_element.attributes['tag']
+    end
+
+
     def get_param_name(el)
       param_name = el.attributes["param"]
-      
+
       if param_name
-        def_tag = find_ancestor(el) {|e| e.name == "def"}
+        def_tag = find_ancestor(el) {|e| e.name == "def" || e.name == "extend" }
         dryml_exception("param is not allowed outside of tag definitions", el) if def_tag.nil?
-        
+
         ruby_name(param_name == "&true" ? el.dryml_name : param_name)
       else
         nil
@@ -432,12 +483,37 @@ module Hobo::Dryml
     end
     
     
+    def inside_def_for_type?
+      @def_element && @def_element.attributes['for']
+    end
+
+
     def call_name(el)
       dryml_exception("invalid tag name", el) unless el.dryml_name =~ /^#{DRYML_NAME}(\.#{DRYML_NAME})*$/
-      Hobo::Dryml.unreserve(ruby_name(el.dryml_name))
+      
+      name = Hobo::Dryml.unreserve(ruby_name(el.dryml_name))
+      if call_to_self_from_type_specific_def?(el)
+        "#{name}__base"
+      elsif old_tag_call?(el)
+        name = name[4..-1] # remove 'old-' prefix
+        name += type_specific_suffix if inside_def_for_type?
+        "#{name}_without_#{@extend_key}"
+      else
+        name
+      end
+    end
+    
+    
+    def old_tag_call?(el)
+      @def_element && el.dryml_name == "old-#{current_def_name}"
+    end
+
+
+    def call_to_self_from_type_specific_def?(el)
+      inside_def_for_type? && el.dryml_name == current_def_name &&!el.attributes['for-type']
     end
+    
 
-   
     def polymorphic_call_type(el)
       t = el.attributes['for-type']
       if t.nil?
@@ -454,18 +530,18 @@ module Hobo::Dryml
         dryml_exception("invalid for-type attribute", el)
       end
     end
-    
-    
+
+
     def tag_call(el)
       name = call_name(el)
       param_name = get_param_name(el)
       attributes = tag_attributes(el)
       newlines = tag_newlines(el)
-      
+
       parameters = tag_newlines(el) + parameter_tags_hash(el)
-      
+
       is_param_restore = el.attributes['restore']
-      
+
       call = if param_name
                param_name = attribute_to_ruby(param_name, :symbolize => true)
                args = "#{attributes}, #{parameters}, all_parameters, #{param_name}"
@@ -502,18 +578,18 @@ module Hobo::Dryml
       call = maybe_make_part_call(el, "<% _output(#{call}) %>")
       wrap_tag_call_with_metadata(el, 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 parameter_tags_hash(el, containing_tag_name=nil)
       call_type = nil
-      
+
       metadata_name = containing_tag_name || el.expanded_name
       
       param_items = el.map do |node|
@@ -528,7 +604,7 @@ module Hobo::Dryml
         when REXML::Element
           e = node
           is_parameter_tag = e.parameter_tag?
-          
+
           # Make sure there isn't a mix of parameter tags and normal content
           case call_type
           when nil
@@ -538,19 +614,21 @@ module Hobo::Dryml
           when :default_param_only
             dryml_exception("mixed parameter tags and non-parameter tags", el) if is_parameter_tag
           end
-          
+
           if is_parameter_tag
             parameter_tag_hash_item(e, metadata_name) + ", "
           end
         end
       end.join
-      
-      if call_type == :default_param_only || (el.children.empty? && el.has_end_tag?)
+
+      if call_type == :default_param_only || (call_type.nil? && param_items.length > 0) || (el.children.empty? && el.has_end_tag?)
         with_containing_tag_name(el) do
           param_items = " :default => #{default_param_proc(el, containing_tag_name)}, "
         end
       end
       
+      param_items.concat without_parameters(el)
+
       merge_params = el.attributes['merge-params'] || merge_attribute(el)
       if merge_params
         extra_params = if merge_params == "&true"
@@ -567,6 +645,12 @@ module Hobo::Dryml
       end
     end
     
+    
+    def without_parameters(el)
+      without_names = el.attributes.keys.map { |name| name =~ /^without-(.*)/ and $1 }.compact
+      without_names.map { |name| ":#{ruby_name name}_replacement => proc {|__discard__| '' }, " }.join
+    end
+
 
     def parameter_tag_hash_item(el, metadata_name)
       name = el.name.dup
@@ -588,8 +672,8 @@ module Hobo::Dryml
         end
       end
     end
-    
-    
+
+
     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
@@ -597,59 +681,63 @@ module Hobo::Dryml
       ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
     end
 
-    
+
     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
-      content = "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>" + children_to_erb(el) 
+      content = "<% _output(#{param_restore_local_name(name)}.call({}, {})) %>" + children_to_erb(el)
       ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
     end
-    
-    
+
+
     def append_parameter_tag_hash_item(name, el, metadata_name)
-      ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + 
+      ":#{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(name, el, metadata_name)
-      ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" + 
+      ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" +
         children_to_erb(el) + param_content_element(name) +
         "<% } } } ] }"
     end
 
-    
+
     def default_param_proc(el, containing_param_name=nil)
       content = children_to_erb(el)
       content = wrap_source_with_metadata(content, "param", containing_param_name,
                                           element_line_num(el)) if containing_param_name
       "proc { |#{param_content_local_name(el.dryml_name)}| new_context { %>#{content}<% } #{tag_newlines(el)}}"
     end
-    
-    
+
+
     def param_restore_local_name(name)
       "_#{ruby_name name}_restore"
     end
-    
-    
+
+
     def wrap_replace_parameter(el, name)
       wrap_source_with_metadata(children_to_erb(el), "replace", name, element_line_num(el))
     end
-    
-    
+
+
     def param_proc(el, metadata_name_prefix)
       metadata_name = "#{metadata_name_prefix}><#{el.name}"
-      
+
       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
-        
+
         replace_parameter_proc(el, metadata_name)
       else
-        attributes = el.attributes.map do |name, value| 
+        attributes = el.attributes.dup
+        # Providing one of 'with' or 'field' but not the other should cancel out the other
+        attributes[:with] = "&nil"  if attributes.key?(:field) && !attributes.key?(:with)
+        attributes[:field] = "&nil" if !attributes.key?(:field) && attributes.key?(:with)
+        attribute_items = attributes.map do |name, value|
           if name.in?(VALID_PARAMETER_TAG_ATTRIBUTES)
             # just ignore
           elsif name.in?(SPECIAL_ATTRIBUTES)
@@ -658,56 +746,51 @@ module Hobo::Dryml
             ":#{ruby_name name} => #{attribute_to_ruby(value, el)}"
           end
         end.compact
-        
+
         nested_parameters_hash = parameter_tags_hash(el, metadata_name)
-        "proc { [{#{attributes * ', '}}, #{nested_parameters_hash}] #{nl}}"
+        "proc { [{#{attribute_items * ', '}}, #{nested_parameters_hash}] #{nl}}"
       end
     end
-    
-    
+
+
     def replace_parameter_proc(el, metadata_name, content=nil)
       content ||= wrap_replace_parameter(el, metadata_name)
       param_name = el.dryml_name.sub(/^(before|after|append|prepend)-/, "")
       "proc { |#{param_restore_local_name(param_name)}| new_context { %>#{content}<% } #{tag_newlines(el)}}"
     end
-    
-    
-    def param_content_local_name(name)
-      "_#{ruby_name name}__default_content"
-    end
-    
-        
+
+
     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>"
+        "<div class='part-wrapper' id='#{part_id}'>" + part_element(el, call) + "</div>"
       else
         call
       end
     end
-    
-    
+
+
     def field_shorthand_element?(el)
       el.expanded_name =~ /:./
     end
-    
-    
+
+
     def tag_attributes(el)
       attributes = el.attributes
       items = attributes.map do |n,v|
         dryml_exception("invalid attribute name '#{n}'", el) unless n =~ DRYML_NAME_RX
-       
-        unless n.in?(SPECIAL_ATTRIBUTES)
+
+        unless n.in?(SPECIAL_ATTRIBUTES) || n =~ /^without-/
           ":#{ruby_name n} => #{attribute_to_ruby(v)}"
         end
       end.compact
-      
+
       # if there's a ':' el.name is just the part after the ':'
       items << ":field => \"#{ruby_name el.name}\"" if field_shorthand_element?(el)
-      
+
       items = items.join(", ")
-      
+
       merge_attrs = attributes['merge-attrs'] || merge_attribute(el)
       if merge_attrs
         extra_attributes = if merge_attrs == "&true"
@@ -730,46 +813,46 @@ module Hobo::Dryml
         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
 
-        "<%= " + apply_control_attributes("element(:#{el.name}, #{attrs} #{tag_newlines(el)})", el) + " %>"
+        "<%= " + apply_control_attributes("element(:#{el.name}, #{attrs}, nil, true, #{!el.has_end_tag?} #{tag_newlines(el)})", el) + " %>"
       else
         if part
           body = part_element(el, children_to_erb(el))
         else
-          body = children_to_erb(el)               
+          body = children_to_erb(el)
         end
 
         output_tag = "element(:#{el.name}, #{attrs}, new_context { %>#{body}<% })"
         "<% _output(" + apply_control_attributes(output_tag, el) + ") %>"
       end
     end
-    
-    
+
+
     def static_element_to_erb(el)
       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, "")
-        
+
         # Allow #{...} as an alternate to <%= ... %>
         start_tag_src.gsub!(/=\s*('.*?'|".*?")/) do |s|
           s.gsub(/#\{(.*?)\}/, '<%= \1 %>')
@@ -782,19 +865,19 @@ module Hobo::Dryml
         end
       end
     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
-      
+
       dryml_exception("You can't have multiple control attributes on the same element", el) if
         controls.length > 1
-      
+
       attr = controls.keys.first
       val = controls.values.first
       if val.nil?
@@ -805,15 +888,15 @@ module Hobo::Dryml
                   elsif is_code_attribute?(val)
                     "#{val[1..-1]}"
                   else
-                    "this.#{val}"
+                    attr == "repeat" ? %("#{val}") : "this.#{val}"
                   end
-        
+
         x = gensym
         case attr
         when "if"
           "(if !(#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " +
             "else (Hobo::Dryml.last_if = false; ''); end)"
-        when "unless" 
+        when "unless"
           "(if (#{control}).blank?; (#{x} = #{expression}; Hobo::Dryml.last_if = true; #{x}) " +
             "else (Hobo::Dryml.last_if = false; ''); end)"
         when "repeat"
@@ -821,12 +904,12 @@ module Hobo::Dryml
         end
       end
     end
-    
+
 
     def attribute_to_ruby(*args)
       options = args.extract_options!
       attr, el = args
-      
+
       dryml_exception('erb scriptlet not allowed in this attribute (use #{ ... } instead)', el) if
         attr.is_a?(String) && attr.index("[![HOBO-ERB")
 
@@ -845,8 +928,7 @@ module Hobo::Dryml
                 else
                   dryml_exception("invalid quote(s) in attribute value")
                 end
-                #attr.starts_with?("++") ? "attr_extension(#{str})" : str
-              end 
+              end
         options[:symbolize] ? (res + ".to_sym") : res
       end
     end
@@ -895,17 +977,17 @@ module Hobo::Dryml
     def logger
       ActionController::Base.logger rescue nil
     end
-    
+
     def gensym(name="__tmp")
       @gensym_counter ||= 0
       @gensym_counter += 1
       "#{name}_#{@gensym_counter}"
     end
-    
+
     def rename_class(name)
       @bundle && name.starts_with?("_") ? @bundle.send(name) : name
     end
-    
+
     def include_source_metadata
       # disabled for now -- we're still getting broken rendering with this feature on
       return false