hobo 0.8.3 → 0.8.4

data/lib/hobo/dryml/tag_parameters.rb

@@ -24,6 +24,7 @@ module Hobo
 
       undef_method :default
 
+      # Question: does this do anything? -Tom 
       def [](param_name)
         fetch(param_name, nil)
       end

data/lib/hobo/dryml/taglib.rb

@@ -46,7 +46,8 @@ module Hobo
                    "#{RAILS_ROOT}/#{options[:template_dir].gsub(/^\//, '')}" # remove leading / if there is one
                  end
 
-          filename = "#{base}/#{options[:src]}.dryml"
+          src = options[:src] || plugin
+          filename = "#{base}/#{src}.dryml"
           raise DrymlException, "No such taglib: #{base} #{options.inspect} #{filename}" unless File.exists?(filename)
           filename
         end

data/lib/hobo/dryml/template.rb

@@ -102,7 +102,7 @@ module Hobo::Dryml
 
 
     def children_to_erb(nodes)
-      nodes.map{|x| node_to_erb(x)}.join
+      nodes.map { |x| node_to_erb(x) }.join
     end
 
 
@@ -443,7 +443,7 @@ module Hobo::Dryml
       @builder.add_part(part_name, restore_erb_scriptlets(part_src), element_line_num(el))
 
       newlines = "\n" * part_src.count("\n")
-      args = [attribute_to_ruby(dom_id), ":#{part_name}", "nil", part_locals].compact
+      args = [attribute_to_ruby(dom_id), ":#{part_name}", part_locals].compact
       "<%= call_part(#{args * ', '}) #{newlines} %>"
     end
 
@@ -523,7 +523,8 @@ module Hobo::Dryml
       elsif t =~ /^[A-Z]/
         t
       elsif t =~ /^[a-z]/ && defined? HoboFields.to_class
-        "Hobo.to_class(:#{t})"
+        klass = HoboFields.to_class(t)
+        klass.name
       elsif is_code_attribute?(t)
         t[1..-1]
       else
@@ -610,9 +611,9 @@ module Hobo::Dryml
           when nil
             call_type = is_parameter_tag ? :named_params : :default_param_only
           when :named_params
-            dryml_exception("mixed parameter tags and non-parameter tags", el) unless is_parameter_tag
+            dryml_exception("mixed parameter tags and non-parameter tags (did you forget a ':'?)", el) unless is_parameter_tag
           when :default_param_only
-            dryml_exception("mixed parameter tags and non-parameter tags", el) if is_parameter_tag
+            dryml_exception("mixed parameter tags and non-parameter tags (did you forget a ':'?)", el) if is_parameter_tag
           end
 
           if is_parameter_tag
@@ -639,7 +640,7 @@ module Hobo::Dryml
                          merge_param_names = merge_params.split(/\s*,\s*/).*.gsub("-", "_")
                          "all_parameters & #{merge_param_names.inspect}"
                        end
-        "{#{param_items}}.merge((#{extra_params}) || {})"
+        "merge_parameter_hashes({#{param_items}}, (#{extra_params}) || {})"
       else
         "{#{param_items}}"
       end
@@ -763,8 +764,8 @@ module Hobo::Dryml
     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)} %>"
-        "<div class='part-wrapper' id='#{part_id}'>" + part_element(el, call) + "</div>"
+        part_id = el.attributes['id'] || part_name
+        "<div class='part-wrapper' id='<%= #{attribute_to_ruby part_id} %>'>#{part_element(el, call)}</div>"
       else
         call
       end
@@ -781,30 +782,40 @@ module Hobo::Dryml
       items = attributes.map do |n,v|
         dryml_exception("invalid attribute name '#{n}'", el) unless n =~ DRYML_NAME_RX
 
-        unless n.in?(SPECIAL_ATTRIBUTES) || n =~ /^without-/
-          ":#{ruby_name n} => #{attribute_to_ruby(v)}"
-        end
+        next if n.in?(SPECIAL_ATTRIBUTES) || n =~ /^without-/
+        next if el.attributes['part'] && n == 'id' # The id is rendered on the <div class="part-wrapper"> instead
+        
+        ":#{ruby_name n} => #{attribute_to_ruby(v)}"
       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"
