zafu 0.6.0 → 0.6.1

data/History.txt

@@ -1,3 +1,13 @@
+== 0.6.1 2010-07-22
+
+* Minor enhancements
+  * Moved dependent method 'get_attribute_or_eval' from Zena.
+  * Fixed bugs in Markup#dup and NodeContext changing.
+  * Fixed error reporting on missing template.
+  * Added 'pre_wrap' method to Markup.
+  * Refactored wrapping to use a single method call.
+  * Fixed block in each dom scoping.
+
 == 0.6.0 2010-05-27
 
 * 3 major enhancements

data/lib/zafu/info.rb

@@ -1,4 +1,4 @@
 module Zafu
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end
 

data/lib/zafu/markup.rb

@@ -165,6 +165,10 @@ module Zafu
       end
     end
 
+    def append_attribute(text_to_append)
+      (@append ||= '') << text_to_append
+    end
+
     def append_dyn_param(key, value, conditional = false)
       spacer = conditional ? '' : ' '
       if prev_value = @params.delete(key)
@@ -189,26 +193,35 @@ module Zafu
 
     # Duplicate markup and make sure params and dyn_params are duplicated as well.
     def dup
-      markup = Markup.new(@tag)
-      markup.params = @params.dup
-      markup.dyn_params = @dyn_params.dup
+      markup = super
+      markup.instance_variable_set(:@params, @params.dup)
+      markup.instance_variable_set(:@dyn_params, @dyn_params.dup)
+      markup.instance_variable_set(:@pre_wrap, @pre_wrap.dup) if @pre_wrap
       markup
     end
 
+    # Store some text to insert at the beggining of the tag content on wrap. Inserted
+    # elements are indexed in a hash but only values are shown.
+    def pre_wrap
+      @pre_wrap ||= {}
+    end
+
     # Wrap the given text with our tag. If 'append' is not empty, append the text
     # after the tag parameters: <li class='foo'[APPEND HERE]>text</li>.
-    def wrap(text, *append)
+    def wrap(text)
       return text if @done
+
+      text = "#{@pre_wrap.values}#{text}" if @pre_wrap
+
       if dyn_params[:id]
         @tag ||= 'div'
       end
 
-      append ||= []
       if @tag
         if text.blank? && EMPTY_TAGS.include?(@tag)
-          res = "<#{@tag}#{params_to_html}#{append.join('')}/>"
+          res = "#{@pre_wrap}<#{@tag}#{params_to_html}#{@append}/>"
         else
-          res = "<#{@tag}#{params_to_html}#{append.join('')}>#{text}</#{@tag}>"
+          res = "<#{@tag}#{params_to_html}#{@append}>#{text}</#{@tag}>"
         end
       else
         res = text

data/lib/zafu/node_context.rb

@@ -36,10 +36,11 @@ module Zafu
     # Return a new node context that corresponds to the current object when rendered alone (in an ajax response or
     # from a direct 'show' in a controller). The returned node context has no parent (up is nil).
     # The convention is to use the class of the current object to build this name.
-    # You can also use an 'after_class' parameter to move up in the current object's class hierarchy (see #master_class).
+    # You can also use an 'after_class' parameter to move up in the current object's class hierarchy to get
+    # ivar name (see #master_class).
     def as_main(after_class = nil)
-      klass = after_class ? master_class(after_class) : self.klass
-      NodeContext.new("@#{klass.to_s.underscore}", klass)
+      klass = after_class ? master_class(after_class) : Array(self.klass).first
+      NodeContext.new("@#{klass.to_s.underscore}", Array(self.klass).first)
     end
 
     # Find the class just afer 'after_class' in the class hierarchy.
@@ -56,12 +57,23 @@ module Zafu
     end
 
     # Generate a unique DOM id for this element based on dom_scopes defined in parent contexts.
-    def dom_id
-      @dom_id ||= begin
+    def dom_id(opts = {})
+      options = {:list => true, :erb => true}.merge(opts)
+
+      if options[:erb]
+        dom = dom_id(options.merge(:erb => false))
+        if dom =~ /^#\{([^\{]+)\}$/
+          "<%= #{$1} %>"
+        elsif dom =~ /#\{/
+          "<%= %Q{#{dom}} %>"
+        else
+          dom
+        end
+      else
         if @up
-          [dom_prefix] + @up.dom_scopes + [make_scope_id]
+          [dom_prefix] + @up.dom_scopes + (options[:list] ? [make_scope_id] : [])
         else
-          [dom_prefix] + [make_scope_id]
+          [dom_prefix] + (options[:list] ? [make_scope_id] : [])
         end.compact.uniq.join('_')
       end
     end
@@ -74,20 +86,20 @@ module Zafu
 
     # Mark the current context as being a looping element (each) whose DOM id needs to be propagated to sub-nodes
     # in order to ensure uniqueness of the dom_id (loops in loops problem).
-    def dom_scope!
+    def propagate_dom_scope!
       @dom_scope = true
     end
 
     def get(klass)
       if list_context?
-        if klass <= self.klass.first
+        if self.klass.first <= klass
           NodeContext.new("#{self.name}.first", self.klass.first)
         elsif @up
           @up.get(klass)
         else
           nil
         end
-      elsif self.klass.ancestors.include?(klass)
+      elsif self.klass <= klass
         return self
       elsif @up
         @up.get(klass)
