pseudohikiparser 0.0.2 → 0.0.3.develop

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6aeacee81ab200ae29767f62343c2c8c3b6383b
-  data.tar.gz: 29c8d6ef7d5546530c0836173b503346c1270f97
+  metadata.gz: 4194b79f711194dc48b8b09a13302ec50dd9f20d
+  data.tar.gz: 1b91b097c191eb63711aae1f62bf92788943310e
 SHA512:
-  metadata.gz: b9e0df31b3ca4d2e347f9ef841f0c86c13bb8398f477f2d2b85fc6185ab9ce54c7ba0420bfa09ebb7e30d12baa26da76f3d8557e90c0df2fda7ed62114efd53c
-  data.tar.gz: abf97289e38d87b669af8ee08a7076fd72f684bab2115be9aef9dbf7512b076fe90c95d0392408cf255c3e1482abe08bc952b8d6ce7af96da21fc4557e97dc23
+  metadata.gz: 7bc7d683db890fc147c1149480481af8df86ac9738e39958f251c9aee2eb5a6792ac2fe3e6465b7af798d31f1eccedda273a47ecba99608eda344772eb04548b
+  data.tar.gz: a0b647bc3512f1ca38a3fadec0a2a77560c7d7b457a564a49cc40b901f00754d6eaa82c37c7f0a01e8234d341252d5e4ee9502adfc53f0a024feabad60bbcbf2

data/README.ja.md

@@ -353,7 +353,7 @@ Hiki記法のマークアップを除去するためのVisitorクラスで、使
 :fax:03-xxxx-xxxx
 ```
 
-will be rendered as
+は次のように変換されます。
 
 ```
 tel:	03-xxxx-xxxx

data/lib/pseudohiki/blockparser.rb

@@ -37,18 +37,17 @@ module PseudoHiki
     end
 
     class BlockStack < TreeStack
-      def pop
-        self.current_node.parse_leafs
-        super
+      def pop_with_breaker(breaker=nil)
+        self.current_node.parse_leafs(breaker)
+        pop
       end
     end
 
     class BlockLeaf < BlockStack::Leaf
-      @@head_re = {}
-      attr_accessor :nominal_level, :node_id
+      attr_accessor :nominal_level, :node_id, :decorator
 
       def self.head_re=(head_regex)
-        @self_head_re = @@head_re[self] = head_regex
+        @self_head_re = head_regex
       end
 
       def self.head_re
@@ -65,7 +64,7 @@ module PseudoHiki
       end
 
       def head_re
-        @head_re ||= @@head_re[self.class]
+        @head_re ||= self.class.head_re
       end
 
       def block
@@ -85,7 +84,7 @@ module PseudoHiki
         super(stack)
       end
 
-      def parse_leafs
+      def parse_leafs(breaker)
         parsed = InlineParser.parse(self.join)
         self.clear
         self.concat(parsed)
@@ -135,6 +134,10 @@ module PseudoHiki
         first.nominal_level if first # @cached_nominal_level ||= (first.nominal_level if first)
       end
 
+      def decorator
+        first.decorator if first
+      end
+
       def push_self(stack)
         @stack = stack
         super(stack)
@@ -144,7 +147,7 @@ module PseudoHiki
         not (kind_of?(breaker.block) and nominal_level == breaker.nominal_level)
       end
 
-      def parse_leafs; end
+      def parse_leafs(breaker); end
 
       def in_link_tag?(preceding_str)
         preceding_str[-2, 2] == "[[".freeze or preceding_str[-1, 1] == "|".freeze
@@ -156,7 +159,7 @@ module PseudoHiki
 
       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
 
@@ -168,8 +171,8 @@ module PseudoHiki
     end
 
     class NonNestedBlockNode < BlockNode
-      def parse_leafs
-        self.each {|leaf| leaf.parse_leafs }
+      def parse_leafs(breaker)
+        self.each {|leaf| leaf.parse_leafs(breaker) }
       end
     end
 
@@ -189,11 +192,11 @@ module PseudoHiki
 
     module BlockElement
       {
-        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf),
+        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf DecoratorLeaf),
         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),
         NonNestedBlockNode => %w(QuoteNode ParagraphNode),
         NestedBlockNode => %w(HeadingNode),
         ListTypeBlockNode => %w(ListNode EnumNode),
