rsyntaxtree 0.9.2 → 1.0.5

data/lib/rsyntaxtree/element.rb

@@ -6,43 +6,174 @@
 #==========================
 #
 # Aa class that represents a basic tree element, either node or leaf.
-#
-# 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>
 
-class Element
+require "markup_parser"
+require 'utils'
+
+module RSyntaxTree
+  class Element
 
-    attr_accessor :id, :parent, :type, :content, :level, :width, :indent, :triangle
-    def initialize(id = 0, parent = 0, content = "", level = 0, type = ETYPE_LEAF)
+    attr_accessor :id,
+      :parent, :type, :level,
+      :width, :height,
+      :content, :content_width, :content_height,
+      :horizontal_indent, :vertical_indent,
+      :triangle, :enclosure, :children, :parent,
+      :font, :fontsize, :contains_phrase,
+      :path
+
+    def initialize(id, parent, content, level, fontset, fontsize)
+      @type = ETYPE_LEAF
       @id = id                 # Unique element id
       @parent = parent         # Parent element id
+      @children = []           # Child element ids
       @type = type             # Element type
       @level = level           # Element level in the tree (0=top etc...)
-      @width = 0               # Width of the element in pixels
-      @indent = 0              # Drawing offset
+      @width = 0               # Width of the part of the tree including itself and it governs
+      @content_width = 0       # Width of the content
+      @horizontal_indent = 0   # Drawing offset
+      @vertical_indent = 0     # Drawing offset
       content = content.strip
-      if /\A.+\^\z/m =~ content
-        @content = content.gsub("^"){""} # The actual element content
-        @triangle = true # draw triangle instead of stright bar when in auto mode
+
+      if /.+?\^?((?:\+\>?\d+)+)\^?\z/m =~ content
+        @path = $1.sub(/\A\+/, "").split("+")
       else
-        @content = content.gsub("^"){""}.strip # The actual element content
-        @triangle = false # draw triangle instead of stright bar when in auto mode
+        @path = []
       end
-      # workaround to save "[A [B [C] [D] ] [E [F] [G [H] [J] ] ] ]"
+
+      @fontset = fontset
+      @fontsize = fontsize
+
+      parsed = Markup.parse(content)
+
+      if parsed[:status] == :success
+        results = parsed[:results]
+      else
+        error_text = "Error: input text contains an invalid string"
+        error_text += "\n > " + content
+        raise RSTError, error_text
+      end
+      @content = results[:contents]
+      @paths = results[:paths]
+      @enclosure = results[:enclosure]
+      @triangle = results[:triangle]
+
+      @contains_phrase = false
+      setup
     end
 
