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

(abstract) handle directives

Methods

Included Modules

Assertion ConvertErrorHelper HandlerHelper Expander

Attributes

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

Public Class methods

[Source]

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

[Source]

# File kwartz/converter.rb, line 629
    def initialize(rulesets=[], properties={})
      @ruleset_table = {}
      rulesets.each { |ruleset| _register_ruleset(ruleset) }
      @elem_info_table = {}
      @delspan = properties.fetch(:delspan, Config::PROPERTY_DELSPAN)  # delete dummy <span> tag or not
      @odd     = properties.fetch(:odd,     Config::PROPERTY_ODD)      # "'odd'"
      @even    = properties.fetch(:even,    Config::PROPERTY_EVEN)     # "'even'"
    end

[Source]

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

Public Instance methods

[Source]

# File kwartz/converter.rb, line 900
    def apply_rulesets(elem_info)
      assert unless !elem_info.applied
      elem_info.applied = true
      tagname = elem_info.stag_info.tagname
      classname = elem_info.attr_info['class']
      #idname = elem_info.name || elem_info.attr_info['id']
      ruleset = nil
      elem_info.apply(ruleset) if ruleset = get_ruleset(tagname)
      elem_info.apply(ruleset) if classname && (ruleset = get_ruleset('.'+classname))
      #elem_info.apply(ruleset) if idname && (ruleset = get_ruleset('#'+idname))
    end

[Source]

# File kwartz/converter.rb, line 913
    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 655
    def get_element_info(name)  # for Expander module
      return @elem_info_table[name]
    end

[Source]

