pseudohikiparser 0.0.3 → 0.0.4.develop

data/lib/pseudohiki/markdownformat.rb

@@ -18,9 +18,15 @@ module PseudoHiki
     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 })
+    @default_options = { :strict_mode => false, :gfm_style => false }
+
+    def self.default_options
+      @default_options
+    end
+
+    def self.format(tree, options=MarkDownFormat.default_options)
       if Formatters.empty?
-        default_options = { :strict_mode=> false, :gfm_style => false }
+        default_options = MarkDownFormat.default_options
         Formatters[default_options] = create(default_options)
       end
 
@@ -28,15 +34,14 @@ module PseudoHiki
       Formatters[options].format(tree)
     end
 
-    def self.convert_to_gfm_id_format(heading)
+    def self.convert_into_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 })
+    def initialize(formatter={}, options=MarkDownFormat.default_options)
       @formatter = formatter
-      options_given_via_block = nil
       if block_given?
         options_given_via_block = yield
         options.merge!(options_given_via_block)
@@ -49,7 +54,7 @@ module PseudoHiki
     end
 
     def visited_result(node)
-      visitor = @formatter[node.class]||@formatter[PlainNode]
+      visitor = @formatter[node.class] || @formatter[PlainNode]
       node.accept(visitor)
     end
 
@@ -69,14 +74,14 @@ module PseudoHiki
 
     def format(tree)
       formatter = get_plain
-      @formatter[LinkNode].id_conv_table = prepare_id_conv_table(tree) if @options.gfm_style
+      prepare_id_conv_table(tree) if @options.gfm_style
       tree.accept(formatter).join
     end
 
     def list_mark(tree, mark)
       mark = mark.dup
       mark << " " if /^ /o !~ tree.join
-      " " * (tree.nominal_level - 1) * 2 + mark
+      " " * (tree.level - 1) * 2 + mark
     end
 
     def enclose_in(element, mark)
@@ -94,63 +99,56 @@ module PseudoHiki
       end
     end
 
+    def heading_to_gfm_id(heading)
+      heading_text = PlainTextFormat.format(heading).strip
+      MarkDownFormat.convert_into_gfm_id_format(heading_text)
+    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)
+            table[node_id] = heading_to_gfm_id(heading)
           end
         end
+        @formatter[LinkNode].id_conv_table = table
       end
     end
 
     def self.create(options={ :strict_mode => false })
       formatter = {}