@@ -134,7 +146,7 @@ module Zafu
 
     private
       def make_scope_id
-        "<%= #{@name}.zip %>"
+        "\#{#{@name}.zip}"
       end
   end
 end

data/lib/zafu/parser.rb

@@ -9,12 +9,23 @@ module Zafu
   end
 
   class Parser
-    TEXT_CALLBACKS    = %w{before_parse after_parse before_wrap wrap after_wrap}
-    PROCESS_CALLBACKS = %w{before_process expander process_unknown after_process}
+    # If you wonder what the difference is between 'after_wrap' and 'after_process' here it is:
+    # 'after_wrap' is called by the 'wrap' method from within the method handler, 'after_process' is called
+    # at the very end. Example:
+    #
+    #   <% if var = Node.all -%>                                  | <---
+    #     <li>...</li>               <--- content for after_wrap  | <---  content for after_process
+    #   <% end -%>                                                | <---
+    #
+
+
+    TEXT_CALLBACKS    = %w{before_parse after_parse before_wrap wrap after_wrap after_process}
+    PROCESS_CALLBACKS = %w{before_process expander process_unknown}
     CALLBACKS         = TEXT_CALLBACKS + PROCESS_CALLBACKS
 
     @@callbacks = {}
-    attr_accessor :text, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent, :errors
+    attr_accessor :text, :name, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent, :errors
+
     # Method parameters "<r:show attr='name'/>" (params contains {'attr' => 'name'}).
     attr_accessor :params
 
@@ -22,6 +33,7 @@ module Zafu
       def new_with_url(path, opts={})
         helper = opts[:helper] || Zafu::MockHelper.new
         text, fullpath, base_path = self.get_template_text(path, helper)
+        return parser_error("template '#{path}' not found", 'include') unless text
         self.new(text, :helper => helper, :base_path => base_path, :included_history => [fullpath], :root => path)
       end
 
@@ -34,7 +46,11 @@ module Zafu
       end
 
       def parser_error(message, method)
-        "<span class='parser_error'><span class='method'>#{method}: <span class='message'>#{message}</span></span>"
+        "<span class='parser_error'><span class='method'>#{erb_safe method}</span> <span class='message'>#{erb_safe message}</span></span>"
+      end
+
+      def erb_safe(text)
+        text.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
       end
 
       CALLBACKS.each do |clbk|
@@ -85,6 +101,17 @@ module Zafu
       }
     end
 
+    alias wrap_callbacks wrap
+
+    def wrap(text)
+      after_wrap(
+        wrap_callbacks(
+          before_wrap(text) + @out_post
+        )
+        # @text contains unparsed data (white space)
+      ) + @text
+    end
+
     # This method is called at the very beginning of the processing chain and is
     # used to store state to make 'process' reintrant...
     def save_state
@@ -104,9 +131,17 @@ module Zafu
       end
     end
 
-    def parser_error(message, method = @method)
-      @errors << "<span class='parser_error'><span class='method'>#{method}</span> <span class='message'>#{message}</span></span>"
-      nil
+    def parser_error(message, method = @method, halt = true)
+      if halt
+        self.class.parser_error(message, method)
+      else
+        @errors << self.class.parser_error(message, method)
+        nil
+      end
+    end
+
+    def parser_continue(message, method = @method)
+      parser_error(message, method, false)
     end
 
     def process_unknown
@@ -194,7 +229,7 @@ module Zafu
     def process(context={})
       return '' if @method == 'ignore' || @method.blank?
 
-      @saved = save_state
+      saved = save_state
 
       if @name
         # we pass the name as 'context' in the children tags
@@ -209,18 +244,12 @@ module Zafu
 
       @pass = {} # used to pass information to the parent (is this used ?)
 
-      res = expander || default_expander
-
-      res = before_wrap(res)
-      res = wrap(res + @out_post)
+      res = wrap(expander || default_expander)
 
-      # @text contains unparsed data (empty space)
-      res = after_wrap(res) + @text
-
-      after_process
+      res = after_process(res)
 
       # restore state
-      restore_state(@saved)
+      restore_state(saved)
 
       res
     end
@@ -287,7 +316,7 @@ module Zafu
     end
 
     def include_template
-      return parser_error("missing 'template' attribute", 'include') unless @params[:template]
+      return parser_error("missing 'template' attribute") unless @params[:template]
       if @options[:part] && @options[:part] == @params[:part]
         # fetching only a part, do not open this element (same as original caller) as it is useless and will make us loop the loop.
         @method = 'ignore'
@@ -301,7 +330,7 @@ module Zafu
 
       included_text, absolute_url, base_path = self.class.get_template_text(@params[:template], @options[:helper], @options[:base_path])
 
-      if included_text
+      if absolute_url
         absolute_url += "::#{@params[:part].gsub('/','_')}" if @params[:part]
         absolute_url += "??#{@options[:part].gsub('/','_')}" if @options[:part]
         if @options[:included_history].include?(absolute_url)
@@ -310,7 +339,9 @@ module Zafu
           included_history  = @options[:included_history] + [absolute_url]
         end
       else
