Class | Kwartz::Handler |
In: |
kwartz/converter.rb
|
Parent: | Object |
(abstract) handle directives
even | [R] | |
filename | [RW] | |
odd | [R] |
# 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
# File kwartz/converter.rb, line 926 def self.register_class(lang, klass) @@class_table[lang] = klass end
# 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
# 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
# File kwartz/converter.rb, line 655 def get_element_info(name) # for Expander module return @elem_info_table[name] end
# 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.
# 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
# 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
# File kwartz/converter.rb, line 660 def register_element_info(name, elem_info) @elem_info_table[name] = elem_info end
(abstract) directive pattern, which is used to detect directives.
# 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.
# File kwartz/converter.rb, line 695 def mapping_pattern not_implemented #return /\A'([-:\w]+)'\s+(.*)/ end