Class Kwartz::Handler
In: kwartz/converter.rb
Parent: Object

.[abstract] handle directives

Methods

Included Modules

Assertion ConverterHelper ElementExpander

Attributes

converter  [RW] 
even  [R] 
filename  [RW] 
odd  [R] 

Public Class methods

[Source]

# File kwartz/converter.rb, line 641
    def self.get_class(lang)
      return @@class_table[lang]
    end

[Source]

# File kwartz/converter.rb, line 448
    def initialize(elem_rulesets=[], properties={})
      @elem_rulesets = elem_rulesets
      #@elem_ruleset_table = elem_rulesets.inject({}) { |table, ruleset| table[ruleset.name] = ruleset; table }
      @elem_ruleset_table = {} ; elem_rulesets.each { |ruleset| @elem_ruleset_table[ruleset.name] = ruleset }
      @elem_info_table = {}
      include_properties(properties)     # @delspan and @dattr
      @odd  = properties[:odd]     || Config::PROPERTY_ODD      # "'odd'"
      @even = properties[:even]    || Config::PROPERTY_EVEN     # "'even'"
      @filename = nil
    end

[Source]

# File kwartz/converter.rb, line 636
    def self.register_class(lang, klass)
      @@class_table[lang] = klass
    end

Public Instance methods

[Source]

# File kwartz/converter.rb, line 623
    def extract(elem_name, content_only=false)
      elem_info = @elem_info_table[elem_name]
      elem_info or raise convert_error("element '#{elem_name}' not found.", nil)
      stmt_list = []
      expand_element_info(elem_info, stmt_list, content_only)
      #stmt_list << build_print_stmt(etag_info, nil, nil)
      return stmt_list
    end

[Source]

# File kwartz/converter.rb, line 467
    def get_element_info(name)  # for ElementExpander module
      @elem_info_table[name]
    end

[Source]

# File kwartz/converter.rb, line 462
    def get_element_ruleset(name)  # for ElementExpander module and Converter class
      @elem_ruleset_table[name]
    end

handle directives (‘stag’, ‘etag’, ‘elem’, ‘cont’(=’value’))

return true if directive name is one of ‘stag’, ‘etag’, ‘elem’, ‘cont’, and ‘value’, else return false.

[Source]