-      main_formatter = self.new(formatter, options)
-      formatter.default = main_formatter
-
-#      formatter[PlainNode] = PlainNodeFormatter.new(formatter, options)
-#      formatter[InlineNode] = InlineNodeFormatter.new(formatter, options)
-      formatter[InlineLeaf] = InlineLeafFormatter.new(formatter, options)
-      formatter[LinkNode] = LinkNodeFormatter.new(formatter, options)
-      formatter[EmNode] = EmNodeFormatter.new(formatter, options)
-      formatter[StrongNode] = StrongNodeFormatter.new(formatter, options)
-      formatter[DelNode] = DelNodeFormatter.new(formatter, options)
-      formatter[LiteralNode] = LiteralNodeFormatter.new(formatter, options)
-      formatter[PluginNode] = PluginNodeFormatter.new(formatter, options)
-#      formatter[DescLeaf] = DescLeafFormatter.new(formatter, options)
-#      formatter[TableCellNode] = TableCellNodeFormatter.new(formatter, options)
-      formatter[VerbatimLeaf] = VerbatimLeafFormatter.new(formatter, options)
-#      formatter[QuoteLeaf] = QuoteLeafFormatter.new(formatter, options)
-#      formatter[TableLeaf] = TableLeafFormatter.new(formatter, options)
-      formatter[CommentOutLeaf] = CommentOutLeafFormatter.new(formatter, options)
-      formatter[HeadingLeaf] = HeadingLeafFormatter.new(formatter, options)
-#      formatter[ParagraphLeaf] = ParagraphLeafFormatter.new(formatter, options)
-      formatter[HrLeaf] = HrLeafFormatter.new(formatter, options)
-#      formatter[BlockNodeEnd] = BlockNodeEndFormatter.new(formatter, options)
-#      formatter[ListLeaf] = ListLeafFormatter.new(formatter, options)
-#      formatter[EnumLeaf] = EnumLeafFormatter.new(formatter, options)
-      formatter[DescNode] = DescNodeFormatter.new(formatter, options)
-      formatter[VerbatimNode] = VerbatimNodeFormatter.new(formatter, options)
-      formatter[QuoteNode] = QuoteNodeFormatter.new(formatter, options)
-      formatter[TableNode] = TableNodeFormatter.new(formatter, options)
-#      formatter[CommentOutNode] = CommentOutNodeFormatter.new(formatter, options)
-      formatter[HeadingNode] = HeadingNodeFormatter.new(formatter, options)
-      formatter[ParagraphNode] = ParagraphNodeFormatter.new(formatter, options)
-#      formatter[HrNode] = HrNodeFormatter.new(formatter, options)
-      formatter[ListNode] = ListNodeFormatter.new(formatter, options)
-      formatter[EnumNode] = EnumNodeFormatter.new(formatter, options)
-      formatter[ListWrapNode] = ListWrapNodeFormatter.new(formatter, options)
-      formatter[EnumWrapNode] = EnumWrapNodeFormatter.new(formatter, options)
-
-      main_formatter
-    end
-
-## Definitions of subclasses of MarkDownFormat begins here.
-
-#    class PlainNodeFormatter < self; end
-#    class InlineNodeFormatter < self; end
+
+      new(formatter, options).tap do |main_formatter|
+        formatter.default = main_formatter
+
+        [[InlineLeaf, InlineLeafFormatter],
+         [LinkNode, LinkNodeFormatter],
+         [EmNode, EmNodeFormatter],
+         [StrongNode, StrongNodeFormatter],
+         [DelNode, DelNodeFormatter],
+         [LiteralNode, LiteralNodeFormatter],
+         [PluginNode, PluginNodeFormatter],
+         [VerbatimLeaf, VerbatimLeafFormatter],
+         [CommentOutLeaf, CommentOutLeafFormatter],
+         [HeadingLeaf, HeadingLeafFormatter],
+         [HrLeaf, HrLeafFormatter],
+         [DescNode, DescNodeFormatter],
+         [VerbatimNode, VerbatimNodeFormatter],
+         [QuoteNode, QuoteNodeFormatter],
+         [TableNode, TableNodeFormatter],
+         [HeadingNode, HeadingNodeFormatter],
+         [ParagraphNode, ParagraphNodeFormatter],
+         [ListNode, ListNodeFormatter],
+         [EnumNode, EnumNodeFormatter],
+         [ListWrapNode, ListWrapNodeFormatter],
+         [EnumWrapNode, EnumWrapNodeFormatter]
+        ].each  do |node, formatter_class|
+          formatter[node] = formatter_class.new(formatter, options)
+        end
+      end
+    end
+
+    ## Definitions of subclasses of MarkDownFormat begins here.
 
     class InlineLeafFormatter < self
       def visit(leaf)
@@ -173,15 +171,11 @@ module PseudoHiki
         tree = tree.dup
         element = create_self_element
         caption = get_caption(tree)
-        begin
-          ref = tree.last.join
-        rescue NoMethodError
-          raise NoMethodError unless tree.empty?
-          STDERR.puts "No uri is specified for #{caption}"
+        if IMAGE_SUFFIX_RE =~ ref_tail(tree, caption) and not_from_thumbnail
+          element.push "!"
         end
-        element.push "!" if ImageSuffix =~ ref and not_from_thumbnail
         link = format_link(tree)
-        element.push "[#{(caption||tree).join}](#{link})"
+        element.push "[#{(caption || tree).join}](#{link})"
         element
       end
 
@@ -202,6 +196,13 @@ module PseudoHiki
           link
         end
       end
+
+      def ref_tail(tree, caption)
+        tree.last.join
+      rescue NoMethodError
+        raise NoMethodError unless tree.empty?
+        STDERR.puts "No uri is specified for #{caption}"
+      end
     end
 
     class EmNodeFormatter < self
@@ -234,24 +235,18 @@ module PseudoHiki
 
     class PluginNodeFormatter < self
       def visit(tree)
-        str =tree.join
+        str = tree.join
         return str.strip * 2 if str == " {" or str == "} "
         super(tree)
       end
     end
 
-#    class DescLeafFormatter < self; end
-#    class TableCellNodeFormatter < self; end
-
     class VerbatimLeafFormatter < InlineLeafFormatter
       def visit(leaf)
         leaf.join
       end
     end
 
-#    class QuoteLeafFormatter < self; end
-#    class TableLeafFormatter < self; end
-
     class CommentOutLeafFormatter < self
       def visit(tree); ""; end
     end
