pseudohikiparser 0.0.5 → 0.0.6.develop

data/lib/pseudohiki/htmlplugin.rb

@@ -8,12 +8,12 @@ require 'pseudohiki/htmlformat'
 module PseudoHiki
   class HtmlFormat
     class << Formatter[PluginNode]
-      def visit(leaf)
+      def visit(leaf, memo)
         escape_inline_tags(leaf) { HtmlPlugin.new(@element_name, leaf.join).apply }
       end
     end
   end
-  
+
   class XhtmlFormat < HtmlFormat
     Formatter = HtmlFormat::Formatter.dup
     setup_new_formatter(Formatter, XhtmlElement)
@@ -48,7 +48,7 @@ module PseudoHiki
       @with_paren = nil
       @data = parse(parsed_data.to_s)
     end
-    
+
     def apply
       self.send @plugin_name
     end

data/lib/pseudohiki/inlineparser.rb

@@ -27,7 +27,24 @@ module PseudoHiki
     tokens
   end
 
+  def self.associate_nodes_with_tags(node_tag_table)
+    from_head, from_tail, to_head, to_tail = {}, {}, {}, {}
+
+    node_tag_table.each do |node_type, head, tail|
+      from_head[head] = node_type
+      from_tail[tail] = node_type
+      to_head[node_type] = head
+      to_tail[node_type] = tail
+    end
+
+    return from_head, from_tail, to_head, to_tail
+  end
+
   class InlineParser < TreeStack
+    class << self
+      attr_reader :token_pat
+    end
+
     module InlineElement
       class InlineNode < InlineParser::Node; end
       class InlineLeaf < InlineParser::Leaf; end
@@ -41,26 +58,20 @@ module PseudoHiki
     end
     include InlineElement
 
-    HEAD = {}
-    TAIL = {}
-    NodeTypeToHead = {}
-    TokenPat = {}
-
-    [[LinkNode, "[[", "]]"],
-     [EmNode, "''", "''"],
-     [StrongNode, "'''", "'''"],
-     [DelNode, "==", "=="],
-     [LiteralNode, "``", "``"],
-     [PluginNode, "{{", "}}"]].each do |type, head, tail|
-      HEAD[head] = type
-      TAIL[tail] = type
-      NodeTypeToHead[type] = head
-    end
+    @node_tag_table = [
+      [LinkNode, "[[", "]]"],
+      [EmNode, "''", "''"],
+      [StrongNode, "'''", "'''"],
+      [DelNode, "==", "=="],
+      [LiteralNode, "``", "``"],
+      [PluginNode, "{{", "}}"]]
+
+    HEAD, TAIL, NodeTypeToHead, _ = PseudoHiki.associate_nodes_with_tags(@node_tag_table)
 
-    TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys, TAIL.keys, [LinkSep, TableSep, DescSep])
+    @token_pat = PseudoHiki.compile_token_pat(HEAD.keys, TAIL.keys, [LinkSep, TableSep, DescSep])
 
     def initialize(str)
-      @tokens = PseudoHiki.split_into_tokens(str, TokenPat[self.class])
+      @tokens = PseudoHiki.split_into_tokens(str, self.class.token_pat)
       super()
     end
 
@@ -113,7 +124,7 @@ module PseudoHiki
     include InlineElement
 
     TAIL[TableSep] = TableCellNode
-    TokenPat[self] = InlineParser::TokenPat[InlineParser]
+    @token_pat = InlineParser.token_pat
 
     class InlineElement::TableCellNode
       def parse_cellspan(token_str)

data/lib/pseudohiki/markdownformat.rb

@@ -36,7 +36,7 @@ module PseudoHiki
 
     def self.convert_into_gfm_id_format(heading)
       heading.gsub(GFM_STRIPPED_CHARS_PAT) do |char|
-        /\A\s+\Z/o =~ char ? '-'.freeze : ''.freeze
+        /\A\s+\Z/o.match?(char) ? '-'.freeze : ''.freeze
       end.downcase
     end
 
@@ -53,21 +53,23 @@ module PseudoHiki
       HtmlElement::Children.new
     end
 
-    def visited_result(node)
+    def visited_result(node, memo)
       visitor = @formatter[node.class] || @formatter[PlainNode]
