pseudohikiparser 0.0.5 → 0.0.6.develop

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ebc8c1ea077d8299c8d99b805fbed3ddc4f45e4
-  data.tar.gz: 02fc8e556784f1bbbe63c6e2a0bcf369c4b0ec04
+  metadata.gz: 98aa9c74058bd6a6da9f43b9f2c7d73872db41c9
+  data.tar.gz: d921304c72c05629e616d47899b28e09c7fc91ab
 SHA512:
-  metadata.gz: c48347a4e2cd673bbc426c0623255d8a64088d393730a5bdbba4962ca626b5ab8dad09bdb48abc64fd0fd307551d69dac7ae99a053ac7d230406ff9dc94ccc94
-  data.tar.gz: ca8187e15865fd7bd5e9d5def177dcf11f4ce843af06412f79e14b44cfdc649eece0487c7ab3f6397057afa1a2c45165b91153198697b79fceb9c4128f791c63
+  metadata.gz: 4f1a030cee17f773f7f9489270874d462c4d1da7c6fa57b86830910a13018e5ee0757155d97e8e07de503cd2f22237bd515151de3583d187ac62aaf703120d37
+  data.tar.gz: 793b3d2c14b5b36fc6ee964c838f9f630a017c3a78cc7e35ab2457fed631c405487ecf0c489da88fd2a5f3342ebb9425831eebd8bb28293682bfdf2834df8481

data/bin/pseudohiki2html

@@ -7,29 +7,10 @@ options.parse_command_line_options
 
 if $KCODE
   PseudoHiki::OptionManager::ENCODING_REGEXP.each do |pat, encoding|
-    options[:encoding] = encoding if pat =~ $KCODE and not options[:force]
+    options[:encoding] = encoding if pat.match? $KCODE and not options[:force]
   end
 end
 
-unless String.new.respond_to? :encode
-  require 'iconv'
-
-  def choose_input_encoding_using_kcode
-    PseudoHiki::OptionManager::ENCODING_REGEXP.each do |pat, encoding|
-      return PseudoHiki::OptionManager::ENCODING_TO_CHARSET[encoding] if pat =~ $KCODE
-    end
-    HtmlElement::CHARSET::UTF8
-  end
-  private :choose_input_encoding_using_kcode
-
-  def encode(to, from=choose_input_encoding_using_kcode)
-    iconv = Iconv.new(to, from)
-    str = iconv.iconv(self)
-    str << iconv.iconv(nil)
-  end
-  public :encode
-end
-
 PseudoHiki::OptionManager.remove_bom
 input_lines = ARGF.readlines.map {|line| line.encode(options.charset) }
 options.set_options_from_input_file(input_lines)

data/lib/htmlelement/htmltemplate.rb

@@ -23,6 +23,11 @@ class HtmlTemplate
     @title = nil
     @title_element = create_element("title")
     @body = create_element("body")
+    @default_skip_link_labels = {
+      "en" => "Skip to Content",
+      "ja" => "\u{672c}\u{6587}\u{3078}", # honbun he
+      "fr" => "Aller au contenu"
+    }
     @html.push @head
     @html.push @body
     [ @content_language,
@@ -36,7 +41,7 @@ class HtmlTemplate
       @head.push element
     end
   end
-  attr_reader :title, :head
+  attr_reader :title, :head, :body
 
   def create_element(*params)
     ELEMENT[self.class].create(*params)
@@ -70,6 +75,12 @@ class HtmlTemplate
     @default_css_link["href"] = file_path
   end
 
+  def embed_style(css)
+    style = create_element("style", nil, "type" => "text/css")
+    @head.push style
+    style.push format_css(css)
+  end
+
   def title=(title)
     @title_element.pop until @title_element.empty?
     @title = title
@@ -103,6 +114,10 @@ class HtmlTemplate
       @html].join("")
   end
 
+  def add_skip_link(to="contents", from=@body,label=default_skip_link_label)
+    skip_link_container(from).unshift create_element("a", label, "href" => "##{to}")
+  end
+
   private
 
   def create_meta(type, content)
@@ -126,6 +141,23 @@ class HtmlTemplate
     return "" unless base_uri
     create_element("base", nil, "href" => base_uri)
   end