@@ -261,7 +256,6 @@ module PseudoHiki
         super(tree).tap {|element| element.push $/ }
       end
     end
-#    class ParagraphLeafFormatter < self; end
 
     class HrLeafFormatter < self
       def visit(tree)
@@ -269,9 +263,6 @@ module PseudoHiki
       end
     end
 
-#    class BlockNodeEndFormatter < self; end
-#    class ListLeafFormatter < self; end
-#    class EnumLeafFormatter < self; end
     class DescNodeFormatter < self
       def visit(tree)
         desc_list = HtmlElement.create("dl").tap do |element|
@@ -284,13 +275,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
@@ -298,6 +290,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
@@ -323,13 +321,13 @@ module PseudoHiki
         cell_width = calculate_cell_width(table)
         header_delimiter = cell_width.map {|width| "-" * width }
         cell_formats = cell_width.map {|width| "%-#{width}s" }
-        table[1,0] = [header_delimiter]
+        table[1, 0] = [header_delimiter]
         table.map do |row|
-          formatted_row = row.zip(cell_formats).map do |cell, format|
-            format%[cell]
+          formatted_row = row.zip(cell_formats).map do |cell, format_str|
+            sprintf(format_str, cell)
           end
           "|#{formatted_row.join("|") }|#{$/}"
-        end.join+$/
+        end.join + $/
       end
 
       def format_html_table(tree)
@@ -344,15 +342,21 @@ module PseudoHiki
         return format_gfm_table(table) if @options.gfm_conformant
 
         if @options.gfm_style == :force
-          begin
-            raise NotConformantStyleError.new("The table is not conformant to GFM style. The first row will be treated as a header row.")
-          rescue
-            STDERR.puts "The table is not conformant to GFM style. The first row will be treated as a header row."
-          end
-          return format_gfm_table(table)
+          warning_for_non_comformant_style
+          format_gfm_table(table)
+        else
+          format_html_table(tree)
         end
+      end
 
-        format_html_table(tree)
+      def warning_for_non_comformant_style
+        warning_message = <<ERROR
+The table is not conformant to GFM style.
+The first row will be treated as a header row.
+ERROR
+        raise NotConformantStyleError.new(warning_message)
+      rescue
+        STDERR.puts warning_message
       end
 
       def calculate_cell_width(table)
@@ -369,8 +373,8 @@ module PseudoHiki
         rows.each_with_index do |row, i|
           row.each do |cell|
             return false if cell.rowspan > 1 or cell.colspan > 1
-            #A table head row should be at the beginning and composed of <th> elements,
-            #and other rows should not include <th> elements
+            # 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
@@ -378,12 +382,10 @@ module PseudoHiki
       end
     end
 
-#    class CommentOutNodeFormatter < self; end
-
     class HeadingNodeFormatter < self
       def visit(tree)
         super(tree).tap do |element|
-          heading_mark = "#" * tree.first.nominal_level
+          heading_mark = "#" * tree.first.level
           heading_mark << " " if /^ /o !~ tree.join
           element.unshift heading_mark
         end
@@ -396,14 +398,10 @@ module PseudoHiki
       end
     end
 
-#    class HrNodeFormatter < self; end
-
     class ListNodeFormatter < self
       def visit(tree)
         super(tree).tap do |element|
-          if /\A\*/o =~ element.first.join
-            element.push $/
-          end
+          element.push $/ if /\A\*/o =~ element.first.join
         end
       end
     end
@@ -411,9 +409,7 @@ module PseudoHiki
     class EnumNodeFormatter < self
       def visit(tree)
         super(tree).tap do |element|
-          if /\A\d/o =~ element.first.join
-            element.push $/
-          end
+          element.push $/ if /\A\d/o =~ element.first.join
         end
       end
     end
@@ -429,7 +425,7 @@ module PseudoHiki
     class EnumWrapNodeFormatter < self
       def visit(tree)
         super(tree).tap do |element|
-          element.unshift list_mark(tree, "#{tree.nominal_level}.")
+          element.unshift list_mark(tree, "#{tree.level}.")
         end
       end
     end

data/lib/pseudohiki/plaintextformat.rb

@@ -27,9 +27,8 @@ module PseudoHiki
       Formatters[options].format(tree)
     end
 
-    def initialize(formatter={}, options = { :verbose_mode=> false })
+    def initialize(formatter={}, options={ :verbose_mode => false })
       @formatter = formatter
