rsyntaxtree 0.9.3 → 1.0.6

data/lib/rsyntaxtree/markup_parser.rb

@@ -0,0 +1,208 @@
+require 'parslet'
+
+class MarkupParser < Parslet::Parser
+  rule(:cr) { str('\\n')}
+  rule(:eof) { any.absent? }
+  rule(:border) { match('[^\-]').absent? >> str('-').repeat(3).as(:border) >> (eof | cr) }
+  rule(:bborder) { match('[^=]').absent? >> str('=').repeat(3).as(:bborder) >> (eof | cr) }
+
+  rule(:brectangle) { str('###') }
+  rule(:rectangle) { str('##') }
+  rule(:brackets) { str('#') }
+  rule(:triangle) { str('^') }
+
+  rule(:path) { (str('+') >> str('>').maybe >> match('\d').repeat(1)).as(:path) }
+  rule(:escaped) { str('\\') >> (match('[#<>{}\\^+*_=~\|\n\-]')).as(:chr) }
+  rule(:non_escaped) { ((match('[#<>{}\\^+*_=~\|\-]') | str('\\n')).absent? >> any).as(:chr) }
+  rule(:text) { (escaped | non_escaped).repeat(1).as(:text) }
+
+  rule(:horizontal_bar) { str('--').as(:horizontal_bar) }
+  rule(:arrow_both) { str('<->').as(:arrow_both) }
+  rule(:arrow_to_r) { str('->').as(:arrow_to_r) }
+  rule(:arrow_to_l) { str('<-').as(:arrow_to_l) }
+  rule(:empty_circle) { str('{}').as(:empty_circle) }
+  rule(:empty_box) { str('||').as(:empty_box) }
+  rule(:hatched_circle) { str('{/}').as(:hatched_circle) }
+  rule(:hatched_box) { str('|/|').as(:hatched_box) }
+  rule(:circle) { str('{') >> (text|decoration).as(:circle) >> str('}')}
+  rule(:box) { str('|') >> (text|decoration).as(:box) >> str('|')}
+
+  rule(:bolditalic) { str('***') >> (text|decoration).as(:bolditalic) >> str('***')}
+  rule(:bold) { str('**') >> (text|decoration).as(:bold) >> str('**')}
+  rule(:italic) { str('*') >> (text|decoration).as(:italic) >> str('*')}
+
+  rule(:bstroke) { str('*') >> shape.as(:bstroke) >> str('*')}
+
+  rule(:overline) { str('=') >> (text|decoration).as(:overline) >> str('=')}
+  rule(:underline) { str('-') >> (text|decoration).as(:underline) >> str('-')}
+  rule(:linethrough) { str('~') >> (text|decoration).as(:linethrough) >> str('~')}
+
+  rule(:small) { str('___') >> (text|decoration|shape).as(:small) >> str('___')}
+  rule(:superscript) { str('__') >> (text|decoration|shape).as(:superscript) >> str('__')}
+  rule(:subscript) { str('_') >> (text|decoration|shape).as(:subscript) >> str('_')}
+
+  rule(:decoration) {(bolditalic | bold | italic | small | superscript | subscript |
+                      overline | underline | linethrough) }
+
+  rule(:shape) {(hatched_circle | hatched_box | empty_circle | empty_box |
+                 horizontal_bar | arrow_both | arrow_to_l | arrow_to_r |
+                 circle | box ) }
+
+  rule(:markup) {(text | decoration | shape | bstroke)}
+
+  rule(:line) { ( cr.as(:extracr) | border | bborder | markup.repeat(1).as(:line) >> (cr | eof | str('+').present?))}
+  rule(:lines) { triangle.maybe.as(:triangle) >>
+                 (brectangle | rectangle | brackets).maybe.as(:enclosure) >>
+                 line.repeat(1) >>
+                 path.repeat(0).as(:paths) >> (cr | eof) }
+  root :lines
+end
+
+module Markup
+  @parser = MarkupParser.new
+
+  @evaluator = Parslet::Transform.new do
+    rule(:chr => simple(:chr)) { chr.to_s }
+    rule(:text => sequence(:text)) {{:text => text.join(""), :decoration => []} }
+
+    rule(:horizontal_bar => subtree(:empty)) {
+      {:text => "　", :decoration => [:bar]}
+    }
+    rule(:arrow_both => subtree(:empty)) {
+      {:text => "　", :decoration => [:bar, :arrow_to_l, :arrow_to_r]}
+    }
+    rule(:arrow_to_l => subtree(:empty)) {
+      {:text => "　", :decoration => [:bar, :arrow_to_l]}
+    }
+    rule(:arrow_to_r => subtree(:empty)) {
+      {:text => "　", :decoration => [:bar, :arrow_to_r]}
+    }
+
+    rule(:empty_circle => subtree(:empty)) {
+      {:text => "　", :decoration => [:circle]}
+    }
+    rule(:empty_box => subtree(:empty)) {
+      {:text => "　", :decoration => [:box]}
+    }
+    rule(:hatched_circle => subtree(:empty)) {
+      {:text => "　", :decoration => [:hatched, :circle]}
+    }
+    rule(:hatched_box => subtree(:empty)) {
+      {:text => "　", :decoration => [:hatched, :box]}
+    }
+
+    rule(:bolditalic => subtree(:text)) {
+      text[:decoration] << :bolditalic; text
+    }
+    rule(:bold => subtree(:text)) {
+      text[:decoration] << :bold; text
+    }
+    rule(:italic => subtree(:text)) {
+      text[:decoration] << :italic; text
+    }
+
+    rule(:bstroke => subtree(:box)) {
+      box[:decoration] << :bstroke; box
+    }
+    rule(:bstroke => subtree(:circle)) {
+      circle[:decoration] << :bstroke; circle
+    }
+    rule(:bstroke => subtree(:horizontal_bar)) {
+      horizontal_bar[:decoration] << :bstroke; horizontal_bar
+    }
+    rule(:bstroke => subtree(:empty_circle)) {
+      empty_circle[:decoration] << :bstroke; empty_circle
+    }
+    rule(:bstroke => subtree(:empty_box)) {
+      empty_box[:decoration] << :bstroke; empty_box
+    }
+    rule(:bstroke => subtree(:hatched_circle)) {
+      hatched_circle[:decoration] << :bstroke; hatched_circle
+    }
+    rule(:bstroke => subtree(:hatched_box)) {
+      hatched_box[:decoration] << :bstroke; hatched_box
+    }
+
+    rule(:overline => subtree(:text)) {
+      text[:decoration] << :overline; text
+    }
+    rule(:underline => subtree(:text)) {
+      text[:decoration] << :underline; text
+    }
+    rule(:linethrough => subtree(:text)) {
+      text[:decoration] << :linethrough; text
+    }
+    rule(:subscript => subtree(:text)) {
+      text[:decoration] << :subscript; text
+    }
+    rule(:superscript => subtree(:text)) {
+      text[:decoration] << :superscript; text
+    }
+    rule(:small => subtree(:text)) {
+      text[:decoration] << :small; text
+    }
+    rule(:box => subtree(:text)) {
+      text[:decoration] << :box; text
+    }
+    rule(:circle => subtree(:text)) {
+      text[:decoration] << :circle; text
+    }
+    rule(:math => subtree(:text)) {
+      text[:decoration] << :math; text
+    }
+    rule(:border => simple(:border)) {
+      {:type => :border}
+    }
+    rule(:bborder => simple(:bborder)) {
+      {:type => :bborder}
+    }
+    rule(:line => subtree(:line)) {
+      {:type => :text, :elements => line }
+    }
+    rule(:extracr => subtree(:extracr)) {
+      {:type => :text, :elements=>[{:text=>"　", :decoration=>[]}]}
+    }
+
+  end
+
+  def parse(txt)
+    begin
+      parsed = @parser.parse(txt)
+    rescue Parslet::ParseFailed => e
+      # puts e.parse_failure_cause.ascii_tree
+      return {:status => :error, :text => txt}
+    end
+
+    applied = @evaluator.apply(parsed)
+
+    results = {:enclosure => :none, :triangle => false, :paths => [], :contents => []}
+    applied.each do |h|
+      if h[:enclosure]
+        if h[:enclosure].to_s == '###'
+          results[:enclosure] = :brectangle
+        elsif h[:enclosure].to_s == '##'
+          results[:enclosure] = :rectangle
+        elsif h[:enclosure].to_s == '#'
+          results[:enclosure] = :brackets
+        else
+          results[:enclosure] = :none
+        end
+      end
+      if h[:triangle]
+        results[:triangle] = h[:triangle].to_s == '^' ? true : false
+      end
+      if h[:paths]
+        results[:paths] = h[:paths]
+      end
+      if h[:type] == :text || h[:type] == :border || h[:type] == :bborder
+        results[:contents] << h
+      end
+    end
+    result = {:status => :success, :results  => results}
+    result
+  end
+
+  module_function :parse
+end
+
+# pp results = Markup.parse('^#\_\#\+あり\-がとう**_X_**\\n----\\n933\\n__|Y|__+>3+2+1343+>5464')

