dryml 1.3.3 → 1.4.0.pre2

data/lib/dryml/template.rb

@@ -14,8 +14,6 @@ module Dryml
 
     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
@@ -53,7 +51,7 @@ module Dryml
 
       unless @template_path.blank?
         p = Pathname.new template_path
-        p = Pathname.new(Rails.root) + p unless p.absolute? || !Object.const_defined?(:Rails)
+        p = Pathname.new(Rails.root) + p unless p.absolute? || !Object.const_defined?(:Rails) || Rails.root.nil?
         mtime = p.mtime rescue Time.now
 
         if !@builder.ready?(mtime)
@@ -155,8 +153,10 @@ module Dryml
         tag_newlines(el)
 
       when "set-theme"
+        require_toplevel(el)
         require_attribute(el, "name", /^#{DRYML_NAME}$/)
-        @builder.add_build_instruction(:set_theme, :name => el.attributes['name'])
+        Rails.logger.debug "set-theme has been deprecated.   Please use <include gem='hobo_#{el.attributes['name']}'/> instead."
+        @builder.add_build_instruction(:include, :gem => "hobo_#{el.attributes['name']}")
 
         # return nothing - set_theme has no presence in the erb source
         tag_newlines(el)
@@ -397,44 +397,9 @@ module Dryml
 
       "#{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)) +
-        "<% output_buffer; end"
-    end
-
-    def wrap_source_with_metadata(content, kind, name, *args)
-      if (!include_source_metadata) || name.in?(NO_METADATA_TAGS)
-        content
-      else
-        metadata = [kind, name] + args + [@template_path]
-        "<% safe_concat(%(<!--[DRYML|#{metadata * '|'}[-->)) %>" +
-        content +
-        "<% safe_concat(%(<!--]DRYML]-->)) %>"
-      end
-    end
-
-    def wrap_tag_method_body_with_metadata(content)
-      name   = @def_element.attributes['tag']
-      for_   = @def_element.attributes['for']
-      name += " for #{for_}" if for_
-      wrap_source_with_metadata(content, "def", name, element_line_num(@def_element))
+        tag_newlines(el) + "%>" + children_to_erb(el) + "<% output_buffer; end"
     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}'"
-      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
@@ -465,9 +430,11 @@ module Dryml
 
     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"]
+      dom_id = el.attributes['id']
+
+      raise 'id should have been added elsewhere' if dom_id.nil?
 
       part_src = "<% def #{part_name}_part(#{part_locals._?.gsub('@', '')}) #{tag_newlines(el)}; new_context do %>" +
         content +
@@ -564,7 +531,6 @@ module Dryml
       end
     end
 
-
     def tag_call(el)
       name = call_name(el)
       param_name = get_param_name(el)
@@ -608,8 +574,7 @@ module Dryml
              end
 
       call = apply_control_attributes(call, el)
-      call = maybe_make_part_call(el, "<% concat(#{call}) %>")
-      wrap_tag_call_with_metadata(el, call)
+      maybe_make_part_call(el, "<% concat(#{call}) %>")
     end
 
 
@@ -623,8 +588,6 @@ module Dryml
     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|
         case node
         when REXML::Text
@@ -649,7 +612,7 @@ module Dryml
           end
 
           if is_parameter_tag
-            parameter_tag_hash_item(e, metadata_name) + ", "
+            parameter_tag_hash_item(e) + ", "
           end
         end
       end.join
@@ -669,7 +632,7 @@ module Dryml
                        elsif is_code_attribute?(merge_params)
                          merge_params[1..-1]
                        else
-                         merge_param_names = merge_params.split(/\s*,\s*/).*.gsub("-", "_")
+                         merge_param_names = merge_params.split(/\s*,\s*/).*.gsub("-", "_").*.to_sym
                          "all_parameters & #{merge_param_names.inspect}"
                        end
         "merge_parameter_hashes({#{param_items}}, (#{extra_params}) || {})"
@@ -685,52 +648,52 @@ module Dryml
     end
 
 
-    def parameter_tag_hash_item(el, metadata_name)
+    def parameter_tag_hash_item(el)
       name = el.name.dup
       if name.sub!(/^before-/, "")