-      node.accept(visitor)
+      node.accept(visitor, memo)
     end
 
-    def push_visited_results(element, tree)
-      tree.each {|token| element.push visited_result(token) }
+    def push_visited_results(element, tree, memo)
+      tree.each {|token| element.push visited_result(token, memo) }
     end
 
-    def visit(tree)
+    def visit(tree, memo)
       element = create_self_element(tree)
-      push_visited_results(element, tree)
-      element
+      push_visited_results(element, tree, memo)
+      element.tap {|elm| tap_element_in_visit(elm, tree, memo) }
     end
 
+    def tap_element_in_visit(elm, tree, memo); end
+
     def get_plain
       @formatter[PlainNode]
     end
@@ -80,7 +82,7 @@ module PseudoHiki
 
     def list_mark(tree, mark)
       mark = mark.dup
-      mark << " " if /^ /o !~ tree.join
+      mark << " " unless /^ /o.match? tree.join
       " " * (tree.level - 1) * 2 + mark
     end
 
@@ -151,7 +153,7 @@ module PseudoHiki
     ## Definitions of subclasses of MarkDownFormat begins here.
 
     class InlineLeafFormatter < self
-      def visit(leaf)
+      def visit(leaf, memo)
         leaf.map do |str|
           escaped_str = str.gsub(/([_*])/o, "\\\\\\1")
           if @options.gfm_style
@@ -166,12 +168,12 @@ module PseudoHiki
     class LinkNodeFormatter < self
       attr_writer :id_conv_table
 
-      def visit(tree)
+      def visit(tree, memo)
         not_from_thumbnail = tree.first.class != LinkNode
         tree = tree.dup
         element = create_self_element
-        caption = get_caption(tree)
-        if IMAGE_SUFFIX_RE =~ ref_tail(tree, caption) and not_from_thumbnail
+        caption = get_caption(tree, memo)
+        if IMAGE_SUFFIX_RE.match? ref_tail(tree, caption) and not_from_thumbnail
           element.push "!"
         end
         link = format_link(tree)
@@ -179,18 +181,18 @@ module PseudoHiki
         element
       end
 
-      def get_caption(tree)
+      def get_caption(tree, memo)
         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_part.map {|element| visited_result(element, memo) }
       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]]
+        if /\A#/o.match? link and gfm_link = @id_conv_table[link[1..-1]]
           "#".concat gfm_link
         else
           link
@@ -206,65 +208,63 @@ module PseudoHiki
     end
 
     class EmNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          enclose_in(element, "_")
-        end
+      def tap_element_in_visit(element, tree, memo)
+        enclose_in(element, "_")
       end
     end
 
     class StrongNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
+      def visit(tree, memo)
+        super(tree, memo).tap do |element|
           enclose_in(element, "**")
         end
       end
     end
 
     class DelNodeFormatter < self
-      def visit(tree)
-        "~~#{super(tree).join.strip}~~"
+      def visit(tree, memo)
+        "~~#{super(tree, memo).join.strip}~~"
       end
     end
 
     class LiteralNodeFormatter < self
-      def visit(tree)
-        "`#{super(tree).join.strip}`"
+      def visit(tree, memo)
+        "`#{super(tree, memo).join.strip}`"
       end
     end
 
     class PluginNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         str = tree.join
         return str.strip * 2 if str == " {" or str == "} "
-        super(tree)
+        super(tree, memo)
       end
     end
 
     class VerbatimLeafFormatter < InlineLeafFormatter
-      def visit(leaf)
+      def visit(leaf, memo)
         leaf.join
       end
     end
 
     class CommentOutLeafFormatter < self
-      def visit(tree); ""; end
+      def visit(tree, memo); ""; end
     end
 
     class HeadingLeafFormatter < self
-      def visit(tree)
-        super(tree).tap {|element| element.push $/ }
+      def tap_element_in_visit(element, tree, memo)
+        element.push $/
       end
     end
 
     class HrLeafFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         "----#{$/}"
       end
     end
 
     class DescNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         desc_list = HtmlElement.create("dl").tap do |element|
           element.push HtmlFormat.format(tree)
         end
@@ -273,15 +273,16 @@ module PseudoHiki
     end
 
     class VerbatimNodeFormatter < self
