rsyntaxtree 2.4.0 → 2.5.0

data/lib/rsyntaxtree/svg_graph.rb

@@ -83,6 +83,15 @@ module RSyntaxTree
       # the deepest leaf) keep a margin instead of touching the image edge. A
       # margin is added around the region extents before unioning with the tree
       # bounds. x2/y2 are the viewBox width/height, so right = x1 + x2.
+      # Bottom to top, a movement path runs above the words, past the top of
+      # the tree; the canvas grows upward to hold it.
+      if @direction == "btt" && @path_bounds
+        top = [y1, @path_bounds[:min_y] - @global[:height_connector_to_text]].min
+        y2 += y1 - top
+        @height += y1 - top
+        y1 = top
+      end
+
       if @region_bounds
         rb = @region_bounds
         m = @global[:h_gap_between_nodes]
@@ -413,6 +422,52 @@ module RSyntaxTree
         "#{dasharray}#{markers}/>"
     end
 
+    # How far the labels standing between a path's two ends reach toward its
+    # rail: the rail runs past the two ends, and has to run past every label
+    # across its span too, or it is drawn through a word that stands farther
+    # out than either end. Measured to the same edge the ends are anchored at.
+    def label_reach(from, to)
+      lo, hi = [from, to].minmax
+      hctt = @global[:height_connector_to_text]
+      @element_list.get_elements.map do |e|
+        if @direction == "ltr"
+          next if e.vertical_indent > hi || e.vertical_indent + e.content_height < lo
+
+          e.horizontal_indent + e.content_width + hctt
+        else
+          next if e.horizontal_indent > hi || e.horizontal_indent + e.content_width < lo
+
+          @direction == "btt" ? e.vertical_indent - hctt : e.vertical_indent + e.content_height + hctt
+        end
+      end.compact.send(@direction == "btt" ? :min : :max) || from
+    end
+
+    RAIL_SLACK = 1e-6
+
+    # A rail that would run along one already drawn, over part of the same
+    # span, is moved outward past it: two paths whose rails coincide read as
+    # one line, and nothing tells which ends it joins.
+    #
+    # Each move goes outward and past the rail in the way, so no rail can be in
+    # the way twice and there are at most as many moves as rails. The distance
+    # is compared with a little slack: a rail moved exactly one spacing past
+    # another can measure a hair under it, and would be moved again forever.
+    def clear_of_rails(at, span, spacing, sign)
+      @rails ||= []
+      lo, hi = span
+      close = spacing - RAIL_SLACK
+      @rails.size.times do
+        blocking = @rails.find do |r|
+          r[:lo] <= hi + spacing && lo <= r[:hi] + spacing && (r[:at] - at).abs < close
+        end
+        break unless blocking
+
+        at = blocking[:at] + (sign * spacing)
+      end
+      @rails << { lo: lo, hi: hi, at: at }
+      at
+    end
+
     # Where the movement paths have been, as a box. The canvas learns of a
     # rail through @width and @height, which only say how far right and down
     # anything got; the plane behind a sheared figure has to enclose the rail
@@ -430,6 +485,13 @@ module RSyntaxTree
     def draw_a_path(s_x, s_y, t_x, t_y, target_arrow = :none)
       spacing = @global[:h_gap_between_nodes] * 1.25
       min_bulge = @global[:height_connector_to_text]
+      # An end that carries an arrowhead needs a run long enough for the head
+      # and a stem before the turn. The rail clears the farther end by the
+      # bulge alone, so an arrowhead on that end — every arrowhead, once the
+      # terminals stand on one row — was pressed against the corner.
+      arrow_run = @global[:h_gap_between_nodes] + (min_bulge * 2)
+      source_arrow = target_arrow == :double
+      target_arrow_drawn = target_arrow != :none
       # Small enough that the turn reads as an eased corner rather than as an
       # arc, and taken from a layout measure so it holds at every font size.
       corner_radius = min_bulge / 2.0
