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

css style presentation logic parser

example of presentation logic in css style:

  // comment
  #list {
    value:   @var;
    attrs:   "class" @classname, "bgcolro" color;
    append:  @value==item['list'] ? ' checked' : '';
    logic:   {
      @list.each { |item|
        _stag
        _cont
        _etag
      }
    }
  }

Methods

Constants

CSSSTYLE_KEYWORDS = { 'begin'=>:begin, 'end'=>:end }

Public Instance methods

[Source]

# File kwartz/parser.rb, line 595
    def parse(input, filename='')
      reset(input, filename)
      scan()
      rulesets = []
      while @token == ?@
        c = getch();
        scan_ident()
        name = @value
        if name == 'import'
          imported_rulesets = parse_import_command()
          rulesets += imported_rulesets
        else
          raise parse_error("@#{name}: unsupported command.")
        end
      end
      while @token == ?#
        scan_ident()
        name = @value
        if name == 'DOCUMENT'
          ruleset = parse_document_ruleset()
        else
          ruleset = parse_element_ruleset()
        end
        rulesets << ruleset
      end
      unless @token == nil
        raise parse_error("'#{@value}': '#name' is expected.")
      end
      return rulesets
    end

Protected Instance methods

[Source]

# File kwartz/parser.rb, line 722
    def has_colon?
      unless @ch == ?:
        raise parse_error("'#{@value}': ':' is required.")
      end
      getch()
    end

[Source]

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

[Source]

# File kwartz/parser.rb, line 689
    def parse_document_ruleset
      assert unless @value == 'DOCUMENT'
      start_linenum = @linenum
      scan()
      unless @token == '{''{'
        raise parse_error("'#{@value}': '{' is expected.")
      end
      ruleset = DocumentRuleset.new
      while @token
        scan()
        case @token
        when '}''}'      ;  break
        when :global   ;  has_colon?();  ruleset.set_global   _parse_words()
        when :local    ;  has_colon?();  ruleset.set_local    _parse_words()
        when :fixture  ;  has_colon?();  ruleset.set_fixture  _parse_block()
        when :begin    ;  has_colon?();  ruleset.set_begin   _parse_block()
        when :end      ;  has_colon?();  ruleset.set_end    _parse_block()
        #when :before   ;  has_colon?();  ruleset.set_before   _parse_block()
        #when :after    ;  has_colon?();  ruleset.set_after    _parse_block()
        else
          unless @token
            raise parse_error("'#DOCUMENT': is not closed by '}'.", start_linenum)
          else
            raise parse_error("'#{@value}': unexpected token.")
          end
        end
      end
      assert unless @token == '}''}'
      scan()
      return ruleset
    end

[Source]

# File kwartz/parser.rb, line 730
    def parse_element_ruleset
      assert unless @token == :ident
      start_linenum = @linenum
      name = @value
      scan()
      unless @token == '{''{'
        raise parse_error("'#{@value}': '{' is expected.")
      end
      ruleset = ElementRuleset.new(name)
      while true
        scan()
        flag_escape = escape?(@value)
        case @token
        when nil     ;  break
        when '}''}'    ;  break
        when :stag   ;  has_colon?();  ruleset.set_stag   _parse_expr() , flag_escape
        when :cont   ;  has_colon?();  ruleset.set_cont   _parse_expr() , flag_escape
        when :etag   ;  has_colon?();  ruleset.set_etag   _parse_expr() , flag_escape
        when :elem   ;  has_colon?();  ruleset.set_elem   _parse_expr() , flag_escape
        when :value  ;  has_colon?();  ruleset.set_value  _parse_expr() , flag_escape
        when :attrs  ;  has_colon?();  ruleset.set_attrs  _parse_pairs(), flag_escape
        when :append ;  has_colon?();  ruleset.set_append _parse_exprs(), flag_escape
        when :remove ;  has_colon?();  ruleset.set_remove _parse_strs()
        when :tagname;  has_colon?();  ruleset.set_tagname  _parse_str()
        when :logic  ;  has_colon?();  ruleset.set_logic  _parse_block()
        else
          raise parse_error("'#{@value}': unexpected token.")
        end
      end
      unless @token
        raise parse_error("'##{name}': is not closed by '}'.", start_linenum)
      end
      assert "@token=#{@token.inspect}" unless @token == '}''}'
      scan()
      return ruleset
    end

[Source]

# File kwartz/parser.rb, line 768
    def parse_import_command
      c = @ch
      c = getch() while is_whitespace(c)
      t = scan_string()
      t == :string  or raise parse_error("@import: requires filename.")
      filename = @value
      test(?f, filename)  or raise parse_error("'#{filename}': import file not found.")
      c = @ch
      c = getch() while is_whitespace(c)
      c == ?; or raise parse_error("';' required.")
      c = getch()
      scan()
      parser = self.class.new(@properties)
      ruleset_list = parser.parse(File.read(filename), filename)
      return ruleset_list
    end

[Source]

# File kwartz/parser.rb, line 630
    def scan_hook
      ## comment
      c = @ch
      if c == ?/
        c = getch()
        if c == ?/      # line comment
          scan_line()
          getch()
          return scan()
        elsif c == ?*   # region comment
          start_linenum = @linenum
          while true
            c = getch() while c != ?*
            break if c == nil
            c = getch()
            break if c == ?/
          end
          if c == nil
            @error = :comment_unclosed
            @value = start_linenum
            return @token == :error
          end
          getch()
          return scan()
        else
          @value = '/'
          return @token = ?/
        end #if
      end #if

      ## '#mark'
      if c == ?#
        c = getch()
        unless is_alpha(c)
          @error = :invalid_char
          @value = '#'
          return @token = :error
        end
        @value = '#'
        return @token = ?#
      end #if

      ## '@import "foo.plogic"'
      if c == ?@
        @value = '@'
        return @token = ?@
      end

      return nil

    end

[Validate]