-      def visit(tree)
-        element = super(tree)
+      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 "```#{$/}"
+          lines.unshift "```#{@language_name + $/}"
           lines.push "```#{$/ * 2}"
         end
       end
@@ -289,11 +290,17 @@ 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
-      def visit(tree)
-        element = super(tree)
+      def visit(tree, memo)
+        element = super(tree, memo)
         element.join.gsub(/^/o, "> ").sub(/> \Z/o, "")
       end
     end
@@ -301,9 +308,9 @@ module PseudoHiki
     class TableNodeFormatter < PlainTextFormat::TableNodeFormatter
       class NotConformantStyleError < StandardError; end
 
-      def visit(tree)
+      def visit(tree, memo)
         @options.gfm_conformant = check_conformance_with_gfm_style(tree)
-        super(tree)
+        super(tree, memo)
       end
 
       def choose_expander_of_col_and_row
@@ -376,50 +383,50 @@ ERROR
     end
 
     class HeadingNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          heading_mark = "#" * tree.first.level
-          heading_mark << " " if /^ /o !~ tree.join
-          element.unshift heading_mark
-        end
+      def tap_element_in_visit(element, tree, memo)
+        heading_mark = "#" * tree.first.level
+        heading_mark << " " unless /^ /o.match? tree.join
+        element.unshift heading_mark
       end
     end
 
     class ParagraphNodeFormatter < self
-      def visit(tree)
-        super(tree).tap {|element| element.push $/ }
+      def tap_element_in_visit(element, tree, memo)
+        element.push $/
       end
     end
 
     class ListNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          element.push $/ if /\A\*/o =~ element.first.join
-        end
+      def tap_element_in_visit(element, tree, memo)
+        element.push $/ if /\A\*/o.match? element.first.join
       end
     end
 
     class EnumNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          element.push $/ if /\A\d/o =~ element.first.join
+      def push_visited_results(element, tree, memo)
+        memo_with_enum_count = { :original => memo, :enum_item_count => 0 }
+        tree.each do |token|
+          if token.kind_of? EnumWrapNode
+            memo_with_enum_count[:enum_item_count] += 1
+          end
+          element.push visited_result(token, memo_with_enum_count)
         end
       end
+
+      def tap_element_in_visit(element, tree, memo)
+        element.push $/ if /\A\d/o.match? element.first.join
+      end
     end
 
     class ListWrapNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          element.unshift list_mark(tree, "*")
-        end
+      def tap_element_in_visit(element, tree, memo)
+        element.unshift list_mark(tree, "*")
       end
     end
 
     class EnumWrapNodeFormatter < self
-      def visit(tree)
-        super(tree).tap do |element|
-          element.unshift list_mark(tree, "#{tree.level}.")
-        end
+      def tap_element_in_visit(element, tree, item_num)
+        element.unshift list_mark(tree, "#{item_num[:enum_item_count]}.")
       end
     end
   end

data/lib/pseudohiki/plaintextformat.rb

@@ -40,18 +40,18 @@ module PseudoHiki
       Node.new
     end
 
-    def visited_result(node)
+    def visited_result(node, memo)
       visitor = @formatter[node.class] || @formatter[PlainNode]
-      node.accept(visitor)
+      node.accept(visitor, memo)
     end
 
-    def push_visited_results(element, tree)
-      tree.each {|token| element.push visited_result(token) }
+    def push_visited_results(element, tree, memo)
+      tree.each {|token| element.push visited_result(token, memo) }
     end
 
-    def visit(tree)
+    def visit(tree, memo)
       element = create_self_element(tree)
-      push_visited_results(element, tree)
+      push_visited_results(element, tree, memo)
       element
     end
 
@@ -99,16 +99,16 @@ module PseudoHiki
     ## Definitions of subclasses of PlainTextFormat begins here.
 
     class InlineLeafFormatter < self
-      def visit(leaf)
+      def visit(leaf, memo)
         leaf.join
       end
     end
 
     class LinkNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         element = Node.new
-        caption, ref = get_caption(tree)
-        if IMAGE_SUFFIX_RE =~ ref_tail(ref, caption)
+        caption, ref = get_caption(tree, memo)
+        if IMAGE_SUFFIX_RE.match? ref_tail(ref, caption)
           element.push (caption || ref).join
         else
           element.push caption || ref.join