-                          "attributes"
-                        elsif is_code_attribute?(merge_attrs)
-                          merge_attrs[1..-1]
-                        else
-                          dryml_exception("invalid merge-attrs", el)
-                        end
-        "merge_attrs({#{items}},(#{extra_attributes}) || {})"
+      hash = "{#{items.join(", ")}}"
+
+      if merge_attribute(el)
+        "merge_attrs(#{hash}, attributes)"
+      elsif el.attributes['merge-attrs']
+        merge_attrs = compile_merge_attrs(el)
+        "merge_attrs(#{hash}, #{merge_attrs} || {})"
+      else
+        hash
+      end
+    end
+    
+    
+    def compile_merge_attrs(el)
+      merge_attrs = el.attributes['merge-attrs']
+      if merge_attrs == "&true"
+        "attributes"
+      elsif is_code_attribute?(merge_attrs)
+        "(#{merge_attrs[1..-1]})"
       else
-        "{#{items}}"
+        merge_attr_names = merge_attrs.split(/\s*,\s*/).*.gsub("-", "_").*.to_sym
+        "(all_attributes & #{merge_attr_names.inspect})"
       end
     end
+    
 
     def static_tag_to_method_call(el)
       part = el.attributes["part"]
@@ -821,11 +832,9 @@ module Hobo::Dryml
 
       # 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__))"
+      attrs = if el.attributes['merge-attrs']
+                merge_attrs = compile_merge_attrs(el)
+                "merge_attrs({#{attrs * ', '}}, #{merge_attrs} || {})"
               else
                 "{" + attrs.join(', ') + "}"
               end
@@ -888,6 +897,7 @@ module Hobo::Dryml
                   elsif is_code_attribute?(val)
                     "#{val[1..-1]}"
                   else
+                    val.gsub!('-', '_')
                     attr == "repeat" ? %("#{val}") : "this.#{val}"
                   end
 

data/lib/hobo/dryml/template_environment.rb

@@ -1,7 +1,7 @@
 module Hobo::Dryml
 
   class TemplateEnvironment
-
+    
     class << self
       def inherited(subclass)
         subclass.compiled_local_names = []
@@ -22,10 +22,9 @@ module Hobo::Dryml
       alias_method :delayed_alias_method_chain, :alias_method_chain
 
     end
+    
+    include ActionView::Helpers
 
-    for mod in ActionView::Helpers.constants.grep(/Helper$/).map {|m| ActionView::Helpers.const_get(m)}
-      include mod
-    end
 
     def initialize(view_name=nil, view=nil)
       unless view_name.nil? && view.nil?
@@ -34,6 +33,7 @@ module Hobo::Dryml
         @_erb_binding = binding
         @_part_contexts = {}
         @_scoped_variables = ScopedVariables.new
+        @_polymorphic_tag_cache = {}
 
         # Make sure the "assigns" from the controller are available (instance variables)
         if view
@@ -51,11 +51,11 @@ module Hobo::Dryml
 
     for attr in [:erb_binding, :part_contexts, :view_name,
                  :this, :this_parent, :this_field, :this_key,
-                 :form_this, :form_field_names]
+                 :form_this, :form_field_path, :form_field_names]
       class_eval "def #{attr}; @_#{attr}; end"
     end
     
-    def form_field_path
+    def path_for_form_field
       @_form_field_path.nil? and raise Hobo::Dryml::DrymlException, 
         "DRYML cannot provide the correct form-field name here (this_field = #{this_field.inspect}, this = #{this.inspect})"
       @_form_field_path
@@ -133,7 +133,7 @@ module Hobo::Dryml
     end
 
 
-    def dom_id(object=nil, attribute=nil)
+    def typed_id(object=nil, attribute=nil)
       if object.nil?
         # nothing passed -- use context
         if this_parent && this_field && !this_parent.respond_to?(:member_class)
@@ -143,29 +143,51 @@ module Hobo::Dryml
         end
       end
       
-      if (id = object.try.typed_id)
-        attribute ? "#{id}_#{attribute}" : id
-      else
-        "nil"
-      end
-    end
+      id = if (typed_id = object.try.typed_id)
+             typed_id
+           elsif object == @this
+             "this"
+           end
+      attribute ? "#{id}:#{attribute}" : id
+  end
 
 
-    def call_part(part_node_id, part_name, part_this=nil, *locals)
+    def call_part(part_node_id, part_name, *locals)
       res = ''