-        before_parameter_tag_hash_item(name, el, metadata_name)
+        before_parameter_tag_hash_item(name, el)
       elsif name.sub!(/^after-/, "")
-        after_parameter_tag_hash_item(name, el, metadata_name)
+        after_parameter_tag_hash_item(name, el)
       elsif name.sub!(/^prepend-/, "")
-        prepend_parameter_tag_hash_item(name, el, metadata_name)
+        prepend_parameter_tag_hash_item(name, el)
       elsif name.sub!(/^append-/, "")
-        append_parameter_tag_hash_item(name, el, metadata_name)
+        append_parameter_tag_hash_item(name, el)
       else
         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}])"
+          ":#{hash_key} => merge_tag_parameter(#{param_proc(el)}, all_parameters[:#{param_name}])"
         else
-          ":#{hash_key} => #{param_proc(el, metadata_name)}"
+          ":#{hash_key} => #{param_proc(el)}"
         end
       end
     end
 
 
-    def before_parameter_tag_hash_item(name, el, metadata_name)
+    def before_parameter_tag_hash_item(name, el)
       param_name = get_param_name(el)
       dryml_exception("param declaration not allowed on 'before' parameters", el) if param_name
       content = children_to_erb(el) + "<% concat(#{param_restore_local_name(name)}.call({}, {})) %>"
-      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
+      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, content)}"
     end
 
 
-    def after_parameter_tag_hash_item(name, el, metadata_name)
+    def after_parameter_tag_hash_item(name, el)
       param_name = get_param_name(el)
       dryml_exception("param declaration not allowed on 'after' parameters", el) if param_name
       content = "<% concat(#{param_restore_local_name(name)}.call({}, {})) %>" + children_to_erb(el)
-      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, metadata_name, content)}"
+      ":#{ruby_name name}_replacement => #{replace_parameter_proc(el, content)}"
     end
 
 
-    def append_parameter_tag_hash_item(name, el, metadata_name)
+    def append_parameter_tag_hash_item(name, el)
       ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" +
         param_content_element(name) + children_to_erb(el) +
         "<% ; output_buffer } } } ] }"
     end
 
 
-    def prepend_parameter_tag_hash_item(name, el, metadata_name)
+    def prepend_parameter_tag_hash_item(name, el)
       ":#{ruby_name name} => proc { [{}, { :default => proc { |#{param_content_local_name(name)}| new_context { %>" +
         children_to_erb(el) + param_content_element(name) +
         "<% ; output_buffer } } } ] }"
@@ -739,8 +702,6 @@ module Dryml
 
     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}<% ; output_buffer } #{tag_newlines(el)}}"
     end
 
@@ -750,21 +711,14 @@ module Dryml
     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_suffix)
-      metadata_name = "#{el.name} < #{metadata_name_suffix}"
-
+    def param_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
 
-        replace_parameter_proc(el, metadata_name)
+        replace_parameter_proc(el, children_to_erb(el))
       else
         attributes = el.attributes.dup
         # Providing one of 'with' or 'field' but not the other should cancel out the other
@@ -780,14 +734,13 @@ module Dryml
           end
         end.compact
 
-        nested_parameters_hash = parameter_tags_hash(el, metadata_name)
+        nested_parameters_hash = parameter_tags_hash(el)
         "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)
+    def replace_parameter_proc(el, content=nil)
       param_name = el.dryml_name.sub(/^(before|after|append|prepend)-/, "")
       "proc { |#{param_restore_local_name(param_name)}| new_context { %>#{content}<% ; output_buffer } #{tag_newlines(el)}}"
     end
@@ -796,7 +749,7 @@ module Dryml
     def maybe_make_part_call(el, call)
       part_name = el.attributes['part']
       if part_name
-        part_id = el.attributes['id'] || part_name
+        part_id=(el.attributes['id'] ||= "\#{create_part_id('#{part_name}', '#{el.attributes['part-locals']}', binding)}")
 
         "<% safe_concat(\"<div class='part-wrapper' id='#{attribute_to_ruby(part_id)[1..-2]}'>\") %>" +
           part_element(el, call) +
@@ -854,17 +807,15 @@ module Dryml
 
     def static_tag_to_method_call(el)
       part = el.attributes["part"]
