pseudohikiparser 0.0.0.4.develop

data/lib/pseudohiki/htmlplugin.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+
+require 'htmlelement'
+require 'pseudohiki/inlineparser'
+require 'pseudohiki/htmlformat'
+#require('hikiparser/hikiblockparser')
+
+module PseudoHiki
+  class HtmlFormat
+    class << Formatter[PluginNode]
+      def visit(leaf)
+        HtmlPlugin.new(@element_name,leaf.join).apply
+      end
+    end
+  end
+  
+  class HtmlPlugin
+
+    PLUGIN_PAT = /^(\w+)([\s\(]+)/
+    NUMBER_RE = /(\d+)/
+
+    def parse(data)
+      result = nil
+      if PLUGIN_PAT =~ data
+        @plugin_name = $1
+        @with_paren = true if $2.chomp == "("
+        result = data.chomp.sub(PLUGIN_PAT,"")
+        result[-1,1] = "" if @with_paren
+      else
+        @plugin_name = data.chomp
+        result = ""
+      end
+      result
+    end
+
+    def initialize(tag_type,parsed_data)
+      @tag_type = tag_type
+      @plugin_name = nil
+      @with_paren = nil
+      @data = parse(parsed_data.to_s)
+    end
+    
+    def apply
+      self.send @plugin_name
+    end
+
+    def html
+      #    "<div class='raw-html'>"+HtmlElement.decode(@data)+"</div>"
+      HtmlElement.decode(@data).to_s
+    end
+
+    #  def inline
+    #    lines = HtmlElement.decode(@data).split(/\r*\n/o)
+    #    lines.shift if lines.first == ""
+    #    HikiBlockParser.new.parse_lines(lines).join
+    #  end
+
+    def anchor
+      name, anchor_mark = @data.split(/,\s*/o,2)
+      anchor_mark = "_" if (anchor_mark.nil? or anchor_mark.empty?)
+      HtmlElement.create("a", anchor_mark,
+                         "name" => name,
+                         "href" => "#"+name)
+    end
+
+    def HtmlPlugin.add_chemical_formula(chemical_formula="CO2",en_word="carbon dioxide")
+      eval(<<-End)
+      def #{chemical_formula.downcase}
+        #(display=":cf",second_display=nil)
+        display, second_display = @data.split(",\s")
+        display = ":cf" unless display
+        return [#{chemical_formula.downcase}(display),
+          "(",
+          #{chemical_formula.downcase}(second_display),
+          ")"].join("") if second_display
+        case display
+        when ":cf"
+          "#{chemical_formula}".gsub(NUMBER_RE, "<sub>\\\\1</sub>")
+        when ":en"
+          "#{en_word}"
+        end
+      end
+      End
+    end
+    %Q(SF6, sulfur hexafluoride
+     CO2, carbon dioxide
+     HFC, hydrofluorocarbon
+     PFC, perfluorocarbon
+     CFC, chlorofluorocarbon
+     CH4, methane
+     H2O, water
+     C2F5Cl, CFC-115, CFC-115).lines.each do |line|
+      chemical_formula, en = line.strip.split(/,\s+/)
+      add_chemical_formula chemical_formula, en
+    end
+
+    def sq
+      # I'm wondering if we'd be better to use &sup2; , but when we search by "km2" for example, we may have problem...
+      "#{@data}<sup>2</sup>"
+    end
+
+    def cb
+      # I'm wondering if we'd be better to use &sup3; , but...
+      "#{@data}<sup>3</sup>"
+    end
+
+    def per
+      "#{@data}<sup>-1</sup>"
+    end
+
+    def c_degree
+      "&deg;C"
+    end
+
+    def chemical_formula
+      @data.gsub(NUMBER_RE, "<sub>\\1</sub>")
+    end
+
+    def iso
+      @data.scan(/\A(\d+)([^\d].*)/o) do |data|
+        weight, molecule = data
+        if self.respond_to? molecule
+          return "<sup>#{weight}</sup>" + HtmlPlugin.new("",molecule).apply
+        else
+          return "<sup>#{weight}</sup>" + molecule
+        end
+      end
+    end
+
+    alias oc c_degree
+
+
+    def method_missing
+      HtmlElement.create(@tag_type, @data, "class" => "plugin")
+    end
+  end
+end
+
+if $0 == __FILE__
+  p HtmlPlugin.new("div","html(
+<ul>
+<li>list
+<li>list
+</ul>)").apply
+  p HtmlPlugin.new("div","inline(
+*list
+*list
+)").apply
+
+p HtmlPlugin.new("div","co2").apply
+p HtmlPlugin.new("div","co2 :en").apply
+p HtmlPlugin.new("div","cb(3km)").apply
+p HtmlPlugin.new("div","per m").apply
+p HtmlPlugin.new("div","iso 18co2").apply
+end

data/lib/pseudohiki/inlineparser.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+
+require 'pseudohiki/treestack'
+require 'htmlelement'
+
+module PseudoHiki
+  PROTOCOL = /^((https?|file|ftp):|\.?\/)/
+  RELATIVE_PATH = /^\./o
+  ROOT_PATH = /^(\/|\\\\|[A-Za-z]:\\)/o
+  FILE_MARK = "file:///"
+  ImageSuffix = /\.(jpg|jpeg|gif|png|bmp)$/io
+
+  def self.compile_token_pat(*token_sets)
+    tokens = token_sets.flatten.uniq.sort do |x,y|
+      [y.length, y] <=> [x.length, x]
+    end.collect {|token| Regexp.escape(token) }
+    Regexp.new(tokens.join("|"))
+  end
+
+  class InlineParser < TreeStack
+    module InlineElement
+      class InlineNode < InlineParser::Node;end
+      class InlineLeaf < InlineParser::Leaf; end
+      #  class LinkSepLeaf < InlineLeaf; end
+
+      class LinkNode < InlineNode; end
+      class EmNode < InlineNode; end
+      class StrongNode < InlineNode; end
+      class DelNode < InlineNode; end
+      class PlainNode < InlineNode; end
+      class PluginNode < InlineNode; end
+
+      LinkSep, TableSep, DescSep = %w(| || :)
+    end
+    include InlineElement
+
+    HEAD = {}
+    TAIL = {}
+    NodeTypeToHead = {}
+    TokenPat = {}
+    
+    [[LinkNode, "[[", "]]"],
+     [EmNode, "''", "''"],
+     [StrongNode, "'''", "'''"],
+     [DelNode, "==", "=="],
+     [PluginNode, "{{","}}"]].each do |type, head, tail|
+      HEAD[head] = type
+      TAIL[tail] = type
+      NodeTypeToHead[type] = head
+    end
+
+    TokenPat[self] = PseudoHiki.compile_token_pat(HEAD.keys,TAIL.keys,[LinkSep, TableSep, DescSep])
+
+    def token_pat
+      TokenPat[self.class]
+    end
+
+    def initialize(str)
+      @tokens = split_into_tokens(str)
+      super()
+    end
+
+    def convert_last_node_into_leaf
+      last_node = remove_current_node
+      tag_head = NodeTypeToHead[last_node.class]
+      tag_head_leaf = InlineLeaf.create(tag_head)
+      self.push tag_head_leaf
+      last_node.each {|leaf| self.push_as_leaf leaf }
+    end
+
+    def node_in_ancestors?(node_class)
+      not @stack.select {|node| node_class == node.class }.empty?
+    end
+
+    def treated_as_node_end(token)
+      return self.pop if current_node.class == TAIL[token]
+      if node_in_ancestors?(TAIL[token])
+        convert_last_node_into_leaf until current_node.class == TAIL[token]
+        return self.pop
+      end
+      nil
+    end
+
+    def split_into_tokens(str)
+      result = []
+      while m = token_pat.match(str)
+        result.push m.pre_match if m.pre_match
+        result.push m[0]
+        str = m.post_match
+      end
+      result.push str unless str.empty?
+      result.delete_if {|token| token.empty? }
+      result
+    end
+
+    def parse
+      while token = @tokens.shift
+        next if TAIL[token] and treated_as_node_end(token)
+        next if HEAD[token] and self.push HEAD[token].new
+        self.push InlineLeaf.create(token)
+      end
+      self
+    end
+
+    def self.parse(str)
+      parser = new(str)
+      parser.parse.tree
+    end
+  end
+
+  class TableRowParser < InlineParser
+    module InlineElement
+      class TableCellNode < InlineParser::InlineElement::InlineNode
+        attr_accessor :cell_type, :rowspan, :colspan
+      end
+    end
+    include InlineElement
+
+    TAIL[TableSep] = TableCellNode
+    TokenPat[self] = InlineParser::TokenPat[InlineParser]
+
+    TD, TH, ROW_EXPANDER, COL_EXPANDER, TH_PAT = %w(td th ^ > !)
+    MODIFIED_CELL_PAT = /^!?[>^]*/o
+
+    class InlineElement::TableCellNode
+      def parse_first_token(token)
+        @cell_type, @rowspan, @colspan, parsed_token = TD, 1, 1, token.dup
+        token_str = parsed_token[0]
+        m = MODIFIED_CELL_PAT.match(token_str) #if token.kind_of? String
+
+        if m
+          cell_modifiers = m[0].split(//o)
+          if cell_modifiers.first == TH_PAT
+            cell_modifiers.shift
+            @cell_type = TH
+          end
+          parsed_token[0] = token_str.sub(MODIFIED_CELL_PAT,"")
+          @rowspan = cell_modifiers.count(ROW_EXPANDER) + 1
+          @colspan = cell_modifiers.count(COL_EXPANDER) + 1
+        end
+        parsed_token
+      end
+
+      def push(token)
+        if self.empty?
+          super(parse_first_token(token))
+        else
+          super(token)
+        end
+      end
+    end
+
+    def treated_as_node_end(token)
+      if token == TableSep
+        self.pop
+        return (self.push TableCellNode.new)
+      end
+
+      super(token)
+    end
+
+    def parse
+      self.push TableCellNode.new
+      super
+    end
+  end
+
+  include InlineParser::InlineElement
+end

data/lib/pseudohiki/plaintextformat.rb

@@ -0,0 +1,235 @@
+#!/usr/bin/env ruby
+
+require 'pseudohiki/inlineparser'
+require 'pseudohiki/blockparser'
+require 'ostruct'
+
+module PseudoHiki
+  class PlainTextFormat
+    include InlineParser::InlineElement
+    include BlockParser::BlockElement
+
+    DescSep = [InlineParser::DescSep]
+
+    class Node < Array
+      def to_s
+        self.join("")
+      end
+    end
+
+    def create_self_element(tree=nil)
+      Node.new
+    end
+
+    def visited_result(node)
+      visitor = @formatter[node.class]||@formatter[PlainNode]
+      node.accept(visitor)
+    end
+
+    def push_visited_results(element, tree)
+      tree.each {|token| element.push visited_result(token) }
+    end
+
+    def visit(tree)
+      element = create_self_element(tree)
+      push_visited_results(element, tree)
+      element
+    end
+
+    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)
+      end
+      @options = OpenStruct.new(options)
+    end
+
+    def self.create(options = { :verbose_mode => false })
+      formatter = {}
+      main = self.new(formatter, options)
+
+      [
+       PlainNode,
+       InlineNode,
+       EmNode,
+       StrongNode,
+       PluginNode,
+       VerbatimLeaf,
+       QuoteLeaf,
+       TableLeaf,
+       CommentOutLeaf,
+       HeadingLeaf,
+       ParagraphLeaf,
+       HrLeaf,
+       BlockNodeEnd,
+       ListLeaf,
+       EnumLeaf,
+       DescNode,
+       QuoteNode,
+       HeadingNode,
+       HrNode,
+       ListNode,
+       EnumNode,
+       ListWrapNode,
+       EnumWrapNode
+      ].each do |node_class|
+        formatter[node_class] = self.new(formatter, options)
+      end
+
+      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)
+      main
+    end
+
+    def get_plain
+      @formatter[PlainNode]
+    end
+
+    def format(tree)
+      formatter = get_plain
+      tree.accept(formatter).join("")
+    end
+
+## Definitions of subclasses of PlainTextFormat begins here.
+
+    class InlineLeafFormatter < self
+      def visit(leaf)
+        leaf.join("")
+      end
+    end
+
+    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("")
+        else
+          element.push caption||tree.join("")
+          element.push " (#{tree.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) }
+      end
+    end
+
+    class DelNodeFormatter < self
+      def visit(tree)
+        return "" unless @options.verbose_mode
+        "[deleted:#{tree.map {|token| visited_result(token) }.join}]"
+      end
+    end
+
+    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
+        unless dd.empty?
+          element.push element.empty? ? "\t" : ":\t"
+          element.push dd
+        end
+        element
+      end
+    end
+
+    class VerbatimNodeFormatter < self
+      def visit(tree)
+        tree.join("")
+      end
+    end
+
+    class TableNodeFormatter < self
+      class MalFormedTableError < StandardError; end
+      ERROR_MESSAGE = <<ERROR_TEXT
+!! A malformed row is found: %s.
+!! Please recheck if it is really what you want.
+ERROR_TEXT
+
+      def visit(tree)
+        table = create_self_element(tree)
+        rows = tree.dup
+        rows.length.times { table.push Node.new }
+        max_col = tree.map{|row| row.reduce(0) {|sum, cell| sum + cell.colspan }}.max - 1
+        max_row = rows.length - 1
+        cur_row = nil
+        each_cell_with_index(table, max_row, max_col) do |cell, r, c|
+          cur_row = rows.shift if c == 0
+          next if table[r][c]
+          unless cell
+            begin
+              raise MalFormedTableError.new(ERROR_MESSAGE%[table[r].inspect]) if cur_row.empty?
+              table[r][c] = cur_row.shift
+              fill_expand(table, r, c, table[r][c])
+            rescue
+              raise if @options.strict_mode
+              STDERR.puts ERROR_MESSAGE%[table[r].inspect]
+              next
+            end
+          end
+        end
+        table.map {|row| row.join("\t")+$/ }.join("")
+      end
+
+      def each_cell_with_index(table, max_row, max_col, initial_row=0, initial_col=0)
+        initial_row.upto(max_row) do |r|
+          initial_col.upto(max_col) do |c|
+            yield table[r][c], r, c
+          end
+        end
+      end
+
+      def fill_expand(table, initial_row, initial_col, cur_cell)
+        row_expand, col_expand = "", ""
+        row_expand, col_expand = "||", "==" if @options.verbose_mode
+        max_row = initial_row + cur_cell.rowspan - 1
+        max_col = initial_col + cur_cell.colspan - 1
+        each_cell_with_index(table, max_row, max_col,
+                             initial_row, initial_col) do |cell, r, c|
+          if initial_row == r and initial_col == c
+            table[r][c] = visited_result(cur_cell).join.lstrip.chomp
+            next
+          end
+          table[r][c] = initial_row == r ? col_expand : row_expand
+        end
+      end
+    end
+
+    class CommentOutNodeFormatter < self
+      def visit(tree); ""; end
+    end
+
+    class ParagraphNodeFormatter < self
+      def visit(tree)
+        super(tree).join+$/
+      end
+    end
+  end
+end