@@ -447,7 +509,7 @@ module RSyntaxTree
       if @direction == "ltr"
         # LTR: route to the RIGHT of the tree (⊃ shape / reversed C)
         # Source → right → vertical → left → Target
-        xmax = [s_x, t_x].max
+        xmax = [s_x, t_x, label_reach(s_y, t_y)].max
         bulge = [min_bulge, (s_y - t_y).abs * 0.3 + min_bulge].min
         # Ensure paths don't overlap: extend beyond previous paths
         new_x = if xmax < @width
@@ -455,6 +517,8 @@ module RSyntaxTree
                 else
                   xmax + bulge
                 end
+        new_x = [new_x, s_x + arrow_run].max if source_arrow
+        new_x = [new_x, t_x + arrow_run].max if target_arrow_drawn
 
         new_s_y = s_y + s_offset
         new_t_y = t_y + t_offset
@@ -468,16 +532,22 @@ module RSyntaxTree
                                       end_arrow: target_arrow != :none)
         @width = new_x if new_x > @width
       else
-        # TTB: route BELOW the tree (U shape)
+        # TTB: route BELOW the tree (U shape), on the side the words are on;
+        # BTT turns the tree over, words at the top, and the path with it.
         # Source → down → horizontal → up → Target
-        ymax = [s_y, t_y].max
+        outward = @direction == "btt" ? :min : :max
+        sign = @direction == "btt" ? -1 : 1
+        edge = [s_y, t_y, label_reach(s_x, t_x)].send(outward)
         # Proportional bulge: based on distance between endpoints,
         # not the full tree height
         bulge = [min_bulge, (s_x - t_x).abs * 0.3 + min_bulge].min
-        new_y = ymax + bulge
+        new_y = edge + (sign * bulge)
+        new_y = [new_y, s_y + (sign * arrow_run)].send(outward) if source_arrow
+        new_y = [new_y, t_y + (sign * arrow_run)].send(outward) if target_arrow_drawn
 
         new_s_x = s_x - s_offset
         new_t_x = t_x - t_offset
+        new_y = clear_of_rails(new_y, [new_s_x, new_t_x].minmax, spacing, sign)
 
         note_path_extent([[new_s_x, s_y], [new_s_x, new_y],
                           [new_t_x, new_y], [new_t_x, t_y]])
@@ -511,7 +581,7 @@ module RSyntaxTree
       # enclosure needs, so the text starts that far inside the node's left
       # edge and the enclosure is drawn on the edge itself.
       enclosure_room = element.label_enclosure_room
-      text_x = txt_pos - element.content_width / 2 + enclosure_room
+      text_x = txt_pos - element.content_width / 2.0 + enclosure_room
       text_y = top + @global[:single_line_height] - @global[:height_connector_to_text]
       text_data  = text_data.sub(/X_VALUE/, text_x.to_s)
       text_data  = text_data.sub(/Y_VALUE/, text_y.to_s)
@@ -869,9 +939,9 @@ module RSyntaxTree
           lgeom = {
             left: element.horizontal_indent,
             right: element.horizontal_indent + element.content_width,
-            top: y_center - element.content_height / 2,
-            bottom: y_center + element.content_height / 2,
-            cx: element.horizontal_indent + element.content_width / 2,
+            top: y_center - element.content_height / 2.0,
+            bottom: y_center + element.content_height / 2.0,
+            cx: element.horizontal_indent + element.content_width / 2.0,
             cy: y_center
           }
         else
@@ -881,12 +951,15 @@ module RSyntaxTree
           # them into the boxes in narrow ones. Only the line pool uses
           # x0/x2; movement paths read x1, which is unchanged.
           x0 = element.horizontal_indent
-          x1 = element.horizontal_indent + element.content_width / 2
+          x1 = element.horizontal_indent + element.content_width / 2.0
           x2 = element.horizontal_indent + element.content_width
           y0 = element.vertical_indent + @global[:height_connector_to_text] / 2
           y1 = element.vertical_indent + element.content_height + @global[:height_connector_to_text]
           lgeom = nil
         end
