zafu 0.5.0 → 0.6.0

data/lib/zafu/parser.rb

@@ -9,8 +9,12 @@ 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}
+    CALLBACKS         = TEXT_CALLBACKS + PROCESS_CALLBACKS
+
     @@callbacks = {}
-    attr_accessor :text, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent
+    attr_accessor :text, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent, :errors
     # Method parameters "<r:show attr='name'/>" (params contains {'attr' => 'name'}).
     attr_accessor :params
 
@@ -18,7 +22,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)
-        self.new(text, :helper => helper, :base_path => base_path, :included_history => [fullpath])
+        self.new(text, :helper => helper, :base_path => base_path, :included_history => [fullpath], :root => path)
       end
 
       # Retrieve the template text in the current folder or as an absolute path.
@@ -26,29 +30,103 @@ module Zafu
       def get_template_text(path, helper, base_path=nil)
         res = helper.send(:get_template_text, path, base_path)
         return [parser_error("template '#{path}' not found", 'include'), nil, nil] unless res
-        text, fullpath, base_path = *res
-        return res
+        res
       end
 
       def parser_error(message, method)
-        "<span class='parser_error'><span class='method'>#{method}</span> #{message}</span>"
+        "<span class='parser_error'><span class='method'>#{method}: <span class='message'>#{message}</span></span>"
       end
 
-      attr_accessor :before_process_callbacks
+      CALLBACKS.each do |clbk|
+        eval %Q{
+          attr_accessor :#{clbk}_callbacks
+
+          def #{clbk}_callbacks
+            @#{clbk}_callbacks ||= superclass.respond_to?(:#{clbk}_callbacks) ? superclass.#{clbk}_callbacks : []
+          end
 
-      def before_process_callbacks
-        @before_process_callbacks ||= []
+          def #{clbk}(*args)
+            self.#{clbk}_callbacks += args
+          end
+        }
       end
+    end # class << self
 
-      def before_process(*args)
-        self.before_process_callbacks += args
+    PROCESS_CALLBACKS.each do |clbk|
+      eval %Q{
+        def #{clbk}
+          self.class.#{clbk}_callbacks.each do |callback|
+            send(callback)
+          end
+        end
+      }
+    end
+
+    def expander
+      self.class.expander_callbacks.reverse_each do |callback|
+        if res = send(callback)
+          if res.kind_of?(String)
+            @result << res
+          end
+          return @result
+        end
       end
+      nil
+    end
+
+    TEXT_CALLBACKS.each do |clbk|
+      eval %Q{
+        def #{clbk}(text)
+          self.class.#{clbk}_callbacks.each do |callback|
+            text = send(callback, text)
+          end
+          text
+        end
+      }
+    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
+      {
+       :@context  => @context, # <== we need this when rendering twice the same part
+       :@result   => @result,
+       :@out_post => @out_post,
+       :@params   => @params.dup,
+       :@method   => @method,
+      }
+    end
+
+    # Restore state from a hash
+    def restore_state(saved)
+      saved.each do |key, value|
+        instance_variable_set(key, value)
+      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
+    end
+
+    def process_unknown
+      self.class.process_unknown_callbacks.each do |callback|
+        if res = send(callback)
+          return res
+        end
+      end
+      @errors.empty? ? default_unknown : show_errors
+    end
+
+    def show_errors
+      @errors.join(' ')
     end
 
     def initialize(text, opts={})
       @stack   = []
       @ok      = true
       @blocks  = []
+      @errors  = []
 
       @options = {:mode=>:void, :method=>'void'}.merge(opts)
       @params  = @options.delete(:params) || {}
@@ -65,16 +143,16 @@ module Zafu
         @text = before_parse(text)
       end
 
-
       start(mode)
 
       # set name
-      @name    ||= @options[:name] || @params[:id]
+      @name ||= extract_name
       @options[:ids][@name] = self if @name
 
       unless opts[:sub]
         @text = after_parse(@text)
       end
+
       @ids.keys.each do |k|
         if original_ids[k] != @ids[k]
           @defined_ids[k] = @ids[k]
@@ -83,6 +161,10 @@ module Zafu
       @ok
     end
 
+    def extract_name
+      @options[:name] || @params[:id]
+    end
+
     def to_erb(context)
       context[:helper] ||= @options[:helper]
       process(context)
@@ -96,7 +178,7 @@ module Zafu
     # This replaces the current object 'self' which is in the original included template, with the custom version 'obj'.
     def replace_with(obj)
       # keep @method (obj's method is always 'with')
-      @blocks   = obj.blocks.empty? ? @blocks : obj.blocks
+      @blocks = obj.blocks.empty? ? @blocks : obj.blocks
       @params.merge!(obj.params)
     end
 
@@ -110,6 +192,10 @@ module Zafu
     end
 
     def process(context={})
+      return '' if @method == 'ignore' || @method.blank?
+
+      @saved = save_state
+
       if @name
         # we pass the name as 'context' in the children tags
         @context = context.merge(:name => @name)