+      if part && !el.attributes["id"]
+        el.attributes["id"] = "\#{create_part_id('#{part}', '#{el.attributes['part-locals']}', binding)}"
+      end
       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 el.attributes['merge-attrs']
@@ -1029,11 +980,6 @@ module Dryml
       "#{name}_#{@gensym_counter}"
     end
 
-    def include_source_metadata
-      @include_source_metadata = Rails.env.development? && !ENV['DRYML_EDITOR'].blank? if @include_source_metadata.nil?
-      @include_source_metadata
-    end
-
   end
 
 end

data/lib/dryml/template_environment.rb

@@ -23,7 +23,6 @@ module Dryml
 
     end
 
-    include ActionView::Helpers
     include Helper  ## FIXME remove
 
     def initialize(view=nil)
@@ -105,6 +104,10 @@ module Dryml
     end
 
 
+    def deunderscore_attributes(attrs)
+      HashWithIndifferentAccess[attrs.map{ |attr, value| [attr.to_s.gsub('_', '-'), value]}]
+    end
+
     def add_classes!(attributes, *classes)
       classes = classes.flatten.select{|x|x}
       current = attributes[:class]
@@ -117,13 +120,28 @@ module Dryml
       add_classes!(HashWithIndifferentAccess.new(attributes), classes)
     end
 
+    def add_data_rapid!(attrs, tag, options)
+      data_rapid = ActiveSupport::JSON.decode(attrs["data_rapid"] || "{}")
+      attrs["data_rapid"] = data_rapid.update(tag => options).to_json
+      attrs
+    end
+
+    def add_data_rapid(attrs, tag, options)
+      add_data_rapid!(HashWithIndifferentAccess.new(attrs), tag, options)
+    end
 
     def merge_attrs(attrs, overriding_attrs)
-      return {}.update(attrs) if overriding_attrs.nil?
+      attrs = {}.update(attrs)
+      return attrs if overriding_attrs.nil?
       attrs = attrs.with_indifferent_access unless attrs.is_a?(HashWithIndifferentAccess)
       classes = overriding_attrs[:class]
-      attrs = add_classes(attrs, *classes.split) if classes
-      attrs.update(overriding_attrs - [:class])
+      add_classes!(attrs, *classes.split) if classes
+      if (data_rapid = overriding_attrs["data_rapid"])
+        attrs["data_rapid"]=ActiveSupport::JSON.decode(attrs["data_rapid"] || "{}").
+          update(ActiveSupport::JSON.decode(data_rapid)).to_json
+      end
+
+      attrs.update(overriding_attrs - [:class, :data_rapid])
     end
 
 
@@ -229,7 +247,7 @@ module Dryml
             found = poly_name
             break
           else
-            if call_type == ActiveRecord::Base || call_type == Object
+            if call_type == Object
               found = name
               break
             else
@@ -270,7 +288,18 @@ module Dryml
     def new_object_context(new_this)
       new_context do
         if new_this.respond_to?(:origin)
-          @_this_parent, @_this_field = new_this.origin, new_this.origin_attribute
+          refl = (new_this.origin && new_this.origin_attribute.is_a?(Symbol) && new_this.origin.class.respond_to?(:reflections) && new_this.origin.class.reflections[new_this.origin_attribute])
+          if refl.nil? || refl.macro==:belongs_to || refl.macro==:has_one
+            @_this_parent, @_this_field = new_this.origin, new_this.origin_attribute
+          else
+            # See bug #989 for more discussion.   The commented out
+            # section is more 'correct', but it is expensive and since
+            # nobody really ran into this before, setting to nil seems
+            # more appropriate.
+            @_this_parent, @_this_field = nil, nil
+            #@_this_parent = new_this.origin.send(new_this.origin_attribute)
+            #@_this_field = @_this_parent.index(new_this) || @_this_parent.length
+          end
         else
           @_this_parent, @_this_field = [nil, nil]
         end
@@ -542,11 +571,10 @@ module Dryml
     end
 
 
-    def part_contexts_storage
-      PartContext.client_side_storage(@_part_contexts, session)
+    def part_contexts_storage_uncoded
+      PartContext.client_side_storage_uncoded(@_part_contexts, session)
     end
 
