Class Kwartz::RubyStyleParser
In: kwartz/parser.rb
Parent: PresentationLogicParser

ruby style presentation logic parser

presentation logic example (ruby style):

  # comment
  element "list" {
    value  @var
    attrs  "class"=>@clssname, "bgcolor"=>color
    append @value==item['list'] ? ' checked' : ''
    logic {
      @list.each { |item|
        _stag
        _cont
        _etag
      }
    }
  }

Methods

Constants

RUBYSTYLE_KEYWORDS = { 'BEGIN' => :BEGIN, 'END' => :END }

Public Instance methods

[Source]

# File kwartz/parser.rb, line 397
    def parse(input, filename='')
      reset(input, filename)
      scan()
      nodes = []
      while @token != nil
        if @token == :element
          node = parse_element_ruleset()
        elsif @token == :document
          node = parse_document_ruleset()
        else
          raise parse_error("'#{@value}': element or document required.")
        end
        nodes << node
      end
      return nodes
    end

Protected Instance methods

[Source]

# File kwartz/parser.rb, line 503
    def _parse_block
      super
    end

[Source]

# File kwartz/parser.rb, line 496
    def _parse_item
      item = scan_line()
      item.strip!
      return item
    end

[Source]

# File kwartz/parser.rb, line 469
    def _parse_list
      line = scan_line()
      list = line.split(/,\s+/).collect {|item| item.strip}
      return list
    end

[Source]

# File kwartz/parser.rb, line 491
    def _parse_str
      return _parse_strs()[0]
    end

[Source]

# File kwartz/parser.rb, line 476
    def _parse_strs
      list = _parse_list()
      list2 = []
      list.each do |item|
        case item
        when /\A"(.*)"\z/  ; list2 << $1
        when /\A'(.*)'\z/  ; list2 << $1
        else
          raise parse_error("'#{item}': argument of 'remove' should be string.")
        end
      end
      return list2
    end

[Source]

# File kwartz/parser.rb, line 508
    def _parse_tuples
      line = scan_line()
      items = line.split(/,\s+/)
      tuples = []
      items.each do |item|
        unless item =~ /(.*?)=>(.*)/
          raise parse_error("'#{item}': invalid pattern.")
        end
        key = $1;   key.strip!
        val = $2;   val.strip!
        if key =~ /\A"(.*)"\z/
          key = $1
        elsif key =~ /\A'(.*)'\z/
          key = $1
        else
          raise parse_error("'#{key}': key must be \"...\" or '...'.")   #
        end
        tuples << [key, val]
      end
      return tuples
    end

[Source]

# File kwartz/parser.rb, line 462
    def has_space?
      unless @ch == ?\  || @ch == ?\t
        raise parse_error("'#{@value}': following spaces are required but got '#{@ch.chr}'.")
      end
    end

[Source]

# File kwartz/parser.rb, line 429
    def keywords(keyword)
      return RUBYSTYLE_KEYWORDS[keyword]
    end

[Source]

# File kwartz/parser.rb, line 435
    def parse_document_ruleset
      assert unless @token == :document
      scan()
      unless @token == '{''{'
        raise parse_error("'#{@value}': document requires '{'.")
      end
      ruleset = DocumentRuleset.new
      while @token
        scan()
        case @token
        when :global    ;  has_space? ;  ruleset.set_global    _parse_list()
        when :local     ;  has_space? ;  ruleset.set_local     _parse_list()
        when :fixture   ;  has_space? ;  ruleset.set_fixture   _parse_block()
        when :before    ;  has_space? ;  ruleset.set_before    _parse_block()
        when :after     ;  has_space? ;  ruleset.set_after     _parse_block()
        when '}''}'       ;  break
        else            ;  raise parse_error("'#{@value}': invalid token.")
        end
      end
      unless @token == '}''}'
        raise parse_error("'#{@value}': document is not closed by '}'.")
      end
      scan()
      return DocumentRuleset.new(hash)
    end

[Source]

# File kwartz/parser.rb, line 531
    def parse_element_ruleset
      assert unless @token == :element
      scan()
      @token == :string   or raise parse_error("'#{@value}': element name required in string.")
      name = @value
      name =~ /\A\w+\z/   or raise parse_error("'#{@value}': invalid element name.")
      scan()
      @token == '{''{'      or raise parse_error("'#{@value}': '{' required.")
      ruleset = ElementRuleset.new(name)
      while true
        scan()
        flag_escape = escape?(@value)
        break unless @token
        #if @token.is_a?(Symbol) && (@ch != ?\  && @ch != ?\t)
        #  raise parse_error("'#{@value}': following spaces are required but got '#{@ch.chr}'.")
        #end
        case @token
        when :stag    ;  has_space? ;  ruleset.set_stag     _parse_item()   , flag_escape
        when :cont    ;  has_space? ;  ruleset.set_cont     _parse_item()   , flag_escape
        when :etag    ;  has_space? ;  ruleset.set_etag     _parse_item()   , flag_escape
        when :elem    ;  has_space? ;  ruleset.set_elem     _parse_item()   , flag_escape
        when :value   ;  has_space? ;  ruleset.set_value    _parse_item()   , flag_escape
        when :attrs   ;  has_space? ;  ruleset.set_attrs    _parse_tuples() , flag_escape
        when :append  ;  has_space? ;  ruleset.set_append   _parse_list()   , flag_escape
        when :remove  ;  has_space? ;  ruleset.set_remove   _parse_strs()
        when :tagname ;  has_space? ;  ruleset.set_tagname  _parse_str()
        when :logic   ;  has_space? ;  ruleset.set_logic    _parse_block()
        when '}''}'     ;  break
        else          ;  raise parse_error("'#{@value}': invalid token.")
        end
      end
      assert unless token == '}''}'
      scan()
      return ruleset
    end

[Source]

# File kwartz/parser.rb, line 418
    def scan_hook
      ## line comment
      c = @ch
      if c == ?#
        scan_line
        return scan()
      end
      return nil
    end

[Validate]