Class: Kwartz::Handler

Inherits:
Object
  • Object
show all
Includes:
Assertion, ConverterHelper, ElementExpander, StatementHelper
Defined in:
lib/kwartz/converter.rb

Overview

(abstract) handle directives

Direct Known Subclasses

EperlHandler, JstlHandler, PhpHandler, RubyHandler

Constant Summary collapse

@@class_table = 
{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ElementExpander

#expand_element_info, #expand_statement

Methods included from Assertion

assert

Methods included from StatementHelper

#add_foreach_stmts, #add_native_code, #add_native_expr_with_default, #build_print_args, #build_print_expr_stmt, #build_print_stmt, #create_text_print_stmt, #etag_stmt, #stag_stmt, #wrap_content_with_native_stmt, #wrap_element_with_native_stmt

Methods included from ConverterHelper

#_last_stmt_kind, #convert_error, #error_if_empty_tag, #error_when_last_stmt_is_not_if, #include_properties

Constructor Details

#initialize(elem_rulesets = [], properties = {}) ⇒ Handler

Returns a new instance of Handler.



583
584
585
586
587
588
589
590
591
592
 
# File 'lib/kwartz/converter.rb', line 583

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

Instance Attribute Details

#converter ⇒ Object

Returns the value of attribute converter.



594
595
596
 
# File 'lib/kwartz/converter.rb', line 594

def converter
  @converter
end

#even ⇒ Object (readonly)

Returns the value of attribute even.



593
594
595
 
# File 'lib/kwartz/converter.rb', line 593

def even
  @even
end

#filename ⇒ Object

Returns the value of attribute filename.



594
595
596
 
# File 'lib/kwartz/converter.rb', line 594

def filename
  @filename
end

#odd ⇒ Object (readonly)

Returns the value of attribute odd.



593
594
595
 
# File 'lib/kwartz/converter.rb', line 593

def odd
  @odd
end

Class Method Details

.get_class(lang) ⇒ Object 



799
800
801
 
# File 'lib/kwartz/converter.rb', line 799

def self.get_class(lang)
  return @@class_table[lang]
end

.register_class(lang, klass) ⇒ Object 



794
795
796
 
# File 'lib/kwartz/converter.rb', line 794

def self.register_class(lang, klass)
  @@class_table[lang] = klass
end

Instance Method Details

#_elem_info_table ⇒ Object

:nodoc:



607
608
609
 
# File 'lib/kwartz/converter.rb', line 607

def _elem_info_table    # :nodoc:
  return @elem_info_table
end

#_import_element_info_from_handler(handler, names = nil) ⇒ Object

:nodoc:



612
613
614
615
616
617
618
619
620
621
622
623
 
# File 'lib/kwartz/converter.rb', line 612

def _import_element_info_from_handler(handler, names=nil) # :nodoc:
  if names
    regexp_list = names.collect { |name| Kwartz::Util.pattern_to_regexp(name) }
    handler._elem_info_table.each do |name, elem_info|
      if regexp_list.any? { |regexp| regexp =~ name }
        @elem_info_table[name] = elem_info
      end
    end
  else
    @elem_info_table.update(handler._elem_info_table)
  end
end

#extract(elem_name, content_only = false) ⇒ Object 



781
782
783
784
785
786
787
788
 
# File 'lib/kwartz/converter.rb', line 781

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

#get_element_info(name) ⇒ Object

for ElementExpander module



602
603
604
 
# File 'lib/kwartz/converter.rb', line 602

def get_element_info(name)  # for ElementExpander module
  return @elem_info_table[name]
end

#get_element_ruleset(name) ⇒ Object

for ElementExpander module and Converter class



597
598
599
 
# File 'lib/kwartz/converter.rb', line 597

def get_element_ruleset(name)  # for ElementExpander module and Converter class
  return @elem_ruleset_table[name]
end

#handle(stmt_list, handler_arg) ⇒ Object

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

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



657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
 
# File 'lib/kwartz/converter.rb', line 657

def handle(stmt_list, handler_arg)
  arg = handler_arg
  d_name = arg.directive_name
  d_arg  = arg.directive_arg
  d_str  = arg.directive_str

  case d_name

  when nil
    assert unless !arg.attr_info.empty? || !arg.append_exprs.empty?
    stmt_list << stag_stmt(arg)
    stmt_list.concat(arg.cont_stmts)
    stmt_list << etag_stmt(arg) if arg.etag_info   # when empty-tag

  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.", arg.stag_info.linenum)
    end
    name = $1
    elem_info = ElementInfo.new(name, arg.stag_info, arg.etag_info, arg.cont_stmts,
                                arg.attr_info, arg.append_exprs)
    if @elem_info_table[name]
      #unless Config::ALLOW_DUPLICATE_ID
        previous_linenum = @elem_info_table[name].stag_info.linenum
        msg = "'#{d_str}': id '#{name}' is already used at line #{previous_linenum}."
        raise convert_error(msg, arg.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(arg)
    flag_escape = d_name == :stag ? nil : (d_name == :Stag)
    expr = NativeExpression.new(d_arg, flag_escape)
    stmt_list << build_print_expr_stmt(expr, arg.stag_info, nil)
    stmt_list.concat(arg.cont_stmts)
    stmt_list << etag_stmt(arg)

  when :etag, :Etag, :ETAG
    error_if_empty_tag(arg)
    flag_escape = d_name == :etag ? nil : (d_name == :Etag)
    expr = NativeExpression.new(d_arg, flag_escape)
    stmt_list << stag_stmt(arg)
    stmt_list.concat(arg.cont_stmts)
    stmt_list << build_print_expr_stmt(expr, nil, arg.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, arg.stag_info, arg.etag_info)

  when :cont, :Cont, :CONT, :value, :Value, :VALUE
    error_if_empty_tag(arg)
    arg.stag_info.tail_space = arg.etag_info.head_space = nil    # delete spaces
    pargs = build_print_args(arg.stag_info, arg.attr_info, arg.append_exprs)
    flag_escape = (d_name == :cont || d_name == :value) ? nil : (d_name == :Cont || d_name == :Value)
    pargs << NativeExpression.new(d_arg, flag_escape)
    pargs << arg.etag_info.tag_text if arg.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.", arg.stag_info.linenum)
    end
    aname = $1;  avalue = $2
    flag_escape = d_name == :attr ? nil : (d_name == :Attr)
    arg.attr_info[aname] = NativeExpression.new(avalue, flag_escape)

  when :append, :Append, :APPEND
    flag_escape = d_name == :append ? nil : (d_name == :Append)
    arg.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(arg)   if replace_cont
    stmt_list << stag_stmt(arg) 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.", arg.stag_info.linenum)
    end
    expand_element_info(elem_info, stmt_list, with_content)
    stmt_list << etag_stmt(arg) 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(arg) if replace_cont
    stmt_list << stag_stmt(arg) if replace_cont
    #stmt_list << ExpandStatement.new(:element, name)
    elem_info = @elem_info_table[name]
    unless elem_info
      msg = "'#{d_str}': element '#{name}' not found."
      raise convert_error(msg, arg.stag_info.linenum)
    end
    expand_element_info(elem_info, stmt_list, with_content)
    stmt_list << etag_stmt(arg) if replace_cont

  else
    return false
  end #case

  return true

end