+
+  def format_css(css)
+    ["<!--", css.rstrip, "-->", ""].join($/)
+  end
+
+  def skip_link_container(from)
+    return from unless from == @body
+    create_element("div").tap do |div|
+      div["class"] = "skip-link"
+      @body.unshift div
+    end
+  end
+
+  def default_skip_link_label
+    @default_skip_link_labels[@html["lang"]] ||
+      @default_skip_link_labels["en"]
+  end
 end
 
 class XhtmlTemplate < HtmlTemplate
@@ -141,6 +173,12 @@ class XhtmlTemplate < HtmlTemplate
     super(language)
     @html["xml:lang"] = language
   end
+
+  private
+
+  def format_css(css)
+    css.rstrip + $/
+  end
 end
 
 class Xhtml5Template < XhtmlTemplate

data/lib/htmlelement.rb

@@ -123,7 +123,21 @@ class HtmlElement
   end
 
   def pop
-    @children.pop
+    last_child = @children.pop
+    last_child.parent = nil if last_child.kind_of? HtmlElement
+    last_child
+  end
+
+  def unshift(child)
+    @children.unshift child
+    child.parent = self if child.kind_of? HtmlElement
+    self
+  end
+
+  def shift
+    first_child = @children.shift
+    first_child.parent = nil if first_child.kind_of? HtmlElement
+    first_child
   end
 
   def []=(attribute, value)

data/lib/pseudohiki/autolink.rb

@@ -47,7 +47,7 @@ module PseudoHiki
       end
 
       def link_wiki_name(line)
