pseudohikiparser 0.0.6.develop → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98aa9c74058bd6a6da9f43b9f2c7d73872db41c9
-  data.tar.gz: d921304c72c05629e616d47899b28e09c7fc91ab
+  metadata.gz: d25782e47a5041970f1724029b8a048fd453c302
+  data.tar.gz: 8b2bfb67cf20795f7c43c8de5df1f7df986d72fd
 SHA512:
-  metadata.gz: 4f1a030cee17f773f7f9489270874d462c4d1da7c6fa57b86830910a13018e5ee0757155d97e8e07de503cd2f22237bd515151de3583d187ac62aaf703120d37
-  data.tar.gz: 793b3d2c14b5b36fc6ee964c838f9f630a017c3a78cc7e35ab2457fed631c405487ecf0c489da88fd2a5f3342ebb9425831eebd8bb28293682bfdf2834df8481
+  metadata.gz: c993101868e60327fe8ad381fb1e4a2999c812ce567d61bad8e018b7321dc075cfff7465ed93fea751886a133531a1afc9933fdfa67b909a77dd6b8a3fa628fe
+  data.tar.gz: 50ebcfe2480943bc124d38f854a2c5755ff071f745530f3e336fd2815df796310c91dd4735249027d4b189770e6b18ace56b305a4759a7fc87e0c2d565f590ac

data/lib/pseudohiki/blockparser.rb

@@ -39,21 +39,14 @@ module PseudoHiki
     end
 
     class BlockStack < TreeStack
-      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
+      def pop
+        current_node.parse_leafs
+        super
       end
     end
 
     class BlockLeaf < BlockStack::Leaf
-      attr_accessor :level, :node_id, :decorator
+      attr_accessor :level, :node_id
 
       class << self
         attr_accessor :head_re
@@ -89,7 +82,7 @@ module PseudoHiki
         super(stack)
       end
 
-      def parse_leafs(breaker)
+      def parse_leafs
         parsed = InlineParser.parse(join)
         clear
         concat(parsed)
@@ -139,10 +132,6 @@ 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)
@@ -152,11 +141,11 @@ module PseudoHiki
         not (kind_of? breaker.block and level == breaker.level)
       end
 
-      def parse_leafs(breaker); end
+      def parse_leafs; end
 
       def add_leaf(line, blockparser)
         leaf = create_leaf(line, blockparser)
-        blockparser.stack.pop_with_breaker(leaf) while blockparser.breakable?(leaf)
+        blockparser.stack.pop while blockparser.breakable?(leaf)
         blockparser.stack.push leaf
       end
 
@@ -168,8 +157,8 @@ module PseudoHiki
     end
 
     class NonNestedBlockNode < BlockNode
-      def parse_leafs(breaker)
-        each {|leaf| leaf.parse_leafs(breaker) }
+      def parse_leafs
+        each {|leaf| leaf.parse_leafs }
       end
     end
 
@@ -187,15 +176,13 @@ module PseudoHiki
       end
     end
 
-    class UnmatchedSectioningTagError < StandardError; end
-
     module BlockElement
       {
-        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf DecoratorLeaf SectioningNodeEnd),
+        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf),
         NonNestedBlockLeaf => %w(QuoteLeaf ParagraphLeaf),
         NestedBlockLeaf => %w(HeadingLeaf),
         ListTypeLeaf => %w(ListLeaf EnumLeaf),
-        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode DecoratorNode SectioningNode),
+        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode),
         NonNestedBlockNode => %w(QuoteNode ParagraphNode),
         NestedBlockNode => %w(HeadingNode),
         ListTypeBlockNode => %w(ListNode EnumNode),
@@ -218,100 +205,15 @@ module PseudoHiki
         attr_accessor :in_block_tag
 
         def add_leaf(line, blockparser)
-          return @stack.pop_with_breaker if VERBATIM_END.match? line
+          return @stack.pop if VERBATIM_END.match? line
           return super(line, blockparser) unless @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(breaker)
+        def parse_leafs
           self[0] = BlockParser.parse(self[0], AutoLink::Off)
         end
       end
@@ -372,8 +274,7 @@ module PseudoHiki
      [HrLeaf, HrNode],
      [ListLeaf, ListNode],
      [EnumLeaf, EnumNode],
-     [BlockNodeEnd, BlockNodeEnd], # special case
-     [DecoratorLeaf, DecoratorNode]
+     [BlockNodeEnd, BlockNodeEnd] # special case
     ].each do |leaf, node|
       PARENT_NODE[leaf] = node
     end
@@ -386,7 +287,6 @@ module PseudoHiki
                           ['!', HeadingLeaf],
                           ['""', QuoteLeaf],
                           ['||', TableLeaf],