@@ -218,15 +221,43 @@ module PseudoHiki
       attr_accessor :in_block_tag
 
       def add_leaf(line, blockparser)
-        return @stack.pop if LINE_PAT::VERBATIM_END =~ line
+        return @stack.pop_with_breaker if LINE_PAT::VERBATIM_END =~ line
         return super(line, blockparser) unless @in_block_tag
         line = " ".concat(line) if BlockElement::BlockNodeEnd.head_re =~ line and not @in_block_tag
         @stack.push BlockElement::VerbatimLeaf.create(line, @in_block_tag)
       end
     end
 
+    class BlockElement::DecoratorNode
+      DECORATOR_PAT = /\A(?:([^\[\]:]+))?(?:\[([^\[\]]+)\])?(?::\s*(\S.*))?/o
+
+      class DecoratorItem < Struct.new(:string, :type, :id, :value)
+        def initialize(*args)
+          super
+          self.value = InlineParser.parse(self.value) if self.value
+        end
+      end
+
+      def parse_leafs(breaker)
+        decorator = {}
+        breaker.decorator = decorator
+        @stack.remove_current_node.each do |leaf|
+          m = DECORATOR_PAT.match(leaf.join)
+          return nil unless m
+          item = DecoratorItem.new(*(m.to_a))
+          decorator[item.type||:id] = item
+        end
+      end
+
+      def breakable?(breaker)
+        return super if breaker.kind_of?(BlockElement::DecoratorLeaf)
+        parse_leafs(breaker)
+        @stack.current_node.breakable?(breaker)
+      end
+    end
+
     class BlockElement::QuoteNode
-      def parse_leafs
+      def parse_leafs(breaker)
         self[0] = BlockParser.parse(self[0])
       end
     end
@@ -284,7 +315,8 @@ module PseudoHiki
      [ParagraphLeaf, ParagraphNode],
      [HrLeaf, HrNode],
      [ListLeaf, ListNode],
-     [EnumLeaf, EnumNode]
+     [EnumLeaf, EnumNode],
+     [DecoratorLeaf, DecoratorNode]
     ].each do |leaf, node|
       ParentNode[leaf] = node
     end
@@ -302,6 +334,7 @@ module PseudoHiki
        ['!', HeadingLeaf],
        ['""', QuoteLeaf],
        ['||', TableLeaf],
+       ['//@', DecoratorLeaf],
        ['//', CommentOutLeaf],
        ['----\s*$', HrLeaf]
       ].each do |head, leaf|
@@ -340,7 +373,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
 end

data/lib/pseudohiki/converter.rb

@@ -60,8 +60,21 @@ module PseudoHiki
       end
     end
 
+    def gfm_id(heading_node)
+      MarkDownFormat.convert_to_gfm_id_format(to_plain(heading_node).strip)
+    end
+
+    def create_gfm_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).strip, gfm_id(toc_node)]
+      end
+
+      @options.formatter.format(BlockParser.parse(toc_lines))
+    end
+
     def create_table_of_contents(tree)
       return "" unless @options[:toc]
+      return create_gfm_table_of_contents(tree) if @options[:html_version].version == "gfm"
       return create_plain_table_of_contents(tree) unless @options.html_template
       create_html_table_of_contents(tree)
     end
@@ -275,9 +288,9 @@ module PseudoHiki
 
     def set_encoding(given_opt)
       return nil unless String.new.respond_to? :encoding
-      external, internal = given_opt.split(/:/o)
-      Encoding.default_external = external if external
-      Encoding.default_internal = internal if internal
+      external, internal = given_opt.split(/:/o, 2)
+      Encoding.default_external = external if external and not external.empty?
+      Encoding.default_internal = internal if internal and not internal.empty?
     end
 
     def parse_command_line_options

data/lib/pseudohiki/htmlformat.rb

@@ -61,6 +61,7 @@ module PseudoHiki
 
     def visit(tree)
       htmlelement = create_self_element(tree)
+      decorate(htmlelement, tree)
       push_visited_results(htmlelement, tree)
       htmlelement
     end
@@ -78,6 +79,21 @@ module PseudoHiki
       chunks.push tree
     end
 