@@ -121,17 +207,31 @@ module Zafu
 
       before_process
 
-      @pass    = {} # used to pass information to the parent
-      res = nil
+      @pass = {} # used to pass information to the parent (is this used ?)
+
+      res = expander || default_expander
+
+      res = before_wrap(res)
+      res = wrap(res + @out_post)
+
+      # @text contains unparsed data (empty space)
+      res = after_wrap(res) + @text
+
+      after_process
+
+      # restore state
+      restore_state(@saved)
+
+      res
+    end
 
+    # Default processing
+    def default_expander
       if respond_to?("r_#{@method}".to_sym)
-        res = do_method("r_#{@method}".to_sym)
+        do_method("r_#{@method}".to_sym)
       else
-        res = do_method(:r_unknown)
+        do_method(:process_unknown)
       end
-
-      # @text contains unparsed data (empty space)
-      after_process(res + @text)
     end
 
     def do_method(sym)
@@ -139,18 +239,15 @@ module Zafu
       if res.kind_of?(String)
         @result << res
       elsif @result.blank?
-        @result << @method
+        @result << (@errors.blank? ? @method : show_errors)
       end
-      @result + @out_post
+      @result
     end
 
     def r_void
       expand_with
     end
 
-    def r_ignore
-    end
-
     alias to_s r_void
 
     def r_inspect
@@ -161,7 +258,7 @@ module Zafu
     end
 
     # basic rule to display errors
-    def r_unknown
+    def default_unknown
       sp = ""
       @params.each do |k,v|
         sp += " #{k}=#{v.inspect.gsub("'","TMPQUOTE").gsub('"',"'").gsub("TMPQUOTE",'"')}"
@@ -185,22 +282,8 @@ module Zafu
       expand_with(hash)
     end
 
-    def before_process
-      self.class.before_process_callbacks.each do |callback|
-        self.send(callback)
-      end
-    end
-
-    def after_process(text)
-      text
-    end
-
-    def before_parse(text)
-      text
-    end
-
-    def after_parse(text)
-      text
+    def r_ignore
+      ''
     end
 
     def include_template
@@ -218,7 +301,7 @@ module Zafu
 
       included_text, absolute_url, base_path = self.class.get_template_text(@params[:template], @options[:helper], @options[:base_path])
 
-      if absolute_url
+      if included_text
         absolute_url += "::#{@params[:part].gsub('/','_')}" if @params[:part]
         absolute_url += "??#{@options[:part].gsub('/','_')}" if @options[:part]
         if @options[:included_history].include?(absolute_url)
@@ -226,8 +309,11 @@ module Zafu
         else
           included_history  = @options[:included_history] + [absolute_url]
         end
+      else
+        return "<span class='parser_error'>[include] template '#{@params[:template]}' not found</span>"
       end
-      res = self.class.new(included_text, :helper => @options[:helper], :base_path => base_path, :included_history => included_history, :part => @params[:part]) # we set :part to avoid loop failure when doing self inclusion
+
+      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
 
       if @params[:part]
         if iblock = res.ids[@params[:part]]
@@ -245,7 +331,6 @@ module Zafu
       enter(:void) # normal scan on content
       # replace 'with'
 
-      not_found = []
       @blocks.each do |b|
         next if b.kind_of?(String) || b.method != 'with'
         if target = res.ids[b.params[:part]]
@@ -258,10 +343,10 @@ module Zafu
           end
         else
           # part not found
-          not_found << parser_error("'#{b.params[:part]}' not found in template '#{@params[:template]}'", 'with')
+          parser_error("'#{b.params[:part]}' not found in template '#{@params[:template]}'", 'with')
         end
       end
-      @blocks = included_blocks + not_found
+      @blocks = included_blocks
     end
 
     # Return a hash of all descendants. Find a specific descendant with descendant['form'] for example.
@@ -289,6 +374,10 @@ module Zafu
       end.compact.flatten]
     end
 
+    def dynamic_blocks?
+      @blocks.detect { |b| !b.kind_of?(String) }
+    end
+
     def descendants(key)
       all_descendants[key] || []
     end
@@ -354,14 +443,14 @@ module Zafu
     def out(str)
       @result << str
       # Avoid double entry when this is the last call in a render method.
-      nil
+      true
     end
 
     # Output ERB code that will be inserted after @result.
     def out_post(str)
       @out_post << str
       # Avoid double entry when this is the last call in a render method.
-      nil
+      true
     end
 
     # Advance parser.
@@ -396,8 +485,8 @@ module Zafu
         custom_text = opts.delete(:text)
       end
       text = custom_text || @text
-      opts = @options.merge(opts).merge(:sub=>true, :mode=>mode, :parent => self)
-      new_obj = self.class.new(text,opts)
+      opts = @options.merge(opts).merge(:sub => true, :mode => mode, :parent => self)
+      new_obj = self.class.new(text, opts)
       if new_obj.success?
         @text = new_obj.text unless custom_text
         new_obj.text = ""
