zena 1.2.1 → 1.2.2

data/lib/zafu/mock_helper.rb

@@ -0,0 +1,42 @@
+module Zafu
+  # This is the 'src_helper' used when none is provided. Its main purpose is to provide some information
+  # during testing.
+  class MockHelper
+    def initialize(strings = {})
+      @strings = strings
+    end
+
+    def get_template_text(opts)
+      src    = opts[:src]
+      folder = (opts[:base_path] && opts[:base_path] != '') ? opts[:base_path][1..-1].split('/') : []
+      src = src[1..-1] if src[0..0] == '/' # just ignore the 'relative' or 'absolute' tricks.
+      url = (folder + src.split('/')).join('_')
+      if test = @strings[url]
+        return [test['src'], url.split('_').join('/')]
+      else
+        nil
+      end
+    end
+
+    def template_url_for_asset(opts)
+      "/test_#{opts[:type]}/#{opts[:src]}"
+    end
+
+    def method_missing(sym, *args)
+      arguments = args.map do |arg|
+        if arg.kind_of?(Hash)
+          res = []
+          arg.each do |k,v|
+            unless v.nil?
+              res << "#{k}:#{v.inspect.gsub(/'|"/, "|")}"
+            end
+          end
+          res.sort.join(' ')
+        else
+          arg.inspect.gsub(/'|"/, "|")
+        end
+      end
+      res = "[#{sym} #{arguments.join(' ')}]"
+    end
+  end # DummyHelper
+end

data/lib/zafu/node_context.rb

@@ -0,0 +1,203 @@
+module Zafu
+  class NodeContext
+    # The name of the variable halding the current object or list ("@node", "var1")
+    attr_reader :name
+
+    # The previous NodeContext
+    attr_reader :up
+
+    # The type of object contained in the current context (Node, Page, Image)
+    attr_reader :klass
+
+    # The current DOM prefix to use when building DOM ids. This is set by the parser when
+    # it has a name or dom id defined ('main', 'related', 'list', etc).
+    attr_writer :dom_prefix
+
+    # This is used to force a given dom_id (in saved templates for example).
+    attr_accessor :saved_dom_id
+
+    # Any kind of information that the compiler might need to use (QueryBuilder query used
+    # to fetch the node for example).
+    attr_reader :opts
+
+    def initialize(name, klass, up = nil, opts = {})
+      @name, @klass, @up, @opts = name, klass, up, opts
+    end
+
+    def move_to(name, klass, opts={})
+      self.class.new(name, klass, self, opts)
+    end
+
+    # Since the idiom to write the node context name is the main purpose of this class, it
+    # deserves this shortcut.
+    def to_s
+      name
+    end
+
+    def single_class
+      @single_class ||= Array(klass).flatten.first
+    end
+
+    # Return true if the NodeContext represents an element of the given type. We use 'will_be' because
+    # it is equivalent to 'is_a', but for future objects (during rendering).
+    def will_be?(type)
+      single_class <= type
+    end
+
+    # 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 to get
+    # ivar name (see #master_class).
+    def as_main(after_class = nil)
+      klass = after_class ? master_class(after_class) : single_class
+      res = self.class.new("@#{klass.to_s.underscore}", single_class, nil)
+      res.propagate_dom_scope! if @dom_scope
+      res.dom_prefix = self.dom_prefix
+      res
+    end
+
+    # Find the class just afer 'after_class' in the class hierarchy.
+    # For example if we have Dog < Mamal < Animal < Creature,
+    # master_class(Creature) would return Animal
+    def master_class(after_class)
+      klass = single_class
+      begin
+        up = klass.superclass
+        return klass if up == after_class
+      end while klass = up
+      return self.klass
+    end
+
+    # Generate a unique DOM id for this element based on dom_scopes defined in parent contexts.
+    # :code option returns ruby
+    # :erb  option returns either string content or "<%= ... %>"
+    #       default returns something to insert in interpolated string such as '#{xxx}'
+    def dom_id(opts = {})
+      dom_prefix = opts[:dom_prefix] || self.dom_prefix
+      options = {:list => true, :erb => true}.merge(opts)
+
+      if options[:erb] || options[:code]
+        dom = dom_id(options.merge(:erb => false, :code => false))
+
+        if dom =~ /^#\{([^\{]+)\}$/
+          code = $1
+        elsif dom =~ /#\{/
+          code = "%Q{#{dom}}"
+        else
+          str  = dom
+          code = dom.inspect
+        end
+
+        if options[:code]
+          code
+        else
+          str || "<%= #{code} %>"
+        end
+      else
+        @saved_dom_id || if options[:list]
+          scopes = dom_scopes
+          scopes = [dom_prefix] if scopes.empty?
+          scopes + [make_scope_id]
+        else
+          scopes = dom_scopes
+          scopes + ((@up || scopes.empty?) ? [dom_prefix] : [])
+        end.compact.uniq.join('_')
+      end
+    end
+
+    # This holds the current context's unique name if it has it's own or one from the hierarchy. If
+    # none is found, it builds one.
+    def dom_prefix
+      @dom_prefix || (@up ? @up.dom_prefix : nil)
+    end
+
+    # Return dom_prefix without looking up.
+    def raw_dom_prefix
+      @dom_prefix
+    end
+
+    # 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 propagate_dom_scope!
+      @dom_scope = true
+    end
+
+    # Returns the first occurence of the klass up in the hierachy
+    # This does not resolve [Node] as [Node].first.
+    def get(klass)
+      if list_context?
+        return @up ? @up.get(klass) : nil
+      end
+      if self.klass <= klass
+        self
+        # return self unless list_context?
+        #
+        # res_class = self.klass
+        # method = self.name
+        # while res_class.kind_of?(Array)
+        #   method = "#{method}.first"
+        #   res_class = res_class.first
+        # end
+        # move_to(method, res_class)
+      elsif @up
+        @up.get(klass)
+      else
+        nil
+      end
+    end
+
+    def up(klass = nil)
+      klass ? @up.get(klass) : @up
+    end
+
+    # Return true if the current klass is an Array.
+    def list_context?
+      klass.kind_of?(Array)
+    end
+
+    # Return the name of the current class with underscores like 'sub_page'.
+    def underscore
+      class_name.to_s.underscore
+    end
+
+    # Return the 'real' class name or the superclass name if the current class is an anonymous class.
+    def class_name
+      klass = single_class
+      while klass.name == ''
+        klass = klass.superclass
+      end
+      if list_context?
+        "[#{klass}]"
+      else
+        klass.name
+      end
+    end
+
+    # Return the name to use for input fields
+    def form_name
+      @form_name ||= master_class(ActiveRecord::Base).name.underscore
+    end
+
+    protected
+      # List of scopes defined in ancestry (used to generate dom_id).
+      def dom_scopes
+        return [@saved_dom_id] if @dom_scope && @saved_dom_id
+        if @up
+          scopes = @up.dom_scopes
+          if @dom_scope
+            (scopes.empty? ? [dom_prefix] : scopes) + [make_scope_id]
+          else
+            scopes
+          end
+        else
+          @dom_scope ? [dom_prefix, make_scope_id] : []
+        end
+      end
+
+    private
+      def make_scope_id
+        "\#{#{@name}.zip}"
+      end
+  end
+end

data/lib/zafu/ordered_hash.rb

@@ -0,0 +1,53 @@
+module Zafu
+
+  if RUBY_VERSION.split('.')[0..1].join('.').to_f > 1.8
+    OrderedHash = Hash
+  else
+    class OrderedHash < Hash
+
+      def []=(k, v)
+        get_keys << k unless get_keys.include?(k)
+        super
+      end
+
+      def merge!(hash)
+        hash.keys.each do |k|
+          get_keys << k unless get_keys.include?(k)
+        end
+        super
+      end
+
+      def merge(hash)
+        res = dup
+        res.merge!(hash)
+        res
+      end
+
+      alias o_keys keys
+      def get_keys
+        @keys ||= o_keys
+      end
+
+      def keys
+        get_keys.dup
+      end
+
+      def each
+        keys.each do |k|
+          yield(k, self[k])
+        end
+      end
+
+      def delete(k)
+        get_keys.delete(k)
+        super
+      end
+
+      def dup
+        copy = super
+        copy.instance_variable_set(:@keys, keys)
+        copy
+      end
+    end
+  end
+end

data/lib/zafu/parser.rb

@@ -0,0 +1,676 @@
+module Zafu
+
+  def self.parser_with_rules(*modules)
+    parser = Class.new(Parser)
+    modules.flatten.each do |mod|
+      parser.send(:include, mod)
+    end
+    parser
+  end
+
+  class Parser
+    # 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, :name, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent, :errors
+
+    # Method parameters "<r:show attr='name'/>" (params contains {'attr' => 'name'}).
+    attr_accessor :params
+
+    class << self
+      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, :master_template => opts[:master_template])
+      end
+
+      # Retrieve the template text in the current folder or as an absolute path.
+      # This method is used when 'including' text
+      def get_template_text(path, helper, base_path=nil, opts={})
+        cache = (visitor.zafu_cache ||= {})
+        unless res = cache[path]
+          res = helper.send(:get_template_text, path, base_path, opts)
+          res = [parser_error("template '#{path}' not found", 'include'), nil, nil] unless res
+          cache[path] = res
+        end
+        res
+      end
+
+      def parser_error(message, method)
+        "<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|
+        eval %Q{
+          attr_accessor :#{clbk}_callbacks
+
+          def #{clbk}_callbacks
+            @#{clbk}_callbacks ||= superclass.respond_to?(:#{clbk}_callbacks) ? superclass.#{clbk}_callbacks : []
+          end
+
+          def #{clbk}(*args)
+            self.#{clbk}_callbacks += args
+          end
+        }
+      end
+    end # class << self
+
+    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
+
+    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
+      {
+       :@context  => @context, # <== we need this when rendering twice the same part
+       :@result   => @result,
+       :@out_post => @out_post,
+       :@params   => @params.dup,
+       :@method   => @method,
+       :@var      => @var,
+      }
+    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, 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
+      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) || {}
+      @method  = @options.delete(:method)
+      @ids     = @options[:ids] ||= {}
+      original_ids = @ids.dup
+      @defined_ids = {} # ids defined in this node or this node's sub blocks
+      mode     = @options.delete(:mode)
+      @parent  = @options.delete(:parent)
+
+      if opts[:sub]
+        @text = text
+      else
+        @text = before_parse(text)
+        if part = opts[:part]
+          # Optimization: try to find part from id
+          if @text =~ /^(.*?)<[^<>]+id='#{part}'/m
+            eat $1
+          end
+        end
+      end
+
+      start(mode)
+
+      # set name
+      @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]
+        end
+      end
+      @ok
+    end
+
+    def extract_name
+      @options[:name] || @params[:id]
+    end
+
+    def to_erb(context)
+      context[:helper] ||= @options[:helper]
+      process(context)
+    end
+
+    def start(mode)
+      enter(mode)
+    end
+
+    # Pass some contextual information to siblings
+    def pass(elems = nil)
+      return @pass unless elems
+      (@pass ||= {}).merge!(elems)
+      @pass
+    end
+
+    # Hook called when replacing part of an included template with '<r:with part='main'>...</r:with>'
+    # 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
+      obj.params.delete(:part)
+      @params.merge!(obj.params)
+    end
+
+    # Hook called when including a part "<r:include template='layout' part='title'/>"
+    def include_part(obj)
+      [obj]
+    end
+
+    def empty?
+      @blocks == [] && (@params == {} || @params == {:part => @params[:part]})
+    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)
+      else
+        @context = context
+      end
+      # FIXME: replace with array and join (faster)
+      @result   = ""
+      @out_post = ""
+      @pass     = nil
+
+      before_process
+
+      res = wrap(expander || default_expander)
+
+      res = after_process(res)
+
+      # restore state
+      restore_state(saved)
+
+      res
+    end
+
+    # Default processing
+    def default_expander
+      if respond_to?("r_#{@method}".to_sym)
+        do_method("r_#{@method}".to_sym)
+      else
+        do_method(:process_unknown)
+      end
+    end
+
+    def do_method(sym)
+      res = self.send(sym)
+      if res.kind_of?(String)
+        @result << res
+      elsif @result.blank?
+        @result << (@errors.empty? ? '' : show_errors)
+      end
+      @result
+    end
+
+    def r_void
+      expand_with
+    end
+
+    alias to_s r_void
+
+    def r_inspect
+      expand_with(:preflight=>true)
+      @blocks = []
+      self.inspect
+    end
+
+    # basic rule to display errors
+    def default_unknown
+      sp = ""
+      @params.each do |k,v|
+        sp += " #{k}=#{v.inspect.gsub("'","TMPQUOTE").gsub('"',"'").gsub("TMPQUOTE",'"')}"
+      end
+
+      res = "<span class='parser_unknown'>&lt;r:#{@method}#{sp}"
+      inner = expand_with
+      if inner != ''
+        res + "&gt;</span>#{inner}<span class='parser_unknown'>&lt;r:/#{@method}&gt;</span>"
+      else
+        res + "/&gt;</span>"
+      end
+    end
+
+    # Set context with variables (unsafe) from template.
+    def r_expand_with
+      hash = {}
+      @params.each do |k,v|
+        hash["exp_#{k}"] = v.inspect
+      end
+      expand_with(hash)
+    end
+
+    def r_ignore
+      ''
+    end
+
+    def include_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'
+        enter(:void)
+        return
+      end
+      @method = 'void'
+
+      # fetch text
+      @options[:included_history] ||= []
+
+      included_text, absolute_url, base_path = self.class.get_template_text(@params[:template], @options[:helper], @options[:base_path])
+
+      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)
+          included_text = parser_error("infinity loop: #{(@options[:included_history] + [absolute_url]).join(' --&gt; ')}", 'include')
+        else
+          included_history  = @options[:included_history] + [absolute_url]
+        end
+      else
+        # 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
+
+      if @params[:part]
+        if iblock = res.ids[@params[:part]]
+          included_blocks = include_part(iblock)
+          # get all ids from inside the included part:
+          @ids.merge! iblock.defined_ids
+        else
+          included_blocks = [parser_error("'#{@params[:part]}' not found in template '#{@params[:template]}'", 'include')]
+        end
+      else
+        included_blocks = res.blocks
+        @ids.merge! res.ids
+      end
+
+      enter(:void) # normal scan on content
+      # replace 'with'
+
+      @blocks.each do |b|
+        next if b.kind_of?(String) || b.method != 'with'
+        if target = res.ids[b.params[:part]]
+          if target.kind_of?(String)
+            # error
+          elsif b.empty?
+            target.method = 'ignore'
+          else
+            target.replace_with(b)
+          end
+        else
+          # part not found
+          parser_error("'#{b.params[:part]}' not found in template '#{@params[:template]}'", 'with')
+        end
+      end
+      @blocks = included_blocks
+    end
+
+    # Return a hash of all descendants. Find a specific descendant with descendant['form'] for example.
+    def all_descendants
+      @all_descendants ||= begin
+        d = {}
+        @blocks.each do |b|
+          next if b.kind_of?(String)
+          b.public_descendants.each do |k,v|
+            d[k] ||= []
+            d[k]  += v
+          end
+          # latest is used first: use direct children before grandchildren.
+          d[b.method] ||= []
+          d[b.method] << b
+        end
+        d
+      end
+    end
+
+    # Find a direct child with +child[method]+.
+    def child
+      Hash[*@blocks.map do |b|
+        b.kind_of?(String) ? nil : [b.method, b]
+      end.compact.flatten]
+    end
+
+    def dynamic_blocks?
+      @blocks.detect { |b| !b.kind_of?(String) }
+    end
+
+    def descendants(key)
+      all_descendants[key] || []
+    end
+
+    def ancestors
+      @ancestors ||= begin
+        if parent
+          parent.ancestors + [parent]
+        else
+          []
+        end
+      end
+    end
+
+    alias public_descendants all_descendants
+
+    # Return the last defined parent for the given keys.
+    def ancestor(keys)
+      keys = Array(keys)
+      ancestors.reverse_each do |a|
+        if keys.include?(a.method)
+          return a
+        end
+      end
+      nil
+    end
+
+    # Return the last defined descendant for the given key.
+    def descendant(key)
+      descendants(key).last
+    end
+
+    # Return the root block (the one opened first).
+    def root
+      @root ||= parent ? parent.root : self
+    end
+
+    def success?
+      return @ok
+    end
+
+    def flush(str=@text)
+      return if str == ''
+      if @blocks.last.kind_of?(String)
+        @blocks[-1] << str
+      else
+        @blocks << str
+      end
+      @text = @text[str.length..-1]
+    end
+
+    # Build blocks
+    def store(obj)
+      if obj.kind_of?(String) && @blocks.last.kind_of?(String)
+        @blocks[-1] << obj
+      elsif obj != ''
+        @blocks << obj
+      end
+    end
+
+    # Output ERB code during ast processing.
+    def out(str)
+      @result << str
+      # Avoid double entry when this is the last call in a render method.
+      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.
+      true
+    end
+
+    # Advance parser.
+    def eat(arg)
+      if arg.kind_of?(String)
+        len = arg.length
+      elsif arg.kind_of?(Fixnum)
+        len = arg
+      else
+        raise
+      end
+      @text = @text[len..-1]
+    end
+
+    def enter(mode)
+      @stack << mode
+      # puts "ENTER(#{@method},:#{mode}) [#{@text}] #{@zafu_tag_count.inspect}"
+      if mode == :void
+        sym = :scan
+      else
+        sym = "scan_#{mode}".to_sym
+      end
+      while (@text != '' && @stack[-1] == mode)
+        # puts "CONTINUE(#{@method},:#{mode}) [#{@text}] #{@zafu_tag_count.inspect}"
+        self.send(sym)
+      end
+      # puts "LEAVE(#{@method},:#{mode}) [#{@text}] #{@zafu_tag_count.inspect}"
+    end
+
+    def make(mode, opts={})
+      if opts[:text]
+        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)
+      if new_obj.success?
+        @text = new_obj.text unless custom_text
+        new_obj.text = ""
+        store new_obj
+      else
+        flush @text[0..(new_obj.text.length - @text.length)] unless custom_text
+      end
+      # puts "MADE #{new_obj.inspect}"
+      # puts "TEXT #{@text.inspect}"
+      new_obj
+    end
+
+    def leave(mode=nil)
+      if mode.nil?
+        @stack = []
+        return
+      end
+      pop  = true
+      while @stack != [] && pop
+        pop = @stack.pop
+        break if pop == mode
+      end
+    end
+
+    def fail
+      @ok   = false
+      @stack = []
+    end
+
+    def check_params(*args)
+      missing = []
+      if args[0].kind_of?(Array)
+        # or groups
+        ok = false
+        args.each_index do |i|
+          unless args[i].kind_of?(Array)
+            missing[i] = [args[i]]
+            next
+          end
+          missing[i] = []
+          args[i].each do |arg|
+            missing[i] << arg.to_s unless @params[arg]
+          end
+          if missing[i] == []
+            ok = true
+            break
+          end
+        end
+        if ok
+          return true
+        else
+          out "[#{@method} parameter(s) missing:#{missing[0].sort.join(', ')}]"
+          return false
+        end
+      else
+        args.each do |arg|
+          missing << arg.to_s unless @params[arg]
+        end
+      end
+      if missing != []
+        out "[#{@method} parameter(s) missing:#{missing.sort.join(', ')}]"
+        return false
+      end
+      true
+    end
+
+    def expand_block(block, new_context={})
+      block.process(@context.merge(new_context))
+    end
+
+    def expand_with(acontext={})
+
+      blocks = acontext.delete(:blocks) || @blocks
+      res = ""
+
+      only   = acontext[:only]
+      new_context = @context.merge(acontext)
+
+      if acontext[:ignore]
+        new_context[:ignore] = (@context[:ignore] || []) + (acontext[:ignore] || []).uniq
+      end
+
+      if acontext[:no_ignore]
+        new_context[:ignore] = (new_context[:ignore] || []) - acontext[:no_ignore]
+      end
+
+      ignore = new_context[:ignore]
+
+      blocks.each do |b|
+        if b.kind_of?(String)
+          if (!only || (only.kind_of?(Array) && only.include?(:string))) && (!ignore || !ignore.include?(:string))
+            res << b
+          end
+        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
+            new_context.merge!(pass)
+          end
+        end
+      end
+      res
+    end
+
+    def inspect
+      attributes = []
+      params = []
+      (@params || {}).each do |k,v|
+        unless v.nil?
+          params << "#{k.inspect.gsub('"', "'")}=>'#{v}'"
+        end
+      end
+      attributes << " {= #{params.sort.join(', ')}}" unless params == []
+
+      context = []
+      (@context || {}).each do |k,v|
+        unless v.nil?
+          context << "#{k.inspect.gsub('"', "'")}=>'#{v}'"
+        end
+      end
+      attributes << " {> #{context.sort.join(', ')}}" unless context == []
+
+      res = []
+      @blocks.each do |b|
+        if b.kind_of?(String)
+          res << b
+        else
+          res << b.inspect
+        end
+      end
+      result = "[#{@method}#{attributes.join('')}"
+      if res != []
+        result += "]#{res}[/#{@method}]"
+      else
+        result += "/]"
+      end
+      result + @text
+    end
+  end # Parser
+end # Zafu