hobo 0.6.2 → 0.6.3

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

@@ -1,143 +1,159 @@
-module Hobo::Dryml
+module Hobo
   
-  class DrymlSyntaxError < RuntimeError; end
-
-  class DrymlException < Exception
-    def initialize(message, path=nil, line_num=nil)
-      if path && line_num
-        super(message + " -- at #{path}:#{line_num}")
-      else
-        super(message)
+  module Dryml
+    
+    class DrymlSyntaxError < RuntimeError; end
+
+    class DrymlException < Exception
+      def initialize(message, path=nil, line_num=nil)
+        if path && line_num
+          super(message + " -- at #{path}:#{line_num}")
+        else
+          super(message)
+        end
       end
     end
-  end
-  
-  class AttributeExtensionString < String;
-    def drop_prefix; self[2..-1]; end
-  end
-
-  TagDef = Struct.new "TagDef", :name, :attrs, :proc
-
-  RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
-
-  EMPTY_PAGE = "[tag-page]"
+    
+    class AttributeExtensionString < String;
+      def drop_prefix; self[2..-1]; end
+    end
 
-  APPLICATION_TAGLIB = "taglibs/application"
-  CORE_TAGLIB = "plugins/hobo/tags/core"
+    TagDef = Struct.new "TagDef", :name, :attrs, :proc
 
-  @renderer_classes = {}
-  @tag_page_renderer_classes = {}
+    RESERVED_WORDS = %w{if for while do class else elsif unless case when module in}
 
-  class << self
+    EMPTY_PAGE = "[tag-page]"
 
-    attr_accessor :last_if
+    APPLICATION_TAGLIB = "taglibs/application"
+    CORE_TAGLIB = "plugins/hobo/tags/core"
     
-    def clear_cache
-      @renderer_classes = {}
-      @tag_page_renderer_classes = {}
-    end
+    DEFAULT_IMPORTS = [Hobo::HoboHelper, ApplicationHelper]
 
-    def render_tag(view, tag, options={})
-      renderer = empty_page_renderer(view)
-      renderer.render_tag(tag, options)
-    end
+    @renderer_classes = {}
+    @tag_page_renderer_classes = {}
 
+    class << self
 
-    def empty_page_renderer(view)
-      page_renderer(view, [], EMPTY_PAGE)
-    end
+      attr_accessor :last_if
+      
+      def clear_cache
+        @renderer_classes = {}
+        @tag_page_renderer_classes = {}
+      end
+
+      def render_tag(view, tag, options={})
+        renderer = empty_page_renderer(view)
+        renderer.render_tag(tag, options)
+      end
 
 
-    def page_renderer(view, local_names=[], page=nil)
-      if RAILS_ENV == "development"
-        clear_cache
-        Taglib.clear_cache
+      def empty_page_renderer(view)
+        controller_name = view.controller.class.name.underscore.sub(/_controller$/, "")
+        page_renderer(view, [], "#{controller_name}/#{EMPTY_PAGE}")
       end
 
-      prepare_view!(view)
-      included_taglibs = if view.controller.class.respond_to? :included_taglibs
-                           view.controller.class.included_taglibs
-                         else
-                           []
-                         end
-
-      if page == EMPTY_PAGE
-        @tag_page_renderer_classes[view.controller.class.name] ||= make_renderer_class("", EMPTY_PAGE, local_names,
-                                                        [Hobo::HoboHelper, ApplicationHelper], included_taglibs)
-        @tag_page_renderer_classes[view.controller.class.name].new(page, view)
-      else
+
+      def page_renderer(view, local_names=[], page=nil)
+        if RAILS_ENV == "development"
+          clear_cache
+          Taglib.clear_cache
+        end
         page ||= view.instance_variable_get('@hobo_template_path')