# File kwartz/converter.rb, line 503
    def handle(directive_name, directive_arg, directive_str, stag_info, etag_info, cont_stmts, attr_info, append_exprs, stmt_list)
      d_name = directive_name
      d_arg  = directive_arg
      d_str  = directive_str

      case directive_name

      when nil
        assert unless !attr_info.empty? || !append_exprs.empty?
        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
        stmt_list.concat(cont_stmts)
        stmt_list << build_print_stmt(etag_info, nil, nil) if etag_info   # when empty-tag

      when :dummy
        # nothing

      when :id, :mark
        unless directive_arg =~ /\A(\w+)\z/ || directive_arg =~ /\A'(\w+)'\z/
          raise convert_error("'#{d_str}': invalid marking name.", stag_info.linenum)
        end
        name = $1
        elem_info = ElementInfo.new(name, stag_info, etag_info, cont_stmts, attr_info, append_exprs)
        if @elem_info_table[name]
          #unless Config::ALLOW_DUPLICATE_ID
            previous_linenum = @elem_info_table[name].stag_info.linenum
            raise convert_error("'#{d_str}': id '#{name}' is already used at line #{previous_linenum}.", stag_info.linenum)
          #end
        else
          @elem_info_table[name] = elem_info
        end
        #stmt_list << ExpandStatement.new(:element, name)     # lazy expantion
        expand_element_info(elem_info, stmt_list)

      when :stag, :Stag, :STAG
        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
        flag_escape = d_name == :stag ? nil : (d_name == :Stag)
        expr = NativeExpression.new(d_arg, flag_escape)
        stmt_list << build_print_expr_stmt(expr, stag_info, nil)
        stmt_list.concat(cont_stmts)
        stmt_list << build_print_stmt(etag_info, nil, nil)

      when :etag, :Etag, :ETAG
        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
        flag_escape = d_name == :etag ? nil : (d_name == :Etag)
        expr = NativeExpression.new(d_arg, flag_escape)
        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs)
        stmt_list.concat(cont_stmts)
        stmt_list << build_print_expr_stmt(expr, nil, etag_info)

      when :elem, :Elem, :ELEM
        flag_escape = d_name == :elem ? nil : (d_name == :Elem)
        expr = NativeExpression.new(d_arg, flag_escape)
        stmt_list << build_print_expr_stmt(expr, stag_info, etag_info)

      when :cont, :Cont, :CONT, :value, :Value, :VALUE
        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)
        stag_info.tail_space = etag_info.head_space = nil    # delete spaces
        args = build_print_args(stag_info, attr_info, append_exprs)
        flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
        args << NativeExpression.new(d_arg, flag_escape)
        #args << etag_info.tag_text
        args << etag_info.tag_text if etag_info.tagname
        stmt_list << PrintStatement.new(args)

      when :attr, :Attr, :ATTR
        unless d_arg =~ self.mapping_pattern()     # ex. /\A'([-:\w]+)'\s+(.*)\z/
          raise convert_error("'#{d_str}': invalid attr pattern.", stag_info.linenum)
        end
        aname = $1;  avalue = $2
        flag_escape = d_name == :attr ? nil : (d_name == :Attr)
        attr_info[aname] = NativeExpression.new(avalue, flag_escape)

      when :append, :Append, :APPEND
        flag_escape = d_name == :append ? nil : (d_name == :Append)
        append_exprs << NativeExpression.new(d_arg, flag_escape)

      when :replace_element_with_element, :replace_element_with_content,
           :replace_content_with_element, :replace_content_with_content
        arr = d_name.to_s.split(/_/)
        replace_cont = arr[1] == 'content'
        with_content = arr[3] == 'content'
        name = d_arg
        #
        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)           if replace_cont
        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info = @elem_info_table[name]
        unless elem_info
          raise convert_error("'#{d_str}': element '#{name}' not found.", stag_info.linenum)
        end
        expand_element_info(elem_info, stmt_list, with_content)
        stmt_list << build_print_stmt(etag_info, nil, nil)                if replace_cont

      when :replace_element_with, :replace_content_with, :replace, :placeholder
        unless d_arg =~ /\A_?(element|content)\(["']?(\w+)["']?\)\z/
          raise convert_error("'#{d_str}': invalid #{d_name} format.", stag_info.linenum)
        end
        kind = $1
        name = $2
        replace_cont = d_name == :replace_content_with || d_name == :placeholder
        with_content = kind == 'content'
        #
        error_if_empty_tag(stag_info, etag_info, d_name, d_arg)           if replace_cont
        stmt_list << build_print_stmt(stag_info, attr_info, append_exprs) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info = @elem_info_table[name]
        unless elem_info
          raise convert_error("'#{d_str}': element '#{name}' not found.", stag_info.linenum)
        end
        expand_element_info(elem_info, stmt_list, with_content)
        stmt_list << build_print_stmt(etag_info, nil, nil)                if replace_cont
      else
        return false
      end #case

      return true

    end

Protected Instance methods

.[abstract] directive format, which is used at has_directive?() method

[Source]

# File kwartz/converter.rb, line 490
    def directive_format
      not_implemented
      #return '%s: %s'
    end

.[abstract] directive pattern, which is used to detect directives.

[Source]

# File kwartz/converter.rb, line 476
    def directive_pattern
      not_implemented
      #return /\A(\w+):\s*(.*)/
    end

.[abstract] mapping pattern, which is used to parse ‘attr’ directive.

[Source]

# File kwartz/converter.rb, line 483
    def mapping_pattern
      not_implemented
      #return /\A'([-:\w]+)'\s+(.*)/
    end

[Validate]