pseudohikiparser 0.0.0.14.develop → 0.0.1

data/lib/pseudohiki/blockparser.rb

@@ -37,15 +37,15 @@ module PseudoHiki
     end
 
     class BlockStack < TreeStack
-      def pop_with_breaker(breaker=nil)
-        self.current_node.parse_leafs(breaker)
-        pop
+      def pop
+        self.current_node.parse_leafs
+        super
       end
     end
 
     class BlockLeaf < BlockStack::Leaf
       @@head_re = {}
-      attr_accessor :nominal_level, :node_id, :decorator
+      attr_accessor :nominal_level, :node_id
 
       def self.head_re=(head_regex)
         @self_head_re = @@head_re[self] = head_regex
@@ -85,7 +85,7 @@ module PseudoHiki
         super(stack)
       end
 
-      def parse_leafs(breaker)
+      def parse_leafs
         parsed = InlineParser.parse(self.join)
         self.clear
         self.concat(parsed)
@@ -135,10 +135,6 @@ 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)
@@ -148,7 +144,7 @@ module PseudoHiki
         not (kind_of?(breaker.block) and nominal_level == breaker.nominal_level)
       end
 
-      def parse_leafs(breaker); end
+      def parse_leafs; end
 
       def in_link_tag?(preceding_str)
         preceding_str[-2, 2] == "[[".freeze or preceding_str[-1, 1] == "|".freeze
@@ -160,7 +156,7 @@ module PseudoHiki
 
       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
 
@@ -172,8 +168,8 @@ module PseudoHiki
     end
 
     class NonNestedBlockNode < BlockNode
-      def parse_leafs(breaker)
-        self.each {|leaf| leaf.parse_leafs(breaker) }
+      def parse_leafs
+        self.each {|leaf| leaf.parse_leafs }
       end
     end
 
@@ -193,11 +189,11 @@ module PseudoHiki
 
     module BlockElement
       {
-        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf DecoratorLeaf),
+        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),
+        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode),
         NonNestedBlockNode => %w(QuoteNode ParagraphNode),
         NestedBlockNode => %w(HeadingNode),
         ListTypeBlockNode => %w(ListNode EnumNode),
@@ -222,43 +218,15 @@ module PseudoHiki
       attr_accessor :in_block_tag
 
       def add_leaf(line, blockparser)
-        return @stack.pop_with_breaker if LINE_PAT::VERBATIM_END =~ line
+        return @stack.pop 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(breaker)
+      def parse_leafs
         self[0] = BlockParser.parse(self[0])
       end
     end
@@ -316,8 +284,7 @@ module PseudoHiki
      [ParagraphLeaf, ParagraphNode],
      [HrLeaf, HrNode],
      [ListLeaf, ListNode],
-     [EnumLeaf, EnumNode],
-     [DecoratorLeaf, DecoratorNode]
+     [EnumLeaf, EnumNode]
     ].each do |leaf, node|
       ParentNode[leaf] = node
     end
@@ -326,31 +293,28 @@ module PseudoHiki
 
     def self.assign_head_re
       irregular_leafs = [BlockNodeEnd, VerbatimLeaf, HrLeaf]
-      irregular_head_pats, regular_leaf_types, head_to_leaf = [], [], {}
+      head_pats, leaf_types = [], [:entire_matched_part]
       [['\r?\n?$', BlockNodeEnd],
-       ['\s', VerbatimLeaf],
-       ['*', ListLeaf],
-       ['#', EnumLeaf],
        [':', DescLeaf],
-       ['!', HeadingLeaf],
+       ['\s', VerbatimLeaf],
        ['""', QuoteLeaf],
        ['||', TableLeaf],
-       ['//@', DecoratorLeaf],
        ['//', CommentOutLeaf],
+       ['!', HeadingLeaf],
+       ['*', ListLeaf],
+       ['#', EnumLeaf],
        ['----\s*$', HrLeaf]
       ].each do |head, leaf|
         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_to_leaf[head] = leaf