+        # A movement path leaves a label on the side the words are on: below
+        # it top to bottom, above it bottom to top.
+        path_y = @direction == "btt" ? element.vertical_indent - @global[:height_connector_to_text] : y1
         et = element.path
         et.each do |tr|
           if /\A-(>|<)?(\d+)\z/ =~ tr
@@ -901,20 +974,20 @@ module RSyntaxTree
           elsif /\A(?:>|<)(\d+)\z/ =~ tr
             tr = $1
             if path_pool_target[tr]
-              path_pool_target[tr] << [x1, y1]
+              path_pool_target[tr] << [x1, path_y]
             else
-              path_pool_target[tr] = [[x1, y1]]
+              path_pool_target[tr] = [[x1, path_y]]
             end
             path_flags << tr
           elsif path_pool_source[tr]
             if path_pool_other[tr]
-              path_pool_other[tr] << [x1, y1]
+              path_pool_other[tr] << [x1, path_y]
             else
-              path_pool_other[tr] = [[x1, y1]]
+              path_pool_other[tr] = [[x1, path_y]]
             end
             path_flags << tr
           else
-            path_pool_source[tr] = [x1, y1]
+            path_pool_source[tr] = [x1, path_y]
             path_flags << tr
           end
           raise RSTError.new(+"Error: input text contains a path having more than two ends:\n > #{tr}", code: :path_multiple_ends, hint: "A path or line takes exactly two ends; check the numbers.", retryable: true) if path_flags.tally.any? { |_k, v| v > 2 } || line_flags.tally.any? { |_k, v| v > 2 }
@@ -956,6 +1029,10 @@ module RSyntaxTree
         end
       end
 
+      # Narrowest first, so a path that spans another runs outside it rather
+      # than across its ends. Left to right, every rail already clears the
+      # ones drawn before it, in the order written.
+      paths = paths.each_with_index.sort_by { |t, i| [(t[:x1] - t[:x2]).abs, i] }.map(&:first) unless @direction == "ltr"
       paths.each do |t|
         draw_a_path(t[:x1], t[:y1], t[:x2], t[:y2], t[:arrow])
       end
@@ -1203,9 +1280,35 @@ module RSyntaxTree
       row ? row[:top] : element.ink_top
     end
 
+    # The lower endpoint clears the element's own ink, not the row's. A row
+    # keeps its labels top-aligned, so a tall one — a feature matrix, a
+    # two-line label — reaches far below its neighbours; taking the row's
+    # union here dragged every short label's downward connector down to that
+    # depth, opening a gap under the label with no line in it and flattening
+    # the branch of a polyline. The upper endpoint still takes the row (see
+    # ink_over): the edges arriving at a row of leaves are what must line up,
+    # which was the point of the band, and that is unchanged.
     def ink_under(element)
-      row = element.enclosure == :none && row_ink[element.vertical_indent.round(1)]
-      row ? row[:bottom] : element.ink_bottom
+      element.ink_bottom
+    end
+
+    # Where a polyline's rail sits: halfway between the parent's end and the
+    # row its children stand in, so every child of one node turns off the same
+    # rail. A plain child's own end is not the measure: a joint's line runs to
+    # its middle, so as to pass straight through it, and a label's lower edge
+    # is its own ink, which differs from letter to letter. An enclosed child is
+    # met at the box drawn round it, as ink_over meets it, so nil sends it to
+    # its own end.
+    def rail_edge_y(child, parent)
+      m = @global[:single_x_metrics].height * @global[:vmargin]
+      row = child.enclosure == :none && row_ink[child.vertical_indent.round(1)]
+      return nil unless m && row
+
+      child.vertical_indent <= parent.vertical_indent ? row[:bottom] + m : row[:top] - m
+    end
+
+    def rail_edge_x(child)
+      child.horizontal_indent - @global[:height_connector_to_text]
     end
 
     def connector_edges(child, parent)
