pseudohikiparser 0.0.0.4.develop

data/lib/pseudohiki/blockparser.rb

@@ -0,0 +1,359 @@
+#!/usr/bin/env ruby
+
+require 'pseudohiki/treestack'
+require 'pseudohiki/inlineparser'
+
+module PseudoHiki
+  class BlockParser
+    URI_RE = /(?:(?:https?|ftp|file):|mailto:)[A-Za-z0-9;\/?:@&=+$,\-_.!~*\'()#%]+/ #borrowed from hikidoc
+    ID_TAG_PAT = /^\[([^\[\]]+)\]/o
+
+    module LINE_PAT
+      VERBATIM_BEGIN = /\A(<<<\s*)/o
+      VERBATIM_END = /\A(>>>\s*)/o
+      PLUGIN_BEGIN = /\{\{/o
+      PLUGIN_END = /\}\}/o
+    end
+
+    ParentNode = {}
+    HeadToLeaf = {}
+
+    attr_reader :stack
+
+    def self.assign_node_id(leaf, node)
+#      return unless tree[0].kind_of? Array ** block_leaf:[inline_node:[token or inline_node]]
+      head = leaf[0]
+      return unless head.kind_of? String
+      m = ID_TAG_PAT.match(head)
+      if m
+        node.node_id = m[1]
+        leaf[0] = head.sub(ID_TAG_PAT,"")
+      end
+      node
+    end
+
+    def self.parse(lines)
+      parser = self.new
+      parser.read_lines(lines)
+      parser.stack.tree
+    end
+
+    class BlockStack < TreeStack
+      def pop
+        self.current_node.parse_leafs
+        super
+      end
+    end
+
+    class BlockLeaf < BlockStack::Leaf
+      @@head_re = {}
+      attr_accessor :nominal_level
+      attr_accessor :node_id
+
+      def self.head_re=(head_regex)
+        @@head_re[self] = head_regex
+      end
+
+      def self.head_re
+        @@head_re[self]
+      end
+
+      def self.with_depth?
+        false
+      end
+
+      def self.create(line, inline_parser=InlineParser)
+        line.sub!(self.head_re,"") if self.head_re
+        leaf = self.new
+        leaf.concat(inline_parser.parse(line))
+      end
+
+      def self.assign_head_re(head, need_to_escape=true, reg_pat="(%s)")
+        head = Regexp.escape(head) if need_to_escape
+        self.head_re = Regexp.new('\\A'+reg_pat%[head])
+      end
+
+      def head_re
+        @@head_re[self.class]
+      end
+
+      def block
+        ParentNode[self.class]
+      end
+
+      def push_block(stack)
+        stack.push(block.new)
+      end
+
+      def under_appropriate_block?(stack)
+        stack.current_node.kind_of? block and stack.current_node.nominal_level == nominal_level
+      end
+
+      def push_self(stack)
+        push_block(stack) unless under_appropriate_block?(stack)
+        super(stack)
+      end
+
+      def parse_leafs
+        parsed = InlineParser.parse(self.join)
+        self.clear
+        self.concat(parsed)
+      end
+    end
+
+    class NonNestedBlockLeaf < BlockLeaf
+      include TreeStack::Mergeable
+
+      def self.create(line)
+        line.sub!(self.head_re,"") if self.head_re
+        self.new.tap {|leaf| leaf.push line }
+      end
+
+      def push_self(stack)
+        push_block(stack) unless under_appropriate_block?(stack)
+        if stack.last_leaf.kind_of? self.class
+          stack.last_leaf.merge(self)
+        else
+          super(stack)
+        end
+      end
+    end
+
+    class NestedBlockLeaf < BlockLeaf
+      def self.assign_head_re(head, need_to_escape)
+        super(head, need_to_escape, "(%s)+")
+      end
+
+      def self.create(line)
+        m = self.head_re.match(line)
+        super(line).tap {|leaf| leaf.nominal_level = m[0].length }
+      end
+
+      def self.with_depth?
+        true
+      end
+
+      def push_self(stack)
+        super(stack)
+        BlockParser.assign_node_id(self[0], self)
+      end
+    end
+
+    class ListTypeLeaf < NestedBlockLeaf; end
+
+    class BlockNode < BlockStack::Node
+      attr_accessor :base_level, :relative_level_from_base
+      attr_accessor :node_id
+
+      def nominal_level
+        return nil unless first
+        first.nominal_level
+      end
+
+      def push_self(stack)
+        @stack = stack
+        super(stack)
+      end
+
+      def breakable?(breaker)
+        not (kind_of?(breaker.block) and nominal_level == breaker.nominal_level)
+      end
+
+      def parse_leafs; end
+    end
+
+    class NonNestedBlockNode < BlockNode
+      def parse_leafs
+        self.each {|leaf| leaf.parse_leafs }
+      end
+    end
+
+    class NestedBlockNode < BlockNode; end
+
+    class ListTypeBlockNode < NestedBlockNode
+      def breakable?(breaker)
+        not (breaker.block.superclass == ListTypeBlockNode and nominal_level <= breaker.nominal_level)
+      end
+    end
+
+    class ListLeafNode < NestedBlockNode
+      def breakable?(breaker)
+        not (breaker.kind_of?(ListTypeLeaf) and nominal_level < breaker.nominal_level)
+      end
+    end
+
+    module BlockElement
+      class DescLeaf < BlockLeaf; end
+      class VerbatimLeaf < BlockLeaf; end
+      class QuoteLeaf < NonNestedBlockLeaf; end
+      class TableLeaf < BlockLeaf; end
+      class CommentOutLeaf < BlockLeaf; end
+      class HeadingLeaf < NestedBlockLeaf; end
+      class ParagraphLeaf < NonNestedBlockLeaf; end
+      class HrLeaf < BlockLeaf; end
+      class BlockNodeEnd < BlockLeaf; end
+
+      class ListLeaf < ListTypeLeaf; end
+      class EnumLeaf < ListTypeLeaf; end
+
+      class DescNode < BlockNode; end
+      class VerbatimNode < BlockNode; end
+      class QuoteNode < NonNestedBlockNode; end
+      class TableNode < BlockNode; end
+      class CommentOutNode < BlockNode; end
+      class HeadingNode < NestedBlockNode; end
+      class ParagraphNode < NonNestedBlockNode; end
+      class HrNode < BlockNode; end
+
+      class ListNode < ListTypeBlockNode; end
+      class EnumNode < ListTypeBlockNode; end
+
+      class ListWrapNode < ListLeafNode; end
+      class EnumWrapNode < ListLeafNode; end
+    end
+    include BlockElement
+
+    class BlockElement::BlockNodeEnd
+      def push_self(stack); end
+    end
+
+    class BlockElement::QuoteNode
+      def parse_leafs
+        self[0] = BlockParser.parse(self[0])
+      end
+    end
+
+#    class HeadingNode
+    class BlockElement::HeadingNode
+      def breakable?(breaker)
+        kind_of?(breaker.block) and nominal_level >= breaker.nominal_level
+      end
+    end
+
+    class BlockElement::VerbatimLeaf
+      def self.create(line)
+        line.sub!(self.head_re,"") if self.head_re
+        self.new.tap {|leaf| leaf.push line }
+      end
+    end
+
+    class BlockElement::TableLeaf
+      def self.create(line)
+        super(line, TableRowParser)
+      end
+    end
+
+    class ListTypeLeaf
+      include BlockElement
+
+      Wrapper = {
+        ListLeaf => ListWrapNode,
+        EnumLeaf => EnumWrapNode
+      }
+
+      def push_self(stack)
+        push_block(stack) unless under_appropriate_block?(stack)
+        stack.push Wrapper[self.class].new
+        BlockParser.assign_node_id(self[0], stack.current_node)
+        stack.push_as_leaf self
+      end
+    end
+
+    [[DescLeaf, DescNode],
+     [VerbatimLeaf, VerbatimNode],
+     [QuoteLeaf, QuoteNode],
+     [TableLeaf, TableNode],
+     [CommentOutLeaf, CommentOutNode],
+     [HeadingLeaf, HeadingNode],
+     [ParagraphLeaf, ParagraphNode],
+     [HrLeaf, HrNode],
+     [ListLeaf, ListNode],
+     [EnumLeaf, EnumNode]
+    ].each do |leaf, node|
+      ParentNode[leaf] = node
+    end
+
+    ParentNode[BlockNodeEnd] = BlockNodeEnd
+
+    def self.assign_head_re
+      space = '\s'
+      head_pats = []
+      [[':', DescLeaf],
+       [space, VerbatimLeaf],
+       ['""', QuoteLeaf],
+       ['||', TableLeaf],
+       ['//', CommentOutLeaf],
+       ['!', HeadingLeaf],
+       ['*', ListLeaf],
+       ['#', EnumLeaf]
+      ].each do |head, leaf|
+        HeadToLeaf[head] = leaf
+        escaped_head = head != space ? Regexp.escape(head) : head
+        head_pat = leaf.with_depth? ? "(#{escaped_head})+" : "(#{escaped_head})"
+        head_pats.push head_pat
+        leaf.head_re = Regexp.new('\\A'+head_pat)
+      end
+      HrLeaf.head_re = Regexp.new(/\A(----)\s*$/o)
+      BlockNodeEnd.head_re = Regexp.new(/^(\r?\n?)$/o)
+      Regexp.new('\\A('+head_pats.join('|')+')')
+    end
+    HEAD_RE = assign_head_re
+
+    def initialize
+      root_node = BlockNode.new
+      def root_node.breakable?(breaker)
+        false
+      end
+      @stack = BlockStack.new(root_node)
+    end
+
+    def breakable?(breaker)
+      @stack.current_node.breakable?(breaker)
+    end
+
+    def tagfy_link(line)
+      line.gsub(URI_RE) do |url|
+        unless ($`)[-2,2] == "[[" or ($`)[-1,1] == "|"
+          "[[#{url}]]"
+        else
+          url
+        end
+      end
+    end
+
+    def select_leaf_type(line)
+      [BlockNodeEnd, HrLeaf].each {|leaf| return leaf if leaf.head_re =~ line }
+      matched = HEAD_RE.match(line)
+      return HeadToLeaf[matched[0]]||HeadToLeaf[line[0,1]] || HeadToLeaf['\s'] if matched
+      ParagraphLeaf
+    end
+
+    def add_verbatim_block(lines)
+      until lines.empty? or LINE_PAT::VERBATIM_END =~ lines.first
+        lines[0] = " " + lines[0] if BlockNodeEnd.head_re =~ lines.first
+        @stack.push(VerbatimLeaf.create(lines.shift))
+      end
+      lines.shift if LINE_PAT::VERBATIM_END =~ lines.first
+    end
+
+    def add_leaf(line)
+      leaf = select_leaf_type(line).create(line)
+      while breakable?(leaf)
+        @stack.pop
+      end
+      @stack.push leaf
+    end
+
+    def read_lines(lines)
+      while line = lines.shift
+        if LINE_PAT::VERBATIM_BEGIN =~ line
+          add_verbatim_block(lines)
+        else
+          line = self.tagfy_link(line) unless VerbatimLeaf.head_re =~ line
+          add_leaf(line)
+        end
+      end
+      @stack.pop
+    end
+  end
+end

data/lib/pseudohiki/htmlformat.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+
+require 'pseudohiki/inlineparser'
+require 'pseudohiki/blockparser'
+
+module PseudoHiki
+  class HtmlFormat
+    include InlineParser::InlineElement
+    include BlockParser::BlockElement
+    include TableRowParser::InlineElement
+
+    #for InlineParser
+    LINK, IMG, EM, STRONG, DEL = %w(a img em strong del)
+    HREF, SRC, ALT = %w(href src alt)
+    PLAIN, PLUGIN = %w(plain span)
+    #for BlockParser
+    DESC, VERB, QUOTE, TABLE, PARA, HR, UL, OL = %w(dl pre blockquote table p hr ul ol)
+    SECTION = "section"
+    DT, DD, TR, HEADING, LI = %w(dt dd tr h li)
+    DescSep = [InlineParser::DescSep]
+
+    Formatter = {}
+
+    attr_reader :element_name
+    attr_writer :generator, :formatter
+
+    def self.setup_new_formatter(new_formatter, generator)
+      new_formatter.each do |node_class, formatter|
+        new_formatter[node_class] = formatter.dup
+        new_formatter[node_class].generator = generator
+        new_formatter[node_class].formatter = new_formatter
+      end
+    end
+
+    def self.get_plain
+      self::Formatter[PlainNode]
+    end
+
+    def self.format(tree)
+      formatter = self.get_plain
+      tree.accept(formatter)
+    end
+
+    def initialize(element_name, generator=HtmlElement)
+      @element_name = element_name
+      @generator = generator
+      @formatter = Formatter
+    end
+
+    def visited_result(element)
+      visitor = @formatter[element.class]||@formatter[PlainNode]
+      element.accept(visitor)
+    end
+
+    def push_visited_results(element, tree)
+      tree.each {|token| element.push visited_result(token) }
+    end
+
+    def visit(tree)
+      htmlelement = create_self_element(tree)
+      push_visited_results(htmlelement, tree)
+      htmlelement
+    end
+
+    def create_self_element(tree=nil)
+      @generator.create(@element_name)
+    end
+
+    def split_into_parts(tree, separator)
+      chunks = []
+      while sep_index = tree.index(separator)
+        chunks.push tree.shift(sep_index)
+        tree.shift
+      end
+      chunks.push tree
+    end
+
+    #for InlineParser
+
+    class LinkNodeFormatter < self
+      def visit(tree)
+        tree = tree.dup
+        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
+          htmlelement = ImgFormat.create_self_element
+          htmlelement[SRC] = tree.join
+          htmlelement[ALT] = caption.join if caption
+        else
+          htmlelement = create_self_element
+          htmlelement[HREF] = tree.join
+          htmlelement.push caption||tree.join
+        end
+        htmlelement
+      end
+
+      def get_caption(tree)
+        first_part, second_part = split_into_parts(tree, [LinkSep])
+        return nil unless second_part
+        first_part.map {|token| visited_result(token) }
+      end
+    end
+
+    class InlineLeafFormatter < self
+      def visit(leaf)
+        @generator.escape(leaf.first)
+      end
+    end
+
+    class PlainNodeFormatter < self
+      def create_self_element(tree=nil)
+        @generator::Children.new
+      end
+    end
+
+    #for BlockParser
+
+    class VerbatimNodeFormatter < self
+      def visit(tree)
+        create_self_element.tap do |element|
+          contents = @generator.escape(tree.join).gsub(BlockParser::URI_RE) do |url|
+            @generator.create("a", url, "href" => url).to_s
+          end
+          element.push contents
+        end
+      end
+    end
+
+    class CommentOutNodeFormatter < self
+      def visit(tree); ""; end
+    end
+
+    class HeadingNodeFormatter < self
+      def create_self_element(tree)
+        super(tree).tap do |element|
+          heading_level = "h#{tree.first.nominal_level}"
+          element['class'] ||= heading_level
+          element['class'] +=  " " + heading_level unless element['class'] == heading_level
+        end
+      end
+    end
+
+    class DescLeafFormatter < self
+      def visit(tree)
+        tree = tree.dup
+        element = @generator::Children.new
+        dt_part, dd_part = split_into_parts(tree, DescSep)
+        dt = super(dt_part)
+        element.push dt
+        unless dd_part.nil? or dd_part.empty?
+          dd = @generator.create(DD)
+          push_visited_results(dd, dd_part)
+          element.push dd
+        end
+        element
+      end
+    end
+
+    class TableCellNodeFormatter < self
+      def visit(tree)
+        @element_name = tree.cell_type
+        super(tree).tap do |element|
+          element["rowspan"] = tree.rowspan if tree.rowspan > 1
+          element["colspan"] = tree.colspan if tree.colspan > 1
+        end
+      end
+    end
+
+    class HeadingLeafFormatter < self
+      def create_self_element(tree)
+        @generator.create(@element_name+tree.nominal_level.to_s).tap do |element|
+          element["id"] = tree.node_id.upcase if tree.node_id
+        end
+      end
+    end
+
+    class ListLeafNodeFormatter < self
+      def create_self_element(tree)
+        super(tree).tap do |element|
+          element["id"] = tree.node_id.upcase if tree.node_id
+        end
+      end
+    end
+
+    [ [EmNode,EM],
+      [StrongNode,STRONG],
+      [DelNode,DEL],
+      [PluginNode,PLUGIN], #Until here is for InlineParser
+      [DescNode, DESC],
+      [QuoteNode, QUOTE],
+      [TableNode, TABLE],
+      [ParagraphNode, PARA],
+      [HrNode, HR],
+      [ListNode, UL],
+      [EnumNode, OL],
+      [TableLeaf, TR], #Until here is for BlockParser
+    ].each {|node_class, element| Formatter[node_class] = self.new(element) }
+
+    #for InlineParser
+    ImgFormat = self.new(IMG)
+    Formatter[LinkNode] = LinkNodeFormatter.new(LINK)
+    Formatter[InlineLeaf] = InlineLeafFormatter.new(nil)
+    Formatter[PlainNode] = PlainNodeFormatter.new(PLAIN)
+    #for BlockParser
+    Formatter[VerbatimNode] = VerbatimNodeFormatter.new(VERB)
+    Formatter[CommentOutNode] = CommentOutNodeFormatter.new(nil)
+    Formatter[HeadingNode] = HeadingNodeFormatter.new(SECTION)
+    Formatter[DescLeaf] = DescLeafFormatter.new(DT)
+    Formatter[TableCellNode] = TableCellNodeFormatter.new(nil)
+    Formatter[HeadingLeaf] = HeadingLeafFormatter.new(HEADING)
+    Formatter[ListWrapNode] = ListLeafNodeFormatter.new(LI)
+    Formatter[EnumWrapNode] = ListLeafNodeFormatter.new(LI)
+  end
+
+  class XhtmlFormat < HtmlFormat
+    Formatter = HtmlFormat::Formatter.dup
+    setup_new_formatter(Formatter, XhtmlElement)
+  end
+
+  class Xhtml5Format < XhtmlFormat
+    Formatter = HtmlFormat::Formatter.dup
+    setup_new_formatter(Formatter, Xhtml5Element)
+  end
+end