data/lib/pseudohiki/treestack.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+class TreeStack
+
+  class NotLeafError < Exception; end
+
+  module Mergeable; end
+
+# a class that includes NodeType is expected to have #push method to include child nodes,
+# and a class that includes LeafType module is expected to have #concat method.
+
+  module TreeElement
+    attr_accessor :depth
+
+    def accept(visitor)
+      visitor.visit(self)
+    end
+  end
+
+  module NodeType
+    def push_self(stack)
+      @depth = stack.current_depth + 1
+      stack.push_as_child_node self
+      nil
+    end
+  end
+
+  module LeafType
+    def push_self(stack)
+      @depth = stack.current_depth + 1
+      stack.push_as_leaf self
+      self
+    end
+
+    def merge(leaf)
+      raise NotLeafError unless leaf.kind_of? Leaf
+      return nil unless leaf.kind_of? Mergeable
+      self.concat(leaf)
+    end
+  end
+
+  class Node < Array
+    include TreeElement
+    include NodeType
+  end
+
+  class Leaf < Array
+    include TreeElement
+    include LeafType
+
+    def self.create(content=nil)
+      self.new.tap {|leaf| leaf.push content if content }
+    end
+  end
+
+  class NodeEnd
+    def push_self(stack)
+      stack.pop
+      nil
+    end
+  end
+  attr_reader :node_end, :last_leaf
+
+  def initialize(root_node=Node.new)
+    @stack = [root_node]
+    @node_end = NodeEnd.new
+    def root_node.depth
+      0
+    end
+  end
+
+  def current_node
+    @stack.last
+  end
+
+  def tree
+    @stack[0]
+  end
+
+  def push(node=Node.new)
+    @last_leaf = node.push_self(self)
+    node
+  end
+
+  def pop
+    @stack.pop if @stack.length > 1
+  end
+  alias return_to_previous_node pop
+
+  def current_depth
+    @stack.last.depth
+  end
+
+  def push_as_child_node(node)
+    @stack.last.push node
+    @stack.push node
+  end
+  
+  def push_as_leaf(node)
+    @stack.last.push node
+  end
+
+  def push_as_sibling(sibling_node=nil)
+    sibling_node ||= current_node.class.new
+    pop if sibling_node.kind_of? NodeType
+    push(sibling_node)
+    sibling_node
+  end
+
+  def remove_current_node
+    removed_node = self.pop
+    self.current_node.pop
+    removed_node
+  end
+
+  def accept(visitor)
+    visitor.visit(tree)
+  end
+end

data/lib/pseudohiki/version.rb

@@ -0,0 +1,3 @@
+module PseudoHiki
+  VERSION = "0.0.0.4.develop"
+end

data/lib/pseudohikiparser.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "pseudohiki/htmlformat"
+require "pseudohiki/plaintextformat"
+require "pseudohiki/version"
+