-        return line if WIKI_NAME_RE !~ line or VERBATIM_LEAF_HEAD_RE =~ line
+        return line if not WIKI_NAME_RE.match? line or VERBATIM_LEAF_HEAD_RE.match? line
         line.gsub(WIKI_NAME_RE) {|url| in_link_tag?($`) ? url : add_tag(url) }
       end
 

data/lib/pseudohiki/blockparser.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+require 'pseudohiki/shim'
 require 'pseudohiki/treestack'
 require 'pseudohiki/inlineparser'
 
@@ -38,14 +39,21 @@ module PseudoHiki
     end
 
     class BlockStack < TreeStack
-      def pop
-        current_node.parse_leafs
-        super
+      attr_reader :stack
+
+      def pop_with_breaker(breaker=nil)
+        current_node.parse_leafs(breaker)
+        pop
+      end
+
+      def current_heading_level
+        i = @stack.rindex {|node| node.kind_of? BlockElement::HeadingNode }
+        @stack[i].level || 0
       end
     end
 
     class BlockLeaf < BlockStack::Leaf
-      attr_accessor :level, :node_id
+      attr_accessor :level, :node_id, :decorator
 
       class << self
         attr_accessor :head_re
@@ -81,7 +89,7 @@ module PseudoHiki
         super(stack)
       end
 
-      def parse_leafs
+      def parse_leafs(breaker)
         parsed = InlineParser.parse(join)
         clear
         concat(parsed)
@@ -131,6 +139,10 @@ module PseudoHiki
         first.level if first # @cached_level ||= (first.level if first)
       end
 
+      def decorator
+        first.decorator if first
+      end
+
       def push_self(stack)
         @stack = stack
         super(stack)
@@ -140,24 +152,24 @@ module PseudoHiki
         not (kind_of? breaker.block and level == breaker.level)
       end
 
-      def parse_leafs; end
+      def parse_leafs(breaker); end
 
       def add_leaf(line, blockparser)
         leaf = create_leaf(line, blockparser)
-        blockparser.stack.pop while blockparser.breakable?(leaf)
+        blockparser.stack.pop_with_breaker(leaf) while blockparser.breakable?(leaf)
         blockparser.stack.push leaf
       end
 
       def create_leaf(line, blockparser)
-        return BlockElement::VerbatimLeaf.create("".freeze, true) if VERBATIM_BEGIN =~ line
+        return BlockElement::VerbatimLeaf.create("".freeze, true) if VERBATIM_BEGIN.match? line
         line = blockparser.auto_linker.link(line)
         blockparser.select_leaf_type(line).create(line)
       end
     end
 
     class NonNestedBlockNode < BlockNode
-      def parse_leafs
-        each {|leaf| leaf.parse_leafs }
+      def parse_leafs(breaker)
+        each {|leaf| leaf.parse_leafs(breaker) }
       end
     end
 
@@ -175,13 +187,15 @@ module PseudoHiki
       end
     end
 
+    class UnmatchedSectioningTagError < StandardError; end
+
     module BlockElement
       {
-        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf),
+        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf DecoratorLeaf SectioningNodeEnd),
         NonNestedBlockLeaf => %w(QuoteLeaf ParagraphLeaf),
         NestedBlockLeaf => %w(HeadingLeaf),
         ListTypeLeaf => %w(ListLeaf EnumLeaf),
-        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode),
+        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode DecoratorNode SectioningNode),
         NonNestedBlockNode => %w(QuoteNode ParagraphNode),
         NestedBlockNode => %w(HeadingNode),
         ListTypeBlockNode => %w(ListNode EnumNode),
@@ -204,15 +218,100 @@ module PseudoHiki
         attr_accessor :in_block_tag
 
         def add_leaf(line, blockparser)
-          return @stack.pop if VERBATIM_END =~ line
+          return @stack.pop_with_breaker if VERBATIM_END.match? line
           return super(line, blockparser) unless @in_block_tag
-          line = " #{line}" if BlockNodeEnd.head_re =~ line and not @in_block_tag
+          line = " #{line}" if BlockNodeEnd.head_re.match? line and not @in_block_tag
           @stack.push VerbatimLeaf.create(line, @in_block_tag)
         end
       end
 
+      class DecoratorNode
+        DECORATOR_PAT = /\A(?:([^\[\]:]+))?(?:\[([^\[\]]+)\])?(?::\s*(\S.*))?/o
+        LABEL_SEP = [":"]
+
+        class DecoratorItem < Struct.new(:string, :type, :id, :value)
+          def self.create(leaf)
+            m = DECORATOR_PAT.match(leaf.join)
+            return nil unless m
+            args = m.to_a
+            if i = leaf.index(LABEL_SEP)
+              value = leaf.dup
+              value.shift(i + 1)
+              args[-1] = lstrip_value!(value)
+            end
+            self.new(*args)
+          end
+
+          def self.lstrip_value!(value)
+            head_val = value[0][0]
+            if head_val.kind_of? String and head_val.start_with? " ".freeze
+              value[0][0] = head_val.lstrip
+            end
+            value
+          end
+        end
+
+        def parse_leafs(breaker)
+          decorator = {}
+          breaker.decorator = decorator
+          @stack.remove_current_node.each do |leaf|
+            if item = DecoratorItem.create(leaf)
+              decorator[item.type || :id] = item
+            end
+          end
+        end
+
+        def breakable?(breaker)
+          return super if breaker.kind_of? DecoratorLeaf
+          parse_leafs(breaker)
+          @stack.current_node.breakable?(breaker)
+        end
+      end
+
+      class DecoratorLeaf
+        def push_sectioning_node(stack, node_class)
+          node = node_class.new
+          m = DecoratorNode::DECORATOR_PAT.match(join)
+          node.node_id = m[2]
+          node.section_level = stack.current_heading_level if node.kind_of? SectioningNode
+          stack.push(node)
+        end
+
+        def push_self(stack)
+          decorator_type = self[0][0]
+          if decorator_type.start_with? "begin[".freeze
+            push_sectioning_node(stack, SectioningNode)
+          elsif decorator_type.start_with? "end[".freeze
+            push_sectioning_node(stack, SectioningNodeEnd)
+          else
+            super
+          end
+        end
+      end
+
+      class SectioningNode
+        attr_accessor :section_level
+
+        def breakable?(breaker)
+          breaker.kind_of? HeadingLeaf and @section_level >= breaker.level
+        end
+      end
+
+      class SectioningNodeEnd
+        def push_self(stack)
+          n = stack.stack.rindex do |node|
+            node.kind_of? SectioningNode and node.node_id == node_id
+          end
+          raise UnmatchedSectioningTagError unless n
+          stack.pop until stack.stack.length == n
+        rescue UnmatchedSectioningTagError => e
+          STDERR.puts "#{e}: The start tag for '#{node_id}' is not found."
+          # FIXME: The handling of this error should be changed appropriately.
+        end
+      end
+
       class QuoteNode
-        def parse_leafs
+        def parse_leafs(breaker)
           self[0] = BlockParser.parse(self[0], AutoLink::Off)
         end
       end
@@ -273,7 +372,8 @@ module PseudoHiki
      [HrLeaf, HrNode],
      [ListLeaf, ListNode],
      [EnumLeaf, EnumNode],
-     [BlockNodeEnd, BlockNodeEnd] # special case
+     [BlockNodeEnd, BlockNodeEnd], # special case
+     [DecoratorLeaf, DecoratorNode]
     ].each do |leaf, node|
       PARENT_NODE[leaf] = node
     end
@@ -286,6 +386,7 @@ module PseudoHiki
                           ['!', HeadingLeaf],
                           ['""', QuoteLeaf],
                           ['||', TableLeaf],
+                          ['//@', DecoratorLeaf],
                           ['//', CommentOutLeaf],
                           ['----\s*$', HrLeaf]]
 
@@ -331,7 +432,7 @@ module PseudoHiki
     def read_lines(lines)
       each_line = lines.respond_to?(:each_line) ? :each_line : :each
       lines.send(each_line) {|line| @stack.current_node.add_leaf(line, self) }
-      @stack.pop
+      @stack.pop_with_breaker
     end
   end
 
@@ -356,7 +457,7 @@ module PseudoHiki
       end
 
       def self.link(line)
-        return line unless URI_RE =~ line and VERBATIM_LEAF_HEAD_RE !~ line
+        return line unless URI_RE.match? line and not VERBATIM_LEAF_HEAD_RE.match? line
         line.gsub(URI_RE) {|url| in_link_tag?($`) ? url : "[[#{url}]]" }
       end
 

