pseudohikiparser 0.0.3 → 0.0.4.develop

data/lib/pseudohikiparser.rb

@@ -3,6 +3,7 @@
 require "pseudohiki/htmlformat"
 require "pseudohiki/plaintextformat"
 require "pseudohiki/markdownformat"
+require 'pseudohiki/autolink'
 require "pseudohiki/version"
 
 # = PseudoHikiParser -- A converter of texts written in a Hiki-like notation into HTML or other formats.
@@ -13,25 +14,41 @@ module PseudoHiki
   # This class provides class methods for converting texts written in a Hiki-like notation into HTML or other formats.
   #
   class Format
-    @@formatter = {}
-    @@preset_options = {}
-    @@type_to_formatter = {}
+    @formatter = {}
+    @preset_options = {}
+    @type_to_formatter = {}
+    @html_types = [:html, :xhtml, :html5]
 
     [
      [:html, HtmlFormat, nil],
      [:xhtml, XhtmlFormat, nil],
      [:html5, Xhtml5Format, nil],
-     [:plain, PlainTextFormat, {:verbose_mode => false }],
-     [:plain_verbose, PlainTextFormat, {:verbose_mode => true }],
-     [:markdown, MarkDownFormat, { :strict_mode=> false, :gfm_style => false }],
-     [:gfm, MarkDownFormat, { :strict_mode=> false, :gfm_style => true }]
+     [:plain, PlainTextFormat, { :verbose_mode => false }],
+     [:plain_verbose, PlainTextFormat, { :verbose_mode => true }],
+     [:markdown, MarkDownFormat, { :strict_mode => false, :gfm_style => false }],
+     [: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
 
+    def self.select_formatter(format_type, options)
+      if options
+        @formatter[[format_type, options]] ||= @type_to_formatter[format_type].create(options)
+      else
+        @formatter[@preset_options[format_type]]
+      end
+    end
+
+    def self.auto_link_url?(auto_linker)
+      return true if auto_linker.nil?
+      auto_linker.auto_link_url?
+    end
+
+    private_class_method :select_formatter, :auto_link_url?
+
     # Converts <hiki_data> into a format specified by <format_type>
     #
     # <hiki_data> should be a string or an array of strings
@@ -45,14 +62,16 @@ module PseudoHiki
     # [:markdown] Markdown
     # [:gfm] GitHub Flavored Markdown
     #
-    def self.format(hiki_data, format_type, options=nil, &block)
-      tree = BlockParser.parse(hiki_data)
+    def self.format(hiki_data, format_type, options=nil,
+                    auto_linker=BlockParser.auto_linker, &block)
+      tree = BlockParser.parse(hiki_data, auto_linker)
+      formatter = select_formatter(format_type, options)
 
-      if options
-        @@formatter[[format_type, options]] ||= @@type_to_formatter[format_type].create(options)
+      if @html_types.include? format_type
+        formatter.format(tree, { :auto_link_in_verbatim => auto_link_url?(auto_linker) })
       else
-        @@formatter[@@preset_options[format_type]]
-      end.format(tree).tap do |formatted|
+        formatter.format(tree)
+      end.tap do |formatted|
         block.call(formatted) if block
       end.to_s
     end
@@ -92,42 +111,44 @@ module PseudoHiki
     #    <!-- end of section h2 -->
     #    </div>
     #
-    def self.to_html(hiki_data, &block)
-      format(hiki_data, :html, options=nil, &block)
+    def self.to_html(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :html, nil, auto_linker, &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)
+    def self.to_xhtml(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :xhtml, nil, auto_linker, &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)
+    def self.to_html5(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :html5, nil, auto_linker, &block)
     end
 
     # Converts <hiki_data> into plain texts without tags
     #
-    def self.to_plain(hiki_data, &block)
-      format(hiki_data, :plain, options=nil, &block)
+    def self.to_plain(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :plain, nil, auto_linker, &block)
     end
 
     # Converts <hiki_data> into Markdown
     #
-    def self.to_markdown(hiki_data, &block)
-      format(hiki_data, :markdown, options=nil, &block)
+    def self.to_markdown(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :markdown, nil, auto_linker, &block)
     end
 
     # Converts <hiki_data> into GitHub Flavored Markdown
     #
-    def self.to_gfm(hiki_data, &block)
-      format(hiki_data, :gfm, options=nil, &block)
+    def self.to_gfm(hiki_data, auto_linker=BlockParser.auto_linker, &block)
+      format(hiki_data, :gfm, nil, auto_linker, &block)
     end
   end
 end
+
+require 'pseudohiki/sinatra_helpers' if defined? Sinatra

data/test/test_autolink.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'minitest/autorun'
+require 'lib/pseudohiki/blockparser'
+require 'lib/pseudohiki/htmlformat'
+require 'lib/pseudohiki/autolink'
+
+class TC_WikiName < MiniTest::Unit::TestCase
+  include PseudoHiki
+
+
+  def test_link_only_url
+    text = <<TEXT
+a line with a url http://www.example.org/ and a WikiName.
+TEXT
+
+    xhtml = <<HTML
+<p>
+a line with a url <a href="http://www.example.org/">http://www.example.org/</a> and a WikiName.
+</p>
+HTML
+    auto_linker = AutoLink::WikiName.new({:wiki_name => false})
+    tree = BlockParser.parse(text.lines.to_a, auto_linker)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_link_wiki_name
+    text = <<TEXT
+a line with a url http://www.example.org/ , an ^EscapedWikiName and a WikiName.
+TEXT
+
+    xhtml = <<HTML
+<p>
+a line with a url <a href="http://www.example.org/">http://www.example.org/</a> , an EscapedWikiName and a <a href="WikiName">WikiName</a>.
+</p>
+HTML
+    auto_linker = AutoLink::WikiName.new
+    tree = BlockParser.parse(text.lines.to_a, auto_linker)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_not_escape_wiki_name
+    text = <<TEXT
+a line with a url http://www.example.org/ , an ^EscapedWikiName and a WikiName.
+TEXT
+
+    xhtml = <<HTML
+<p>
+a line with a url <a href="http://www.example.org/">http://www.example.org/</a> , an ^<a href="EscapedWikiName">EscapedWikiName</a> and a <a href="WikiName">WikiName</a>.
+</p>
+HTML
+    auto_linker = AutoLink::WikiName.new({:wiki_name => true, :escape_wiki_name => false})
+    tree = BlockParser.parse(text.lines.to_a, auto_linker)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_link_only_wiki_name
+    text = <<TEXT
+a line with a url http://www.example.org/ , an ^EscapedWikiName and a WikiName.
+TEXT
+
+    xhtml = <<HTML
+<p>
+a line with a url http://www.example.org/ , an EscapedWikiName and a <a href="WikiName">WikiName</a>.
+</p>
+HTML
+    auto_linker = AutoLink::WikiName.new({:url => false, :wiki_name => true, :escape_wiki_name => true})
+    tree = BlockParser.parse(text.lines.to_a, auto_linker)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+  end
+
+  def test_link_wiki_name_in_quote
+    text = <<TEXT
+""a line with a url http://www.example.org/ , an ^EscapedWikiName and a WikiName.
+TEXT
+
+    xhtml = <<HTML
+<blockquote>
+<p>
+a line with a url <a href="http://www.example.org/">http://www.example.org/</a> , an EscapedWikiName and a <a href="WikiName">WikiName</a>.
+</p>
+</blockquote>
+HTML
+
+    wikiname_off_xhtml = <<HTML
+<blockquote>
+<p>
+a line with a url <a href="http://www.example.org/">http://www.example.org/</a> , an ^EscapedWikiName and a WikiName.
+</p>
+</blockquote>
+HTML
+    auto_linker = AutoLink::WikiName.new({:wiki_name => true, :escape_wiki_name => true})
+    tree = BlockParser.parse(text.lines.to_a, auto_linker)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+
+    BlockParser.auto_linker = AutoLink::WikiName.new({:wiki_name => true, :escape_wiki_name => true})
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal(xhtml, XhtmlFormat.format(tree).to_s)
+
+    BlockParser.auto_linker = nil
+    tree = BlockParser.parse(text.lines.to_a)
+    assert_equal(wikiname_off_xhtml, XhtmlFormat.format(tree).to_s)
+  end
+end

data/test/test_blockparser.rb

@@ -39,7 +39,7 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     paragraph_line = "This is a paragraph."
     paragraph = parser.select_leaf_type(paragraph_line).create(paragraph_line)
     assert_equal([paragraph_line], paragraph)
-    assert_equal(nil, paragraph.nominal_level)
+    assert_equal(nil, paragraph.level)
   end
 
   def test_nestedleaf_create
@@ -47,12 +47,12 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     level1_heading_line = "!This is a level1 heading."
     heading1 = parser.select_leaf_type(level1_heading_line).create(level1_heading_line)
     assert_equal([["This is a level1 heading."]], heading1)
-    assert_equal(1, heading1.nominal_level)
+    assert_equal(1, heading1.level)
 
     level2_heading_line = "!!This is a level2 heading."
     heading2 = parser.select_leaf_type(level2_heading_line).create(level2_heading_line)
     assert_equal([["This is a level2 heading."]], heading2)
-    assert_equal(2, heading2.nominal_level)
+    assert_equal(2, heading2.level)
   end
 
   def test_select_leaf_type
@@ -85,7 +85,7 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     stack.push create_leaf(paragraph_str)
     paragraph_tree = stack.tree
     assert_equal([[[paragraph_str]]],paragraph_tree)
-    assert_equal(nil,paragraph_tree.first.nominal_level)
+    assert_equal(nil,paragraph_tree.first.level)
     another_paragraph = create_leaf(another_paragraph_str)
     stack.push another_paragraph
     assert_equal([[[paragraph_str,
@@ -96,7 +96,7 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     stack.push create_leaf("!"+heading_str)
     heading_tree = stack.tree
 #    heading_tree = push_leaf_on_stack("!"+heading_str).tree
-    assert_equal(1,heading_tree.first.nominal_level)
+    assert_equal(1,heading_tree.first.level)
     assert_equal(HeadingNode, heading_tree.first.class)
     assert_equal(HeadingLeaf, heading_tree.first.first.class)
     stack.push create_leaf("!!"+heading_str)
@@ -107,7 +107,7 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     stack.push create_leaf("!!"+heading_str)
     heading2_tree = stack.tree
     assert_equal([[[[heading_str]]]], heading2_tree)
-    assert_equal(2,heading2_tree.first.nominal_level)
+    assert_equal(2,heading2_tree.first.level)
 
     stack = PseudoHiki::BlockParser.new.stack
     stack.push create_leaf("!"+heading_str)
@@ -180,11 +180,11 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     parser.stack.push list2_leaf
     current_node_superclass = parser.stack.current_node.class.superclass
     leaf_superclass = list1_leaf.block.superclass
-    assert_equal(2, parser.stack.current_node.nominal_level)
+    assert_equal(2, parser.stack.current_node.level)
     assert_equal(ListNode, list1_leaf.block)
-    assert_equal(1, list1_leaf.nominal_level)
+    assert_equal(1, list1_leaf.level)
     assert_equal(ListNode, list2_leaf.block)
-    assert_equal(2, list2_leaf.nominal_level)
+    assert_equal(2, list2_leaf.level)
     assert_equal(ListWrapNode, parser.stack.current_node.class)
 #    assert_equal(true, parser.stack.current_node.class.kind_of?(PseudoHiki::BlockParser::ListTypeBlockNode))
     assert_equal(PseudoHiki::BlockParser::ListLeafNode, current_node_superclass)
@@ -192,8 +192,8 @@ class TC_BlockLeaf < MiniTest::Unit::TestCase
     assert_equal(false, current_node_superclass == leaf_superclass)
     assert_equal(true, PseudoHiki::BlockParser::ListTypeBlockNode == leaf_superclass)
     assert_equal(true, parser.breakable?(blocknode_end))
-    assert_equal(false, parser.stack.current_node.nominal_level <= list1_leaf.nominal_level)
-    assert_equal(true, parser.stack.current_node.nominal_level <= list2_leaf.nominal_level)
+    assert_equal(false, parser.stack.current_node.level <= list1_leaf.level)
+    assert_equal(true, parser.stack.current_node.level <= list2_leaf.level)
     assert_equal(true, parser.breakable?(list1_leaf))
     assert_equal(true, parser.breakable?(list2_leaf))
     parser.stack.pop
@@ -311,6 +311,73 @@ 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