-        template_path = "app/views/" + page + ".dryml"
-        src_file = File.new(File.join(RAILS_ROOT, template_path))
-        renderer_class = @renderer_classes[page]
-
-        # do we need to recompile?
-        if (!renderer_class or                                          # nothing cached?
-            (local_names - renderer_class.compiled_local_names).any? or # any new local names?
-            renderer_class.load_time < src_file.mtime)                  # cache out of date?
-          renderer_class = make_renderer_class(src_file.read, template_path, local_names,
-                                               default_imports_for_view(view), included_taglibs)
-          renderer_class.load_time = src_file.mtime
-          @renderer_classes[page] = renderer_class
+
+        prepare_view!(view)
+        included_taglibs = ([subsite_taglib(page)] + controller_taglibs(page)).compact
+
+        if page.ends_with?(EMPTY_PAGE)
+          controller_class = controller_class_for(page)
+          @tag_page_renderer_classes[controller_class.name] ||= 
+            make_renderer_class("", page, local_names, DEFAULT_IMPORTS, included_taglibs)
+          @tag_page_renderer_classes[controller_class.name].new(page, view)
+        else
+          template_path = "app/views/" + page + ".dryml"
+          src_file = File.new(File.join(RAILS_ROOT, template_path))
+          renderer_class = @renderer_classes[page]
+
+          # do we need to recompile?
+          if (!renderer_class or                                          # nothing cached?
+              (local_names - renderer_class.compiled_local_names).any? or # any new local names?
+              renderer_class.load_time < src_file.mtime)                  # cache out of date?
+            renderer_class = make_renderer_class(src_file.read, template_path, local_names,
+                                                 DEFAULT_IMPORTS, included_taglibs)
+            renderer_class.load_time = src_file.mtime
+            @renderer_classes[page] = renderer_class
+          end
+          renderer_class.new(page, view)
+        end
+      end
+      
+      
+      def controller_class_for(page)
+        controller, view = Controller.controller_and_view_for(page)
+        "#{controller.camelize}Controller".constantize
+      end
+      
+      
+      def controller_taglibs(page)
+        controller_class = controller_class_for(page)
+        (controller_class.respond_to?(:included_taglibs) && controller_class.included_taglibs) || []
+      end
+      
+      
+      def subsite_taglib(page)
+        parts = page.split("/")
+        if parts.length == 3
+          subsite = parts.first
+          "taglibs/#{subsite}" if File.exists?("#{RAILS_ROOT}/app/views/taglibs/#{subsite}.dryml")
         end
-        renderer_class.new(page, view)
       end
-    end
 
 
-    def prepare_view!(view)
-      # Not sure why this isn't done for me...
-      # There's probably a button to press round here somewhere
-      for var in %w(@flash @cookies @action_name @_session @_request @request_origin
+      def prepare_view!(view)
+        # Not sure why this isn't done for me...
+        # There's probably a button to press round here somewhere
+        for var in %w(@flash @cookies @action_name @_session @_request @request_origin
                     @template @request @ignore_missing_templates @_headers @variables_added
                     @_flash @response @template_class
                     @_cookies @before_filter_chain_aborted @url
                     @_response @template_root @headers @_params @params @session)
-        unless @view.instance_variables.include?(var)
-          view.instance_variable_set(var, view.controller.instance_variable_get(var))
+          unless @view.instance_variables.include?(var)
+            view.instance_variable_set(var, view.controller.instance_variable_get(var))
+          end
         end
       end
 
-    end
-
-    
-    def default_imports_for_view(view)
-      imports = [Hobo::HoboHelper, ApplicationHelper]
-      controller_helper = view.controller.class.name.sub(/Controller$/, "Helper")
-      imports << controller_helper.constantize if Object.const_defined? controller_helper
-      imports
-    end
-
-    
-    def make_renderer_class(template_src, template_path, locals, imports, included_taglibs=[])
-      renderer_class = Class.new(TemplateEnvironment)
-      compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs)
-      renderer_class
-    end
+      
+      def make_renderer_class(template_src, template_path, locals, imports, included_taglibs=[])
+        renderer_class = Class.new(TemplateEnvironment)
+        compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs)
+        renderer_class
+      end
 
-    
-    def compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs=[])
-      template = Template.new(template_src, renderer_class, template_path)
-      imports.each {|m| template.import_module(m)}
+      
+      def compile_renderer_class(renderer_class, template_src, template_path, locals, imports, included_taglibs=[])
+        template = Template.new(template_src, renderer_class, template_path)
+        imports.each {|m| template.import_module(m)}
 
-      taglibs = [CORE_TAGLIB, APPLICATION_TAGLIB] + included_taglibs
+        taglibs = [CORE_TAGLIB, APPLICATION_TAGLIB] + included_taglibs
 