data/lib/pseudohiki/converter.rb

@@ -29,8 +29,6 @@ module PseudoHiki
         @options.formatter.format(tree)
       end
 
-      def create_style(path_to_css_file); "".freeze; end
-
       private
 
       def toc_item_pat?(node)
@@ -87,15 +85,6 @@ module PseudoHiki
         end
       end
 
-      def create_style(path_to_css_file)
-        style = formatter.create_element("style").tap do |element|
-          element["type"] = "text/css"
-          open(File.expand_path(path_to_css_file)) do |css_file|
-            element.push css_file.read
-          end
-        end
-      end
-
       private
 
       def setup_link_manager(options)
@@ -200,7 +189,7 @@ module PseudoHiki
 
     def split_main_heading(input_lines)
       return "" unless @options[:split_main_heading]
-      h1_pos = input_lines.find_index {|line| /^![^!]/o =~ line }
+      h1_pos = input_lines.find_index {|line| /^![^!]/o.match? line }
       return "" unless h1_pos
       tree = BlockParser.parse([input_lines.delete_at(h1_pos)])
       @options.formatter.format(tree)
@@ -223,8 +212,9 @@ module PseudoHiki
       else
         html = @options.create_html_template_with_current_options
         embed_css = @options[:embed_css]
-        html.head.push @composer.create_style(embed_css) if embed_css
+        html.embed_style(File.read(File.expand_path(embed_css))) if embed_css
         html.push main || body
+        html.add_skip_link if html.kind_of?(HtmlTemplate) and main
       end
 
       html
@@ -313,7 +303,7 @@ module PseudoHiki
     end
 
     def win32?
-      true if RUBY_PLATFORM =~ /win/i
+      true if RUBY_PLATFORM.match? /win/i
     end
 
     def value_given?(value)
@@ -334,9 +324,9 @@ module PseudoHiki
 
     def base
       base_dir = self[:base]
-      if base_dir and base_dir !~ /[\/\\]\.*$/o
+      if base_dir and not /[\/\\]\.*$/o.match? base_dir
         base_dir = File.join(base_dir, ".")
-        base_dir = "file:///" + base_dir if base_dir !~ /^\./o and win32?
+        base_dir = "file:///" + base_dir if not /^\./o.match? base_dir and win32?
       end
       base_dir
     end
@@ -354,7 +344,7 @@ module PseudoHiki
         if v.version == version
           return self[:html_version] = v
         else