-                          ['//@', DecoratorLeaf],
                           ['//', CommentOutLeaf],
                           ['----\s*$', HrLeaf]]
 
@@ -432,7 +332,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_with_breaker
+      @stack.pop
     end
   end
 

data/lib/pseudohiki/htmlformat.rb

@@ -78,7 +78,6 @@ module PseudoHiki
 
     def visit(tree, memo)
       htmlelement = create_element(tree)
-      decorate(htmlelement, tree)
       push_visited_results(htmlelement, tree, memo)
       htmlelement
     end
@@ -97,21 +96,6 @@ 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|
@@ -137,7 +121,6 @@ module PseudoHiki
      [EnumNode, "ol"],
      [TableLeaf, "tr"],
      [VerbatimNode, "pre"],
-     [SectioningNode, "section"],
      [CommentOutNode, nil],
      [HeadingNode, "section"],
      [DescLeaf, DT],
@@ -206,23 +189,6 @@ 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, memo)
         contents = add_link(@generator.escape(tree.join))
@@ -237,37 +203,6 @@ 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, memo); BLANK; end
     end

data/lib/pseudohiki/markdownformat.rb

@@ -275,14 +275,13 @@ module PseudoHiki
     class VerbatimNodeFormatter < self
       def visit(tree, memo)
         element = super(tree, memo)
-        @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 "```#{@language_name + $/}"
+          lines.unshift "```#{$/}"
           lines.push "```#{$/ * 2}"
         end
       end
@@ -290,12 +289,6 @@ 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

data/lib/pseudohiki/version.rb

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

data/lib/pseudohikiparser.rb

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

data/test/test_blockparser.rb

@@ -311,73 +311,6 @@ 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_sectioning_node
-    text = <<TEXT
-! Main title
-
-//@begin[header]
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-//@end[header]
-
-!! first subtitle in main part
-
-paragraph3
-
-TEXT
-
-    expected_tree = [[[[" Main title\n"]],
-                      [
-                       [[[" first title in header\n"]],
-                        [[["paragraph\n"]]]],
-                       [[[" second title in header\n"]],
-                        [[["paragraph2\n"]]]]
-                      ],
-                      [[[" first subtitle in main part\n"]],
-                       [[["paragraph3\n"]]]]]]
-
-
-    tree = PseudoHiki::BlockParser.parse(text)
-    assert_equal(expected_tree, tree)
-    assert_kind_of(PseudoHiki::BlockParser::BlockElement::SectioningNode, tree[0][1])
-    assert_equal("header", tree[0][1].node_id)
-  end
-
   def test_comment_out_followed_by_a_verbatim_block
     text = <<TEXT
 the first paragraph

data/test/test_htmlelement_utils.rb

@@ -135,19 +135,11 @@ table_with_col_header_text = <<TABLE
 ||!header1||col1-1||col2-1
 ||!header2||col1-2||col2-2
 ||!header3||col1-3||col2-3
-TABLE
-
-table_with_row_header_and_caption_text = <<TABLE
-//@caption: Caption
-||!header1||!header2||!header3
-||row1-1||row1-2||row1-3
-||row2-1||row2-2||row2-3
 TABLE
 
     @table_manager = HtmlElement::Utils::TableManager.new
     @table_with_row_header = PseudoHiki::BlockParser.parse(table_with_row_header_text)
     @table_with_col_header = PseudoHiki::BlockParser.parse(table_with_col_header_text)
-    @table_with_row_header_and_caption = PseudoHiki::BlockParser.parse(table_with_row_header_and_caption_text)
 
   end
 
@@ -157,9 +149,6 @@ TABLE
 
     html_table = PseudoHiki::HtmlFormat.format(@table_with_col_header)[0]
     assert_equal("row", @table_manager.guess_header_scope(html_table))
-
-    html_table = PseudoHiki::HtmlFormat.format(@table_with_row_header_and_caption)[0]
-    assert_equal("col", @table_manager.guess_header_scope(html_table))
   end
 
   def test_assign_scope

data/test/test_htmlformat.rb