-        irregular_head_pats.push "(#{escaped_head})" if irregular_leafs.include?(leaf)
-        regular_leaf_types.push head unless irregular_leafs.include?(leaf)
+        head_pats.push "(#{escaped_head})"
+        leaf_types.push leaf
       end
-      irregular_leaf_types = [:entire_matched_part].concat(irregular_leafs)
-      return Regexp.new('\\A(?:'+irregular_head_pats.join('|')+')'), regular_leaf_types, head_to_leaf, irregular_leaf_types, irregular_leafs.length
+      return Regexp.new('\\A(?:'+head_pats.join('|')+')'), leaf_types, leaf_types.length - 1
     end
 
-    IRREGULAR_HEAD_PAT, REGULAR_LEAF_TYPES, HEAD_TO_LEAF, IRREGULAR_LEAF_TYPES, NUMBER_OF_IRREGULAR_LEAF_TYPES = 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
@@ -365,16 +329,15 @@ module PseudoHiki
     end
 
     def select_leaf_type(line)
-      matched = IRREGULAR_HEAD_PAT.match(line)
-      1.upto(NUMBER_OF_IRREGULAR_LEAF_TYPES) {|i| return IRREGULAR_LEAF_TYPES[i] if matched[i] } if matched
-      REGULAR_LEAF_TYPES.each {|head| return HEAD_TO_LEAF[head] if line.start_with?(head) }
-      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)
       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
 end

data/lib/pseudohiki/htmlformat.rb

@@ -61,7 +61,6 @@ module PseudoHiki
 
     def visit(tree)
       htmlelement = create_self_element(tree)
-      decorate(htmlelement, tree)
       push_visited_results(htmlelement, tree)
       htmlelement
     end
@@ -79,21 +78,6 @@ 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|
@@ -191,14 +175,6 @@ 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/markdownformat.rb

@@ -140,6 +140,7 @@ module PseudoHiki
 
     class LinkNodeFormatter < self
       def visit(tree)
+        not_from_thumbnail = tree.first.class != LinkNode
         tree = tree.dup
         element = create_self_element
         caption = get_caption(tree)
@@ -149,7 +150,7 @@ module PseudoHiki
           raise NoMethodError unless tree.empty?
           STDERR.puts "No uri is specified for #{caption}"
         end
-        element.push "!" if ImageSuffix =~ ref
+        element.push "!" if ImageSuffix =~ ref and not_from_thumbnail
         element.push "[#{(caption||tree).join}](#{tree.join})"
         element
       end
@@ -243,14 +244,13 @@ 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 "```#{@language_name + $/}"
+          lines.unshift "```#{$/}"
           lines.push "```#{$/ * 2}"
         end
       end
@@ -258,12 +258,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.0.14.develop"
+  VERSION = "0.0.1"
 end

data/lib/pseudohikiparser.rb

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

data/test/test_blockparser.rb

@@ -311,35 +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_comment_out_followed_by_a_verbatim_block
     text = <<TEXT
 the first paragraph

data/test/test_htmlformat.rb

@@ -696,69 +696,6 @@ 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_markdownformat.rb

@@ -68,6 +68,13 @@ IMAGE
     assert_equal("A test for a link to ![an image](image.png)\n#{$/}", @formatter.format(tree).to_s)
   end
 
+  def test_link_from_image
+    text = "[[[[thumbnail of an image|http://www.example.org/image_thumb.png]]|http://www.example.org/image.png]]"
+
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal("[![thumbnail of an image](http://www.example.org/image_thumb.png)](http://www.example.org/image.png)#{$/}", @formatter.format(tree).to_s)
+  end
+
   def test_em
     text = "string with ''emphasis'' "
     tree = BlockParser.parse(text.lines.to_a)
@@ -501,65 +508,5 @@ 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
 end