+    def decorate(htmlelement, tree)
+      each_decorator(htmlelement, tree) do |element, decorator|
+        element[CLASS] = HtmlElement.escape(decorator[CLASS].id) if decorator[CLASS]
+        if id_item = decorator[ID]||decorator[:id]
+          element[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_self_element(tree)
         super(tree).tap do |element|
@@ -148,8 +164,9 @@ module PseudoHiki
           htmlelement[ALT] = caption.join if caption
         else
           htmlelement = create_self_element
-          htmlelement[HREF] = tree.join
-          htmlelement.push caption||tree.join
+          url = tree.join
+          htmlelement[HREF] = url.start_with?("#".freeze) ? url.upcase : url
+          htmlelement.push caption||url
         end
         htmlelement
       end
@@ -175,6 +192,14 @@ module PseudoHiki
 
     #for BlockParser
 
+    class << Formatter[TableNode]
+      def decorate(htmlelement, tree)
+        each_decorator(htmlelement, tree) do |element, decorator|
+          htmlelement["summary"] = HtmlElement.escape(decorator["summary"].value.join) if decorator["summary"]
+        end
+      end
+    end
+
     class << Formatter[VerbatimNode]
       def visit(tree)
         create_self_element.tap do |element|

data/lib/pseudohiki/inlineparser.rb

@@ -20,6 +20,17 @@ module PseudoHiki
     Regexp.new(tokens.join("|"))
   end
 
+  def self.split_into_tokens(str, token_pat)
+    tokens = []
+    while m = token_pat.match(str)
+      tokens.push m.pre_match unless m.pre_match.empty?
+      tokens.push m[0]
+      str = m.post_match
+    end
+    tokens.push str unless str.empty?
+    tokens
+  end
+
   class InlineParser < TreeStack
     module InlineElement
       class InlineNode < InlineParser::Node; end
@@ -43,7 +54,7 @@ module PseudoHiki
      [StrongNode, "'''", "'''"],
      [DelNode, "==", "=="],
      [LiteralNode, "``", "``"],
-     [PluginNode, "{{","}}"]].each do |type, head, tail|
+     [PluginNode, "{{", "}}"]].each do |type, head, tail|
       HEAD[head] = type
       TAIL[tail] = type
       NodeTypeToHead[type] = head
@@ -52,8 +63,7 @@ module PseudoHiki
     TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys,TAIL.keys,[LinkSep, TableSep, DescSep])
 
     def initialize(str)
-      @token_pat = TokenPat[self.class]
-      @tokens = split_into_tokens(str)
+      @tokens = PseudoHiki.split_into_tokens(str, TokenPat[self.class])
       super()
     end
 
@@ -75,17 +85,6 @@ module PseudoHiki
       self.pop
     end
 
-    def split_into_tokens(str)
-      tokens = []
-      while m = @token_pat.match(str)
-        tokens.push m.pre_match unless m.pre_match.empty?
-        tokens.push m[0]
-        str = m.post_match
-      end
-      tokens.push str unless str.empty?
-      tokens
-    end
-
     def parse
       while token = @tokens.shift
         next if TAIL[token] and treated_as_node_end(token)

data/lib/pseudohiki/markdownformat.rb

@@ -4,6 +4,7 @@ require 'pseudohiki/inlineparser'
 require 'pseudohiki/blockparser'
 require 'pseudohiki/htmlformat'
 require 'pseudohiki/plaintextformat'
+require 'pseudohiki/utils'
 require 'htmlelement'
 require 'ostruct'
 
@@ -14,6 +15,8 @@ module PseudoHiki
     include BlockParser::BlockElement
 
     Formatters = {}