@@ -775,419 +775,6 @@ HTML
     assert_equal(xhtml, HtmlFormat.format(tree, {:auto_link_in_verbatim => false }).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_table_summary
-    text = <<TEXT
-//@summary: Summary of the table
-||!header 1||! header 2
-TEXT
-
-    xhtml = <<HTML
-<table summary="Summary of the table">
-<tr><th>header 1</th><th> header 2
-</th></tr>
-</table>
-HTML
-    tree = BlockParser.parse(text.lines.to_a.map {|line| line })
-    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
-  end
-
-  def test_decorator_for_table_caption
-    text = <<TEXT
-//@caption: Caption of ''the table''
-||!header 1||! header 2
-||cell 1||cell 2
-TEXT
-
-    xhtml = <<HTML
-<table>
-<caption>Caption of <em>the table</em></caption>
-<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_table_caption_with_tags
-    text = <<TEXT
-//@caption: [[''Table caption''that begins with a link|http://www.example.org/]] and contains other strings
-||!header 1||! header 2
-TEXT
-
-    xhtml = <<HTML
-<table>
-<caption><a href="http://www.example.org/"><em>Table caption</em>that begins with a link</a> and contains other strings</caption>
-<tr><th>header 1</th><th> header 2</th></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_sectioning_node
-        text = <<TEXT
-! Main title
-
-//@begin[header]
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-//@end[header]
-
-!! first subtitle in main part
-
-paragraph3
-
-//@begin[#footer]
-
-paragraph4
-
-//@end[#footer]
-
-TEXT
-
-    expected_html = <<HTML
-<div class="section h1">
-<h1> Main title
-</h1>
-<div class="header">
-<div class="section h2">
-<h2> first title in header
-</h2>
-<p>
-paragraph
-</p>
-<!-- end of section h2 -->
-</div>
-<div class="section h2">
-<h2> second title in header
-</h2>
-<p>
-paragraph2
-</p>
-<!-- end of section h2 -->
-</div>
-<!-- end of header -->
-</div>
-<div class="section h2">
-<h2> first subtitle in main part
-</h2>
-<p>
-paragraph3
-</p>
-<div class="section" id="footer">
-<p>
-paragraph4
-</p>
-<!-- end of footer -->
-</div>
-<!-- end of section h2 -->
-</div>
-<!-- end of section h1 -->
-</div>
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_html, XhtmlFormat.format(tree).to_s)
-  end
-
-  def test_sectioning_node_for_html5
-        text = <<TEXT
-! Main title
-
-//@begin[header]
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-//@end[header]
-
-!! first subtitle in main part
-
-paragraph3
-
-//@begin[#footer]
-
-paragraph4
-
-//@end[#footer]
-
-TEXT
-
-    expected_html = <<HTML
-<section class="h1">
-<h1> Main title
-</h1>
-<header>
-<section class="h2">
-<h2> first title in header
-</h2>
-<p>
-paragraph
-</p>
-<!-- end of h2 -->
-</section>
-<section class="h2">
-<h2> second title in header
-</h2>
-<p>
-paragraph2
-</p>
-<!-- end of h2 -->
-</section>
-</header>
-<section class="h2">
-<h2> first subtitle in main part
-</h2>
-<p>
-paragraph3
-</p>
-<section id="footer">
-<p>
-paragraph4
-</p>
-<!-- end of footer -->
-</section>
-<!-- end of h2 -->
-</section>
-<!-- end of h1 -->
-</section>
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_html, Xhtml5Format.format(tree).to_s)
-  end
-
-  def test_sectioning_node_when_end_tag_is_omitted
-        text = <<TEXT
-!! First part
-
-paragraph1
-
-//@begin[first_sub_part]
-!!! first title in first sub-part
-
-paragraph2
-
-!!! second title in first sub-part
-
-paragraph3
-
-//you should put //@end[first_sub_part] here.
-
-!! Second part
-
-paragraph4
-
-//@begin[#footer]
-
-paragraph5
-
-//@end[#footer]
-
-TEXT
-
-    expected_html = <<HTML
-<div class=\"section h2\">
-<h2> First part
-</h2>
-<p>
-paragraph1
-</p>
-<div class=\"section first_sub_part\">
-<div class=\"section h3\">
-<h3> first title in first sub-part
-</h3>
-<p>
-paragraph2
-</p>
-<!-- end of section h3 -->
-</div>
-<div class=\"section h3\">
-<h3> second title in first sub-part
-</h3>
-<p>
-paragraph3
-</p>
-<!-- end of section h3 -->
-</div>
-<!-- end of section first_sub_part -->
-</div>
-<!-- end of section h2 -->
-</div>
-<div class=\"section h2\">
-<h2> Second part
-</h2>
-<p>
-paragraph4
-</p>
-<div class=\"section\" id=\"footer\">
-<p>
-paragraph5
-</p>
-<!-- end of footer -->
-</div>
-<!-- end of section h2 -->
-</div>
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_html, XhtmlFormat.format(tree).to_s)
-  end
-
-  def test_sectioning_node_when_end_tag_is_wrongly_placed
-        text = <<TEXT
-!! First part
-
-paragraph1
-
-//@begin[first_sub_part]
-!!! first title in first sub-part
-
-paragraph2
-
-!!! second title in first sub-part
-
-paragraph3
-
-//you should put //@end[first_sub_part] here.
-
-!! Second part
-
-paragraph4
-
-
-//@end[first_sub_part] this end tag is wrongly placed.
-
-//@begin[#footer]
-
-paragraph5
-
-//@end[#footer]
-
-TEXT
-
-    expected_html = <<HTML
-<div class=\"section h2\">
-<h2> First part
-</h2>
-<p>
-paragraph1
-</p>
-<div class=\"section first_sub_part\">
-<div class=\"section h3\">
-<h3> first title in first sub-part
-</h3>
-<p>
-paragraph2
-</p>
-<!-- end of section h3 -->
-</div>
-<div class=\"section h3\">
-<h3> second title in first sub-part
-</h3>
-<p>
-paragraph3
-</p>
-<!-- end of section h3 -->
-</div>
-<!-- end of section first_sub_part -->
-</div>
-<!-- end of section h2 -->
-</div>
-<div class=\"section h2\">
-<h2> Second part
-</h2>
-<p>
-paragraph4
-</p>
-<div class=\"section\" id=\"footer\">
-<p>
-paragraph5
-</p>
-<!-- end of footer -->
-</div>
-<!-- end of section h2 -->
-</div>
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_html, XhtmlFormat.format(tree).to_s)
-  end
-
   def test_comment_out_followed_by_a_verbatim_block
     text = <<TEXT
 the first paragraph