data/lib/rsyntaxtree/string_parser.rb

@@ -7,248 +7,231 @@
 #
 # Parses a phrase into leafs and nodes and store the result in an element list
 # (see element_list.rb)
-#
-# This file is part of RSyntaxTree, which is a ruby port of Andre Eisenbach's
-# excellent program phpSyntaxTree.
-#
 # Copyright (c) 2007-2021 Yoichiro Hasebe <yohasebe@gmail.com>
-# Copyright (c) 2003-2004 Andre Eisenbach <andre@ironcreek.net>
 
 require 'elementlist'
 require 'element'
-
-# def escape_high_ascii(string)
-#   html = ""
-#   string.length.times do |i|
-#     ch = string[i]
-#     if(ch < 127)
-#       html += ch.chr
-#     else
-#       html += sprintf("&#%d;", ch)
-#     end
-#   end  
-#   html
-# end
-
-class StringParser
-
-  attr_accessor :data, :elist, :pos, :id, :level, :tncnt
-  def initialize(str)
-    # Clean up the data a little to make processing easier
-    string = str.gsub(/\t/, "") rescue ""
-    string.gsub!(/\s+/, " ")
-    string.gsub!(/\] \[/, "][")
-    string.gsub!(/ \[/, "[")
-
-    @data = string # Store it for later...
-    @elist = ElementList.new # Initialize internal element list 
-    @pos = 0 # Position in the sentence
-    @id = 1 # ID for the next element
-    @level = 0 # Level in the diagram
-    @tncnt = Hash.new # Node type counts
-  end
-
-  # caution: quick and dirty solution      
-  def valid?
-    if(@data.length < 1)
-      return false
-    end
-
-    if /\[\s*\]/m =~ @data
-      return false  
-    end
-
-    if /\[\_/ =~ @data
-      return false
-    end
-
-    text = @data.strip
-    text_r = text.split(//)
-    open_br, close_br = [], []
-    escape = false
-    text_r.each do |chr|
-      if chr == "\\"
-        escape = true
-      elsif chr == '[' && !escape
-        open_br.push(chr)
-      elsif chr == ']' && !escape
-        close_br.push(chr)
-        if open_br.length < close_br.length
-          break
+require 'utils'
+
+module RSyntaxTree
+  class StringParser
+
+    attr_accessor :data, :elist, :pos, :id, :level
+    def initialize(str, fontset, fontsize)
+      # Clean up the data a little to make processing easier
+      # repeated newlines => a newline
+      string = str.gsub(/[\n\r]+/m, "\n")
+      # a backslash followed by a newline => a backslash followed by an 'n'
+      string.gsub!(/\\\n\s*/m, "\\n")
+      # repeated whitespace characters => " "
+      string.gsub!(/\s+/, " ")
+      string.gsub!(/\]\s+\[/, "][")
+      string.gsub!(/\s+\[/, "[")
+      string.gsub!(/\[\s+/, "[")
+      string.gsub!(/\s+\]/, "]")
+      string.gsub!(/\]\s+/, "]")
+      string.gsub!(/<(\d*)>/) do
+        num_padding = $1.to_i
+        if num_padding > 0
+          result = WHITESPACE_BLOCK * num_padding
+        else
+          result = WHITESPACE_BLOCK
         end
-      elsif escape
-        escape = false
+        result
       end
-    end
-
-    return false unless open_br.length == close_br.length
-    # make_tree(0)
-    # return false if @tncnt.empty?
-    # @tncnt.each do |key, value|
-    #   return false if key == ""
-    # end
-    return true
-  end 
-
-  def parse
-    make_tree(0);
-  end
 
-  def get_elementlist
-    @elist;
-  end
+      @data = string # Store it for later...
+      if @data.contains_cjk?
+        fontset[:normal] = fontset[:cjk]
+      end
+      @elist = ElementList.new # Initialize internal element list
+      @pos = 0 # Position in the sentence
+      @id = 1 # ID for the next element
+      @level = 0 # Level in the diagram
+      @fontset = fontset
+      @fontsize = fontsize
+    end
 
-  def auto_subscript
-    elements = @elist.get_elements
-    tmpcnt   = Hash.new
-    elements.each do |element|
-      if(element.type == ETYPE_NODE)
-        count = 1
-        content = element.content
+    def self.valid?(data)
+      if(data.length < 1)
+        raise RSTError, "Error: input text is empty"
+      end
 
-        if @tncnt[content]
-          count = @tncnt[content]
-        end
+      if /\[\s*\]/m =~ data
+        raise RSTError, "Error: inside the brackets is empty"
+      end
 
-        if(count > 1)
-          if tmpcnt[content]
-            tmpcnt[content] += 1
+      text = data.strip
+      text_r = text.split(//)
+      open_br, close_br = [], []
+      escape = false
+      text_r.each do |chr|
+        if chr == "\\"
+          if escape
+            escape = false
           else
-            tmpcnt[content] = 1
+            escape = true
           end
+          next
+        end
 
-          element.content += ("_" + tmpcnt[content].to_s)
+        if escape && /[\[\]]/ =~ chr
+          escape = false
+          next
+        elsif chr == '['
+          open_br.push(chr)
+        elsif chr == ']'
+          close_br.push(chr)
+          if open_br.length < close_br.length
+            break
+          end
         end
+        escape = false
+      end
 
+      if open_br.empty? && close_br.empty?
+        raise RSTError, "Error: input text does not contain paired brackets"
+      elsif open_br.length == close_br.length
+        return true
+      else
+        raise RSTError, "Error: open and close brackets do not match"
       end
-    end  
-    @tncnt
-  end
- 
-  def count_node(name)
-    name = name.strip
-    if @tncnt[name]
-      @tncnt[name] += 1
-    else
-      @tncnt[name] = 1
     end
-  end
 
-  def get_next_token
-    data = @data.split(//)
-    gottoken = false
-    token = ""
-    i = 0
+    def parse
+      make_tree(0);
+      @elist.set_hierarchy
+    end
 
-    if((@pos + 1) >= data.length)
-      return ""
+    def get_elementlist
+      @elist;
     end
 
-    escape = false
-    while(((@pos + i) < data.length) && !gottoken)
-      ch = data[@pos + i];
-      case ch
-      when "["
-        if escape
-          token += ch
-          escape = false
-        else
-          if(i > 0)
+    def get_next_token
+      data = @data.split(//)
+      gottoken = false
+      token = ""
+      i = 0
+
+      if((@pos + 1) >= data.length)
+        return ""
+      end
+
+      escape = false
+      while(((@pos + i) < data.length) && !gottoken)
+        ch = data[@pos + i];
+        case ch
+        when "["
+          if escape
+            token += ch
+            escape = false
+          else
+            if(i > 0)
+              gottoken = true
+            else
+              token += ch
+            end
+          end
+        when "]"
+          if escape
+            token += ch
+            escape = false
+          else
+            if(i == 0 )
+              token += ch
+            end
             gottoken = true
+          end
+        when "\\"
+          if escape
+            token += '\\\\'
+            escape = false
+          else
+            escape = true
+          end
+        when " "
+          if escape
+            token += '\\n'
+            escape = false
           else
             token += ch
           end
-        end
-      when "]"
-        if escape
-          token += ch
-          escape = false
-        else
-          if(i == 0 )
+        when /[n{}<>^+*_=~\|\-]/
+          if escape
+            token += '\\' + ch
+            escape = false
+          else
             token += ch
           end
-          gottoken = true
-        end
-      when "\\"
-        escape = true
-      when "n", " ", "+", "-", "=", "~", "#", "*"
-        if escape
-          token += "\\#{ch}"
-          escape = false
         else
-          token += ch
+          if escape
+            token += ch
+            escape = false
+          else
+            token += ch
+          end
         end
-      # when /[\n\r]/
-      #   gottoken = false # same as do nothing
-      else
-        token += ch
-        escape = false if escape
+        i += 1
       end
-      i += 1
-    end
 
-    if(i > 1)
-      @pos += (i - 1)
-    else
-      @pos += 1
+      if(i > 1)
+        @pos += (i - 1)
+      else
+        @pos += 1
+      end
+      return token
     end
-    return token
-  end
 
-  def make_tree(parent)
-    token = get_next_token.strip
-    parts = Array.new
-
-    while(token != "" && token != "]" )
-      token_r = token.split(//)
-      case token_r[0]
-      when "["
-        tl = token_r.length
-        token_r = token_r[1, tl - 1]
-        spaceat = token_r.index(" ")
-        newparent  = -1
-
-        if spaceat
-          parts[0] = token_r[0, spaceat].join
-          parts[0] = parts[0].gsub("<>", " ")
-
-          tl =token_r.length
-          parts[1] = token_r[spaceat, tl - spaceat].join
-          parts[1] = parts[1].gsub("<>", " ")
-
-          element = Element.new(@id, parent, parts[0], @level)
-          @id += 1
-          @elist.add(element)
-          newparent = element.id
-          count_node(parts[0])
-
-          element = Element.new(@id, @id - 1, parts[1], @level + 1 )
-          @id += 1          
-          @elist.add(element)
-        else
-          joined = token_r.join.gsub("<>", " ")
-          element = Element.new(@id, parent, joined, @level)
-          @id += 1          
-          newparent = element.id
-          @elist.add(element)
-          count_node(joined)
-        end 
+    def make_tree(parent)
+      token = get_next_token.strip
+      parts = Array.new
+
+      while(token != "" && token != "]" )
+        token_r = token.split(//)
+        case token_r[0]
+        when "["
+          tl = token_r.length
+          token_r = token_r[1, tl - 1]
+          spaceat = token_r.index(" ")
+          newparent  = -1
+
+          if spaceat
+            parts[0] = token_r[0, spaceat].join
+
+            tl =token_r.length
+            parts[1] = token_r[spaceat, tl - spaceat].join
+
+            element = Element.new(@id, parent, parts[0], @level, @fontset, @fontsize)
+            @id += 1
+            @elist.add(element)
+            newparent = element.id
+
+            element = Element.new(@id, @id - 1, parts[1], @level + 1, @fontset, @fontsize)
+            @id += 1
+            @elist.add(element)
+          else
+            joined = token_r.join
+            element = Element.new(@id, parent, joined, @level, @fontset,  @fontsize)
+            @id += 1
+            newparent = element.id
+            @elist.add(element)
+          end
 
-        @level += 1
-        make_tree(newparent)
+          @level += 1
+          make_tree(newparent)
 
-      else
-        if token.strip != ""
-          element = Element.new(@id, parent, token, @level)
-          @id += 1          
-          @elist.add(element)
-          count_node(token)
+        else
+          if token.strip != ""
+            element = Element.new(@id, parent, token, @level, @fontset, @fontsize)
+            @id += 1
+            @elist.add(element)
+          end
         end
-      end
 
-      token = get_next_token
+        token = get_next_token
+      end
+      @level -= 1
     end
-    @level -= 1
   end
 end