-    # Debug helper function
-    def dump
-      printf( "ID      : %d\n", @id );
-      printf( "Parent  : %d\n", @parent );
-      printf( "Level   : %d\n", @level );
-      printf( "Type    : %d\n", @type );
-      printf( "Width   : %d\n", @width );
-      printf( "Indent  : %d\n", @indent );
-      printf( "Content : %s\n\n", @content );
+    def setup
+      total_width = 0
+      total_height = 0
+      @content.each_with_index do |content, idx|
+        content_width = 0
+        case content[:type]
+        when :border, :bborder
+          height = $single_line_height / 2
+          content[:height] = height
+          total_height += height
+        when :text
+          row_width = 0
+          elements_height = []
+          content[:elements].each do |e|
+            text = e[:text]
+            e[:text] = text.gsub(" ", WHITESPACE_BLOCK).gsub(">", '&#62;').gsub("<", '&#60;')
+
+
+            @contains_phrase = true if text.include?(" ")
+            decoration = e[:decoration]
+            fontsize = decoration.include?(:small) || decoration.include?(:small) ? @fontsize * SUBSCRIPT_CONST : @fontsize
+            fontsize = decoration.include?(:subscript) || decoration.include?(:superscript)  ? fontsize * SUBSCRIPT_CONST : fontsize
+            style    = decoration.include?(:italic) || decoration.include?(:bolditalic) ? :italic : :normal
+            weight   = decoration.include?(:bold) || decoration.include?(:bolditalic) ? :bold : :normal
+
+            # e[:cjk] = false
+            # if e[:decoration].include?(:math)
+            #   font = @fontset[:math]
+            # elsif text.contains_cjk?
+            #   font = @fontset[:cjk]
+            #   e[:cjk] = true
+            # elsif decoration.include? :bolditalic
+            if decoration.include? :bolditalic
+              font = @fontset[:bolditalic]
+            elsif decoration.include? :bold
+              font = @fontset[:bold]
+            elsif decoration.include? :italic
+              font = @fontset[:italic]
+            else
+              font = @fontset[:normal]
+            end
+
+            standard_metrics = FontMetrics.get_metrics('X', @fontset[:normal], fontsize, :normal, :normal)
+            height = standard_metrics.height
+            if /\A[\<\>]+\z/ =~ text
+              width = standard_metrics.width * text.size / 2
+            elsif text.contains_emoji?
+              segments = text.split_by_emoji
+              width = 0
+              segments.each do |seg|
+                if /\s/ =~ seg[:char]
+                  ch = 't'
+                else
+                  ch = seg[:char]
+                end
+                if seg[:type] == :emoji
+                  this_font = @fontset[:emoji]
+                  metrics = FontMetrics.get_metrics(ch, this_font, fontsize, style, weight)
+                  width += metrics.width
+                else
+                  this_font = font
+                  metrics = FontMetrics.get_metrics(ch, this_font, fontsize, style, weight)
+                  width += metrics.width
+                end
+              end
+            else
+              text.gsub!("\\\\", 'i')
+              text.gsub!("\\", "")
+              text.gsub!(" ", "x")
+              text.gsub!("%", "X")
+              metrics = FontMetrics.get_metrics(text, font, fontsize, style, weight)
+              width = metrics.width
+            end
+
+            if e[:decoration].include?(:box) || e[:decoration].include?(:circle) || e[:decoration].include?(:bar)
+              if e[:text].size == 1
+                e[:content_width] = width
+                width += (height - width)
+              else
+                e[:content_width] = width
+                width += $width_half_X
+              end
+            end
+
+            if e[:decoration].include?(:whitespace)
+              width = $width_half_X / 2 * e[:text].size / 4
+              e[:text] = ""
+            end
+
+            e[:height] = height
+            elements_height << height + $box_vertical_margin / 2
+
+            e[:width] = width
+            row_width += width
+          end
+
+          if @enclosure != :none
+            total_height += (elements_height.max + $height_connector_to_text)
+          else
+            total_height += elements_height.max
+          end
+          content_width += row_width
+        end
+        total_width = content_width if total_width < content_width
+      end
+      @content_width = total_width
+      @content_height = total_height
     end
 
+    def add_child(child_id)
+      @children << child_id
+    end
+  end
 end

data/lib/rsyntaxtree/elementlist.rb

@@ -6,23 +6,25 @@
 #==========================
 #
 # Contains a list of unordered tree elements with a defined parent
-#
-# 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 'element'
 
-class ElementList
+module RSyntaxTree
+  class ElementList
 
-    attr_accessor :elements, :iterator
+    attr_accessor :elements, :iterator 
     def initialize
       @elements = Array.new # The element array
       @iterator = -1 # Iterator index (used for get_first / get_next)
     end
 
+    def set_hierarchy
+      @elements.each do |e|
+        get_id(e.parent).add_child(e.id) unless e.parent == 0
+      end
+    end
+
     def add(element)
       @elements << element
       if(element.parent != 0)
@@ -41,12 +43,12 @@ class ElementList
     end
 
     def get_next
-        @iterator += 1
-        if @elements[@iterator]
-          return @elements[@iterator]
-        else
-          return nil
-        end
+      @iterator += 1
+      if @elements[@iterator]
+        return @elements[@iterator]
+      else
+        return nil
+      end
     end
 
     def get_id(id)
@@ -118,4 +120,5 @@ class ElementList
       end
       return maxlevel + 1;
     end
+  end
 end

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')