+    GFM_STRIPPED_CHARS = " -&+$,/:;=?@\"{}#|^~[]`\\*()%.!'"
+    GFM_STRIPPED_CHARS_PAT = Regexp.union(/\s+/o, /[#{Regexp.escape(GFM_STRIPPED_CHARS)}]/o)
 
     def self.format(tree, options={ :strict_mode=> false, :gfm_style => false })
       if Formatters.empty?
@@ -25,6 +28,12 @@ module PseudoHiki
       Formatters[options].format(tree)
     end
 
+    def self.convert_to_gfm_id_format(heading)
+      heading.gsub(GFM_STRIPPED_CHARS_PAT) do |char|
+        /\A\s+\Z/o =~ char ? '-'.freeze : ''.freeze
+      end.downcase
+    end
+
     def initialize(formatter={}, options={ :strict_mode=> false, :gfm_style => false })
       @formatter = formatter
       options_given_via_block = nil
@@ -60,6 +69,7 @@ module PseudoHiki
 
     def format(tree)
       formatter = get_plain
+      @formatter[LinkNode].id_conv_table = prepare_id_conv_table(tree) if @options.gfm_style
       tree.accept(formatter).join
     end
 
@@ -78,6 +88,23 @@ module PseudoHiki
       element.to_s.gsub(/([^>])\r?\n/, "\\1") << $/
     end
 
+    def collect_headings(tree)
+      PseudoHiki::Utils::NodeCollector.select(tree) do |node|
+        node.kind_of? PseudoHiki::BlockParser::HeadingLeaf
+      end
+    end
+
+    def prepare_id_conv_table(tree)
+      {}.tap do |table|
+        collect_headings(tree).each do |heading|
+          if node_id = heading.node_id
+            heading_text = PlainTextFormat.format(heading).strip
+            table[node_id] = MarkDownFormat.convert_to_gfm_id_format(heading_text)
+          end
+        end
+      end
+    end
+
     def self.create(options={ :strict_mode => false })
       formatter = {}
       main_formatter = self.new(formatter, options)
@@ -139,6 +166,8 @@ module PseudoHiki
     end
 
     class LinkNodeFormatter < self
+      attr_writer :id_conv_table
+
       def visit(tree)
         not_from_thumbnail = tree.first.class != LinkNode
         tree = tree.dup
@@ -151,7 +180,8 @@ module PseudoHiki
           STDERR.puts "No uri is specified for #{caption}"
         end
         element.push "!" if ImageSuffix =~ ref and not_from_thumbnail
-        element.push "[#{(caption||tree).join}](#{tree.join})"
+        link = format_link(tree)
+        element.push "[#{(caption||tree).join}](#{link})"
         element
       end
 
@@ -162,6 +192,16 @@ module PseudoHiki
         tree.shift
         caption_part.map {|element| visited_result(element) }
       end
+
+      def format_link(tree)
+        link = tree.join
+        return link unless @id_conv_table
+        if /\A#/o =~ link and gfm_link = @id_conv_table[link[1..-1]]
+          "#".concat gfm_link
+        else
+          link
+        end
+      end
     end
 
     class EmNodeFormatter < self
@@ -244,13 +284,14 @@ module PseudoHiki
     class VerbatimNodeFormatter < self
       def visit(tree)
         element = super(tree)
+        @language_name = language_name(tree)
         return gfm_verbatim(element) if @options.gfm_style
         md_verbatim(element)
       end
 
       def gfm_verbatim(element)
         element.tap do |lines|
-          lines.unshift "```#{$/}"
+          lines.unshift "```#{@language_name + $/}"
           lines.push "```#{$/ * 2}"
         end
       end
@@ -258,6 +299,12 @@ module PseudoHiki
       def md_verbatim(element)
         element.join.gsub(/^/o, "    ").sub(/    \Z/o, "").concat $/
       end
+
+      def language_name(tree)
+        tree.decorator.tap do |decorator|
+          return decorator ? decorator["code"].id : ""
+        end
+      end
     end
 
     class QuoteNodeFormatter < self
@@ -329,11 +376,9 @@ module PseudoHiki
         rows.each_with_index do |row, i|
           row.each do |cell|
             return false if cell.rowspan > 1 or cell.colspan > 1
-            if i == 0
-              return false unless cell.cell_type == "th"
-            else
-              return false if cell.cell_type == "th"
-            end
+            #A table head row should be at the beginning and composed of <th> elements,
+            #and other rows should not include <th> elements
+            return false unless (i == 0) == (cell.cell_type == "th")
           end
         end
         true

data/lib/pseudohiki/plaintextformat.rb

@@ -159,25 +159,31 @@ ERROR_TEXT
 
       def visit(tree)
         table = create_self_element(tree)
-        rows = deep_copy_tree(tree)
-        rows.length.times { table.push create_self_element(tree) }
+        tree.length.times { table.push create_self_element(tree) }
         max_col = tree.map{|row| row.reduce(0) {|sum, cell| sum + cell.colspan }}.max - 1
-        max_row = rows.length - 1
+        max_row = tree.length - 1
+        each_empty_cell_index(max_row, max_col, tree, table) do |r, c, cur_row|
+          table[r][c] = cur_row.shift
+          fill_expand(table, r, c, table[r][c])
+        end
+        format_table(table, tree)
+      end
+
+      def each_empty_cell_index(max_row, max_col, tree, table)
+        rows = deep_copy_tree(tree)
         cur_row = nil
         each_cell_index(max_row, max_col) do |r, c|
           cur_row = rows.shift if c == 0
           next if table[r][c]
           begin
             raise MalFormedTableError.new(ERROR_MESSAGE%[table[r].inspect]) if cur_row.empty?
-            table[r][c] = cur_row.shift
-            fill_expand(table, r, c, table[r][c])
+            yield r, c, cur_row
           rescue
             raise if @options.strict_mode
             STDERR.puts ERROR_MESSAGE%[table[r].inspect]
             next
           end
         end
-        format_table(table, tree)
       end
 
       def deep_copy_tree(tree)

data/lib/pseudohiki/sinatra_helpers.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+begin
+  module Sinatra
+    module PseudoHikiParserHelpers
+      XHTML5_CONTENT_TYPE = 'application/xhtml+xml'
+      def phiki(hiki_data, &block)
+        case content_type
+        when XHTML5_CONTENT_TYPE
+          PseudoHiki::Format.to_html5(hiki_data, &block)
+        else
+          PseudoHiki::Format.to_xhtml(hiki_data, &block)
+        end
+      end
+    end
+
+    class Base
+      helpers PseudoHikiParserHelpers
+    end
+  end
+rescue
+  #Sinatra is not available
+end

data/lib/pseudohiki/utils.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'pseudohiki/inlineparser'
+require 'pseudohiki/blockparser'
+
+module PseudoHiki
+  module Utils
+
+    class NodeCollector
+      attr_reader :nodes
+
+      def self.select(tree, &condition)
+        collector = new(&condition)
+        collector.visit(tree)
+        collector.nodes
+      end
+
+      def initialize (&condition)
+        @nodes = []
+        @condition = condition
+      end
+
+      def visit(tree)
+        if @condition.call(tree)
+          @nodes.push tree
+        else
+          tree.each do |node|
+            node.accept(self) if node.respond_to? :accept
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pseudohiki/version.rb

@@ -1,3 +1,3 @@
 module PseudoHiki
-  VERSION = "0.0.2"
+  VERSION = "0.0.3.develop"
 end

data/lib/pseudohikiparser.rb

@@ -131,3 +131,5 @@ module PseudoHiki
     end
   end
 end
+
+require 'pseudohiki/sinatra_helpers'if defined? Sinatra

data/test/test_blockparser.rb

@@ -311,6 +311,35 @@ TEXT
     assert_equal([[[["heading"]]]],parsed)
   end
 
+
+  def test_decorator
+    text = <<TEXT
+//@class[section_name]
+!!title of section
+
+//@summary: Summary of the table
+||!header 1||! header 2
+||cell 1||cell 2
+
+a paragraph.
+
+//@class[class_name]
+//@[id_name]
+another paragraph.
+TEXT
+
+    tree = PseudoHiki::BlockParser.parse(text.lines.to_a.map {|line| line.chomp })
+    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])
+    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)
+    assert_equal('class_name', tree[0][3].decorator["class"].id)
+  end
+
   def test_comment_out_followed_by_a_verbatim_block
     text = <<TEXT
 the first paragraph