-
     def render_tag(tag_name, attributes)
       method_name = tag_name.to_s.gsub('-', '_')
       if respond_to?(method_name)
@@ -583,15 +611,10 @@ module Dryml
         attr_string = " #{attrs.sort * ' '}" unless attrs.empty?
       end
       content = capture { new_context &block } if block_given?
-      res = if empty
-              "<#{name}#{attr_string}#{scope.xmldoctype ? ' /' : ''}>".html_safe
-            else
-              "<#{name}#{attr_string}>".html_safe + content + "</#{name}>".html_safe
-            end
-      if content.is_a? ActionView::NonConcattingString
-        concat res
+      if empty
+        "<#{name}#{attr_string}#{scope.xmldoctype ? ' /' : ''}>".html_safe
       else
-        res
+        "<#{name}#{attr_string}>".html_safe + content + "</#{name}>".html_safe
       end
     end
 

data/lib/dryml.rb

@@ -17,6 +17,7 @@ module Dryml
   VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).strip
   @@root = Pathname.new File.expand_path('../..', __FILE__)
   def self.root; @@root; end
+  EDIT_LINK_BASE = "https://github.com/tablatom/hobo_tree_table/edit/master/dryml"
 
   class DrymlSyntaxError < RuntimeError; end
 
@@ -35,7 +36,6 @@ module Dryml
   ID_SEPARATOR = '; dryml-tag: '
   APPLICATION_TAGLIB = { :src => "taglibs/application" }
   CORE_TAGLIB        = { :src => "core", :plugin => "dryml" }
-  DEFAULT_IMPORTS = defined?(ApplicationHelper) ? [ApplicationHelper] : []
   @cache = {}
   extend self
   attr_accessor :last_if
@@ -43,7 +43,7 @@ module Dryml
   def precompile_taglibs
     Dir.chdir(Rails.root) do
       Dir["app/views/taglibs/**/*.dryml"].each do |f|
-        Taglib.get(:template_dir => File.dirname(f), :src => File.basename(f).remove(".dryml"))
+        Taglib.get(:template_dir => File.dirname(f), :src => File.basename(f).remove(".dryml"), :source_template => f)
       end
     end
   end
@@ -78,11 +78,18 @@ module Dryml
     end
   end
 
-  def page_renderer(view, identifier, local_names=[], controller_path=nil)
+  def imports_for_view(view)
+    imports = []
+    imports << Sprockets::Helpers::RailsHelper if defined?(Sprockets) && defined?(Rails)
+    imports << ActionView::Helpers if defined?(ActionView)
+    imports + view.controller.class.modules_for_helpers(view.controller.class.all_helpers_from_path(view.controller.class.helpers_path))
+  end
+
+  def page_renderer(view, identifier, local_names=[], controller_path=nil, imports=nil)
     controller_path ||= view.controller.controller_path
     if identifier =~ /#{ID_SEPARATOR}/
       identifier = identifier.split(ID_SEPARATOR).first
-      @cache[identifier] ||=  make_renderer_class("", "", local_names, taglibs_for(controller_path))
+      @cache[identifier] ||=  make_renderer_class("", "", local_names, taglibs_for(controller_path), imports_for_view(view))
       @cache[identifier].new(view)
     else
       mtime = File.mtime(identifier)
@@ -92,7 +99,8 @@ module Dryml
           (local_names - renderer_class.compiled_local_names).any? || # any new local names?
           renderer_class.load_time < mtime)                           # cache out of date?
         renderer_class = make_renderer_class(File.read(identifier), identifier,
-                                             local_names, taglibs_for(controller_path))
+                                             local_names, taglibs_for(controller_path),
+                                             imports_for_view(view))
         renderer_class.load_time = mtime
         @cache[identifier] = renderer_class
       end
@@ -169,13 +177,15 @@ module Dryml
   #                    "core", :plugin => "dryml" } is automatically
   #                    added to this list.
   # @param [ActionView::Base] view an ActionView instance
-  def render(template_src, locals={}, template_path=nil, included_taglibs=[], view=nil)
+  # @param [Array] A list of helper modules to import.  For example,
+  #                     [ActionView::Base]
+  def render(template_src, locals={}, template_path=nil, included_taglibs=[], view=nil, imports=nil)
     template_path ||= template_src
     view ||= ActionView::Base.new(ActionController::Base.view_paths, {})
     this = locals.delete(:this) || nil
 
     renderer_class = Dryml::Template.build_cache[template_path]._?.environment ||