-      if part_this
-        new_object_context(part_this) do
-          @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals)
-          res = send("#{part_name}_part", *locals)
-        end
-      else
-        new_context do
-          @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals)
-          res = send("#{part_name}_part", *locals)
-        end
+      new_context do
+        @_part_contexts[part_node_id] = PartContext.for_call(part_name, self, locals)
+        res = send("#{part_name}_part", *locals)
       end
       res
     end
+    
+    
+    def refresh_part(encoded_context, session, dom_id)
+      context = Hobo::Dryml::PartContext.for_refresh(encoded_context, @this, session)
+        
+      with_part_context(context) do
+        send("#{context.part_name}_part", *context.locals)
+      end
+    end
+
+    
+    def with_part_context(context, &block)
+      this, this_field = context.this, context.this_field
+      
+      b = if context.form_field_path
+            proc { with_form_context(:unknown, context.form_field_path, &block) }
+          else
+            block
+          end
+      
+      if this && this_field
+        new_object_context(this) { new_field_context(this_field, &b) }
+      elsif this
+        new_object_context(this, &b)
+      else
+        new_context(&b)
+      end
+    end
 
 
     def call_polymorphic_tag(name, *args)
@@ -185,16 +207,22 @@ module Hobo::Dryml
     def find_polymorphic_tag(name, call_type=nil)
       call_type ||= (this.respond_to?(:member_class) && this.member_class) || this_type
       
-      while true
-        if respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}")
-          return poly_name
-        else
-          if call_type == ActiveRecord::Base || call_type == Object
-            return name
+      begin
+        found = nil
+        while true
+          if respond_to?(poly_name = "#{name}__for_#{call_type.name.to_s.underscore.gsub('/', '__')}")
+            found = poly_name
+            break
           else
-            call_type = call_type.superclass
+            if call_type == ActiveRecord::Base || call_type == Object
+              found = name
+              break
+            else
+              call_type = call_type.superclass
+            end
           end
         end
+        found
       end
     end
 
@@ -313,10 +341,10 @@ module Hobo::Dryml
     end
 
 
-    def with_form_context
-      @_form_this = this
-      @_form_field_path = []
-      @_form_field_paths_by_object = { @_form_this => [] }
+    def with_form_context(form_this=this, form_field_path=[form_this.class.name.underscore])
+      @_form_this = form_this
+      @_form_field_path = form_field_path
+      @_form_field_paths_by_object = { form_this => form_field_path }
       res = scope.new_scope :in_form => true, :form_field_names => [] do
         yield
       end
@@ -453,7 +481,7 @@ module Hobo::Dryml
     end
 
 
-    # This proc is used where 'param' is declared on a tag that is
+    # This method is used where 'param' is declared on a tag that is
     # itself a parameter tag.  Takes two procs that each return a pair
     # of hashes (attributes and parameters). Returns a single proc
     # that also returns a pair of hashes - the merged atributes and
@@ -472,7 +500,7 @@ module Hobo::Dryml
 
             attrs  = merge_attrs(general_attrs, overriding_attrs)
             overriding_default = overriding_parameters.delete(:default)
-            params = general_parameters.merge(overriding_parameters)
+            params = merge_parameter_hashes(general_parameters, overriding_parameters)
 
             # The overrider should provide its :default as the new
             # 'default_content'
@@ -494,6 +522,20 @@ module Hobo::Dryml
         end
       end
     end
+    
+    
+    def merge_parameter_hashes(given_parameters, overriding_parameters)
+      to_merge = given_parameters.keys & overriding_parameters.keys
+      no_merge = overriding_parameters.keys - to_merge
+      result = given_parameters.dup
+      
+      no_merge.each { |k| result[k] = overriding_parameters[k] }
+      to_merge.each { |k| result[k] = merge_tag_parameter(given_parameters[k], overriding_parameters[k])}
+      
+      result
+    end
+      
+      
 
 
     def part_contexts_javascripts

data/lib/hobo/dryml/template_handler.rb

@@ -1,21 +1,27 @@
 module Hobo::Dryml
 
   class TemplateHandler < ActionView::TemplateHandler
-
+    
+    def compile(*args)
+      # Ignore - we handle compilation ourselves
+    end
+    
+    # Pre Rails 2.2
     def render(template)