data/test/test_htmlformat.rb

@@ -696,6 +696,69 @@ HTML
     assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
   end
 
+  def test_decorator
+    text = <<TEXT
+//@class[section_type]
+!!title of section
+
+a paragraph.
+
+//@class[class_name]
+//@id[id_name]
+another paragraph.
+TEXT
+
+    xhtml = <<HTML
+<div class="section_type">
+<h2>title of section</h2>
+<p>
+a paragraph.</p>
+<p class="class_name" id="ID_NAME">
+another paragraph.</p>
+<!-- end of section_type -->
+</div>
+HTML
+    tree = BlockParser.parse(text.lines.to_a.map {|line| line.chomp })
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_decorator_for_table
+    text = <<TEXT
+//@summary: Summary of the table
+||!header 1||! header 2
+||cell 1||cell 2
+TEXT
+
+    xhtml = <<HTML
+<table summary="Summary of the table">
+<tr><th>header 1</th><th> header 2</th></tr>
+<tr><td>cell 1</td><td>cell 2</td></tr>
+</table>
+HTML
+    tree = BlockParser.parse(text.lines.to_a.map {|line| line.chomp })
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_decorator_for_verbatim
+    text = <<TEXT
+//@code[ruby]
+ def bonjour!
+   puts "Bonjour!"
+ end
+TEXT
+
+    xhtml = <<HTML
+<pre>
+def bonjour!
+  puts &quot;Bonjour!&quot;
+end
+</pre>
+HTML
+
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
   def test_comment_out_followed_by_a_verbatim_block
     text = <<TEXT
 the first paragraph