@@ -1225,7 +1328,7 @@ module RSyntaxTree
       m = @global[:single_x_metrics].height * @global[:vmargin]
 
       child_y = if child.empty_label?
-                  child.vertical_indent + child.content_height / 2
+                  child.vertical_indent + child.content_height / 2.0
                 elsif child_above
                   if m && child.ink_bottom
                     ink_under(child) + m
@@ -1239,7 +1342,7 @@ module RSyntaxTree
                 end
 
       parent_y = if parent.empty_label?
-                   parent.vertical_indent + parent.content_height / 2
+                   parent.vertical_indent + parent.content_height / 2.0
                  elsif child_above
                    if m && parent.ink_top
                      ink_over(parent) - m
@@ -1280,11 +1383,11 @@ module RSyntaxTree
         hctt = @global[:height_connector_to_text]
         y1 = child.vertical_indent + (child.content_height + hctt * 1.5) / 2
         y2 = parent.vertical_indent + (parent.content_height + hctt * 1.5) / 2
-        x1 = child.empty_label? ? child.horizontal_indent + child.content_width / 2 : child.horizontal_indent - hctt
-        x2 = parent.empty_label? ? parent.horizontal_indent + parent.content_width / 2 : parent.horizontal_indent + parent.content_width + hctt
+        x1 = child.empty_label? ? child.horizontal_indent + child.content_width / 2.0 : child.horizontal_indent - hctt
+        x2 = parent.empty_label? ? parent.horizontal_indent + parent.content_width / 2.0 : parent.horizontal_indent + parent.content_width + hctt
 
         if @polyline
-          mid_x1 = x2 + (x1 - x2) / 2
+          mid_x1 = x2 + (rail_edge_x(child) - x2) / 2
           mid_y1 = y1
           mid_x2 = mid_x1
           mid_y2 = y2
@@ -1305,12 +1408,12 @@ module RSyntaxTree
       else
         # TTB: parent's bottom → child's top
         if @polyline
-          chi_x = child.horizontal_indent + child.content_width / 2
-          par_x = parent.horizontal_indent + parent.content_width / 2
+          chi_x = child.horizontal_indent + child.content_width / 2.0
+          par_x = parent.horizontal_indent + parent.content_width / 2.0
           chi_y, par_y = connector_edges(child, parent)
 
           mid_x1 = chi_x
-          mid_y1 = par_y + (chi_y - par_y) / 2
+          mid_y1 = par_y + ((rail_edge_y(child, parent) || chi_y) - par_y) / 2
 
           mid_x2 = par_x
           mid_y2 = mid_y1
@@ -1324,8 +1427,8 @@ module RSyntaxTree
                                         .sub(/PARX/, par_x.to_s)
                                         .sub(/PARY/, par_y.to_s)
         else
-          x1 = child.horizontal_indent + child.content_width / 2
-          x2 = parent.horizontal_indent + parent.content_width / 2
+          x1 = child.horizontal_indent + child.content_width / 2.0
+          x2 = parent.horizontal_indent + parent.content_width / 2.0
           y1, y2 = connector_edges(child, parent)
 
           line_data   = @line_styles.sub(/X1/, x1.to_s)
@@ -1337,7 +1440,7 @@ module RSyntaxTree
     end
 
     # Draw a triangle between child/parent elements
-    def triangle_to_parent(parent, child)
+    def triangle_to_parent(parent, child, _joints = [])
       return if child.horizontal_indent.zero?
 
       if @direction == "ltr"
@@ -1366,7 +1469,7 @@ module RSyntaxTree
         # bottom-to-top examples are derivations, which draw rules instead.
         x1 = child.horizontal_indent
         x2 = child.horizontal_indent + child.content_width
-        x3 = parent.horizontal_indent + parent.content_width / 2
+        x3 = parent.horizontal_indent + parent.content_width / 2.0
         child_above = child.vertical_indent <= parent.vertical_indent
         m = child.ink_top && parent.ink_bottom ? @global[:single_x_metrics].height * @global[:vmargin] : nil
         if child_above