-      make_renderer_class(template_src, template_path, locals.keys)
+      make_renderer_class(template_src, template_path, locals.keys, included_taglibs, imports)
     renderer_class.new(view).render_page(this, locals)
   end
 
@@ -217,15 +227,16 @@ private
   #                    "core", :plugin => "dryml" } is automatically
   #                    added to this list.
   #
-  def make_renderer_class(template_src, template_path, locals=[], taglibs=[])
+  def make_renderer_class(template_src, template_path, locals=[], taglibs=[], imports=nil)
     renderer_class = Class.new(TemplateEnvironment)
-    compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs)
+    compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs, imports)
     renderer_class
   end
 
-  def compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs=[])
+  def compile_renderer_class(renderer_class, template_src, template_path, locals, taglibs=[], imports=nil)
     template = Dryml::Template.new(template_src, renderer_class, template_path)
-    DEFAULT_IMPORTS.each {|m| template.import_module(m)}
+
+    imports.each {|m| template.import_module(m)} if imports
 
     # the sum of all the names we've seen so far - eventually we'll be ready for all of 'em
     all_local_names = renderer_class.compiled_local_names | locals

data/taglibs/core.dryml

@@ -5,7 +5,7 @@
 -->
 <def tag="call-tag" attrs="tag">
   <%= Dryml.static_tags.include?(tag) ?
-      content_tag(tag, parameters.default, attributes) :
+      content_tag(tag, parameters.default, deunderscore_attributes(attributes)) :
       send(tag.gsub('-', '_'), attributes, parameters) %>
 </def>
 
@@ -25,7 +25,7 @@ For example, you might want to wrap an `<img>` tag in an `<a>` tag but only unde
   <% parameter ||= :default %>
   <%= if when_
         if Dryml.static_tags.include?(tag)
-          content_tag(tag, parameters.default, attributes)
+          content_tag(tag, parameters.default, deunderscore_attributes(attributes))
         else
           send(tag.gsub('-', '_'), attributes, { parameter.to_sym => parameters[:default] })
         end
@@ -115,32 +115,38 @@ collection is considered blank)
 
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="html"><%=raw "<html#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</html>" -%></def>
+<def tag="html"><%=raw "<html#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</html>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="table"><%=raw "<table#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</table>" -%></def>
+<def tag="table"><%=raw "<table#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</table>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="a"><%=raw "<a#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</a>" -%></def>
+<def tag="a"><%=raw "<a#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</a>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="section"><%=raw "<section#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</section>" -%></def>
+<def tag="section"><%=raw "<section#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</section>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="header"><%=raw "<header#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</header>" -%></def>
+<def tag="header"><%=raw "<header#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</header>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="footer"><%=raw "<footer#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</footer>" -%></def>
+<def tag="footer"><%=raw "<footer#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</footer>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="form"><%=raw "<form#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</form>" -%></def>
+<def tag="form"><%=raw "<form#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</form>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="submit"><%=raw "<submit#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</submit>" -%></def>
+<def tag="submit"><%=raw "<submit#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</submit>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="input"><%=raw "<input#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</input>" -%></def>
+<def tag="input"><%=raw "<input#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</input>" -%></def>
 
 <!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
-<def tag="link"><%=raw "<link#{tag_options(attributes, true)}>" -%><do param="default"/><%= raw "</link>" -%></def>
+<def tag="link"><%=raw "<link#{tag_options(deunderscore_attributes(attributes), true)}>" -%><do param="default"/><%= raw "</link>" -%></def>
 
+<!-- nodoc.  Define core HTML tags defined in Rapid so that DRYML can be used without Rapid. -->
+<def tag="img"><%=raw "<img#{tag_options(attributes, true)} />" -%></def>
+
+<!-- nodoc: used to provide documentation for a tag without actually defining the tag -->
+<def tag="fakedef">
+</def>

data/taglibs/dryml.dryml

@@ -0,0 +1,3 @@
+<!-- this file exists so the cookbook can find it. -->
+
+<include src="core"/>