rsyntaxtree 2.4.1 → 2.6.0

data/lib/rsyntaxtree/svg_graph.rb

@@ -57,7 +57,6 @@ module RSyntaxTree
       @polygon_styles = "<polygon style='fill: none; stroke: #{@col_connector}; stroke-width:#{@global[:stroke_normal]}; stroke-linejoin:round;stroke-linecap:round;' points='X1 Y1 X2 Y2 X3 Y3' />\n"
       @text_styles = "<text white-space='pre' alignment-baseline='text-top' style='fill: COLOR; stroke-width: 0; font-size: fontsize' x='X_VALUE' y='Y_VALUE'>CONTENT</text>\n"
       @tree_data = String.new
-      @visited_x = {}
       @visited_y = {}
       @global = global
     end
@@ -83,6 +82,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]
@@ -378,6 +386,12 @@ module RSyntaxTree
       d << " L#{at.call(points.last)}"
     end
 
+    # The dash every dashed line in the figure is drawn with.
+    def dash_array
+      dash = @fontsize / 4.0
+      "stroke-dasharray='#{dash} #{dash}'"
+    end
+
     # One stroke rather than three lines meeting at right angles. Drawn this way
     # the dash pattern runs round each turn instead of restarting at it, and an
     # arrowhead is the end of the stroke rather than a marker on whichever line
@@ -393,8 +407,7 @@ module RSyntaxTree
       radius = [radius, leg.call(points[-2], points[-1]) - arrow_length].min if end_arrow
       radius = [radius, 0].max
 
-      dash = @fontsize / 4.0
-      dasharray = dashed ? "stroke-dasharray='#{dash} #{dash}' " : ""
+      dasharray = dashed ? "#{dash_array} " : ""
       markers = +""
       markers << "marker-start='url(#arrowStart)' " if start_arrow
       markers << "marker-end='url(#arrow)' " if end_arrow
@@ -413,6 +426,59 @@ 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
+
+    # How far apart two rails stand, and two path ends on one label.
+    def rail_spacing
+      @global[:h_gap_between_nodes] * 1.25
+    end
+
+    # A rail that would run along one already drawn, over part of the same
+    # span or less than one spacing short of it, is moved outward past it: two
+    # paths whose rails coincide read as one line, and nothing tells which
+    # ends it joins. Rails a spacing or more apart end to end stay on one
+    # level, as two paths meeting at a label do once their ends are spread.
+    #
+    # 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. Distances
+    # are 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 + close && lo < r[:hi] + close && (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
@@ -427,27 +493,56 @@ module RSyntaxTree
       b[:max_y] = [b[:max_y], ys.max].max
     end
 
-    def draw_a_path(s_x, s_y, t_x, t_y, target_arrow = :none)
-      spacing = @global[:h_gap_between_nodes] * 1.25
+    # Path ends that stand in one line across the paths' run (on one label,
+    # or on labels straight above one another) are spread apart, each to the
+    # side its path heads for: a path going left leaves from the left and one
+    # going right from the right, so neither crosses the other's rail. Among
+    # ends heading the same way, the one that goes farther takes the outer
+    # place, since its rail runs outside. Left to right, the same holds with
+    # up and down in place of left and right. Neighbouring ends stand one
+    # rail spacing apart, the same distance that keeps two rails apart, or
+    # closer where that would take them past the narrowest label they share:
+    # an end stays on its label, and so off its neighbours and on the canvas.
+    def spread_shared_ends(paths)
+      along = @direction == "ltr" ? 1 : 0
+      ends = Hash.new { |h, k| h[k] = [] }
+      paths.each do |t|
+        s = [t[:x1], t[:y1]]
+        e = [t[:x2], t[:y2]]
+        ends[s[along].round] << [t, :s_offset, s[along], e[along], t[:across1]]
+        ends[e[along].round] << [t, :t_offset, e[along], s[along], t[:across2]]
+      end
+      ends.each_value do |shared|
+        gaps = shared.size - 1
+        step = gaps.zero? ? 0 : [rail_spacing, shared.map(&:last).min / gaps.to_f].min
+        shared.each_with_index
+              .sort_by { |(_, _, at, other, _), i| [other <=> at, -other, i] }
+              .each_with_index do |((t, key, _, _, _), _), place|
+          t[key] = (place - (gaps / 2.0)) * step
+        end
+      end
+    end
+
+    def draw_a_path(s_x, s_y, t_x, t_y, target_arrow = :none, s_offset: 0, t_offset: 0)
+      spacing = rail_spacing
       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
 
-      # Centered offset for multiple lines at the same endpoint
-      s_key = "#{s_x.round}"
-      t_key = "#{t_x.round}"
-      @visited_x[s_key] = (@visited_x[s_key] || 0) + 1
-      @visited_x[t_key] = (@visited_x[t_key] || 0) + 1
-      s_offset = ((@visited_x[s_key] - 1) - (@visited_x[s_key] - 1) / 2.0) * spacing
-      t_offset = ((@visited_x[t_key] - 1) - (@visited_x[t_key] - 1) / 2.0) * spacing
-
       dashed = true if target_arrow == :none
 
       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 +550,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 +565,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_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 +614,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 +972,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 +984,23 @@ 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