-          self[:html_version] = v if v.opt_pat =~ version
+          self[:html_version] = v if v.opt_pat.match? version
         end
       end
       STDERR.puts "\"#{version}\" is an invalid option for --format-version. \
@@ -366,7 +356,7 @@ module PseudoHiki
         self[:encoding] = given_opt
       else
         ENCODING_REGEXP.each do |pat, encoding|
-          self[:encoding] = encoding if pat =~ given_opt
+          self[:encoding] = encoding if pat.match? given_opt
         end
         STDERR.puts "\"#{self[:encoding]}\" is chosen as an encoding system, \
 instead of \"#{given_opt}\"."
@@ -513,7 +503,7 @@ inside (default: not specified)") do |template|
 
     def set_options_from_input_file(input_lines)
       input_lines.each do |line|
-        break if FILE_HEADER_PAT !~ line
+        break unless FILE_HEADER_PAT.match? line
         line = line.chomp
         @options.keys.each do |opt|
           next if self[opt] and self[:force]

data/lib/pseudohiki/htmlformat.rb

@@ -50,12 +50,12 @@ module PseudoHiki
       { :auto_link_in_verbatim => @auto_link_in_verbatim }
     end
 
-    def self.format(tree, options=nil)
+    def self.format(tree, options=nil, memo=nil)
       cur_auto_link_setting = @auto_link_in_verbatim
       options = default_options unless options
       @auto_link_in_verbatim = options[:auto_link_in_verbatim]
       formatter = get_plain
-      tree.accept(formatter)
+      tree.accept(formatter, memo)
     ensure
       @auto_link_in_verbatim = cur_auto_link_setting
     end
@@ -67,18 +67,19 @@ module PseudoHiki
       @format_class = self.class
     end
 
-    def visited_result(element)
+    def visited_result(element, memo)
       visitor = @formatter[element.class] || @formatter[PlainNode]
-      element.accept(visitor)
+      element.accept(visitor, memo)
     end
 
-    def push_visited_results(element, tree)
-      tree.each {|token| element.push visited_result(token) }
+    def push_visited_results(element, tree, memo)
+      tree.each {|token| element.push visited_result(token, memo) }
     end
 
-    def visit(tree)
+    def visit(tree, memo)
       htmlelement = create_element(tree)
-      push_visited_results(htmlelement, tree)
+      decorate(htmlelement, tree)
+      push_visited_results(htmlelement, tree, memo)
       htmlelement
     end
 
@@ -96,6 +97,21 @@ module PseudoHiki
       chunks.push tree
     end
 
+    def decorate(htmlelement, tree)
+      each_decorator(htmlelement, tree) do |elm, decorator|
+        elm[CLASS] = HtmlElement.escape(decorator[CLASS].id) if decorator[CLASS]
+        if id_item = decorator[ID] || decorator[:id]
+          elm[ID] = HtmlElement.escape(id_item.id).upcase
+        end
+      end
+    end
+
+    def each_decorator(element, tree)
+      return unless element.kind_of? HtmlElement
+      return unless tree.kind_of? BlockParser::BlockNode and tree.decorator
+      tree.decorator.tap {|decorator| yield element, decorator }
+    end
+
     class ListLeafNodeFormatter < self
       def create_element(tree)
         super(tree).tap do |elm|
@@ -121,6 +137,7 @@ module PseudoHiki
      [EnumNode, "ol"],
      [TableLeaf, "tr"],
      [VerbatimNode, "pre"],
+     [SectioningNode, "section"],
      [CommentOutNode, nil],
      [HeadingNode, "section"],
      [DescLeaf, DT],
@@ -137,8 +154,8 @@ module PseudoHiki
     # for InlineParser
 
     class << Formatter[PluginNode]
-      def visit(tree)
-        escape_inline_tags(tree) { super(tree) }
+      def visit(tree, memo)
+        escape_inline_tags(tree) { super(tree, memo) }
       end
 
       def escape_inline_tags(tree)
@@ -150,10 +167,10 @@ module PseudoHiki
     end
 
     class << Formatter[LinkNode]
-      def visit(tree)
+      def visit(tree, memo)
         not_from_thumbnail = tree.first.class != LinkNode