-        return "<span class='parser_error'>[include] template '#{@params[:template]}' not found</span>"
+        # Error: included_text contains the error meessage
+        @blocks = [included_text]
+        return
       end
 
       res = self.class.new(included_text, :helper => @options[:helper], :base_path => base_path, :included_history => included_history, :part => @params[:part], :parent => self) # we set :part to avoid loop failure when doing self inclusion
@@ -558,6 +589,7 @@ module Zafu
     end
 
     def expand_with(acontext={})
+
       blocks = acontext.delete(:blocks) || @blocks
       res = ""
 
@@ -580,10 +612,10 @@ module Zafu
 
       blocks.each do |b|
         if b.kind_of?(String)
-          if (!only || only.include?(:string)) && (!ignore || !ignore.include?(:string))
+          if (!only || (only.kind_of?(Array) && only.include?(:string))) && (!ignore || !ignore.include?(:string))
             res << b
           end
-        elsif (!only || only.include?(b.method)) && (!ignore || !ignore.include?(b.method))
+        elsif (!only || (only.kind_of?(Array) && only.include?(b.method)) || only =~ b.method) && (!ignore || !ignore.include?(b.method))
           res << b.process(new_context.dup)
           if pass = b.pass
             if pass[:part]

data/lib/zafu/process/ajax.rb

@@ -10,6 +10,9 @@ module Zafu
       def expand_with_finder(finder)
         return super unless finder[:class].kind_of?(Array)
 
+        # reset scope
+        @context[:saved_template] = nil
+
         # Get the block responsible for rendering each elements in the list
         each_block = descendant('each')
         add_block  = descendant('add')
@@ -35,14 +38,14 @@ module Zafu
           set_dom_prefix
 
           # New node context.
-          open_node_context(finder, :node => self.node.move_to(var, finder[:class])) do #, :need_link_id => form_block.need_link_id) do
+          open_node_context(finder, :node => self.node.move_to(var, finder[:class])) do
             # Pagination count and other contextual variables exist here.
 
             # INLINE ==========