+        # How much of the label there is across the paths' run, for the ends
+        # that share it to be spread over: an even amount either side of the
+        # anchor, which left to right sits below the middle of the label.
+        across = if @direction == "ltr"
+                   [element.content_height - (@global[:height_connector_to_text] * 1.5), 0].max
+                 else
+                   element.content_width
+                 end
         et = element.path
         et.each do |tr|
           if /\A-(>|<)?(\d+)\z/ =~ tr
@@ -901,20 +1015,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, across]
             else
-              path_pool_target[tr] = [[x1, y1]]
+              path_pool_target[tr] = [[x1, path_y, across]]
             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, across]
             else
-              path_pool_other[tr] = [[x1, y1]]
+              path_pool_other[tr] = [[x1, path_y, across]]
             end
             path_flags << tr
           else
-            path_pool_source[tr] = [x1, y1]
+            path_pool_source[tr] = [x1, path_y, across]
             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 }
@@ -935,11 +1049,11 @@ module RSyntaxTree
         path_flags.delete(k)
         if (targets = path_pool_target[k])
           targets.each do |t|
-            paths << { x1: v[0], y1: v[1], x2: t[0], y2: t[1], arrow: :single }
+            paths << { x1: v[0], y1: v[1], x2: t[0], y2: t[1], across1: v[2], across2: t[2], arrow: :single }
           end
         elsif (others = path_pool_other[k])
           others.each do |t|
-            paths << { x1: v[0], y1: v[1], x2: t[0], y2: t[1], arrow: :none }
+            paths << { x1: v[0], y1: v[1], x2: t[0], y2: t[1], across1: v[2], across2: t[2], arrow: :none }
           end
         end
       end
@@ -952,12 +1066,17 @@ module RSyntaxTree
         next if fst.nil?
 
         targets.each do |t|
-          paths << { x1: fst[0], y1: fst[1], x2: t[0], y2: t[1], arrow: :double }
+          paths << { x1: fst[0], y1: fst[1], x2: t[0], y2: t[1], across1: fst[2], across2: t[2], arrow: :double }
         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"
+      spread_shared_ends(paths)
       paths.each do |t|
-        draw_a_path(t[:x1], t[:y1], t[:x2], t[:y2], t[:arrow])
+        draw_a_path(t[:x1], t[:y1], t[:x2], t[:y2], t[:arrow], s_offset: t[:s_offset], t_offset: t[:t_offset])
       end
 
       line_pool.each do |_k, v|
@@ -1025,8 +1144,7 @@ module RSyntaxTree
                else
                  ""
                end
-      dash = @fontsize / 4.0
-      dasharray = dashed ? "stroke-dasharray='#{dash} #{dash}'" : ""
+      dasharray = dashed ? dash_array : ""
       swidth = bline ? @global[:stroke_bold] : @global[:stroke_normal]
 
       if s_arrow && t_arrow
@@ -1091,8 +1209,7 @@ module RSyntaxTree
                else
                  ""
                end
-      dash = @fontsize / 4.0
-      dasharray = dashed ? "stroke-dasharray='#{dash} #{dash}'" : ""
+      dasharray = dashed ? dash_array : ""
       swidth = bline ? @global[:stroke_bold] : @global[:stroke_normal]
 
       "<line x1='#{x1}' y1='#{y1}' x2='#{x2}' y2='#{y2}' style='fill: none; stroke: #{col}; stroke-width:#{swidth}; stroke-linecap:round;' #{dasharray} #{string}/>"
@@ -1215,6 +1332,25 @@ module RSyntaxTree
       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)
       hctt = @global[:height_connector_to_text]
       child_above = child.vertical_indent <= parent.vertical_indent
@@ -1232,7 +1368,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
@@ -1246,7 +1382,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
@@ -1276,8 +1412,12 @@ module RSyntaxTree
       [child_y, parent_y]
     end
 
-    def line_to_parent(parent, child)
-      return if child.horizontal_indent.zero?
+    # Dashed from +dash_from+ on, when given: a line through the joints leaf
+    # alignment inserted is drawn one piece at a time, and each piece picks up
+    # the dash where the one above it left off, so the run reads as one line.
+    # Returns how long the line drawn is.
+    def line_to_parent(parent, child, dash_from: nil)
+      return 0 if child.horizontal_indent.zero?
 
       if @direction == "ltr"
         # LTR: parent's right side → child's left side
@@ -1287,64 +1427,67 @@ 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
-          @tree_data += @polyline_styles.sub(/CHIX/, x1.to_s)
-                                        .sub(/CHIY/, y1.to_s)
-                                        .sub(/MIDX1/, mid_x1.to_s)
-                                        .sub(/MIDY1/, mid_y1.to_s)
-                                        .sub(/MIDX2/, mid_x2.to_s)
-                                        .sub(/MIDY2/, mid_y2.to_s)
-                                        .sub(/PARX/, x2.to_s)
-                                        .sub(/PARY/, y2.to_s)
+          points = [[x1, y1], [mid_x1, mid_y1], [mid_x2, mid_y2], [x2, y2]]
         else