-      options_given_via_block = nil
       if block_given?
         options_given_via_block = yield
         options.merge!(options_given_via_block)
@@ -42,7 +41,7 @@ module PseudoHiki
     end
 
     def visited_result(node)
-      visitor = @formatter[node.class]||@formatter[PlainNode]
+      visitor = @formatter[node.class] || @formatter[PlainNode]
       node.accept(visitor)
     end
 
@@ -65,24 +64,39 @@ module PseudoHiki
       tree.accept(formatter).join
     end
 
-    def self.create(options = { :verbose_mode => false })
+    def split_into_parts(tree, separator)
+      tree = tree.dup
+      first_part = nil
+      sep_index = tree.index(separator)
+      if sep_index
+        first_part = tree.shift(sep_index)
+        tree.shift
+      end
+      return first_part, tree
+    end
+
+    def self.create(options={ :verbose_mode => false })
       formatter = {}
-      main_formatter = self.new(formatter, options)
-      formatter.default = main_formatter
 
-      formatter[InlineLeaf] = InlineLeafFormatter.new(formatter, options)
-      formatter[LinkNode] = LinkNodeFormatter.new(formatter, options)
-      formatter[DelNode] = DelNodeFormatter.new(formatter, options)
-      formatter[DescLeaf] = DescLeafFormatter.new(formatter, options)
-      formatter[VerbatimNode] = VerbatimNodeFormatter.new(formatter, options)
-      formatter[TableNode] = TableNodeFormatter.new(formatter, options)
-      formatter[CommentOutNode] = CommentOutNodeFormatter.new(formatter, options)
-      formatter[ParagraphNode] = ParagraphNodeFormatter.new(formatter, options)
-      formatter[PluginNode] = PluginNodeFormatter.new(formatter, options)
-      main_formatter
+      new(formatter, options).tap do |main_formatter|
+        formatter.default = main_formatter
+
+        [[InlineLeaf, InlineLeafFormatter],
+         [LinkNode, LinkNodeFormatter],
+         [DelNode, DelNodeFormatter],
+         [DescLeaf, DescLeafFormatter],
+         [VerbatimNode, VerbatimNodeFormatter],
+         [TableNode, TableNodeFormatter],
+         [CommentOutNode, CommentOutNodeFormatter],
+         [ParagraphNode, ParagraphNodeFormatter],
+         [PluginNode, PluginNodeFormatter]
+        ].each do |node, formatter_class|
+          formatter[node] = formatter_class.new(formatter, options)
+        end
+      end
     end
 
-## Definitions of subclasses of PlainTextFormat begins here.
+    ## Definitions of subclasses of PlainTextFormat begins here.
 
     class InlineLeafFormatter < self
       def visit(leaf)
@@ -92,30 +106,28 @@ module PseudoHiki
 
     class LinkNodeFormatter < self
       def visit(tree)
-        tree = tree.dup
         element = Node.new
-        caption = get_caption(tree)
-        begin
-          ref = tree.last.join
-        rescue NoMethodError
-          raise NoMethodError unless tree.empty?
-          STDERR.puts "No uri is specified for #{caption}"
-        end
-        if ImageSuffix =~ ref
-          element.push (caption||tree).join
+        caption, ref = get_caption(tree)
+        if IMAGE_SUFFIX_RE =~ ref_tail(ref, caption)
+          element.push (caption || ref).join
         else
-          element.push caption||tree.join
-          element.push " (#{tree.join('')})" if @options.verbose_mode and caption
+          element.push caption || ref.join
+          element.push " (#{ref.join})" if @options.verbose_mode and caption
         end
         element
       end
 
       def get_caption(tree)
-        link_sep_index = tree.find_index([LinkSep])
-        return nil unless link_sep_index
-        caption_part = tree.shift(link_sep_index)
-        tree.shift
-        caption_part.map {|element| visited_result(element) }
+        caption, ref_part = split_into_parts(tree, [LinkSep])
+        caption = caption.map {|element| visited_result(element) } if caption
+        return caption, ref_part
+      end
+
+      def ref_tail(tree, caption)
+        tree.last.join
+      rescue NoMethodError
+        raise NoMethodError unless tree.empty?
+        STDERR.puts "No uri is specified for #{caption}"
       end
     end
 
@@ -128,14 +140,10 @@ module PseudoHiki
 
     class DescLeafFormatter < self
       def visit(tree)