-      renderer = Hobo::Dryml.page_renderer_for_template(@view, template)
+      renderer = Hobo::Dryml.page_renderer_for_template(@view, template.locals.keys, template)
       this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || template.locals[:this])
       s = renderer.render_page(this, template.locals)
-
       # Important to strip whitespace, or the browser hangs around for ages (FF2)
-      s = s.strip
+      s.strip
+    end
+    
+    def render_for_rails22(template, view, local_assigns)
+      renderer = Hobo::Dryml.page_renderer_for_template(view, local_assigns.keys, template)
+      this = @view.instance_variable_set("@this", view.controller.send(:dryml_context) || local_assigns[:this])
+      s = renderer.render_page(this, local_assigns)
 
-      # TODO: Temporary hack to get the dryml metadata comments in the right place
-      if RAILS_ENV == "development"
-        s.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1")
-      else
-        s
-      end
+      # Important to strip whitespace, or the browser hangs around for ages (FF2)
+      s.strip
     end
 
   end
@@ -36,7 +42,7 @@ module ActionController
 
 
     def call_dryml_tag(tag, options={})
-      add_variables_to_assigns
+      @template.send(:_evaluate_assigns_and_ivars)
 
       # TODO: Figure out what this bit is all about :-)
       if options[:with]
@@ -50,23 +56,62 @@ module ActionController
 
 
     # TODO: This is namespace polution, should be called render_dryml_tag
-    def render_tag(tag, options={}, render_options={})
-      text = call_dryml_tag(tag, options)
-      text && render({:text => text, :layout => false }.merge(render_options))
+    def render_tag(tag, attributes={}, options={})
+      text = call_dryml_tag(tag, attributes)
+      text && render({:text => text, :layout => false }.merge(options))
     end
 
-    def render_for_file_with_dryml(template_path, *args)
-      if template_path !~ /^([a-z]:)?\//i &&                   # not an absolute path (e.g. an exception ERB template)
-          !template_exists?(template_path) &&                  # no template available in app/views
-          tag_name = @dryml_fallback_tag || "#{File.basename(template_path).dasherize}-page"
 
-        # The template was missing, try to use a DRYML <page> tag instead
-        render_tag(tag_name) or raise ActionView::MissingTemplate, "Missing template #{template_path}.html.erb in view path #{RAILS_ROOT}/app/views"
+    # DRYML fallback tags -- monkey patch this method to attempt to render a tag if there's no template
+    def render_for_file_with_dryml(template_path, status = nil, layout = nil, locals = {})
+      render_for_file_without_dryml(template_path, status, layout, locals)
+    rescue ActionView::MissingTemplate => ex
+      # Try to use a DRYML <page> tag instead
+      tag_name = @dryml_fallback_tag || "#{File.basename(template_path).dasherize}-page"
+
+      text = call_dryml_tag(tag_name)
+      if text
+        render_for_text text, status 
       else
-        render_for_file_without_dryml(template_path, *args)
+        raise ex
       end
     end
     alias_method_chain :render_for_file, :dryml
 
   end
 end
+
+class ActionView::Template
+  
+  def render_with_dryml(view, local_assigns = {})
+    if handler == Hobo::Dryml::TemplateHandler
+      render_dryml(view, local_assigns)
+    else
+      render_without_dryml(view, local_assigns)
+    end
+  end
+  alias_method_chain :render, :dryml
+  
+  # We've had to copy a bunch of logic from Renderable#render, because we need to prevent Rails
+  # from trying to compile our template. DRYML templates are each compiled as a class, not just a method,
+  # so the support for compiling templates that Rails provides is innadequate.
+  def render_dryml(view, local_assigns = {})
+    stack = view.instance_variable_get(:@_render_stack)
+    stack.push(self)
+
+    # This is only used for TestResponse to set rendered_template
+    unless is_a?(ActionView::InlineTemplate) || view.instance_variable_get(:@_first_render)
+      view.instance_variable_set(:@_first_render, self)
+    end
+
+    view.send(:_evaluate_assigns_and_ivars)
+    view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+
+    result = Hobo::Dryml::TemplateHandler.new.render_for_rails22(self, view, local_assigns)
+
+    stack.pop
+    result
+  end
+  
+end  
+