data/test/test_inlineparser.rb

@@ -10,16 +10,19 @@ class TC_InlineParser < MiniTest::Unit::TestCase
 
   def test_inlineparser_compile_token_pat
     parser = InlineParser.new("")
-    assert_equal(/'''|\}\}|\|\||\{\{|``|\]\]|\[\[|==|''|\||:/, parser.instance_variable_get(:@token_pat))
+    assert_equal(/'''|\}\}|\|\||\{\{|``|\]\]|\[\[|==|''|\||:/, InlineParser::TokenPat[parser.class])
   end
 
   def test_inlineparser_split_into_tokens
     parser = InlineParser.new("")
-    tokens = parser.split_into_tokens("As a test case, '''this part''' must be in <strong>.")
+    tokens = PseudoHiki.split_into_tokens("As a test case, '''this part''' must be in <strong>.",
+                                          InlineParser::TokenPat[parser.class])
     assert_equal(["As a test case, ","'''","this part","'''"," must be in <strong>."],tokens)
-    tokens = parser.split_into_tokens("As another {{test case}}, '''this part''' must be in <strong>.")
+    tokens = PseudoHiki.split_into_tokens("As another {{test case}}, '''this part''' must be in <strong>.",
+                                          InlineParser::TokenPat[parser.class])
     assert_equal(["As another ","{{","test case","}}", ", ","'''","this part","'''"," must be in <strong>."],tokens)
-    tokens = parser.split_into_tokens("As another ''test case'', '''this part''' must be in <strong>.")
+    tokens = PseudoHiki.split_into_tokens("As another ''test case'', '''this part''' must be in <strong>.",
+                                          InlineParser::TokenPat[parser.class])
     assert_equal(["As another ","''","test case","''", ", ","'''","this part","'''"," must be in <strong>."],tokens)
   end
 

data/test/test_markdownformat.rb

@@ -44,6 +44,15 @@ TEXT
     assert_equal(gfm_text, MarkDownFormat.format(tree, :gfm_style => true))
   end
 
+  def test_self_convert_to_gfm_id_format
+    heading_with_non_ascii_chars = "class PseudoHiki::BlockParser"
+    heading_with_multiple_spaces = "Development status of features from the original Hiki notation"
+    gfm_id_with_non_ascii_chars = MarkDownFormat.convert_to_gfm_id_format(heading_with_non_ascii_chars)
+    gfm_id_with_multiple_spaces = MarkDownFormat.convert_to_gfm_id_format(heading_with_multiple_spaces)
+    assert_equal("class-pseudohikiblockparser", gfm_id_with_non_ascii_chars)
+    assert_equal("development-status-of-features-from-the-original-hiki-notation", gfm_id_with_multiple_spaces)
+  end
+
   def test_plain
     text = <<TEXT
 test string
@@ -508,5 +517,132 @@ TEXT
     tree = BlockParser.parse(text.lines.to_a)
     assert_equal(md_text, @formatter.format(tree).to_s)
   end
+
+  def test_decorator_for_verbatim
+    text = <<TEXT
+//@code[ruby]
+ def bonjour!
+   puts "Bonjour!"
+ end
+TEXT
+
+    gfm_text =<<TEXT
+```ruby
+def bonjour!
+  puts "Bonjour!"
+end
+```
+
+TEXT
+
+    md_text = <<TEXT
+    def bonjour!
+      puts "Bonjour!"
+    end
+
+TEXT
+
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal(gfm_text, @gfm_formatter.format(tree).to_s)
+    assert_equal(md_text, @formatter.format(tree).to_s)
+  end
+
+  def test_decorator_for_verbatim_block
+    text = <<TEXT
+//@code[ruby]
+<<<
+def bonjour!
+  puts "Bonjour!"
+end
+>>>
+TEXT
+
+    gfm_text =<<TEXT
+```ruby
+def bonjour!
+  puts "Bonjour!"
+end
+```
+
+TEXT
+
+    md_text = <<TEXT
+    def bonjour!
+      puts "Bonjour!"
+    end
+
+TEXT
+
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal(gfm_text, @gfm_formatter.format(tree).to_s)
+    assert_equal(md_text, @formatter.format(tree).to_s)
+  end
+
+  def test_collect_headings
+    text = <<TEXT
+!![main-heading] heading
+
+paragraph
+
+!!![sub-heading] subheading
+
+another paragraph
+TEXT
+
+    tree = BlockParser.parse(text)
+    headings = @gfm_formatter.collect_headings(tree)
+
+    assert_equal([[[" heading\n"]], [[" subheading\n"]]], headings)
+  end
+
+  def test_prepare_id_conv_table
+    text = <<TEXT
+!![main-heading] heading
+
+paragraph
+
+!!![sub-heading] subheading
+
+another paragraph
+TEXT
+
+    expected_table = {
+      "main-heading" => "heading",
+      "sub-heading" => "subheading"
+    }
+
+    tree = BlockParser.parse(text)
+    id_conv_table = @gfm_formatter.prepare_id_conv_table(tree)
+
+    assert_equal(expected_table, id_conv_table)
+  end
+
+  def test_gfm_style_in_page_anchor
+    text = <<TEXT
+!![main_heading] Main Heading
+
+a paragraph
+
+!!![sub-heading] SubHeading
+
+a link to [[main heading|#main_heading]]
+TEXT
+
+    expected_text = <<TEXT
+## Main Heading
+
+a paragraph
+
+### SubHeading
+
+a link to [main heading](#main-heading)
+
+TEXT
+
+    tree = BlockParser.parse(text)
+    gfm_text = @gfm_formatter.format(tree)
+
+    assert_equal(expected_text, gfm_text)
+  end
 end
 

data/test/test_pseudohiki2html.rb

@@ -194,17 +194,17 @@ TEXT
     toc = PageComposer.new(options).create_table_of_contents(@parsed_tree)
     assert_equal("", toc)
 
-    toc_in_plain_text = <<TEXT
-  * Heading1
-  * Heading2
-    * Heading2-1
+    toc_in_gfm_text = <<TEXT
+  * [Heading1](#heading1)
+  * [Heading2](#heading2)
+    * [Heading2-1](#heading21)
 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)
+    assert_equal(toc_in_gfm_text, toc)
 
     toc_in_html = <<TEXT
 <ul>
@@ -293,12 +293,12 @@ paragraph
 </html>
 HTML
 
-    expected_plain_text = <<TEXT
+    expected_gfm_text = <<TEXT
 ## table of contents
 
-  * Heading1
-  * Heading2
-    * Heading2-1
+  * [Heading1](#heading1)
+  * [Heading2](#heading2)
+    * [Heading2-1](#heading21)
 
 # Title
 
@@ -329,8 +329,8 @@ TEXT
     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)
+    composed_gfm_text = PageComposer.new(options).compose_html(@input_lines).join
+    assert_equal(expected_gfm_text, composed_gfm_text)
   end
 
   def test_output_in_gfm_with_toc
@@ -355,8 +355,8 @@ output = <<GFM
 
 ## Table of Contents
 
-  * The first heading
-  * The second heading
+  * [The first heading](#the-first-heading)
+  * [The second heading](#the-second-heading)
 
 ## The first heading
 

data/test/test_pseudohikiparser.rb

@@ -33,7 +33,7 @@ TEXT
 the first paragraph with <em>inline</em> <code>tags</code>
 </p>
 <p>
-the second paragraph with <del>block</del> <a href="#id">inline</a> tags
+the second paragraph with <del>block</del> <a href="#ID">inline</a> tags
 </p>
 <!-- end of section h2 -->
 </div>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pseudohikiparser
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3.develop
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-30 00:00:00.000000000 Z
+date: 2015-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,7 +74,9 @@ files:
 - lib/pseudohiki/inlineparser.rb
 - lib/pseudohiki/markdownformat.rb
 - lib/pseudohiki/plaintextformat.rb
+- lib/pseudohiki/sinatra_helpers.rb
 - lib/pseudohiki/treestack.rb
+- lib/pseudohiki/utils.rb
 - lib/pseudohiki/version.rb
 - lib/pseudohikiparser.rb
 - test/test_blockparser.rb
@@ -105,12 +107,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: 'PseudoHikiParser: a parser of texts in a Hiki like notation.'