data/test/test_markdownformat.rb

@@ -518,159 +518,6 @@ TEXT
     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_without_sectioning_node
-        text = <<TEXT
-! Main title
-
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-!! first subtitle in main part
-
-paragraph3
-
-paragraph4
-
-TEXT
-
-    expected_text = <<HTML
-# Main title
-
-## first title in header
-
-paragraph
-
-## second title in header
-
-paragraph2
-
-## first subtitle in main part
-
-paragraph3
-
-paragraph4
-
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_text, @gfm_formatter.format(tree).to_s)
-  end
-
-  def test_sectioning_node
-        text = <<TEXT
-! Main title
-
-//@begin[header]
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-//@end[header]
-
-!! first subtitle in main part
-
-paragraph3
-
-//@begin[#footer]
-
-paragraph4
-
-//@end[#footer]
-
-TEXT
-
-    expected_text = <<HTML
-# Main title
-
-## first title in header
-
-paragraph
-
-## second title in header
-
-paragraph2
-
-## first subtitle in main part
-
-paragraph3
-
-paragraph4
-
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_text, @gfm_formatter.format(tree).to_s)
-  end
-
   def test_collect_headings
     text = <<TEXT
 !![main-heading] heading

data/test/test_plaintextformat.rb

@@ -265,89 +265,4 @@ TEXT
     assert_equal(expected_text_in_verbose_mode, PlainTextFormat.format(tree, { :verbose_mode => true }).to_s)
     assert_equal(expected_text, PlainTextFormat.format(tree, { :verbose_mode => false }).to_s)
   end
-
-  def test_without_sectioning_node
-        text = <<TEXT
-! Main title
-
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-!! first subtitle in main part
-
-paragraph3
-
-paragraph4
-
-TEXT
-
-    expected_text = <<HTML
- Main title
- first title in header
-paragraph
-
- second title in header
-paragraph2
-
- first subtitle in main part
-paragraph3
-
-paragraph4
-
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_text, PlainTextFormat.format(tree, { :verbose_mode => false }).to_s)
-  end
-
-  def test_sectioning_node
-        text = <<TEXT
-! Main title
-
-//@begin[header]
-!! first title in header
-
-paragraph
-
-!! second title in header
-
-paragraph2
-
-//@end[header]
-
-!! first subtitle in main part
-
-paragraph3
-
-//@begin[#footer]
-
-paragraph4
-
-//@end[#footer]
-
-TEXT
-
-    expected_text = <<HTML
- Main title
- first title in header
-paragraph
-
- second title in header
-paragraph2
-
- first subtitle in main part
-paragraph3
-
-paragraph4
-
-HTML
-
-    tree = BlockParser.parse(text.lines.to_a)
-    assert_equal(expected_text, PlainTextFormat.format(tree, { :verbose_mode => false }).to_s)
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pseudohikiparser
 version: !ruby/object:Gem::Version
-  version: 0.0.6.develop
+  version: 0.0.6
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-27 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,7 +91,6 @@ files:
 - lib/pseudohiki/markdownformat.rb
 - lib/pseudohiki/plaintextformat.rb
 - lib/pseudohiki/shim.rb
-- lib/pseudohiki/sinatra_helpers.rb
 - lib/pseudohiki/treestack.rb
 - lib/pseudohiki/utils.rb
 - lib/pseudohiki/version.rb
@@ -126,9 +125,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.6

data/lib/pseudohiki/sinatra_helpers.rb

@@ -1,23 +0,0 @@
-#!/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