-          line_data   = @line_styles.sub(/X1/, x1.to_s)
-          line_data   = line_data.sub(/Y1/, y1.to_s)
-          line_data   = line_data.sub(/X2/, x2.to_s)
-          @tree_data += line_data.sub(/Y2/, y2.to_s)
+          points = [[x1, y1], [x2, y2]]
         end
       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
 
-          @tree_data += @polyline_styles.sub(/CHIX/, chi_x.to_s)
-                                        .sub(/CHIY/, chi_y.to_s)
-                                        .sub(/MIDX1/, mid_x1.to_s)
-                                        .sub(/MIDY1/, mid_y1.to_s)
-                                        .sub(/MIDX2/, mid_x2.to_s)
-                                        .sub(/MIDY2/, mid_y2.to_s)
-                                        .sub(/PARX/, par_x.to_s)
-                                        .sub(/PARY/, par_y.to_s)
+          points = [[chi_x, chi_y], [mid_x1, mid_y1], [mid_x2, mid_y2], [par_x, par_y]]
         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)
-          line_data   = line_data.sub(/Y1/, y1.to_s)
-          line_data   = line_data.sub(/X2/, x2.to_s)
-          @tree_data += line_data.sub(/Y2/, y2.to_s)
+          points = [[x1, y1], [x2, y2]]
         end
       end
+      emit_connector(points, dash_from)
+    end
+
+    # +points+ run from the child to the parent. A dashed line is laid the
+    # other way, from the parent down, so that its dash carries on into the
+    # piece below it.
+    def emit_connector(points, dash_from)
+      dash = ""
+      if dash_from
+        points = points.reverse
+        dash = " #{dash_array} stroke-dashoffset='#{dash_from.round(3)}'"
+      end
+      if points.size == 2
+        (x1, y1), (x2, y2) = points
+        @tree_data += @line_styles.sub(/X1/, x1.to_s).sub(/Y1/, y1.to_s)
+                                  .sub(/X2/, x2.to_s).sub(/Y2/, y2.to_s).sub(" />", "#{dash} />")
+      else
+        (chix, chiy), (mx1, my1), (mx2, my2), (parx, pary) = points
+        @tree_data += @polyline_styles.sub(/CHIX/, chix.to_s).sub(/CHIY/, chiy.to_s)
+                                      .sub(/MIDX1/, mx1.to_s).sub(/MIDY1/, my1.to_s)
+                                      .sub(/MIDX2/, mx2.to_s).sub(/MIDY2/, my2.to_s)
+                                      .sub(/PARX/, parx.to_s).sub(/PARY/, pary.to_s).sub(" />", "#{dash} />")
+      end
+      points.each_cons(2).sum { |(ax, ay), (bx, by)| Math.hypot(bx - ax, by - ay) }
     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"
@@ -1373,7 +1516,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/tikz_generator.rb

@@ -189,7 +189,7 @@ module RSyntaxTree
 
       label = extract_label(element)
       escaped_label = escape_latex(label)
-      head = "#{escaped_label}#{region_option(element)}"
+      head = "#{escaped_label}#{leaf_edge_option(element)}#{region_option(element)}"
 
       children = element.children
       indent_str = "  " * indent
@@ -202,6 +202,17 @@ module RSyntaxTree
       end
     end
 
+    # The edge down to a word is dashed when leafstyle asks for it, every
+    # piece of it: leaf alignment runs it through joints, and forest gives
+    # each joint the edge from the node above. Added to the edge style the
+    # tree sets, not in place of it, so the width holds.
+    def leaf_edge_option(element)
+      return "" unless @params[:leafstyle] == "dashed"
+
+      element = @element_list.get_id(element.children.first) while element.inserted_joint
+      element.type == ETYPE_LEAF ? ", edge+=dashed" : ""
+    end
+
     # forest node option that paints a semi-transparent plane behind the whole
     # subtree governed by +element+ (region shade). Uses forest's "fit to=tree"
     # on the background layer so the plane sits below the tree. Empty string

data/lib/rsyntaxtree/version.rb

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

data/lib/rsyntaxtree.rb

@@ -55,13 +55,14 @@ OPTION_VALUES = {
   # an alias until 3.0. It collided with a code-intelligence format of the
   # same initials, and claimed an interchange nobody else had implemented.
   format: FORMATS + ["lsif"],
-  leafstyle: %w[auto triangle bar nothing],
+  leafstyle: %w[auto triangle bar dashed nothing],
   fontstyle: ["sans", "serif", "cjk", "mono", "noto-sans", "noto-serif", "noto-sans-mono", "cjk zenhei"],
   color: %w[modern traditional gray grey off none on true false],
   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.1
+  version: 2.6.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