-      # 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
+        # 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
 
-      template.compile(all_local_names, taglibs)
-    end
+        template.compile(all_local_names, taglibs)
+      end
 
-    
-    def unreserve(word)
-      word = word.to_s
-      if RESERVED_WORDS.include?(word)
-        word + "_"
-      else
-        word
+      
+      def unreserve(word)
+        word = word.to_s
+        if RESERVED_WORDS.include?(word)
+          word + "_"
+        else
+          word
+        end
       end
+      
     end
-    
+
   end
 
 end

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

@@ -94,7 +94,8 @@ module Hobo::Dryml
           @environment.send(:alias_method, instruction[:new], instruction[:old])
           
         else
-          raise RuntimeError.new("DRYML: Unknown build instruction :#{instruction[:type]}, building #{template_path}")
+          raise RuntimeError.new("DRYML: Unknown build instruction :#{instruction[:type]}, " + 
+                                 "building #{template_path}")
         end
       end
       @last_build_time = Time.now

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

@@ -20,7 +20,7 @@ module Hobo
 
         contexts.map do |dom_id, context|
           code = context.marshal(session).split("\n").map{|line| "'#{line}\\n'"}.join(" +\n    ")
-          "hoboParts.#{dom_id} = (#{code})\n"
+          "hoboParts.#{dom_id} = (#{code});\n"
         end.join
       end
       
@@ -28,7 +28,7 @@ module Hobo
       def initialize(part_name, this_id, locals)
         @part_name = part_name
         @this_id = this_id
-        @locals = locals.map {|l| pre_marshal(l) }
+        @locals = locals.map { |l| pre_marshal(l) }
       end
       
       
@@ -66,6 +66,7 @@ module Hobo
           raise TamperedWithPartContext unless digest == generate_digest(data, session)
 
           part_name, this_id, locals = Marshal.load(Base64.decode64(data))
+          RAILS_DEFAULT_LOGGER.info("Call part: #{part_name}. this-id = #{this_id}, locals = #{locals.inspect}")
 
           [part_name, restore_part_this(this_id, this), restore_locals(locals)]
         end

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

@@ -37,13 +37,29 @@ module Hobo::Dryml
 
     def load
       @module = Module.new do
+        
         @tag_attrs = {}
-        def self._register_tag_attrs(tag_name, attrs)
-          @tag_attrs[tag_name] = attrs
-        end
+        @tag_aliases = {}
+        
         class << self
+          
+          def included(base)
+            @tag_aliases.each do |tag, feature|
+              base.send(:alias_tag_chain, tag, feature)
+            end
+          end
+
+          def _register_tag_attrs(tag, attrs)
+            @tag_attrs[tag] = attrs
+          end
           attr_reader :tag_attrs
+          
+          def _alias_tag_chain(tag, feature)
+            @tag_aliases[tag] = feature
+          end
+          
         end
+        
       end
       @file.rewind
       template = Template.new(@file.read, @module, @file.path)

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

@@ -9,7 +9,11 @@ module Hobo::Dryml
     
     CODE_ATTRIBUTE_CHAR = "&"
     
-    SPECIAL_ATTRIBUTES = %w(param merge_attrs for_type if unless repeat part restore)
+    SPECIAL_ATTRIBUTES = %w(param merge merge_params merge_attrs 
+                            for_type 
+                            if unless repeat 
+                            part part_locals
+                            restore)
 
     @build_cache = {}
     
@@ -39,7 +43,7 @@ module Hobo::Dryml
     def compile(local_names=[], auto_taglibs=[])
       now = Time.now
 
-      unless @template_path == EMPTY_PAGE
+      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
@@ -230,7 +234,7 @@ module Hobo::Dryml
       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, "alias_current_as", DRYML_NAME_RX, true)
+      require_attribute(el, "extend_with", DRYML_NAME_RX, true)
       
       unsafe_name = el.attributes["tag"]
       name = Hobo::Dryml.unreserve(unsafe_name)
@@ -254,26 +258,28 @@ module Hobo::Dryml
       @def_name = @def_name ? "#{@def_name}_#{unsafe_name}" : unsafe_name
 
       alias_of = el.attributes['alias_of']
-      alias_current = el.attributes['alias_current_as']
+      extend_with = el.attributes['extend_with']
 
-      dryml_exception("def cannot have both alias_of and alias_current_as", el) if alias_of && alias_current
+      dryml_exception("def cannot have both alias_of and extend_with", el) if alias_of && extend_with
       dryml_exception("def with alias_of must be empty", el) if alias_of and el.size > 0
       
-      if alias_of || alias_current
-        old_name = alias_current ? name : alias_of
-        new_name = alias_current ? alias_current : name
-
-        @builder.add_build_instruction(:alias_method, :new => new_name.to_sym, :old => old_name.to_sym)
-      end
+      
+      @builder.add_build_instruction(:alias_method,
+                                     :new => name.to_sym, :old => alias_of.to_sym) if alias_of
       
       res = if alias_of
               "<% #{tag_newlines(el)} %>"
             else
-              src = if template_name?(name)
-                      template_method(name, el)
-                    else
-                      tag_method(name, el)
-                    end
+              src = ""
+              if extend_with
+                src << "<% _alias_tag_chain :#{name}, :#{extend_with} %>"
+                name = extended_name(name, extend_with)
+              end
+              src << if template_name?(name)
+                       template_method(name, el)
+                     else
+                       tag_method(name, el)
+                     end
               src << "<% _register_tag_attrs(:#{name}, #{declared_attributes(el).inspect}) %>"
               
               logger.debug(restore_erb_scriptlets(src)) if el.attributes["debug_source"]
@@ -289,8 +295,17 @@ module Hobo::Dryml
     end
     
     
+    def extended_name(name, feature)
+      if template_name?(name)
+        "#{name}With#{feature.camelize}"
+      else
+        "#{name}_with_#{feature}"
+      end
+    end
+    
+    
     def template_call?(el)
-      template_name?(el.name)
+      template_name?(el.dryml_name)
     end
     
     
@@ -386,7 +401,7 @@ module Hobo::Dryml
       
       part_locals = el.attributes["part_locals"]
       
-      part_src = "<% def #{part_name}_part(#{part_locals}) #{tag_newlines(el)}; new_context do %>" +
+      part_src = "<% def #{part_name}_part(#{part_locals._?.gsub('@', '')}) #{tag_newlines(el)}; new_context do %>" +
         content +
         "<% end; end %>"
       @builder.add_part(part_name, restore_erb_scriptlets(part_src), element_line_num(el))
@@ -408,9 +423,9 @@ module Hobo::Dryml
       
       res = param_name == "&true" ? el.dryml_name : param_name
 
-      dryml_exception("param name for a template call must be capitalised", el) if
+      dryml_exception("param '#{res}' is 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
+      dryml_exception("param '#{res}' is for a block-tag call and must not be capitalised", el) if
         res && !template_call?(el) && template_name?(res)
       
       res
@@ -456,7 +471,7 @@ module Hobo::Dryml
                to_call = if is_param_default_call
                            # The tag is available in a local variable
                            # holding a proc
-                           el.dryml_name
+                           name
                          elsif (call_type = polymorphic_call_type(el))
                            "find_polymorphic_template(:#{name}, #{call_type})"
                          else
@@ -501,9 +516,9 @@ module Hobo::Dryml
           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}]), "
+              ":#{e.name} => merge_template_parameter(#{template_proc(e)}, all_parameters[:#{param_name}]), "
             else
-              ":#{e.name} => merge_option_procs(#{template_proc(e)}, all_parameters[:#{param_name}]), "
+              ":#{e.name} => merge_block_tag_parameter(#{template_proc(e)}, all_parameters[:#{param_name}]), "
             end
           else
             ":#{e.name} => #{template_proc(e)}, "
@@ -580,7 +595,7 @@ module Hobo::Dryml
                to_call = if is_param_default_call
                            # The tag is available in a local variable
                            # holding a proc
-                           el.dryml_name
+                           name
                          elsif (call_type = polymorphic_call_type(el))
                            "find_polymorphic_tag(:#{name}, #{call_type})"
                          else
@@ -644,7 +659,7 @@ module Hobo::Dryml
                         else
                           dryml_exception("invalid merge_attrs", el)
                         end
-        "{#{items}}.merge((#{extra_attributes}) || {})"
+        "merge_attrs({#{items}},(#{extra_attributes}) || {})"
       else
         "{#{items}}"
       end