-            # 'r_add' needs the form when rendering. Send with :form.
-            out @markup.wrap(
+            out wrap(
               expand_with(
                 :in_if              => false,
+                # 'r_add' needs the form when rendering. Send with :form.
                 :form               => form_block,
                 :publish_after_save => publish_after_save,
                 # Do not render the form block directly: let [add] do this.
@@ -53,32 +56,32 @@ module Zafu
 
             # Render 'else' clauses
             @markup.done = false
-            out @markup.wrap(
+            out wrap(
               expand_with(
                 :in_if => true,
                 :only  => ['elsif', 'else']
               )
             )
-          end
-          out "<% end -%>"
 
-          # 2. Save 'each' template
-          store_block(each_block) #, :klass => klass) # do we need klass here ?
+            # 2. Save 'each' template
+            store_block(each_block, :node => self.node.move_to(var, finder[:class])) #, :klass => klass) # do we need klass here ?
 
-          # 3. Save 'form' template
-          cont = {
-            :saved_template     => form_url(node),
-            :klass              => klass,
-            :make_form          => each_block == form_block,
-            :publish_after_save => publish_after_save,
-          }
+            # 3. Save 'form' template
+            cont = {
+              :saved_template     => form_url(node.dom_prefix),
+              :klass              => klass,
+              :make_form          => each_block == form_block,
+              :publish_after_save => publish_after_save,
+            }
 
-          store_block(form_block, cont)
+            store_block(form_block, cont)
+          end
+          out "<% end -%>"
         else
           super
         end
 
-        # out @markup.wrap(expand_with(:node => node.move_to(var, finder[:class]), :in_if => true))
+        # out wrap(expand_with(:node => node.move_to(var, finder[:class]), :in_if => true))
 
 
         #query = opts[:query]
@@ -114,13 +117,21 @@ module Zafu
 
       # Store a context as a sub-template that can be used in ajax calls
       def r_block
+        if parent.method == 'each' && @method == parent.single_child_method
+          # Block stored in 'each', do nothing
+          # What happens when this is used as remote target ?
+          return expand_with
+        end
+
         # Since we are using ajax, we will need this object to have an ID set.
         set_dom_prefix
 
+        @markup.done = false
+
         if @context[:block] == self
           # Storing template (called from within store_block)
-          # Set id with the template's node context (<%= @node.zip %>)
-          @markup.set_id(node.dom_id)
+          # Set id with the template's node context (<%= @node.zip %>).
+          @markup.set_id(node.dom_id(:list => false))
           expand_with
         else
           # 1. store template
@@ -128,14 +139,43 @@ module Zafu
           store_block(self)
 
           # 2. render
-          # Set id with the current node context (<%= var1.zip %>)
-          @markup.set_id(node.dom_id)
+          # Set id with the current node context (<%= var1.zip %>).
+          @markup.set_id(node.dom_id(:list => false))
           out expand_with
         end
       end
 
+
+      def r_edit
+        # ajax
+        if @context[:form_cancel]
+          # cancel button
+          @context[:form_cancel]
+        else
+          # edit button
+
+          # TODO: show 'reply' instead of 'edit' in comments if visitor != author
+          each_block = ancestor('each')
+
+          link = wrap(make_link(:default_text => _('edit'), :update => each_block, :action => 'edit'))
+
+          out "<% if #{node}.can_write? -%>#{link}<% end -%>"
+        end
+
+        #if @context[:template_url]
+        #else
+        #  # FIXME: we could link to some html page to edit the item.
+        #  ""
+        #end
+      end
+
+      def r_cancel
+        (@context[:form_options] || {})[:form_cancel]
+      end
+
       def r_add
         return parser_error("Should not be called from within 'each'") if parent.method == 'each'
+        return parser_error("Should not be called outside list context") unless node.list_context?
         return '' if @context[:make_form]
 
         if node.will_be?(Comment)
@@ -165,7 +205,7 @@ module Zafu
           end
 
           # Expand 'add' block
-          out @markup.wrap("#{expand_with(:onclick=>"[\"#{node.dom_prefix}_add\", \"#{node.dom_prefix}_form\"].each(Element.toggle);#{focus}return false;")}")
+          out wrap("#{expand_with(:onclick=>"[\"#{node.dom_prefix}_add\", \"#{node.dom_prefix}_form\"].each(Element.toggle);#{focus}return false;")}")
 
           # New object to render form.
           # FIXME: use 'klass' param in r_add or r_form instead of current list content.
@@ -185,10 +225,10 @@ module Zafu
           # Expand (inline) 'form' block
           out expand_block(form_block,
             # Needed in form to be able to return the result
-            :template_url => template_url(node),
+            :template_url => template_url(node.dom_prefix),
             # ??
             :in_add       => true,
-            # ??
+            # Used to get parameters like 'publish' or 'klass'
             :add          => self,
             # Transform 'each' block into a form
             :make_form    => form_block.method == 'each',
@@ -199,7 +239,7 @@ module Zafu
         else
           # no ajax
           @markup.append_param(:class, 'btn_add') if @markup.tag
-          out @markup.wrap(expand_with)
+          out wrap(expand_with)
         end
         out "<% end -%>"
       end
@@ -217,30 +257,49 @@ module Zafu
           @markup.set_id(options[:id]) if options[:id]
           @markup.set_param(:style, options[:style]) if options[:style]
 
-          out @markup.wrap(expand_with)
+          out wrap(expand_with)
         else
           super
         end
       end
 
-      # Return true if we need to insert the dom id for this element. This method is overwritten in Ajax.
+      # Block visibility of descendance with 'do_list'.
+      def public_descendants
+        all = super
+        if ['context', 'each', 'block'].include?(self.method)
+          # do not propagate 'form',etc up
+          all.reject do |k,v|
+            ['form','unlink'].include?(k)
+          end
+        elsif ['if', 'case'].include?(self.method)
+          all.reject do |k,v|
+            ['else', 'elsif', 'when'].include?(k)
+          end
+        else
+          all
+        end
+      end
+
+      # Return true if we need to insert the dom id for this element.
       def need_dom_id?
-        @context[:form]
+        @context[:form] || descendant('unlink') || descendant('drop')
       end
 
       # Set a unique DOM prefix to build unique ids in the page.
-      def set_dom_prefix
+      def set_dom_prefix(node = self.node)
         @name ||= unique_name
+        raise if @name == 'list3'
+        # TODO: should rebuild descendants list in parents...
         node.dom_prefix = @name
       end
 
       # Unique template_url, ending with dom_id
-      def template_url(node)
-        "#{root.options[:root]}/#{node.dom_prefix}"
+      def template_url(dom_prefix = node.dom_prefix)
+        "#{root.options[:root]}/#{dom_prefix}"
       end
 
-      def form_url(node)
-        template_url(node) + '_form'
+      def form_url(dom_prefix = node.dom_prefix)
+        template_url(dom_prefix) + '_form'
       end
 
       # Return a different name on each call
@@ -263,27 +322,39 @@ module Zafu
         end
       end
 
+      private
 
+        # Find a block to update on the page
+        def find_target(name)
+          # Hack for drop until descendants is rebuilt on set_dom_prefix
+          return self if name == self.name
+
+          root.descendants('block').each do |block|
+            return block if block.name == name
+          end
+
+          out parser_error("could not find a block named '#{name}'")
+          return nil
+        end
 
-      private
         def store_block(block, cont = {})
-          cont = @context.merge(cont)
+          cont = context_without_vars.merge(cont)
 
           # Create new node context
           node = cont[:node].as_main(ActiveRecord::Base)
           node.dom_prefix = @name
 
-          cont[:template_url] = template_url(node)
+          cont[:template_url] = template_url(node.dom_prefix)
           cont[:node]  = node
           cont[:block] = block
           cont[:saved_template] ||= cont[:template_url]
-          @context.each do |k, v|
-            if k.kind_of?(String)
-              cont[k] = nil
-            end
-          end
 
-          template = expand_block(block, cont)
+          template = nil
+
+          # We overwrite all context: no merge.
+          with_context(cont, false) do
+            template = expand_block(block)
+          end
 
           out helper.save_erb_to_url(template, cont[:saved_template])
         end

data/lib/zafu/process/conditional.rb

@@ -3,8 +3,8 @@ module Zafu
     # This module manages conditional rendering (if, else, elsif, case, when).
     module Conditional
       def r_if(cond = nil)
-        cond ||= get_attribute_or_eval(false)
-        return parser_error("condition error") unless cond
+        cond ||= get_condition
+        return unless cond
         expand_if(cond)
       end
 
@@ -22,8 +22,8 @@ module Zafu
 
       def r_elsif(cond = nil)
         return '' unless @context[:in_if]
-        cond ||= get_attribute_or_eval(false)
-        return parser_error("condition error") unless cond
+        cond ||= get_condition
+        return unless cond
 
         res = expand_with(:in_if => false, :markup => nil)
 
@@ -32,25 +32,50 @@ module Zafu
           @markup.tag ||= markup.tag
           @markup.steal_html_params_from(@params)
           markup.params.each do |k, v|
-            next if @markup.param[k]
+            next if @markup.params[k]
             @markup.set_param(k, v)
           end
-          out "<% elsif #{cond} -%>#{@markup.wrap(res)}" # do not propagate
+
+          markup.dyn_params.each do |k, v|
+            next if @markup.params[k] || @markup.dyn_params[k]
+            @markup.set_dyn_param(k, v)
+          end
+
+          out "<% elsif #{cond} -%>#{wrap(res)}" # do not propagate
         else
           @markup.done = true # never wrap else/elsif clause
           out "<% elsif #{cond} -%>#{res}" # do not propagate
         end
       end
 
-      # Expand blocks with conditional enabled (else, elsif, etc).
-      def expand_if(condition, new_node_context = self.node)
+      # Expand blocks with conditional processing enabled (else, elsif, etc).
+      #
+      # ==== Parameters
+      #
+      # * +condition+ - ruby condition for the conditional execution.
+      # * +new_node_context+ - (optional) new node context to enter if the clause succeeds.
+      # * +alt_markup+ - (optional) alternative markup to use for the 'else', 'elsif' clauses.
+      def expand_if(condition, new_node_context = self.node, alt_markup = @markup)
         res = ""
         res << "<% if #{condition} -%>"
-        res << @markup.wrap(expand_with(:node => new_node_context))
-        res << expand_with(:in_if => true, :only => %w{else elsif when}, :markup => @markup)
+
+        with_context(:node => new_node_context) do
+          res << wrap(expand_with)
+        end
+
+        res << expand_with(:in_if => true, :only => /^[A-Z]|else|elsif|when/, :markup => alt_markup)
         res << "<% end -%>"
         res
       end
+
+      private
+        def get_condition
+          if in_tag = @params[:in]
+            ancestor(in_tag) ? 'true' : 'false'
+          else
+            get_attribute_or_eval(false)
+          end
+        end
     end # Context
   end # Process
 end # Zafu

data/lib/zafu/process/context.rb

@@ -5,7 +5,7 @@ module Zafu
     # context, the "node" context holds information on the type of "this" (first responder).
     module Context
       def r_each
-        if node.klass.kind_of?(Array)
+        if node.list_context?
           if @params[:alt_class] || @params[:join]
             out "<% #{var}_max_index = #{node}.size - 1 -%>" if @params[:alt_reverse]
             out "<% #{node}.each_with_index do |#{var},#{var}_index| -%>"
@@ -31,10 +31,19 @@ module Zafu
             out "<% #{node}.each do |#{var}| -%>"
           end
 
+
           with_context(:node => node.move_to(var, node.klass.first)) do
+            # The id set here should be used as prefix for sub-nodes to ensure uniqueness of generated DOM ids
+            node.propagate_dom_scope!
+
             steal_and_eval_html_params_for(@markup, @params)
-            @markup.set_id(node.dom_id) if need_dom_id?
-            out @markup.wrap(expand_with)
+
+            if need_dom_id?
+              set_dom_prefix
+              @markup.set_id(node.dom_id)
+            end
+
+            out wrap(expand_with)
           end
           out "<% end -%>"
         else
@@ -63,28 +72,37 @@ module Zafu
 
       # Store some contextual value / variable inside a named group. This should be
       # used to avoid key clashes between different types of elements to store.
-      def set_context_var(group, key, obj)
-        @context["#{group}::#{key}"] = obj
+      def set_context_var(group, key, obj, context = @context)
+        context["#{group}::#{key}"] = obj
       end
 
       # Retrieve a value from a given contextual group. The value must have been
       # previously set with 'set_context_var' somewhere in the hierarchy.
-      def get_context_var(group, key)
-        @context["#{group}::#{key}"]
+      def get_context_var(group, key, context = @context)
+        context["#{group}::#{key}"]
+      end
+
+      # Return a new context without contextual variables.
+      def context_without_vars
+        context = @context.dup
+        context.keys.each do |k|
+          context.delete(k) if k.kind_of?(String)
+        end
+        context
       end
 
       # Expand blocks in a new context.
       # This method is partly overwriten in Ajax
       def expand_with_finder(finder)
         if finder[:nil]
-          open_node_context(finder) do
+          open_node_context(finder, :form => nil) do # do not propagate :form
             expand_if("#{var} = #{finder[:method]}", node.move_to(var, finder[:class]))
           end
         else
           res = ''
           res << "<% #{var} = #{finder[:method]} -%>"
-          open_node_context(finder, :node => node.move_to(var, finder[:class])) do
-            res << @markup.wrap(expand_with)
+          open_node_context(finder, :node => node.move_to(var, finder[:class]), :form => nil) do
+            res << wrap(expand_with)
           end
           res
         end
@@ -110,19 +128,36 @@ module Zafu
         {}
       end
 
-      # Declare a variable that can be used later in the compilation. This method
-      # returns the variable name to use.
-      def set_var(var_list, var_name)
-        var_name = var_name.to_sym
-        out parser_error("'#{var_name}' already defined.") if @context[var_name] || var_list[var_name]
-        var_list[var_name] = "_z#{var_name}"
+      # Get a variable name and store the name in context variables for the given group.
+      #
+      # ==== Parameters
+      #
+      # * +group_name+  - name of the variable context group
+      # * +wanted_name+ - wanted variable name (used as key to get real var back later with #get_context_var)
+      # * +context+ - (optional) can be used if we do not want to store the variable definition in the current context
+      #
+      def get_var_name(group_name, wanted_name, context = @context)
+        secure_name = wanted_name.gsub(/[^a-zA-Z0-9]/,'')
+        name = "_z#{secure_name}"
+        i    = 0
+        while get_context_var('var', name, context)
+          i += 1
+          name = "_z#{secure_name}#{i}"
+        end
+        set_context_var('var', name, true)
+        set_context_var(group_name, wanted_name, name)
+        name
       end
 
       # Change context for a given scope.
-      def with_context(cont)
+      def with_context(cont, merge = true)
         raise "Block missing" unless block_given?
         cont_bak = @context.dup
-          @context.merge!(cont)
+          if merge
+            @context.merge!(cont)
+          else
+            @context = cont
+          end
           res = yield
         @context = cont_bak
         res

data/lib/zafu/process/forms.rb

@@ -13,7 +13,7 @@ module Zafu
 
         if descendant('form_tag')
           # We have a specific place to insert our form
-          out expand_with(:form_options => options)
+          out expand_with(:form_options => options, :form => self)
         else
           r_form_tag(options)
         end
@@ -26,14 +26,16 @@ module Zafu
           @params.each do |k, v|
             markup.set_param(k, v)
           end
-          out markup.wrap(expand_with)
         else
           # <form> inside <r:form>
           form_tag(options) do |opts|
             # Render error messages tag
             form_error_messages(opts[:form_helper])
 
-            # Render hidden fields
+            # Render form elements
+            out expand_with(opts)
+
+            # Render hidden fields (these must go after normal elements so that focusFirstElement works)
             hidden_fields = form_hidden_fields(options)
             out "<div class='hidden'>"
             hidden_fields.each do |k,v|
@@ -47,9 +49,6 @@ module Zafu
             end
             out '</div>'
 
-            # Render form elements
-            out expand_with(opts)
-
             # What is this ?
             #@blocks = opts[:blocks_bak] if opts[:blocks_bak]
           end
@@ -70,7 +69,10 @@ module Zafu
         # Return id, style, form and cancel parts of the form.
         def form_options
           opts = {}
-          opts[:klass] = node.master_class(ActiveRecord::Base)
+
+          # Do we need this ?
+          # opts[:klass] = node.master_class(ActiveRecord::Base).to_s
+
           if @context[:in_add]
             opts[:id]    = "#{node.dom_prefix}_form"
             opts[:style] = 'display:none;'
@@ -99,8 +101,9 @@ module Zafu
         # Render the 'form' tag and set expansion context.
         def form_tag(options)
           opts = options.dup
+          form = @context[:form]
 
-          if descendant('cancel') || descendant('edit')
+          if form && (form.descendant('cancel') || form.descendant('edit'))
             # Pass 'form_cancel' content to expand_with (already in options).
           else
             # Insert cancel before form

data/lib/zafu/process/html.rb

@@ -107,7 +107,8 @@ module Zafu
 
         src = @params.delete(key)
         if src && src[0..6] != 'http://'
-          @markup.params[key] = helper.send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type)
+          new_value = helper.send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type)
+          @markup.params[key] = new_value.blank? ? src : new_value
         end
 
         @markup.steal_html_params_from(@params)

data/lib/zafu/process/ruby_less_processing.rb

@@ -12,7 +12,7 @@ module Zafu
           def do_method(sym)
             super
           rescue RubyLess::Error => err
-            self.class.parser_error(err.message, @method)
+            parser_error(err.message)
           end
         end
       end
@@ -27,21 +27,21 @@ module Zafu
 
       # Resolve unknown methods by using RubyLess in the current compilation context (the
       # translate method in RubyLess will call 'safe_method_type' in this module).
-      def rubyless_eval
+      def rubyless_eval(params = @params)
         if @method =~ /^[A-Z]\w+$/
           return rubyless_class_scope(@method)
         end
 
         if code = @method[/^\#\{(.+)\}$/, 1]
-          @params[:eval] = $1
+          params[:eval] = $1
           r_show
         else
-          rubyless_render(@method, @params)
+          rubyless_render(@method, params)
         end
       rescue RubyLess::NoMethodError => err
-        parser_error("#{err.error_message} <span class='type'>#{err.method_with_arguments}</span> (#{node.class_name} context)")
+        parser_continue("#{err.error_message} <span class='type'>#{err.method_with_arguments}</span> for #{err.receiver_with_class}")
       rescue RubyLess::Error => err
-        parser_error(err.message)
+        parser_continue(err.message)
       end
 
       # Print documentation on the current node type.
@@ -98,9 +98,40 @@ module Zafu
         end
       end
 
+      def get_attribute_or_eval(use_string_block = true)
+        if attribute = @params[:attr] || @params[:date]
+          code = "this.#{attribute}"
+        elsif code = @params[:eval] || @params[:test]
+        elsif text = @params[:text]
+          code = "%Q{#{text}}"
+        elsif use_string_block && @blocks.size == 1 && @blocks.first.kind_of?(String)
+          return RubyLess::TypedString.new(@blocks.first.inspect, :class => String, :literal => @blocks.first)
+        else
+          return parser_continue("Missing attribute/eval parameter")
+        end
+
+        RubyLess.translate(code, self)
+      rescue RubyLess::Error => err
+        return parser_continue(err.message, code)
+      end
+
       private
+        # Extract arguments from params
+        def extract_from_params(*keys)
+          res = []
+
+          keys.each do |key|
+            next unless value = @params[key.to_sym]
+            res << ":#{key} => #{RubyLess.translate_string(value, self)}"
+          end
+
+          res.empty? ? nil : res
+        end
+
         # block_owner should be set to true when we are resolving <r:xxx>...</r:xxx> or <div do='xxx'>...</div>
         def get_method_type(signature, added_options = false)
+          raise "#{node.klass.class}" unless node.klass.kind_of?(Array) || node.klass.kind_of?(Class)
+
           if type = node_context_from_signature(signature)
             # Resolve self, @page, @node
             type
@@ -213,15 +244,21 @@ module Zafu
         def node_context_from_signature(signature)
           return nil unless signature.size == 1
           ivar = signature.first
-          return {:class => node.klass, :method => node.name} if ivar == 'this'
-          return nil unless ivar[0..0] == '@'
-          begin
-            klass = Module.const_get(ivar[1..-1].capitalize)
-            context = node(klass)
-          rescue NameError
-            return nil
+          if ivar == 'this'
+            if node.list_context?
+              raise RubyLess::Error.new("Cannot use 'this' in list_context.")
+            else
+              {:class => node.klass, :method => node.name}
+            end
+          elsif ivar[0..0] == '@' && klass = get_class(ivar[1..-1].capitalize)
+            if node = self.node(klass)
+              {:class => node.klass, :method => node.name}
+            else
+              nil
+            end
+          else
+            nil
           end
-          {:class => context.klass, :method => context.name}
         end
 
         # Find stored variables back. Stored elements are set with set_xxx='something to eval'.

data/test/markup_test.rb

@@ -236,7 +236,7 @@ class MarkupTest < Test::Unit::TestCase
         @markup.append_dyn_param(:class, '<%= @bar %>')
         assert_equal '<%= @foo %> <%= @bar %>', @markup.dyn_params[:class]
       end
-      
+
       should 'append param without spacer if conditional' do
         @markup.append_dyn_param(:class, '<%= @bar %>', true)
         assert_equal '<%= @foo %><%= @bar %>', @markup.dyn_params[:class]
@@ -278,7 +278,7 @@ class MarkupTest < Test::Unit::TestCase
         @markup.prepend_dyn_param(:class, '<%= @to %>')
         assert_equal '<%= @to %> <%= @fu %>', @markup.dyn_params[:class]
       end
-      
+
       should 'prepend param without spacer if conditional' do
         @markup.prepend_dyn_param(:class, '<%= @to %>', true)
         assert_equal '<%= @to %><%= @fu %>', @markup.dyn_params[:class]
@@ -309,6 +309,11 @@ class MarkupTest < Test::Unit::TestCase
       assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@text)
     end
 
+    should 'add the appended params inside the tag' do
+      @markup.append_attribute("<%= anything %>")
+      assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'<%= anything %>>#{@text}</p>", @markup.wrap(@text)
+    end
+
     should 'not wrap twice if called twice' do
       assert_equal "<p class='quote' style='padding:3px; border:1px solid red;'>#{@text}</p>", @markup.wrap(@markup.wrap(@text))
     end
@@ -318,6 +323,11 @@ class MarkupTest < Test::Unit::TestCase
       @markup.set_params(:baz => 'buzz')
       assert_equal "<p class='quote' style='padding:3px; border:1px solid red;' baz='buzz' foo='<%= @bar %>'>foo</p>", @markup.wrap('foo')
     end
+
+    should 'insert pre_wrap content' do
+      @markup.pre_wrap[:foo] = 'FOO'
+      assert_equal %q{<p class='quote' style='padding:3px; border:1px solid red;'>FOOcontent</p>}, @markup.wrap('content')
+    end
   end
 
   context 'Compiling params' do
@@ -345,14 +355,41 @@ class MarkupTest < Test::Unit::TestCase
     context 'and changing params' do
       setup do
         @markup = Markup.new('p')
-        @markup.params[:class] = 'one'
+        @markup.params[:class]  = 'one'
         @duplicate = @markup.dup
       end
 
-      should 'not propagate changes to original' do
+      should 'not propagate params changes to original' do
         @duplicate.params[:class] = 'two'
         assert_equal "<p class='one'>one</p>", @markup.wrap('one')
       end
+
+      should 'not propagate params changes to duplicate' do
+        @markup.params[:class] = 'two'
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate appended params to duplicate' do
+        @markup.append_param(:class, 'drop')
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate dyn_params changes to original' do
+        @markup.append_dyn_param(:class, 'two')
+        assert_equal "<p class='one'>one</p>", @duplicate.wrap('one')
+      end
+
+      should 'not propagate dyn_params changes to duplicate' do
+        @duplicate.append_dyn_param(:class, 'two')
+        assert_equal "<p class='one'>one</p>", @markup.wrap('one')
+      end
+
+      should 'not propagate pre_wrap changes to duplicate' do
+        @markup.pre_wrap[:drop] = 'no bombs'
+        @duplicate = @markup.dup
+        @duplicate.pre_wrap[:drop] = 'ego'
+        assert_equal "<p class='one'>no bombs</p>", @markup.wrap('')
+      end
     end
 
     context 'and wrapping' do
@@ -366,7 +403,7 @@ class MarkupTest < Test::Unit::TestCase
         assert_equal '<p>one</p>', @duplicate.wrap('one')
       end
     end
-  end
+  end # Duplicating a markup
 end
 
 

data/test/node_context_test.rb

@@ -90,15 +90,30 @@ class NodeContextTest < Test::Unit::TestCase
           assert_equal subject.klass, subject.as_main.klass
         end
 
-        should 'return an ancestor when using after_class argument' do
+        should 'return current class when using after_class argument' do
           subject = NodeContext.new('@node', SubSubPage)
-          assert_equal SubPage, subject.as_main(Page).klass
+          assert_equal SubSubPage, subject.as_main(Page).klass
         end
 
         should 'rebuild name from ancestor when using after_class argument' do
           subject = NodeContext.new('@node', SubSubPage)
           assert_equal '@sub_page', subject.as_main(Page).name
         end
+
+        context 'in a list context' do
+          subject do
+            NodeContext.new('list', [SubSubPage])
+          end
+
+          should 'return current class when using after_class argument' do
+            assert_equal SubSubPage, subject.as_main(Page).klass
+          end
+
+          should 'rebuild name from ancestor when using after_class argument' do
+            assert_equal '@sub_page', subject.as_main(Page).name
+          end
+        end # in a list context
+
       end
 
       should 'return subclass on class_name' do
@@ -180,14 +195,14 @@ class NodeContextTest < Test::Unit::TestCase
       NodeContext.new('super', SubPage)
     end
 
-    should 'find the current context required class is an ancestor' do
+    should 'find the required class in ancestors' do
       assert_equal subject.object_id, subject.get(Page).object_id
     end
   end
 
   context 'In a list context' do
     setup do
-      @grandma = NodeContext.new('@page', Page)
+      @grandma = NodeContext.new('@page', SubPage)
       @mother = @grandma.move_to('@comment', Comment)
     end
 
@@ -223,6 +238,10 @@ class NodeContextTest < Test::Unit::TestCase
       should 'return the node name in DOM id' do
         assert_equal '<%= @foo.zip %>', subject.dom_id
       end
+
+      should 'scope without erb on erb false' do
+        assert_equal '#{@foo.zip}', subject.dom_id(:erb => false)
+      end
     end
 
     context 'in a hierarchy of contexts' do
@@ -238,23 +257,23 @@ class NodeContextTest < Test::Unit::TestCase
 
       context 'with parents as dom_scopes' do
         setup do
-          @b.dom_scope!
-          @c.dom_scope!
+          @b.propagate_dom_scope!
+          @c.propagate_dom_scope!
         end
 
         should 'use dom_scopes' do
-          assert_equal '<%= var1.zip %>_<%= var2.zip %>_<%= var3.zip %>', subject.dom_id
+          assert_equal '<%= %Q{#{var1.zip}_#{var2.zip}_#{var3.zip}} %>', subject.dom_id
         end
       end
 
       context 'with ancestors and self as dom_scopes' do
         setup do
-          @a.dom_scope!
-          subject.dom_scope!
+          @a.propagate_dom_scope!
+          subject.propagate_dom_scope!
         end
 
         should 'not use self twice' do
-          assert_equal '<%= @node.zip %>_<%= var3.zip %>', subject.dom_id
+          assert_equal '<%= %Q{#{@node.zip}_#{var3.zip}} %>', subject.dom_id
         end
       end
 
@@ -264,7 +283,7 @@ class NodeContextTest < Test::Unit::TestCase
         end
 
         should 'use dom_prefix' do
-          assert_equal 'cart_<%= var3.zip %>', subject.dom_id
+          assert_equal '<%= %Q{cart_#{var3.zip}} %>', subject.dom_id
         end
       end
 

data/test/zafu/meta.yml

@@ -5,4 +5,8 @@ some_template:
 include_with_part:
   # part 'a' is moved around
   src: "<r:include template='/some/template'><r:with part='a'/><r:with part='b'>new b:<r:include template='/some/template' part='a'/></r:with></r:include>"
-  tem: "<div id='b'>new b:<div id='a'>a</div></div>"
+  tem: "<div id='b'>new b:<div id='a'>a</div></div>"
+
+missing_template:
+  src: "<r:include template='Foo'/>"
+  tem: "/template 'Foo' not found/"

data/zafu.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{zafu}
-  s.version = "0.6.0"
+  s.version = "0.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Gaspard Bucher"]
-  s.date = %q{2010-05-27}
+  s.date = %q{2010-07-22}
   s.description = %q{Provides a powerful templating language based on xhtml for rails}
   s.email = %q{gaspard@teti.ch}
   s.extra_rdoc_files = [

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Gaspard Bucher
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-27 00:00:00 +02:00
+date: 2010-07-22 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency