pseudohikiparser 0.0.0.12.develop → 0.0.0.13.develop

data/README.md

@@ -312,7 +312,7 @@ paragraph
 
 will be renderes as
 
-```
+```html
 <div class="class_name">
 <h2>A section with a class name
 </h2>

data/bin/pseudohiki2html.rb

@@ -11,6 +11,25 @@ if $KCODE
   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/pseudohiki/blockparser.rb

@@ -6,17 +6,16 @@ require 'pseudohiki/inlineparser'
 module PseudoHiki
   class BlockParser
     URI_RE = /(?:(?:https?|ftp|file):|mailto:)[A-Za-z0-9;\/?:@&=+$,\-_.!~*\'()#%]+/ #borrowed from hikidoc
-    ID_TAG_PAT = /^\[([^\[\]]+)\]/o
+    ID_TAG_PAT = /\A\[([^\[\]]+)\]/o
 
     module LINE_PAT
-      VERBATIM_BEGIN = /\A(<<<\s*)/o
-      VERBATIM_END = /\A(>>>\s*)/o
+      VERBATIM_BEGIN = /\A<<<\s*/o
+      VERBATIM_END = /\A>>>\s*/o
       PLUGIN_BEGIN = /\{\{/o
       PLUGIN_END = /\}\}/o
     end
 
     ParentNode = {}
-    HeadToLeaf = {}
 
     attr_reader :stack
 
@@ -26,7 +25,7 @@ module PseudoHiki
       return unless head.kind_of? String
       if m = ID_TAG_PAT.match(head)
         node.node_id = m[1]
-        leaf[0] = head.sub(ID_TAG_PAT, "")
+        leaf[0] = head.sub(ID_TAG_PAT, "".freeze)
       end
       node
     end
@@ -49,11 +48,11 @@ module PseudoHiki
       attr_accessor :nominal_level, :node_id, :decorator
 
       def self.head_re=(head_regex)
-        @@head_re[self] = head_regex
+        @self_head_re = @@head_re[self] = head_regex
       end
 
       def self.head_re
-        @@head_re[self]
+        @self_head_re
       end
 
       def self.with_depth?
@@ -61,21 +60,16 @@ module PseudoHiki
       end
 
       def self.create(line, inline_parser=InlineParser)
-        line.sub!(self.head_re, "") if self.head_re
+        line = line.sub(self.head_re, "".freeze) if self.head_re
         new.concat(inline_parser.parse(line)) #leaf = self.new
       end
 
-      def self.assign_head_re(head, need_to_escape=true, reg_pat="(%s)")
-        head = Regexp.escape(head) if need_to_escape
-        self.head_re = Regexp.new('\\A'+reg_pat%[head])
-      end
-
       def head_re
-        @@head_re[self.class]
+        @head_re ||= @@head_re[self.class]
       end
 
       def block
-        ParentNode[self.class]
+        @parent_node ||= ParentNode[self.class]
       end
 
       def push_block(stack)
@@ -102,7 +96,7 @@ module PseudoHiki
       include TreeStack::Mergeable
 
       def self.create(line)
-        line.sub!(self.head_re, "") if self.head_re
+        line = line.sub(self.head_re, "".freeze) if self.head_re
         self.new.tap {|leaf| leaf.push line }
       end
 
@@ -117,10 +111,6 @@ module PseudoHiki
     end
 
     class NestedBlockLeaf < BlockLeaf
-      def self.assign_head_re(head, need_to_escape)
-        super(head, need_to_escape, "(%s)+")
-      end
-
       def self.create(line)
         m = self.head_re.match(line)
         super(line).tap {|leaf| leaf.nominal_level = m[0].length }
@@ -142,13 +132,11 @@ module PseudoHiki
       attr_accessor :node_id
 
       def nominal_level
-        return nil unless first
-        first.nominal_level
+        first.nominal_level if first # @cached_nominal_level ||= (first.nominal_level if first)
       end
 
       def decorator
-        return nil unless first
-        first.decorator
+        first.decorator if first
       end
 
       def push_self(stack)
@@ -163,7 +151,7 @@ module PseudoHiki
       def parse_leafs(breaker); end
 
       def in_link_tag?(preceding_str)
-        preceding_str[-2, 2] == "[[" or preceding_str[-1, 1] == "|"
+        preceding_str[-2, 2] == "[[".freeze or preceding_str[-1, 1] == "|".freeze
       end
 
       def tagfy_link(line)
@@ -177,8 +165,8 @@ module PseudoHiki
       end
 
       def create_leaf(line, blockparser)
-        return BlockElement::VerbatimLeaf.create("", true) if LINE_PAT::VERBATIM_BEGIN =~ line
-        line = tagfy_link(line) unless BlockElement::VerbatimLeaf.head_re =~ line
+        return BlockElement::VerbatimLeaf.create("".freeze, true) if LINE_PAT::VERBATIM_BEGIN =~ line
+        line = tagfy_link(line) if URI_RE =~ line and BlockElement::VerbatimLeaf.head_re !~ line
         blockparser.select_leaf_type(line).create(line)
       end
     end
@@ -221,7 +209,13 @@ module PseudoHiki
     include BlockElement
 
     class BlockElement::BlockNodeEnd
+      PARSED_NODE_END = new.concat(InlineParser.parse(""))
+
       def push_self(stack); end
+
+      def self.create(line, inline_parser=InlineParser)
+        PARSED_NODE_END
+      end
     end
 
     class BlockElement::VerbatimNode
@@ -279,7 +273,7 @@ module PseudoHiki
       attr_accessor :in_block_tag
 
       def self.create(line, in_block_tag=nil)
-        line.sub!(self.head_re, "") if self.head_re and not in_block_tag
+        line = line.sub(self.head_re, "".freeze) if self.head_re and not in_block_tag
         self.new.tap do |leaf|
           leaf.push line
           leaf.in_block_tag = in_block_tag
@@ -331,29 +325,30 @@ module PseudoHiki
     ParentNode[BlockNodeEnd] = BlockNodeEnd
 
     def self.assign_head_re
-      space = '\s'
-      head_pats = []
-      [[':', DescLeaf],
-       [space, VerbatimLeaf],
+      irregular_leafs = [BlockNodeEnd, VerbatimLeaf, HrLeaf]
+      head_pats, leaf_types = [], [:entire_matched_part]
+      [['\r?\n?$', BlockNodeEnd],
+       ['//@', DecoratorLeaf],
+       [':', DescLeaf],
+       ['\s', VerbatimLeaf],
        ['""', QuoteLeaf],
        ['||', TableLeaf],
        ['//', CommentOutLeaf],
        ['!', HeadingLeaf],
        ['*', ListLeaf],
-       ['#', EnumLeaf]
+       ['#', EnumLeaf],
+       ['----\s*$', HrLeaf]
       ].each do |head, leaf|
-        HeadToLeaf[head] = leaf
-        escaped_head = head != space ? Regexp.escape(head) : head
-        head_pat = leaf.with_depth? ? "(#{escaped_head})+" : "(#{escaped_head})"
-        head_pats.push head_pat
+        escaped_head = irregular_leafs.include?(leaf) ? head : Regexp.escape(head)
+        head_pat = leaf.with_depth? ? "#{escaped_head}+" : "#{escaped_head}"
         leaf.head_re = Regexp.new('\\A'+head_pat)
+        head_pats.push "(#{escaped_head})"
+        leaf_types.push leaf
       end
-      HrLeaf.head_re = Regexp.new(/\A(----)\s*$/o)
-      BlockNodeEnd.head_re = Regexp.new(/^(\r?\n?)$/o)
-      DecoratorLeaf.head_re = Regexp.new(/^(\/\/@)/o)
-      Regexp.new('\\A('+head_pats.join('|')+')')
+      return Regexp.new('\\A(?:'+head_pats.join('|')+')'), leaf_types, leaf_types.length - 1
     end
-    HEAD_RE = assign_head_re
+
+    LEAF_HEAD_PAT, NOT_PARAGRAPH_LEAF_TYPES, NUMBER_OF_NOT_PARAGRAPH_LEAF_TYPES = assign_head_re
 
     def initialize
       root_node = BlockNode.new
@@ -368,10 +363,9 @@ module PseudoHiki
     end
 
     def select_leaf_type(line)
-      [BlockNodeEnd, HrLeaf, DecoratorLeaf].each {|leaf| return leaf if leaf.head_re =~ line }
-      matched = HEAD_RE.match(line)
-      return HeadToLeaf[matched[0]]||HeadToLeaf[line[0, 1]] || HeadToLeaf['\s'] if matched
-      ParagraphLeaf
+      matched = LEAF_HEAD_PAT.match(line)
+      return ParagraphLeaf unless matched
+      1.upto(NUMBER_OF_NOT_PARAGRAPH_LEAF_TYPES) {|i| return NOT_PARAGRAPH_LEAF_TYPES[i] if matched[i] }
     end
 
     def read_lines(lines)

data/lib/pseudohiki/converter.rb

@@ -7,6 +7,7 @@ require 'pseudohiki/blockparser'
 require 'pseudohiki/htmlformat'
 require 'pseudohiki/plaintextformat'
 require 'pseudohiki/markdownformat'
+require 'pseudohiki/utils'
 require 'htmlelement/htmltemplate'
 require 'htmlelement'
 
@@ -18,6 +19,11 @@ module PseudoHiki
 
     def initialize(options)
       @options = options
+      @is_toc_item_pat = Proc.new do |node|
+        node.kind_of?(PseudoHiki::BlockParser::HeadingLeaf) and
+          (2..3).include? node.nominal_level and
+          node.node_id
+      end
     end
 
     def formatter
@@ -25,25 +31,26 @@ module PseudoHiki
     end
 
     def to_plain(line)
-      PlainFormat.format(BlockParser.parse(line.lines.to_a)).to_s.chomp
+      PlainFormat.format(line).to_s
+    end
+
+    def collect_nodes_for_table_of_contents(tree)
+      Utils::NodeCollector.select(tree) {|node| @is_toc_item_pat.call(node) }
     end
 
-    def create_plain_table_of_contents(lines)
-      toc_lines = lines.grep(HEADING_WITH_ID_PAT).map do |line|
-        m = HEADING_WITH_ID_PAT.match(line)
-        heading_depth = m[1].length
-        line.sub(/^!+/o, '*'*heading_depth)
+    def create_plain_table_of_contents(tree)
+      toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
+        ('*' * toc_node.nominal_level) + to_plain(toc_node)
       end
 
       @options.formatter.format(BlockParser.parse(toc_lines))
     end
 
-    def create_html_table_of_contents(lines)
-      toc_lines = lines.grep(HEADING_WITH_ID_PAT).map do |line|
-        m = HEADING_WITH_ID_PAT.match(line)
-        heading_depth, id = m[1].length, m[2].upcase
-        "%s[[%s|#%s]]"%['*'*heading_depth, to_plain(line.sub(HEADING_WITH_ID_PAT,'')), id]
+    def create_html_table_of_contents(tree)
+      toc_lines = collect_nodes_for_table_of_contents(tree).map do |toc_node|
+        "%s[[%s|#%s]]"%['*'*toc_node.nominal_level, to_plain(toc_node).lstrip, toc_node.node_id.upcase]
       end
+
       @options.formatter.format(BlockParser.parse(toc_lines)).tap do |toc|
         toc.traverse do |element|
           if element.kind_of? HtmlElement and element.tagname == "a"
@@ -53,10 +60,10 @@ module PseudoHiki
       end
     end
 
-    def create_table_of_contents(lines)
+    def create_table_of_contents(tree)
       return "" unless @options[:toc]
-      return create_plain_table_of_contents(lines) unless @options.html_template
-      create_html_table_of_contents(lines)
+      return create_plain_table_of_contents(tree) unless @options.html_template
+      create_html_table_of_contents(tree)
     end
 
     def split_main_heading(input_lines)
@@ -108,18 +115,18 @@ module PseudoHiki
       end
     end
 
-    def compose_body(input_lines)
-      tree = BlockParser.parse(input_lines)
+    def compose_body(tree)
       @options.formatter.format(tree)
     end
 
     def compose_html(input_lines)
       h1 = split_main_heading(input_lines)
       css = @options[:css]
-      toc = create_table_of_contents(input_lines)
-      body = compose_body(input_lines)
+      tree = BlockParser.parse(input_lines)
+      toc = create_table_of_contents(tree)
+      body = compose_body(tree)
       title = @options.title
-      main = create_main(toc,body, h1)
+      main = create_main(toc, body, h1)
 
       if @options[:template]
         erb = ERB.new(@options.read_template_file)

data/lib/pseudohiki/htmlformat.rb

@@ -149,6 +149,7 @@ module PseudoHiki
 
     class << Formatter[LinkNode]
       def visit(tree)
+        not_from_thumbnail = tree.first.class != LinkNode
         tree = tree.dup
         caption = get_caption(tree)
         begin
@@ -157,7 +158,7 @@ module PseudoHiki
           raise NoMethodError unless tree.empty?
           STDERR.puts "No uri is specified for #{caption}"
         end
-        if ImageSuffix =~ ref
+        if ImageSuffix =~ ref and not_from_thumbnail
           htmlelement = ImgFormat.create_self_element
           htmlelement[SRC] = tree.join
           htmlelement[ALT] = caption.join if caption

data/lib/pseudohiki/inlineparser.rb

@@ -14,7 +14,7 @@ module PseudoHiki
   end
 
   def self.compile_token_pat(*token_sets)
-    tokens = token_sets.flatten.uniq.sort do |x,y|
+    tokens = token_sets.flatten.uniq.sort do |x, y|
       [y.length, y] <=> [x.length, x]
     end.collect {|token| Regexp.escape(token) }
     Regexp.new(tokens.join("|"))
@@ -22,7 +22,7 @@ module PseudoHiki
 
   class InlineParser < TreeStack
     module InlineElement
-      class InlineNode < InlineParser::Node;end
+      class InlineNode < InlineParser::Node; end
       class InlineLeaf < InlineParser::Leaf; end
       #  class LinkSepLeaf < InlineLeaf; end
 
@@ -51,11 +51,8 @@ module PseudoHiki
 
     TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys,TAIL.keys,[LinkSep, TableSep, DescSep])
 
-    def token_pat
-      TokenPat[self.class]
-    end
-
     def initialize(str)
+      @token_pat = TokenPat[self.class]
       @tokens = split_into_tokens(str)
       super()
     end
@@ -80,7 +77,7 @@ module PseudoHiki
 
     def split_into_tokens(str)
       tokens = []
-      while m = token_pat.match(str)
+      while m = @token_pat.match(str)
         tokens.push m.pre_match unless m.pre_match.empty?
         tokens.push m[0]
         str = m.post_match

data/lib/pseudohiki/treestack.rb

@@ -18,7 +18,7 @@ class TreeStack
 
   module NodeType
     def push_self(stack)
-      @depth = stack.current_depth + 1
+      @depth = stack.current_node.depth + 1
       stack.push_as_child_node self
       nil
     end
@@ -26,7 +26,7 @@ class TreeStack
 
   module LeafType
     def push_self(stack)
-      @depth = stack.current_depth + 1
+      @depth = stack.current_node.depth + 1
       stack.push_as_leaf self
       self
     end
@@ -59,18 +59,13 @@ class TreeStack
     end
   end
 
-  attr_reader :node_end, :last_leaf
+  attr_reader :node_end, :last_leaf, :current_node
 
   def initialize(root_node=Node.new)
     @stack = [root_node]
+    @current_node = root_node # @stack[-1]
     @node_end = NodeEnd.new
-    def root_node.depth
-      0
-    end
-  end
-
-  def current_node
-    @stack.last
+    root_node.depth = 0
   end
 
   def tree
@@ -83,25 +78,24 @@ class TreeStack
   end
 
   def pop
-    @stack.pop if @stack.length > 1
+    return unless @stack.length > 1
+    @current_node = @stack[-2]
+    @stack.pop
   end
   alias return_to_previous_node pop
 
-  def current_depth
-    @stack.last.depth
-  end
-
   def push_as_child_node(node)
-    @stack.last.push node
+    @current_node.push node
+    @current_node = node
     @stack.push node
   end
   
   def push_as_leaf(node)
-    @stack.last.push node
+    @current_node.push node
   end
 
   def push_as_sibling(sibling_node=nil)
-    sibling_node ||= current_node.class.new
+    sibling_node ||= @current_node.class.new
     pop if sibling_node.kind_of? NodeType
     push(sibling_node)
     sibling_node
@@ -109,7 +103,7 @@ class TreeStack
 
   def remove_current_node
     removed_node = self.pop
-    self.current_node.pop
+    @current_node.pop
     removed_node
   end
 

data/lib/pseudohiki/version.rb

@@ -1,3 +1,3 @@
 module PseudoHiki
-  VERSION = "0.0.0.12.develop"
+  VERSION = "0.0.0.13.develop"
 end

data/lib/pseudohikiparser.rb

@@ -13,9 +13,9 @@ module PseudoHiki
   # This class provides class methods for converting texts written in a Hiki-like notation into HTML or other formats.
   #
   class Format
-    Formatter = {} # :nodoc:
-    PRESET_OPTIONS = {} # :nodoc:
-    TYPE_TO_FORMATTER = {} # :nodoc:
+    @@formatter = {}
+    @@preset_options = {}
+    @@type_to_formatter = {}
 
     [
      [:html, HtmlFormat, nil],
@@ -27,73 +27,107 @@ module PseudoHiki
      [:gfm, MarkDownFormat, { :strict_mode=> false, :gfm_style => true }]
     ].each do |type, formatter, options|
       preset_options = [type, nil]
-      Formatter[preset_options] = formatter.create(options)
-      PRESET_OPTIONS[type] = preset_options
-      TYPE_TO_FORMATTER[type] = formatter
+      @@formatter[preset_options] = formatter.create(options)
+      @@preset_options[type] = preset_options
+      @@type_to_formatter[type] = formatter
     end
 
-    class << self
-      # Converts <hiki_data> into a format specified by <format_type>
-      #
-      # <hiki_data> should be a string or an array of strings
-      #
-      # Options for <format_type> are:
-      # [:html] HTML4.1
-      # [:xhtml] XHTML1.0
-      # [:html5] HTML5
-      # [:plain] remove all of tags
-      # [:plain_verbose] similar to :plain, but certain information such as urls in link tags will be kept
-      # [:markdown] Markdown
-      # [:gfm] GitHub Flavored Markdown
-      #
-      def format(hiki_data, format_type, options=nil, &block)
-        tree = BlockParser.parse(hiki_data)
+    # Converts <hiki_data> into a format specified by <format_type>
+    #
+    # <hiki_data> should be a string or an array of strings
+    #
+    # Options for <format_type> are:
+    # [:html] HTML4.1
+    # [:xhtml] XHTML1.0
+    # [:html5] HTML5
+    # [:plain] remove all of tags. certain information such as urls in link tags does not appear in the output
+    # [:plain_verbose] similar to :plain, but certain information such as urls in link tags will be kept in the output
+    # [:markdown] Markdown
+    # [:gfm] GitHub Flavored Markdown
+    #
+    def self.format(hiki_data, format_type, options=nil, &block)
+      tree = BlockParser.parse(hiki_data)
 
-        if options
-          Formatter[[format_type, options]] ||= TYPE_TO_FORMATTER[format_type].create(options)
-        else
-          Formatter[PRESET_OPTIONS[format_type]]
-        end.format(tree).tap do |formatted|
-          block.call(formatted) if block
-        end.to_s
-      end
+      if options
+        @@formatter[[format_type, options]] ||= @@type_to_formatter[format_type].create(options)
+      else
+        @@formatter[@@preset_options[format_type]]
+      end.format(tree).tap do |formatted|
+        block.call(formatted) if block
+      end.to_s
+    end
 
-      # Converts <hiki_data> into HTML4.1
-      #
-      #
-      def to_html(hiki_data, &block)
-        format(hiki_data, :html, options=nil, &block)
-      end
+    # Converts <hiki_data> into HTML4.1
+    #
+    # When you give a block to this method, a tree of HtmlElement objects is passed as the parameter to the block,
+    # so you can traverse it, as in the following example:
+    #
+    #    hiki = <<HIKI
+    #    !! heading
+    #
+    #    paragraph 1 that contains [[a link to a html file|http://www.example.org/example.html]]
+    #
+    #    paragraph 2 that contains [[a link to a pdf file|http://www.example.org/example.pdf]]
+    #    HIKI
+    #
+    #    html_str = PseudoHiki::Format.to_html(hiki) do |html|
+    #      html.traverse do |elm|
+    #        if elm.kind_of? HtmlElement and elm.tagname == "a"
+    #          elm["class"] = "pdf" if /\.pdf\Z/o =~ elm["href"]
+    #        end
+    #      end
+    #    end
+    #
+    # and the value of html_str is
+    #
+    #    <div class="section h2">
+    #    <h2> heading
+    #    </h2>
+    #    <p>
+    #    paragraph 1 that contains <a href="http://www.example.org/example.html">a link to a html file</a>
+    #    </p>
+    #    <p>
+    #    paragraph 2 that contains <a class="pdf" href="http://www.example.org/example.pdf">a link to a pdf file</a>
+    #    </p>
+    #    <!-- end of section h2 -->
+    #    </div>
+    #
+    def self.to_html(hiki_data, &block)
+      format(hiki_data, :html, options=nil, &block)
+    end
 
-      # Converts <hiki_data> into XHTML1.0
-      #
-      def to_xhtml(hiki_data, &block)
-        format(hiki_data, :xhtml, options=nil, &block)
-      end
+    # Converts <hiki_data> into XHTML1.0
+    #
+    # You can give a block to this method as in the case of ::to_html, but the parameter to the block is a tree of XhtmlElement objects
+    #
+    def self.to_xhtml(hiki_data, &block)
+      format(hiki_data, :xhtml, options=nil, &block)
+    end
 
-      # Converts <hiki_data> into HTML5
-      #
-      def to_html5(hiki_data, &block)
-        format(hiki_data, :html5, options=nil, &block)
-      end
+    # Converts <hiki_data> into HTML5
+    #
+    # You can give a block to this method as in the case of ::to_html, but the parameter to the block is a tree of Xhtml5Element objects
+    #
+    def self.to_html5(hiki_data, &block)
+      format(hiki_data, :html5, options=nil, &block)
+    end
 
-      # Converts <hiki_data> into plain texts without tags
-      #
-      def to_plain(hiki_data, &block)
-        format(hiki_data, :plain, options=nil, &block)
-      end
+    # Converts <hiki_data> into plain texts without tags
+    #
+    def self.to_plain(hiki_data, &block)
+      format(hiki_data, :plain, options=nil, &block)
+    end
 
-      # Converts <hiki_data> into Markdown
-      #
-      def to_markdown(hiki_data, &block)
-        format(hiki_data, :markdown, options=nil, &block)
-      end
+    # Converts <hiki_data> into Markdown
+    #
+    def self.to_markdown(hiki_data, &block)
+      format(hiki_data, :markdown, options=nil, &block)
+    end
 
-      # Converts <hiki_data> into GitHub Flavored Markdown
-      #
-      def to_gfm(hiki_data, &block)
-        format(hiki_data, :gfm, options=nil, &block)
-      end
+    # Converts <hiki_data> into GitHub Flavored Markdown
+    #
+    def self.to_gfm(hiki_data, &block)
+      format(hiki_data, :gfm, options=nil, &block)
     end
   end
 end

data/test/test_blockparser.rb

@@ -15,15 +15,15 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
   end
 
   def test_block_head_re_when_verbatimleaf
-    assert_equal(/\A(\s)/o, VerbatimLeaf.new.head_re)
+    assert_equal(/\A\s/o, VerbatimLeaf.new.head_re)
   end
 
   def test_block_head_re_when_tableleaf
-    assert_equal(/\A(\|\|)/o, TableLeaf.new.head_re)
+    assert_equal(/\A\|\|/o, TableLeaf.new.head_re)
   end
 
   def test_block_head_re_when_commentoutleaf
-    assert_equal(/\A(\/\/)/o.to_s, CommentOutLeaf.new.head_re.to_s)
+    assert_equal(/\A\/\//o.to_s, CommentOutLeaf.new.head_re.to_s)
   end
 
   def test_block_head_re_when_commentoutleaf2
@@ -31,7 +31,7 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
   end
 
   def test_block_head_re_when_headingleaf
-    assert_equal(/\A(!)+/o, HeadingLeaf.new.head_re)
+    assert_equal(/\A!+/o, HeadingLeaf.new.head_re)
   end
 
   def test_leaf_create
@@ -332,8 +332,8 @@ TEXT
     assert_equal(PseudoHiki::BlockParser::BlockNode, tree.class)
     assert_equal("section_name", tree[0].decorator["class"].id)
     assert_equal(PseudoHiki::BlockParser::BlockElement::HeadingNode, tree[0].class)
-    assert_equal('[[["title of section"]], [[[["header 1"]], [[" header 2"]]], [[["cell 1"]], [["cell 2"]]]], [[["a paragraph."]]], [[["another paragraph."]]]]', tree[0].to_s)
-    assert_equal('[["Summary of the table"]]', tree[0][1].decorator["summary"].value.to_s)
+    assert_equal([[["title of section"]], [[[["header 1"]], [[" header 2"]]], [[["cell 1"]], [["cell 2"]]]], [[["a paragraph."]]], [[["another paragraph."]]]], tree[0])
+    assert_equal([["Summary of the table"]], tree[0][1].decorator["summary"].value)
     assert_equal(PseudoHiki::BlockParser::BlockElement::TableNode, tree[0][1].class)
     assert_equal(nil, tree[0][2].decorator)
     assert_equal('id_name', tree[0][3].decorator[:id].id)

data/test/test_htmlformat.rb

@@ -115,6 +115,34 @@ HTML
     assert_equal(html,convert_text_to_html(text))
   end
 
+  def test_img
+    text = <<TEXT
+a paragraph with a normal [[link|http://www.example.org/]]
+
+a paragraph with an [[image|http://www.example.org/image.png]]
+
+a paragraph with a link to an image from [[[[a thumbnail image|image/thumb_nail.png]]|http://www.example.org/image.png]]
+TEXT
+
+    html = <<HTML
+<p>
+a paragraph with a normal <a href="http://www.example.org/">link</a>
+</p>
+<p>
+a paragraph with an <img alt="image" src="http://www.example.org/image.png">
+
+</p>
+<p>
+a paragraph with a link to an image from <a href="http://www.example.org/image.png"><img alt="a thumbnail image" src="image/thumb_nail.png">
+</a>
+</p>
+HTML
+
+
+    tree = BlockParser.parse(text)
+    assert_equal(html, HtmlFormat.format(tree).to_s)
+  end
+
   def test_plugin
     text = <<TEXT
 a paragraph with several plugin tags.

data/test/test_inlineparser.rb

@@ -10,7 +10,7 @@ class TC_InlineParser < MiniTest::Unit::TestCase
 
   def test_inlineparser_compile_token_pat
     parser = InlineParser.new("")
-    assert_equal(/'''|\}\}|\|\||\{\{|``|\]\]|\[\[|==|''|\||:/,parser.token_pat)
+    assert_equal(/'''|\}\}|\|\||\{\{|``|\]\]|\[\[|==|''|\||:/, parser.instance_variable_get(:@token_pat))
   end
 
   def test_inlineparser_split_into_tokens

data/test/test_latexformat.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'pseudohiki/latexformat'
+
+class TC_LaTeXTag < MiniTest::Unit::TestCase
+  include PseudoHiki
+
+  def test_escape
+    unescaped = '# $ % \\ & {} ^ _ ~'
+    escaped = '\\# \\$ \\% \\textbackslash{} \\& \\{\\} \\^{} \\_ \\~{}'
+    assert_equal(escaped, LaTeXTag.escape(unescaped))
+  end
+
+  def test_format_options
+    command = LaTeXTag.new("documentclass")
+  end
+end
+

data/test/test_pseudohiki2html.rb

@@ -111,6 +111,228 @@ end
 class TC_PageComposer < MiniTest::Unit::TestCase
   include PseudoHiki
 
+  def setup
+    @input_lines = <<HIKI.each_line.to_a
+!Title
+
+!![heading1]Heading1
+
+paragraph
+
+paragran
+
+!![heading2]Heading2
+
+!!![heading2-1]Heading2-1
+
+paragraph
+
+paragraph
+
+HIKI
+
+    @parsed_tree = BlockParser.parse(@input_lines)
+  end
+
+  def test_collect_nodes_for_table_of_contents
+    set_argv("-fg -s -c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+    collected_nodes = [[["Heading1\n"]],
+                       [["Heading2\n"]],
+                       [["Heading2-1\n"]]]
+
+    tree = BlockParser.parse(@input_lines)
+    toc_nodes = PageComposer.new(options).collect_nodes_for_table_of_contents(tree)
+    assert_equal(collected_nodes, toc_nodes)
+  end
+
+  def test_create_plain_table_of_contents
+    toc_in_plain_text = <<TEXT
+  * Heading1
+  * Heading2
+    * Heading2-1
+TEXT
+    set_argv("-fg -s -c css/with_toc.css wikipage.txt")
+
+    options = OptionManager.new
+    options.set_options_from_command_line
+
+    toc = PageComposer.new(options).create_plain_table_of_contents(@parsed_tree)
+
+    assert_equal(toc_in_plain_text, toc)
+  end
+
+  def test_create_html_table_of_contents
+    toc_in_html = <<TEXT
+<ul>
+<li><a href="#HEADING1" title="toc_item: Heading1">Heading1
+</a></li>
+<li><a href="#HEADING2" title="toc_item: Heading2">Heading2
+</a><ul>
+<li><a href="#HEADING2-1" title="toc_item: Heading2-1">Heading2-1
+</a></li>
+</ul>
+</li>
+</ul>
+TEXT
+
+    set_argv("-fh5 -s -c css/with_toc.css wikipage.txt")
+
+    options = OptionManager.new
+    options.set_options_from_command_line
+
+    toc = PageComposer.new(options).create_html_table_of_contents(@parsed_tree).join
+
+    assert_equal(toc_in_html, toc)
+  end
+
+  def test_create_table_of_contents
+    set_argv("-c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+    toc = PageComposer.new(options).create_table_of_contents(@parsed_tree)
+    assert_equal("", toc)
+
+    toc_in_plain_text = <<TEXT
+  * Heading1
+  * Heading2
+    * Heading2-1
+TEXT
+
+    set_argv("-fg -m 'table of contents' -c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+    toc = PageComposer.new(options).create_table_of_contents(@parsed_tree)
+    assert_equal(toc_in_plain_text, toc)
+
+    toc_in_html = <<TEXT
+<ul>
+<li><a href="#HEADING1" title="toc_item: Heading1">Heading1
+</a></li>
+<li><a href="#HEADING2" title="toc_item: Heading2">Heading2
+</a><ul>
+<li><a href="#HEADING2-1" title="toc_item: Heading2-1">Heading2-1
+</a></li>
+</ul>
+</li>
+</ul>
+TEXT
+
+    set_argv("-fh5 -m 'table of contents' -c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+    toc = PageComposer.new(options).create_table_of_contents(@parsed_tree).join
+    assert_equal(toc_in_html, toc)
+  end
+
+  def test_compose_html
+    expected_html =<<HTML
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html lang="en" xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta charset="UTF-8" />
+<title>wikipage</title>
+<link href="css/with_toc.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<section id="main">
+<section id="toc">
+<h2>table of contents</h2>
+<ul>
+<li><a href="#HEADING1" title="toc_item: Heading1">Heading1
+</a></li>
+<li><a href="#HEADING2" title="toc_item: Heading2">Heading2
+</a><ul>
+<li><a href="#HEADING2-1" title="toc_item: Heading2-1">Heading2-1
+</a></li>
+</ul>
+</li>
+</ul>
+<!-- end of toc -->
+</section>
+<section id="contents">
+<section class="h1">
+<h1>Title
+</h1>
+<section class="h2">
+<h2 id="HEADING1">Heading1
+</h2>
+<p>
+paragraph
+</p>
+<p>
+paragran
+</p>
+<!-- end of h2 -->
+</section>
+<section class="h2">
+<h2 id="HEADING2">Heading2
+</h2>
+<section class="h3">
+<h3 id="HEADING2-1">Heading2-1
+</h3>
+<p>
+paragraph
+</p>
+<p>
+paragraph
+</p>
+<!-- end of h3 -->
+</section>
+<!-- end of h2 -->
+</section>
+<!-- end of h1 -->
+</section>
+<!-- end of contents -->
+</section>
+<!-- end of main -->
+</section>
+</body>
+</html>
+HTML
+
+    expected_plain_text = <<TEXT
+## table of contents
+
+  * Heading1
+  * Heading2
+    * Heading2-1
+
+# Title
+
+## Heading1
+
+paragraph
+
+paragran
+
+## Heading2
+
+### Heading2-1
+
+paragraph
+
+paragraph
+
+TEXT
+
+    set_argv("-fh5 -m 'table of contents' -c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+
+    composed_html = PageComposer.new(options).compose_html(@input_lines).to_s
+    assert_equal(expected_html, composed_html)
+
+    set_argv("-fg -m 'table of contents' -c css/with_toc.css wikipage.txt")
+    options = OptionManager.new
+    options.set_options_from_command_line
+
+    composed_plain_text = PageComposer.new(options).compose_html(@input_lines).join
+    assert_equal(expected_plain_text, composed_plain_text)
+  end
+
   def test_output_in_gfm_with_toc
     input = <<TEXT.each_line.to_a
 //title: Test Data

data/test/test_utils.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'pseudohikiparser'
+require 'pseudohiki/utils'
+
+class TC_NodeCollector < MiniTest::Unit::TestCase
+
+  def setup
+    @input_text = <<TEXT
+!Title
+
+!![heading1]Heading1
+
+paragaraph
+
+!!Heading2
+
+paragragh
+
+!![heading3]Heading3
+
+paragraph
+TEXT
+  end
+
+  def test_nodecollector
+    tree = PseudoHiki::BlockParser.parse(@input_text)
+    nodes = PseudoHiki::Utils::NodeCollector.select(tree) do |node|
+      node.kind_of?(PseudoHiki::BlockParser::HeadingLeaf) and
+        node.nominal_level == 2 and
+        node.node_id
+    end
+
+    selected_headings = [[["Heading1\n"]],
+                [["Heading3\n"]]]
+
+    assert_equal(selected_headings, nodes)
+  end
+end
+

metadata

@@ -1,118 +1,148 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: pseudohikiparser
-version: !ruby/object:Gem::Version
-  version: 0.0.0.12.develop
+version: !ruby/object:Gem::Version 
+  hash: -1684086064
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 0
+  - 13
+  - develop
+  version: 0.0.0.13.develop
 platform: ruby
-authors:
+authors: 
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-12-25 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: minitest
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: PseudoHikiParser is a parser of texts written in a Hiki like notation,
-  and coverts them into HTML or other formats.
-email:
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 1
+        - 3
+        - 1
+        version: 1.3.1
+  type: :development
+  version_requirements: *id003
+description: PseudoHikiParser is a parser of texts written in a Hiki like notation, and coverts them into HTML or other formats.
+email: 
 - hashimoto.naoki@gmail.com
-executables:
+executables: 
 - pseudohiki2html.rb
 extensions: []
+
 extra_rdoc_files: []
-files:
-- LICENSE
+
+files: 
 - README.md
-- bin/pseudohiki2html.rb
-- lib/htmlelement.rb
-- lib/htmlelement/htmltemplate.rb
+- LICENSE
+- lib/pseudohikiparser.rb
+- lib/pseudohiki/treestack.rb
+- lib/pseudohiki/inlineparser.rb
 - lib/pseudohiki/blockparser.rb
-- lib/pseudohiki/converter.rb
 - lib/pseudohiki/htmlformat.rb
-- lib/pseudohiki/htmlplugin.rb
-- lib/pseudohiki/inlineparser.rb
-- lib/pseudohiki/markdownformat.rb
 - lib/pseudohiki/plaintextformat.rb
+- lib/pseudohiki/markdownformat.rb
 - lib/pseudohiki/sinatra_helpers.rb
-- lib/pseudohiki/treestack.rb
 - lib/pseudohiki/version.rb
-- lib/pseudohikiparser.rb
+- lib/pseudohiki/converter.rb
+- lib/pseudohiki/htmlplugin.rb
+- lib/htmlelement.rb
+- lib/htmlelement/htmltemplate.rb
+- test/test_htmltemplate.rb
+- test/test_pseudohikiparser.rb
 - test/test_blockparser.rb
+- test/test_pseudohiki2html.rb
+- test/test_plaintextformat.rb
 - test/test_htmlelement.rb
-- test/test_htmlformat.rb
-- test/test_htmlplugin.rb
-- test/test_htmltemplate.rb
+- test/test_treestack.rb
 - test/test_inlineparser.rb
 - test/test_markdownformat.rb
-- test/test_plaintextformat.rb
-- test/test_pseudohiki2html.rb
-- test/test_pseudohikiparser.rb
-- test/test_treestack.rb
+- test/test_htmlformat.rb
+- test/test_htmlplugin.rb
+- test/test_utils.rb
+- test/test_latexformat.rb
+- bin/pseudohiki2html.rb
+has_rdoc: true
 homepage: https://github.com/nico-hn/PseudoHikiParser/wiki
-licenses:
+licenses: 
 - BSD 2-Clause license
-metadata: {}
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
   - - ">"
-    - !ruby/object:Gem::Version
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
       version: 1.3.1
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 4
-summary: 'PseudoHikiParser: a parser of texts in a Hiki like notation.'
-test_files:
+specification_version: 3
+summary: "PseudoHikiParser: a parser of texts in a Hiki like notation."
+test_files: 
 - test/test_htmltemplate.rb
 - test/test_pseudohikiparser.rb
 - test/test_blockparser.rb
@@ -124,3 +154,5 @@ test_files:
 - test/test_markdownformat.rb
 - test/test_htmlformat.rb
 - test/test_htmlplugin.rb
+- test/test_utils.rb
+- test/test_latexformat.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: ab6d03f5f2b3131e62af81faa6540355f115b489
-  data.tar.gz: d95e43ed55af9b8b0ecb6868b7075315e1a8e5e2
-SHA512:
-  metadata.gz: 66e3bec04f94faa3cbbd21b6e945ad46e23e58d1ffd8b0e36cb1c400e4caee43a4e9ce55e0fdfd70bf5ce6b65a5bf877f979882ae6190f348db5cbdef7cea392
-  data.tar.gz: 7a0be29c24383e9ff375404413df96ca209d7c885dc13eec566828c84ad19dd7cbd9a6029e7cbb0cadaa280aa5746dad8c5bf34e0fc5620db99a2bf962c3d1ac