@@ -556,9 +645,5 @@ module Zafu
       end
       result + @text
     end
-
-    def parser_error(message, method = @method)
-      self.class.parser_error(message, method)
-    end
   end # Parser
 end # Zafu

data/lib/zafu/parsing_rules.rb

@@ -13,16 +13,21 @@ module Zafu
     # indentation information that should be used when rendered. This context is not inherited.
     attr_accessor :markup
 
+    # We need this flag to detect cases like <r:with part='list' do='other list finder'/>
+    attr_reader :sub_do
+
+    def self.included(base)
+      base.before_parse :remove_erb
+      base.before_process :unescape_ruby
+    end
+
     # This callback is run just after the block is initialized (Parser#initialize).
     def start(mode)
       # tag_context
       @markup = Markup.new(@options.delete(:html_tag))
 
       # html_tag
-      @markup.params = @options.delete(:html_tag_params) # @html_tag_params
-
-      # have we already wrapped the result with our tag ?
-      @markup.done = false # @html_tag_done
+      @markup.params = @options.delete(:html_tag_params)
 
       # end_tag is used to know when to close parsing in sub-do
       # Example:
@@ -42,11 +47,14 @@ module Zafu
       # FIXME: what is this ???
       @options[:form] ||= true if @method == 'form'
 
-      # puts "[#{@markup[:space_before]}(#{@method})#{@markup[:space_after]}]"
       if @params =~ /\A([^>]*?)do\s*=('|")([^\2]*?[^\\])\2([^>]*)\Z/
+        #puts $~.to_a.inspect
         # we have a sub 'do'
+
         @params = Markup.parse_params($1)
-        @sub_do = $3 # this is used by replace_with (FIXME)
+
+        # We need this flag to detect cases cases like <r:with part='list' do='other list finder'/>
+        @sub_do = true
 
         opts = {:method=>$3, :params=>$4}
 
@@ -61,14 +69,14 @@ module Zafu
       end
 
       # set name used for include/replace from html_tag if not allready set by superclass
-      @name = @options[:name] || @params[:name] || @params[:id] || @markup.params[:id]
+      @name = extract_name
 
       if !@markup.tag && (@markup.tag = @params.delete(:tag))
         # Extract html tag parameters from @params
         @markup.steal_html_params_from(@params)
       end
 
-      if @method == 'include'
+      if @method == 'include' && @params[:template]
         include_template
       elsif mode == :tag && !sub
         scan_tag
@@ -77,10 +85,36 @@ module Zafu
       end
     end
 
-    def before_parse(text)
+    def extract_name
+      super ||
+      (%w{input select textarea}.include?(@method) ? nil : @params[:name]) ||
+      @markup.params[:id]
+    end
+
+    def remove_erb(text)
       text.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
     end
 
+    def unescape_ruby
+      @params.each do |k,v|
+        v.gsub!('&gt;', '>')
+        v.gsub!('&lt;', '<')
+      end
+      @method.gsub!('&gt;', '>')
+      @method.gsub!('&lt;', '<')
+    end
+
+    def single_child_method
+      return @single_child_method if defined?(@single_child_method)
+      @single_child_method = if @blocks.size == 1
+        single_child = @blocks[0]
+        return nil if single_child.kind_of?(String)
+        single_child.markup.tag ? nil : single_child.method
+      else
+        nil
+      end
+    end
+
     # scan rules
     def scan
       # puts "SCAN(#{@method}): [#{@text}]"
@@ -110,11 +144,8 @@ module Zafu
         if $1 == @end_tag
           @end_tag_count -= 1
           if @end_tag_count == 0
-            if @end_tag == 'script'
-              flush $& # keep closing tag
-            else
-              eat $&
-            end
+            eat $&
+
             @markup.space_after = $2
             leave
           else
@@ -162,7 +193,7 @@ module Zafu
         opts.merge!(:text=>'') if $3 != ''
         make(:void, opts)
       elsif @text =~ /\A<(\w+)([^>]*?)do\s*=('([^>]*?[^\\]|)'|"([^>]*?[^\\]|)")([^>]*?)(\/?)>/
-        #puts "DO:#{$~.to_a.inspect}" # do tag
+        #puts "DO:#{($4||$5).inspect}" # do tag
         eat $&
         opts.merge!(:method=>($4||$5), :html_tag=>$1, :html_tag_params=>$2, :params=>$6)
         opts.merge!(:text=>'') if $7 != ''
@@ -216,7 +247,7 @@ module Zafu
         @method = 'rename_asset'
         @markup.tag = @end_tag = $1
         closed = ($3 != '')
-        @params = parse_params($2)
+        @params = Markup.parse_params($2)
         if closed
           leave(:asset)
         elsif @markup.tag == 'script'
@@ -233,7 +264,8 @@ module Zafu
 
     def scan_inside_asset
       if @text =~ /\A(.*?)<\/#{@end_tag}>/m
-        flush $&
+        eat $&
+        store $1
         leave(:asset)
       else
         # never ending asset