@@ -117,9 +117,9 @@ module PseudoHiki
         element
       end
 
-      def get_caption(tree)
+      def get_caption(tree, memo)
         caption, ref_part = split_into_parts(tree, [LinkSep])
-        caption = caption.map {|element| visited_result(element) } if caption
+        caption = caption.map {|element| visited_result(element, memo) } if caption
         return caption, ref_part
       end
 
@@ -132,18 +132,18 @@ module PseudoHiki
     end
 
     class DelNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         return "" unless @options.verbose_mode
-        "[deleted:#{tree.map {|token| visited_result(token) }.join}]"
+        "[deleted:#{tree.map {|token| visited_result(token, memo) }.join}]"
       end
     end
 
     class DescLeafFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         element = create_self_element(tree)
         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
+        push_visited_results(element, dt_part, memo) if dt_part
+        dd = dd_part.map {|token| visited_result(token, memo) }.join.lstrip
         unless dd.empty?
           element.push element.empty? ? "\t" : ":\t"
           element.push dd
@@ -153,7 +153,7 @@ module PseudoHiki
     end
 
     class VerbatimNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         tree.join
       end
     end
@@ -165,14 +165,14 @@ module PseudoHiki
 !! Please recheck if it is really what you want.
 ERROR_TEXT
 
-      def visit(tree)
+      def visit(tree, memo)
         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_row = tree.length - 1
         each_empty_cell_index(max_row, max_col, tree, table) do |r, c, cur_row|
           cur_cell = cur_row.shift
-          table[r][c] = visited_result(cur_cell).join.lstrip.chomp
+          table[r][c] = visited_result(cur_cell, memo).join.lstrip.chomp
           fill_expand(table, r, c, cur_cell)
         end
         format_table(table, tree)
@@ -234,20 +234,20 @@ ERROR_TEXT
     end
 
     class CommentOutNodeFormatter < self
-      def visit(tree); ""; end
+      def visit(tree, memo); ""; end
     end
 
     class ParagraphNodeFormatter < self
-      def visit(tree)
-        super(tree).join + $/
+      def visit(tree, memo)
+        super(tree, memo).join + $/
       end
     end
 
     class PluginNodeFormatter < self
-      def visit(tree)
+      def visit(tree, memo)
         str = tree.join
         return str.strip * 2 if str == " {" or str == "} "
-        super(tree)
+        super(tree, memo)
       end
     end
   end

data/lib/pseudohiki/shim.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+unless //.respond_to? :match?
+  class Regexp
+    def match?(str)
+      self === str
+    end
+  end
+end
+
+unless String.new.respond_to? :encode
+  require 'iconv'
+
+  class String
+    def choose_input_encoding_using_kcode
+      PseudoHiki::OptionManager::ENCODING_REGEXP.each do |pat, encoding|
+        return PseudoHiki::OptionManager::ENCODING_TO_CHARSET[encoding] if pat.match? $KCODE
+      end
+      HtmlElement::CHARSET::UTF8
+    end
+    private :choose_input_encoding_using_kcode
+
+    def encode(to, from=choose_input_encoding_using_kcode)
+      iconv = Iconv.new(to, from)
+      str = iconv.iconv(self)
+      str << iconv.iconv(nil)
+    end
+    public :encode
+  end
+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

@@ -11,8 +11,8 @@ class TreeStack
   module TreeElement
     attr_accessor :depth
 
-    def accept(visitor)
-      visitor.visit(self)
+    def accept(visitor, memo=nil)
+      visitor.visit(self, memo)
     end
   end
 
@@ -107,7 +107,7 @@ class TreeStack
     removed_node
   end
 
-  def accept(visitor)
-    visitor.visit(tree)
+  def accept(visitor, memo=nil)
+    visitor.visit(tree, memo)
   end
 end

data/lib/pseudohiki/utils.rb

@@ -19,12 +19,12 @@ module PseudoHiki
         @condition = condition
       end
 
-      def visit(tree)
+      def visit(tree, memo=nil)
         if @condition.call(tree)
           @nodes.push tree
         else
           tree.each do |node|
-            node.accept(self) if node.respond_to? :accept
+            node.accept(self, memo) if node.respond_to? :accept
           end
         end
       end

data/lib/pseudohiki/version.rb

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

data/lib/pseudohikiparser.rb

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