zafu 0.5.0

data/lib/zafu/parser.rb

@@ -0,0 +1,564 @@
+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
+    @@callbacks = {}
+    attr_accessor :text, :method, :pass, :options, :blocks, :ids, :defined_ids, :parent
+    # 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)
+        self.new(text, :helper => helper, :base_path => base_path, :included_history => [fullpath])
+      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)
+        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
+      end
+
+      def parser_error(message, method)
+        "<span class='parser_error'><span class='method'>#{method}</span> #{message}</span>"
+      end
+
+      attr_accessor :before_process_callbacks
+
+      def before_process_callbacks
+        @before_process_callbacks ||= []
+      end
+
+      def before_process(*args)
+        self.before_process_callbacks += args
+      end
+    end
+
+    def initialize(text, opts={})
+      @stack   = []
+      @ok      = true
+      @blocks  = []
+
+      @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)
+      end
+
+
+      start(mode)
+
+      # set name
+      @name    ||= @options[:name] || @params[:id]
+      @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 to_erb(context)
+      context[:helper] ||= @options[:helper]
+      process(context)
+    end
+
+    def start(mode)
+      enter(mode)
+    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
+      @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={})
+      if @name
+        # we pass the name as 'context' in the children tags
+        @context = context.merge(:name => @name)
+      else
+        @context = context
+      end
+      @result   = ""
+      @out_post = ""
+
+      before_process
+
+      @pass    = {} # used to pass information to the parent
+      res = nil
+
+      if respond_to?("r_#{@method}".to_sym)
+        res = do_method("r_#{@method}".to_sym)
+      else
+        res = do_method(:r_unknown)
+      end
+
+      # @text contains unparsed data (empty space)
+      after_process(res + @text)
+    end
+
+    def do_method(sym)
+      res = self.send(sym)
+      if res.kind_of?(String)
+        @result << res
+      elsif @result.blank?
+        @result << @method
+      end
+      @result + @out_post
+    end
+
+    def r_void
+      expand_with
+    end
+
+    def r_ignore
+    end
+
+    alias to_s r_void
+
+    def r_inspect
+      expand_with(:preflight=>true)
+      @blocks = []
+      @pass.merge!(@parts||{})
+      self.inspect
+    end
+
+    # basic rule to display errors
+    def r_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 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
+    end
+
+    def include_template
+      return parser_error("missing 'template' attribute", 'include') 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
+      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
+
+      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'
+
+      not_found = []
+      @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
+          not_found << parser_error("'#{b.params[:part]}' not found in template '#{@params[:template]}'", 'with')
+        end
+      end
+      @blocks = included_blocks + not_found
+    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 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 key.
+    def ancestor(key)
+      res = nil
+      ancestors.reverse_each do |a|
+        if key == a.method
+          res = a
+          break
+        end
+      end
+      res
+    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.
+      nil
+    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
+    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 = ""
+
+      # FIXME: I think we can delete @pass and @parts stuff now (test first).
+
+      @pass  = {} # current object sees some information from it's direct descendants
+      @parts = {}
+      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.include?(:string)) && (!ignore || !ignore.include?(:string))
+            res << b
+          end
+        elsif (!only || only.include?(b.method)) && (!ignore || !ignore.include?(b.method))
+          res << b.process(new_context.dup)
+          if pass = b.pass
+            if pass[:part]
+              @parts.merge!(pass[:part])
+              pass.delete(:part)
+            end
+            @pass.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 == []
+
+      pass = []
+      (@pass || {}).each do |k,v|
+        unless v.nil?
+          if v.kind_of?(Array)
+            pass << "#{k.inspect.gsub('"', "'")}=>#{v.inspect.gsub('"', "'")}"
+          elsif v.kind_of?(Parser)
+            pass << "#{k.inspect.gsub('"', "'")}=>['#{v}']"
+          else
+            pass << "#{k.inspect.gsub('"', "'")}=>#{v.inspect.gsub('"', "'")}"
+          end
+        end
+      end
+      attributes << " {< #{pass.sort.join(', ')}}" unless pass == []
+
+      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
+
+    def parser_error(message, method = @method)
+      self.class.parser_error(message, method)
+    end
+  end # Parser
+end # Zafu