pseudohikiparser 0.0.3 → 0.0.4.develop

data/lib/pseudohiki/blockparser.rb

@@ -5,19 +5,16 @@ require 'pseudohiki/inlineparser'
 
 module PseudoHiki
   class BlockParser
-    URI_RE = /(?:(?:https?|ftp|file):|mailto:)[A-Za-z0-9;\/?:@&=+$,\-_.!~*\'()#%]+/ #borrowed from hikidoc
     ID_TAG_PAT = /\A\[([^\[\]]+)\]/o
 
-    module LINE_PAT
-      VERBATIM_BEGIN = /\A<<<\s*/o
-      VERBATIM_END = /\A>>>\s*/o
-      PLUGIN_BEGIN = /\{\{/o
-      PLUGIN_END = /\}\}/o
-    end
+    VERBATIM_BEGIN = /\A<<<\s*/o
+    VERBATIM_END = /\A>>>\s*/o
+    PLUGIN_BEGIN = /\{\{/o
+    PLUGIN_END = /\}\}/o
 
-    ParentNode = {}
+    PARENT_NODE = {}
 
-    attr_reader :stack
+    attr_reader :stack, :auto_linker
 
     def self.assign_node_id(leaf, node)
 #      return unless tree[0].kind_of? Array ** block_leaf:[inline_node:[token or inline_node]]
@@ -30,28 +27,35 @@ module PseudoHiki
       node
     end
 
-    def self.parse(lines)
-      parser = self.new
+    class << self
+      attr_accessor :auto_linker
+    end
+
+    def self.parse(lines, tmp_auto_linker=BlockParser.auto_linker)
+      parser = new(tmp_auto_linker)
       parser.read_lines(lines)
       parser.stack.tree
     end
 
     class BlockStack < TreeStack
-      def pop
-        self.current_node.parse_leafs
-        super
+      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
       end
     end
 
     class BlockLeaf < BlockStack::Leaf
-      attr_accessor :nominal_level, :node_id
-
-      def self.head_re=(head_regex)
-        @self_head_re = head_regex
-      end
+      attr_accessor :level, :node_id, :decorator
 
-      def self.head_re
-        @self_head_re
+      class << self
+        attr_accessor :head_re
       end
 
       def self.with_depth?
@@ -59,8 +63,8 @@ module PseudoHiki
       end
 
       def self.create(line, inline_parser=InlineParser)
-        line = line.sub(self.head_re, "".freeze) if self.head_re
-        new.concat(inline_parser.parse(line)) #leaf = self.new
+        line = line.sub(head_re, "".freeze) if head_re
+        new.concat(inline_parser.parse(line)) # leaf = self.new
       end
 
       def head_re
@@ -68,7 +72,7 @@ module PseudoHiki
       end
 
       def block
-        @parent_node ||= ParentNode[self.class]
+        @parent_node ||= PARENT_NODE[self.class]
       end
 
       def push_block(stack)
@@ -76,7 +80,7 @@ module PseudoHiki
       end
 
       def under_appropriate_block?(stack)
-        stack.current_node.kind_of? block and stack.current_node.nominal_level == nominal_level
+        stack.current_node.kind_of? block and stack.current_node.level == level
       end
 
       def push_self(stack)
@@ -84,10 +88,10 @@ module PseudoHiki
         super(stack)
       end
 
-      def parse_leafs
-        parsed = InlineParser.parse(self.join)
-        self.clear
-        self.concat(parsed)
+      def parse_leafs(breaker)
+        parsed = InlineParser.parse(join)
+        clear
+        concat(parsed)
       end
     end
 
@@ -95,8 +99,8 @@ module PseudoHiki
       include TreeStack::Mergeable
 
       def self.create(line)
-        line = line.sub(self.head_re, "".freeze) if self.head_re
-        self.new.tap {|leaf| leaf.push line }
+        line = line.sub(head_re, "".freeze) if head_re
+        new.tap {|leaf| leaf.push line }
       end
 
       def push_self(stack)
@@ -111,8 +115,8 @@ module PseudoHiki
 
     class NestedBlockLeaf < BlockLeaf
       def self.create(line)
-        m = self.head_re.match(line)
-        super(line).tap {|leaf| leaf.nominal_level = m[0].length }
+        m = head_re.match(line)
+        super(line).tap {|leaf| leaf.level = m[0].length }
       end
 
       def self.with_depth?
@@ -130,8 +134,12 @@ module PseudoHiki
     class BlockNode < BlockStack::Node
       attr_accessor :node_id
 
-      def nominal_level
-        first.nominal_level if first # @cached_nominal_level ||= (first.nominal_level if first)
+      def level
+        first.level if first # @cached_level ||= (first.level if first)
+      end
+
+      def decorator
+        first.decorator if first
       end
 
       def push_self(stack)
@@ -140,35 +148,27 @@ module PseudoHiki
       end
 
       def breakable?(breaker)
-        not (kind_of?(breaker.block) and nominal_level == breaker.nominal_level)
+        not (kind_of? breaker.block and level == breaker.level)
       end
 
-      def parse_leafs; end
-
-      def in_link_tag?(preceding_str)
-        preceding_str[-2, 2] == "[[".freeze or preceding_str[-1, 1] == "|".freeze
-      end
-
-      def tagfy_link(line)
-        line.gsub(URI_RE) {|url| in_link_tag?($`) ? url : "[[#{url}]]" }
-      end
+      def parse_leafs(breaker); end
 
       def add_leaf(line, blockparser)
         leaf = create_leaf(line, blockparser)
-        blockparser.stack.pop while blockparser.breakable?(leaf)
+        blockparser.stack.pop_with_breaker(leaf) while blockparser.breakable?(leaf)
         blockparser.stack.push leaf
       end
 
       def create_leaf(line, blockparser)
-        return BlockElement::VerbatimLeaf.create("".freeze, true) if LINE_PAT::VERBATIM_BEGIN =~ line
-        line = tagfy_link(line) if URI_RE =~ line and BlockElement::VerbatimLeaf.head_re !~ line
+        return BlockElement::VerbatimLeaf.create("".freeze, true) if VERBATIM_BEGIN =~ line
+        line = blockparser.auto_linker.link(line)
         blockparser.select_leaf_type(line).create(line)
       end
     end
 
     class NonNestedBlockNode < BlockNode
-      def parse_leafs
-        self.each {|leaf| leaf.parse_leafs }
+      def parse_leafs(breaker)
+        each {|leaf| leaf.parse_leafs(breaker) }
       end
     end
 
@@ -176,99 +176,171 @@ module PseudoHiki
 
     class ListTypeBlockNode < NestedBlockNode
       def breakable?(breaker)
-        not (breaker.block.superclass == ListTypeBlockNode and nominal_level <= breaker.nominal_level)
+        not (breaker.block.superclass == ListTypeBlockNode and level <= breaker.level)
       end
     end
 
     class ListLeafNode < NestedBlockNode
       def breakable?(breaker)
-        not (breaker.kind_of?(ListTypeLeaf) and nominal_level < breaker.nominal_level)
+        not (breaker.kind_of? ListTypeLeaf and level < breaker.level)
       end
     end
 
+    class UnmatchedSectioningTagError < StandardError; end
+
     module BlockElement
       {
-        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf),
+        BlockLeaf => %w(DescLeaf VerbatimLeaf TableLeaf CommentOutLeaf BlockNodeEnd HrLeaf DecoratorLeaf SectioningNodeEnd),
         NonNestedBlockLeaf => %w(QuoteLeaf ParagraphLeaf),
         NestedBlockLeaf => %w(HeadingLeaf),
         ListTypeLeaf => %w(ListLeaf EnumLeaf),
-        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode),
+        BlockNode => %w(DescNode VerbatimNode TableNode CommentOutNode HrNode DecoratorNode SectioningNode),
         NonNestedBlockNode => %w(QuoteNode ParagraphNode),
         NestedBlockNode => %w(HeadingNode),
         ListTypeBlockNode => %w(ListNode EnumNode),
         ListLeafNode => %w(ListWrapNode EnumWrapNode)
-      }.each do |parent_class, children|
-        PseudoHiki.subclass_of(parent_class, binding, children)
+      }.each do |parent_class, sub_classes|
+        sub_classes.each {|sub| const_set(sub, Class.new(parent_class)) }
       end
-    end
-    include BlockElement
 
-    class BlockElement::BlockNodeEnd
-      PARSED_NODE_END = new.concat(InlineParser.parse(""))
+      class BlockNodeEnd
+        PARSED_NODE_END = new.concat(InlineParser.parse(""))
 
-      def push_self(stack); end
+        def push_self(stack); end
 
-      def self.create(line, inline_parser=InlineParser)
-        PARSED_NODE_END
+        def self.create(line, inline_parser=InlineParser)
+          PARSED_NODE_END
+        end
       end
-    end
 
-    class BlockElement::VerbatimNode
-      attr_accessor :in_block_tag
+      class VerbatimNode
+        attr_accessor :in_block_tag
 
-      def add_leaf(line, blockparser)
-        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)
+        def add_leaf(line, blockparser)
+          return @stack.pop_with_breaker if VERBATIM_END =~ line
+          return super(line, blockparser) unless @in_block_tag
+          line = " #{line}" if BlockNodeEnd.head_re =~ line and not @in_block_tag
+          @stack.push VerbatimLeaf.create(line, @in_block_tag)
+        end
       end
-    end
 
-    class BlockElement::QuoteNode
-      def parse_leafs
-        self[0] = BlockParser.parse(self[0])
+      class 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? DecoratorLeaf
+          parse_leafs(breaker)
+          @stack.current_node.breakable?(breaker)
+        end
       end
-    end
 
-    class BlockElement::HeadingNode
-      def breakable?(breaker)
-        kind_of?(breaker.block) and nominal_level >= breaker.nominal_level
+      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
-    end
 
-    class BlockElement::VerbatimLeaf
-      attr_accessor :in_block_tag
+      class SectioningNode
+        attr_accessor :section_level
 
-      def self.create(line, in_block_tag=nil)
-        line = line.sub(self.head_re, "".freeze) if self.head_re and not in_block_tag
-        self.new.tap do |leaf|
-          leaf.push line
-          leaf.in_block_tag = in_block_tag
+        def breakable?(breaker)
+          breaker.kind_of? HeadingLeaf and @section_level >= breaker.level
         end
       end
 
-      def push_block(stack)
-        stack.push(block.new.tap {|n| n.in_block_tag = @in_block_tag })
+      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
-    end
 
-    class BlockElement::TableLeaf
-      def self.create(line)
-        super(line, TableRowParser)
+      class QuoteNode
+        def parse_leafs(breaker)
+          self[0] = BlockParser.parse(self[0], AutoLink::Off)
+        end
+      end
+
+      class HeadingNode
+        def breakable?(breaker)
+          kind_of? breaker.block and level >= breaker.level
+        end
+      end
+
+      class VerbatimLeaf
+        attr_accessor :in_block_tag
+
+        def self.create(line, in_block_tag=nil)
+          line = line.sub(head_re, "".freeze) if head_re and not in_block_tag
+          new.tap do |leaf|
+            leaf.push line
+            leaf.in_block_tag = in_block_tag
+          end
+        end
+
+        def push_block(stack)
+          stack.push(block.new.tap {|n| n.in_block_tag = @in_block_tag })
+        end
+      end
+
+      class TableLeaf
+        def self.create(line)
+          super(line, TableRowParser)
+        end
       end
     end
+    include BlockElement
 
     class ListTypeLeaf
       include BlockElement
 
-      Wrapper = {
+      WRAPPER = {
         ListLeaf => ListWrapNode,
         EnumLeaf => EnumWrapNode
       }
 
       def push_self(stack)
         push_block(stack) unless under_appropriate_block?(stack)
-        stack.push Wrapper[self.class].new
+        stack.push WRAPPER[self.class].new
         BlockParser.assign_node_id(self[0], stack.current_node)
         stack.push_as_leaf self
       end
@@ -283,46 +355,51 @@ module PseudoHiki
      [ParagraphLeaf, ParagraphNode],
      [HrLeaf, HrNode],
      [ListLeaf, ListNode],
-     [EnumLeaf, EnumNode]
+     [EnumLeaf, EnumNode],
+     [BlockNodeEnd, BlockNodeEnd], # special case
+     [DecoratorLeaf, DecoratorNode]
     ].each do |leaf, node|
-      ParentNode[leaf] = node
+      PARENT_NODE[leaf] = node
     end
 
-    ParentNode[BlockNodeEnd] = BlockNodeEnd
-
-    def self.assign_head_re
-      irregular_leafs = [BlockNodeEnd, VerbatimLeaf, HrLeaf]
-      irregular_head_pats, regular_leaf_types, head_to_leaf = [], [], {}
-      [['\r?\n?$', BlockNodeEnd],
-       ['\s', VerbatimLeaf],
-       ['*', ListLeaf],
-       ['#', EnumLeaf],
-       [':', DescLeaf],
-       ['!', HeadingLeaf],
-       ['""', QuoteLeaf],
-       ['||', TableLeaf],
-       ['//', CommentOutLeaf],
-       ['----\s*$', HrLeaf]
-      ].each do |head, leaf|
-        escaped_head = irregular_leafs.include?(leaf) ? head : Regexp.escape(head)
+    head_to_leaf_table = [['\r?\n?$', BlockNodeEnd],
+                          ['\s', VerbatimLeaf],
+                          ['*', ListLeaf],
+                          ['#', EnumLeaf],
+                          [':', DescLeaf],
+                          ['!', HeadingLeaf],
+                          ['""', QuoteLeaf],
+                          ['||', TableLeaf],
+                          ['//@', DecoratorLeaf],
+                          ['//', CommentOutLeaf],
+                          ['----\s*$', HrLeaf]]
+
+    IRREGULAR_LEAFS = [:entire_matched_part, BlockNodeEnd, VerbatimLeaf, HrLeaf]
+    NUMBER_OF_IRREGULAR_LEAFS = IRREGULAR_LEAFS.length - 1
+    HEAD_TO_LEAF = head_to_leaf_table.inject({}) {|h, kv| h[kv[0]] = kv[1]; h }
+
+    def self.assign_head_re(head_to_leaf_table)
+      irregular_head_pats, regular_heads = [], []
+      head_to_leaf_table.each do |head, leaf|
+        leaf_is_irregular = IRREGULAR_LEAFS.include?(leaf)
+        escaped_head = leaf_is_irregular ? 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)
+        leaf.head_re = /\A#{head_pat}/
+        irregular_head_pats.push "(#{escaped_head})" if leaf_is_irregular
+        regular_heads.push head unless leaf_is_irregular
       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 /\A(?:#{irregular_head_pats.join('|')})/, regular_heads
     end
 
-    IRREGULAR_HEAD_PAT, REGULAR_LEAF_TYPES, HEAD_TO_LEAF, IRREGULAR_LEAF_TYPES, NUMBER_OF_IRREGULAR_LEAF_TYPES = assign_head_re
+    IRREGULAR_HEAD_PAT, REGULAR_HEADS = assign_head_re(head_to_leaf_table)
 
-    def initialize
+    def initialize(auto_linker=BlockParser.auto_linker)
       root_node = BlockNode.new
       def root_node.breakable?(breaker)
         false
       end
       @stack = BlockStack.new(root_node)
+      @auto_linker = auto_linker || AutoLink::URL
     end
 
     def breakable?(breaker)
@@ -331,15 +408,46 @@ module PseudoHiki
 
     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) }
+      1.upto(NUMBER_OF_IRREGULAR_LEAFS) {|i| return IRREGULAR_LEAFS[i] if matched[i] } if matched
+      REGULAR_HEADS.each {|head| return HEAD_TO_LEAF[head] if line.start_with?(head) }
       ParagraphLeaf
     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
+      @stack.pop_with_breaker
+    end
+  end
+
+  module AutoLink
+    # URI_RE is borrowed from hikidoc
+    URI_RE = /(?:https?|ftp|file|mailto):[A-Za-z0-9;\/?:@&=+$,\-_.!~*\'()#%]+/
+    VERBATIM_LEAF_HEAD_RE = BlockParser::BlockElement::VerbatimLeaf.head_re
+
+    module Off
+      def self.link(line) line; end
+
+      def self.auto_link_url?
+        false
+      end
+    end
+
+    module URL
+      OPEN_TAG, LINK_SEP = "[[", "|"
+
+      def self.in_link_tag?(preceding_str)
+        preceding_str.end_with?(OPEN_TAG) or preceding_str.end_with?(LINK_SEP)
+      end
+
+      def self.link(line)
+        return line unless URI_RE =~ line and VERBATIM_LEAF_HEAD_RE !~ line
+        line.gsub(URI_RE) {|url| in_link_tag?($`) ? url : "[[#{url}]]" }
+      end
+
+      def self.auto_link_url?
+        true
+      end
     end
   end
 end