data/lib/rsyntaxtree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RSyntaxTree
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 end

data/lib/rsyntaxtree.rb

@@ -61,7 +61,8 @@ OPTION_VALUES = {
   tidy: %w[off symmetric low medium high on compact true false],
   direction: %w[ttb ltr btt],
   hyphen: %w[markup literal],
-  derivation: %w[on off true false yes no 0 1 none]
+  derivation: %w[on off true false yes no 0 1 none],
+  leaf_align: %w[off words subtrees]
 }.freeze
 
 NUMERIC_RANGES = {
@@ -96,6 +97,7 @@ DEFAULT_OPTS = {
   transparent: "off",
   polyline: "off",
   hide_default_connectors: "off",
+  leaf_align: "off",
   mirror: "off",
   tidy: "off",
   hspacing: 1.0,
@@ -306,6 +308,8 @@ module RSyntaxTree
                             end
         when :transparent, :polyline, :hide_default_connectors, :mirror, :derivation
           new_params[key] = switched_on?(value)
+        when :leaf_align
+          new_params[key] = value.to_s
         when :color
           new_params[key] = case value.to_s
                             when "modern", "on", "true"
@@ -693,16 +697,12 @@ module RSyntaxTree
     end
 
     def draw_svg
-      sp = StringParser.new(@params[:data].gsub('&', '&'), @params[:fontset], @params[:fontsize], @global)
-      sp.parse
-      graph = SVGGraph.new(sp.get_elementlist, @params, @global)
+      graph = SVGGraph.new(parsed_element_list, @params, @global)
       graph.svg_data
     end
 
     def draw_json
-      sp = StringParser.new(@params[:data].gsub('&', '&'), @params[:fontset], @params[:fontsize], @global)
-      sp.parse
-      graph = JSONGraph.new(sp.get_elementlist, @params, @global)
+      graph = JSONGraph.new(parsed_element_list, @params, @global)
       graph.json_data
     end
 
@@ -712,10 +712,20 @@ module RSyntaxTree
     end
 
     def draw_tikz(standalone: false, font: nil)
+      generator = TikZGenerator.new(parsed_element_list, @params)
+      generator.generate(standalone: standalone, font: font)
+    end
+
+    private
+
+    def parsed_element_list
       sp = StringParser.new(@params[:data].gsub('&', '&'), @params[:fontset], @params[:fontsize], @global)
       sp.parse
-      generator = TikZGenerator.new(sp.get_elementlist, @params)
-      generator.generate(standalone: standalone, font: font)
+      list = sp.get_elementlist
+      if @params[:leaf_align] != "off" && @params[:derivation] != true
+        list.align_leaves(@params[:leaf_align], @params[:fontset], @params[:fontsize], @global)
+      end
+      list
     end
   end
 end

data/rsyntaxtree.gemspec

@@ -19,8 +19,8 @@ Gem::Specification.new do |s|
   # the scripts that build them, the tests, the CI and container setup, the
   # bundle and the rake tasks — and whoever wants those clones the repository.
   development = ["docs/", "dev/", "img/", "test/", ".github/"]
-  development_files = [".gitattributes", ".gitignore", ".ruby-version",
-                       "Dockerfile", "Gemfile", "Rakefile"]
+  development_files = [".dockerignore", ".gitattributes", ".gitignore",
+                       ".ruby-version", "Dockerfile", "Gemfile", "Rakefile"]
   s.files         = `git ls-files`.split("\n").reject do |path|
                       development.any? { |dir| path.start_with?(dir) } ||
                         development_files.include?(path)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsyntaxtree
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Yoichiro Hasebe
@@ -115,7 +115,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dockerignore"
 - CHANGELOG.md
 - CITATION.cff
 - CODE_OF_CONDUCT.md

data/.dockerignore

@@ -1,5 +0,0 @@
-# The image needs the working tree, not the repository: without this, ADD .
-# copies .git into every image — hundreds of megabytes of history, including
-# refs that exist only on the build machine.
-.git
-pkg