-        caption, ref = caption_and_ref(tree)
-        if IMAGE_SUFFIX_RE =~ ref and not_from_thumbnail
+        caption, ref = caption_and_ref(tree, memo)
+        if IMAGE_SUFFIX_RE.match? ref and not_from_thumbnail
           htmlelement = ImgFormat.create_element
           htmlelement[SRC] = ref
           htmlelement[ALT] = caption.join if caption
@@ -165,9 +182,9 @@ module PseudoHiki
         htmlelement
       end
 
-      def caption_and_ref(tree)
+      def caption_and_ref(tree, memo)
         caption, ref = split_into_parts(tree, LinkSep)
-        caption = ref ? caption.map {|token| visited_result(token) } : nil
+        caption = ref ? caption.map {|token| visited_result(token, memo) } : nil
         return caption, (ref || tree).join
       rescue NoMethodError
         raise NoMethodError unless (ref || tree).empty?
@@ -176,7 +193,7 @@ module PseudoHiki
     end
 
     class << Formatter[InlineLeaf]
-      def visit(leaf)
+      def visit(leaf, memo)
         @generator.escape(leaf.first)
       end
     end
@@ -189,8 +206,25 @@ module PseudoHiki
 
     # for BlockParser
 
+    class << Formatter[TableNode]
+      def decorate(htmlelement, tree, memo=nil)
+        each_decorator(htmlelement, tree) do |elm, decorator|
+          visited_value(decorator["summary"], memo) do |summary|
+            htmlelement["summary"] = HtmlElement.escape(summary.join.chomp)
+          end
+          visited_value(decorator["caption"], memo) do |caption|
+            htmlelement.push @generator.create("caption", caption)
+          end
+        end
+      end
+
+      def visited_value(decorator_item, memo)
+        yield visited_result(decorator_item.value, memo) if decorator_item
+      end
+    end
+
     class << Formatter[VerbatimNode]
-      def visit(tree)
+      def visit(tree, memo)
         contents = add_link(@generator.escape(tree.join))
         create_element.tap {|elm| elm.push contents }
       end
@@ -203,8 +237,39 @@ module PseudoHiki
       end
     end
 
+    class << Formatter[SectioningNode]
+      ID_MARK = "#"
+
+      alias :orig_create_element :create_element
+
+      def section_with_id(tree, node_id)
+        orig_create_element(tree).tap do |elm|
+          elm[ID] = node_id[1..-1] # remove the first charactor from node_id
+        end
+      end
+
+      def section_for_class(tree, node_id)
+        if HtmlElement::HTML5_TAGS.include? node_id
+          @generator.create(node_id)
+        else
+          orig_create_element(tree).tap do |elm|
+            elm[CLASS] = elm[CLASS] ? "#{elm[CLASS]} #{node_id}" : node_id
+          end
+        end
+      end
+
+      def create_element(tree)
+        node_id = tree.node_id
+        if node_id.start_with? ID_MARK
+          section_with_id(tree, node_id)
+        else
+          section_for_class(tree, node_id)
+        end
+      end
+    end
+
     class << Formatter[CommentOutNode]
-      def visit(tree); BLANK; end
+      def visit(tree, memo); BLANK; end
     end
 
     class << Formatter[HeadingNode]
@@ -218,14 +283,14 @@ module PseudoHiki
     end
 
     class << Formatter[DescLeaf]
-      def visit(tree)
+      def visit(tree, memo)
         elm = @generator::Children.new
         dt_part, dd_part = split_into_parts(tree, DescSep)
-        dt = super(dt_part)
+        dt = super(dt_part, memo)
         elm.push dt
         unless dd_part.nil? or dd_part.empty?
           dd = @generator.create(DD)
-          push_visited_results(dd, dd_part)
+          push_visited_results(dd, dd_part, memo)
           elm.push dd
         end
         elm
@@ -233,9 +298,9 @@ module PseudoHiki
     end
 
     class << Formatter[TableCellNode]
-      def visit(tree)
+      def visit(tree, memo)
         @element_name = tree.cell_type
-        super(tree).tap do |elm|
+        super(tree, memo).tap do |elm|
           elm[ROWSPAN] = tree.rowspan if tree.rowspan > 1
           elm[COLSPAN] = tree.colspan if tree.colspan > 1
           # elm.push "&#160;" if elm.empty? # &#160; = &nbsp; this line would be necessary for HTML 4 or XHTML 1.0