# File kwartz/converter.rb, line 650
    def get_ruleset(selector)  # for Expander module and Converter class
      return @ruleset_table[selector]
    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 772
    def handle(directive, elem_info, stmt_list)
      d_name = directive.name
      d_arg  = directive.arg
      d_str  = directive.str
      d_attr = directive.dattr
      e = elem_info
      linenum = e.stag_info.linenum

      case d_name

      when nil
        assert false

      when :dummy
        # nothing

      when :id, :mark
        unless d_arg =~ /\A([-\w]+)\z/ || d_arg =~ /\A'([-\w]+)'\z/
          raise convert_error("'#{d_str}': invalid marking name.", linenum)
        end
        name = $1
        if get_element_info(name)
          unless Config::ALLOW_DUPLICATE_ID
            previous_linenum = get_element_info(name).stag_info.linenum
            msg = "'#{d_str}': id '#{name}' is already used at line #{previous_linenum}."
            raise convert_error(msg, linenum)
          end
        end
        ruleset = get_ruleset('#' + name)
        elem_info.apply(ruleset) if ruleset
        register_element_info(name, elem_info)
        #stmt_list << ExpandStatement.new(:element, name)     # lazy expantion
        expand_element_info(elem_info, stmt_list)

      when :stag, :Stag, :STAG
        error_if_empty_tag(elem_info, d_str)
        flag_escape = d_name == :stag ? nil : (d_name == :Stag)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << build_print_expr_stmt(expr, e.stag_info, nil)
        stmt_list.concat(e.cont_stmts)
        stmt_list << etag_stmt(elem_info)

      when :etag, :Etag, :ETAG
        error_if_empty_tag(elem_info, d_str)
        flag_escape = d_name == :etag ? nil : (d_name == :Etag)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << stag_stmt(elem_info)
        stmt_list.concat(e.cont_stmts)
        stmt_list << build_print_expr_stmt(expr, nil, e.etag_info)

      when :elem, :Elem, :ELEM
        flag_escape = d_name == :elem ? nil : (d_name == :Elem)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        expr = NativeExpression.new(expr_str, flag_escape)
        stmt_list << build_print_expr_stmt(expr, e.stag_info, e.etag_info)

      when :cont, :Cont, :CONT, :value, :Value, :VALUE
        error_if_empty_tag(elem_info, directive.str)
        e.stag_info.tail_space = e.etag_info.head_space = nil    # delete spaces
        pargs = build_print_args(e.stag_info, e.attr_info, e.append_exprs)
        flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        pargs << NativeExpression.new(expr_str, flag_escape)
        pargs << e.etag_info.tag_text if e.etag_info.tagname
        stmt_list << PrintStatement.new(pargs)

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

      when :append, :Append, :APPEND
        flag_escape = d_name == :append ? nil : (d_name == :Append)
        expr_str = d_attr == 'id' ? parse_expr_str(d_arg, linenum) : d_arg
        e.append_exprs << NativeExpression.new(expr_str, 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(elem_info, d_str)   if replace_cont
        stmt_list << stag_stmt(elem_info) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info2 = @elem_info_table[name]
        unless elem_info
          raise convert_error("'#{d_str}': element '#{name}' not found.", linenum)
        end
        expand_element_info(elem_info2, stmt_list, with_content)
        stmt_list << etag_stmt(elem_info) 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.", linenum)
        end
        kind = $1
        name = $2
        replace_cont = d_name == :replace_content_with || d_name == :placeholder
        with_content = kind == 'content'
        #
        error_if_empty_tag(elem_info, d_str) if replace_cont
        stmt_list << stag_stmt(elem_info) if replace_cont
        #stmt_list << ExpandStatement.new(:element, name)
        elem_info2 = @elem_info_table[name]
        unless elem_info2
          msg = "'#{d_str}': element '#{name}' not found."
          raise convert_error(msg, linenum)
        end
        expand_element_info(elem_info2, stmt_list, with_content)
        stmt_list << etag_stmt(elem_info) if replace_cont

      else
        return false
      end #case

      return true

    end

[Source]

# File kwartz/converter.rb, line 710
    def handle_directives(directive, elem_info, stmt_list)
      e = elem_info
      linenum = elem_info.stag_info.linenum
      append_exprs = nil

      if directive.dattr == 'id'
        ## nothing
      else
        ## handle 'attr:' and 'append:' directives
        d_str = nil
        directive.str.split(/;/).each do |d_str|
          d_str.strip!
          unless d_str =~ self.directive_pattern     # ex. /\A(\w+):\s*(.*)\z/
            raise convert_error("'#{d_str}': invalid directive pattern", linenum)
          end
          d_name = $1.intern   # directive name
          d_arg  = $2 || ''    # directive arg
          case d_name
          when :attr, :Attr, :ATTR
            directive2 = Directive.new(:name=>d_name, :arg=>d_arg, :sr=>d_str)
            handle(directive2, elem_info, stmt_list)
          when :append, :Append, :APPEND
            append_exprs ||= []
            elem_info.append_exprs = append_exprs
            directive2 = Directive.new(:name=>d_name, :arg=>d_arg, :sr=>d_str)
            handle(directive2, elem_info, stmt_list)
          else
            if directive.name
              raise convert_error("'#{d_str}': not available with '#{directive.name}' directive.", linenum)
            end
            directive.name = d_name
            directive.arg  = d_arg
            directive.str  = d_str
          end #case
        end
      end

      ## remove dummy <span> tag
      if @delspan && elem_info.dummy_span_tag?('span')
        #e.stag_info.tagname = e.etag_info.tagname = nil
        e.stag_info.clear_as_dummy_tag()
        e.etag_info.clear_as_dummy_tag()
      end

      ## handle other directives
      if directive.name
        handled = handle(directive, elem_info, stmt_list)
        handled or raise convert_error("'#{directive.str}': unknown directive.", linenum)
      else   # for 'attr' and 'append' directive
        assert unless !elem_info.attr_info.empty? || !elem_info.append_exprs.empty?
        stmt_list << stag_stmt(elem_info)
        stmt_list.concat(elem_info.cont_stmts)
        stmt_list << etag_stmt(elem_info) if elem_info.etag_info   # when empty-tag
      end

    end

[Source]

# File kwartz/converter.rb, line 660
    def register_element_info(name, elem_info)
      @elem_info_table[name] = elem_info
    end

Protected Instance methods

(abstract) directive pattern, which is used to detect directives.

[Source]

# File kwartz/converter.rb, line 688
    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 695
    def mapping_pattern
      not_implemented
      #return /\A'([-:\w]+)'\s+(.*)/
    end

(abstract) convert universal expression string to native expression string

[Source]

# File kwartz/converter.rb, line 702
    def parse_expr_str(expr_str, linenum)
      not_implemented
    end

[Validate]