-        tree = tree.dup
         element = create_self_element(tree)
-        dt_sep_index = tree.index(DescSep)
-        if dt_sep_index
-          push_visited_results(element, tree.shift(dt_sep_index))
-          tree.shift
-        end
-        dd = tree.map {|token| visited_result(token) }.join.lstrip
+        dt_part, dd_part = split_into_parts(tree, DescSep)
+        push_visited_results(element, dt_part) if dt_part
+        dd = dd_part.map {|token| visited_result(token) }.join.lstrip
         unless dd.empty?
           element.push element.empty? ? "\t" : ":\t"
           element.push dd
@@ -160,11 +168,12 @@ ERROR_TEXT
       def visit(tree)
         table = 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_col = tree.map {|row| row.reduce(0) {|sum, cell| sum + cell.colspan }}.max - 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])
+          cur_cell = cur_row.shift
+          table[r][c] = visited_result(cur_cell).join.lstrip.chomp
+          fill_expand(table, r, c, cur_cell)
         end
         format_table(table, tree)
       end
@@ -175,17 +184,20 @@ ERROR_TEXT
         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?
+          if cur_row.empty?
+            warning_for_malformed_row(table[r])
+          else
             yield r, c, cur_row
-          rescue
-            raise if @options.strict_mode
-            STDERR.puts ERROR_MESSAGE%[table[r].inspect]
-            next
           end
         end
       end
 
+      def warning_for_malformed_row(row)
+        message = sprintf(ERROR_MESSAGE, row.inspect)
+        raise MalFormedTableError.new(message) if @options.strict_mode
+        STDERR.puts message
+      end
+
       def deep_copy_tree(tree)
         tree.dup.clear.tap do |new_tree|
           new_tree.concat tree.map {|node| node.dup }
@@ -206,11 +218,9 @@ ERROR_TEXT
         max_col = initial_col + cur_cell.colspan - 1
         each_cell_index(max_row, max_col,
                         initial_row, initial_col) do |r, c|
-          if initial_row == r and initial_col == c
-            table[r][c] = visited_result(cur_cell).join.lstrip.chomp
-            next
+          unless initial_row == r and initial_col == c
+            table[r][c] = initial_row == r ? col_expand : row_expand
           end
-          table[r][c] = initial_row == r ? col_expand : row_expand
         end
       end
     end
@@ -220,7 +230,7 @@ ERROR_TEXT
     end
 
     def format_table(table, tree)
-      table.map {|row| row.join("\t")+$/ }.join
+      table.map {|row| row.join("\t") + $/ }.join
     end
 
     class CommentOutNodeFormatter < self
@@ -229,13 +239,13 @@ ERROR_TEXT
 
     class ParagraphNodeFormatter < self
       def visit(tree)
-        super(tree).join+$/
+        super(tree).join + $/
       end
     end
 
     class PluginNodeFormatter < self
       def visit(tree)
-        str =tree.join
+        str = tree.join
         return str.strip * 2 if str == " {" or str == "} "
         super(tree)
       end

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/treestack.rb

@@ -34,7 +34,7 @@ class TreeStack
     def merge(leaf)
       raise NotLeafError unless leaf.kind_of? Leaf
       return nil unless leaf.kind_of? Mergeable
-      self.concat(leaf)
+      concat(leaf)
     end
   end
 
@@ -48,7 +48,7 @@ class TreeStack
     include LeafType
 
     def self.create(content=nil)
-      self.new.tap {|leaf| leaf.push content if content }
+      new.tap {|leaf| leaf.push content if content }
     end
   end
 
@@ -89,7 +89,7 @@ class TreeStack
     @current_node = node
     @stack.push node
   end
-  
+
   def push_as_leaf(node)
     @current_node.push node
   end
@@ -102,7 +102,7 @@ class TreeStack
   end
 
   def remove_current_node
-    removed_node = self.pop
+    removed_node = pop
     @current_node.pop
     removed_node
   end

data/lib/pseudohiki/utils.rb

@@ -5,7 +5,6 @@ require 'pseudohiki/blockparser'
 
 module PseudoHiki
   module Utils
-
     class NodeCollector
       attr_reader :nodes
 
@@ -15,7 +14,7 @@ module PseudoHiki
         collector.nodes
       end
 
-      def initialize (&condition)
+      def initialize(&condition)
         @nodes = []
         @condition = condition
       end

data/lib/pseudohiki/version.rb

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