rsyntaxtree 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f32301303f9acaffacc1783b5c66380187cb4394d559060f520bcbab64831680
-  data.tar.gz: 80e8d7d6922d6025cbdef82a3efd64ee83ec8c60ff6f17f9607aefd4f7d8f782
+  metadata.gz: eb96318785756ecb47e67a06a809eb96bde5c4f63ceda113c13ba9bb221d032c
+  data.tar.gz: 48f083c0cec6539557959b0205e61c503f2aeeb68dea8b06ba3e5faf3b8dba6e
 SHA512:
-  metadata.gz: cf8ebd19d64a05f09c88974c833ea87da9495b375f125e02a4ff34146b0ea2364115dc17cd08c3c9454d73f3a8e262a3a19f42c555f7af231901a19eb0813cad
-  data.tar.gz: 0c5361ece29a29b4965d59bff8ef4f210a427c49643228c9afb92f8c2c012921752d53988898a720a1652a906c26a2b2f81de5b7876563747f35b3f5c41a4694
+  metadata.gz: fdd263b44eea3a6106bbdf504fe603d966e505d7f9b92251979fd373b5f50ddb15a686d87a3d9ec1ac6ce46d90a1153cfe79637063dabc3953542d66657d25c0
+  data.tar.gz: 37ba04230f1909bf30433f67ea51e283f19b9f45eccee865912eaee7fbb7d272bdd28d340f055d17716f92e02352ad5459cac9b29a8366dfc75e657d2fc1886d

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.6.0] - 2026-11-12
+
+### Added
+- `leafstyle: dashed` (`-l dashed`): the line down to each word dashed, every line between nodes solid
+- Gallery: each example lists its leaf alignment, and its number can be found with the browser's search
+
+### Fixed
+- Two movement paths that meet at one label no longer cross, and run on one level when nothing else is in the way
+
 ## [2.5.0] - 2026-11-04
 
 ### Added

data/CITATION.cff

@@ -11,8 +11,8 @@ repository-code: "https://github.com/yohasebe/rsyntaxtree"
 # Concept DOI: always resolves to the latest archived version on Zenodo
 doi: "10.5281/zenodo.21916150"
 license: MIT
-version: 2.5.0
-date-released: 2026-11-04
+version: 2.6.0
+date-released: 2026-11-12
 keywords:
   - linguistics
   - syntax tree

data/bin/rsyntaxtree

@@ -18,7 +18,7 @@ CONFIG_VALIDATORS = {
   outdir: ->(v) { FileTest.directory?(v) ? nil : "must be an existing directory path" },
   outfilename: ->(v) { v.is_a?(String) ? nil : "must be a string" },
   format: ->(v) { FORMATS.include?(v.to_s) || v.to_s == "lsif" ? nil : "must be #{FORMAT_LIST_MESSAGE}" },
-  leafstyle: ->(v) { OPTION_VALUES[:leafstyle].include?(v.to_s) ? nil : "must be auto, triangle, bar, or nothing" },
+  leafstyle: ->(v) { OPTION_VALUES[:leafstyle].include?(v.to_s) ? nil : "must be auto, triangle, bar, dashed, or nothing" },
   fontstyle: ->(v) { OPTION_VALUES[:fontstyle].include?(v.to_s) ? nil : "must be sans, serif, cjk, or mono" },
   fontsize: ->(v) { v.is_a?(Integer) && v >= 6 && v <= 26 ? nil : "must be in the range of 6-26" },
   linewidth: ->(v) { v.is_a?(Numeric) && v >= 0.5 && v <= 3.0 ? nil : "must be in the range of 0.5-3.0" },
@@ -110,7 +110,7 @@ opts = Optimist.options do
   opt :outdir, "Output directory", default: "./", short: :o
   opt :outfilename, "Output file base name", default: "syntree", short: :u
   opt :format, "Output format: #{FORMAT_LIST_MESSAGE}", default: "png", short: :f
-  opt :leafstyle, "visual style of tree leaves: auto, triangle, bar, or nothing", default: "auto", short: :l
+  opt :leafstyle, "visual style of tree leaves: auto, triangle, bar, dashed, or nothing", default: "auto", short: :l
   opt :fontstyle, "Font style: sans, serif, cjk, mono", default: "sans", short: :n
   opt :fontsize, "Size: 6-26", default: 16, short: :s
   opt :linewidth, "Size: 0.5-3.0", default: 1.0, short: :i
@@ -147,7 +147,7 @@ Optimist.die :direction, "must be one of: #{OPTION_VALUES[:direction].join(', ')
 Optimist.die :derivation, "must be one of: #{OPTION_VALUES[:derivation].join(', ')}" unless OPTION_VALUES[:derivation].include?(opts[:derivation])
 Optimist.die :hyphen, "must be markup or literal" unless OPTION_VALUES[:hyphen].include?(opts[:hyphen])
 Optimist.die :format, "must be #{FORMAT_LIST_MESSAGE}" unless FORMATS.include?(opts[:format])
-Optimist.die :leafstyle, "must be auto, triangle, bar, or nothing" unless OPTION_VALUES[:leafstyle].include?(opts[:leafstyle])
+Optimist.die :leafstyle, "must be auto, triangle, bar, dashed, or nothing" unless OPTION_VALUES[:leafstyle].include?(opts[:leafstyle])
 Optimist.die :fontstyle, "must be sans, serif, cjk, or mono" unless OPTION_VALUES[:fontstyle].include?(opts[:fontstyle])
 Optimist.die :fontsize, "must be in the range of 6-26" unless opts[:fontsize] >= 6 && opts[:fontsize] <= 26
 Optimist.die :linewidth, "must be in the range of 0.5-3.0" unless opts[:linewidth] >= 0.5 && opts[:linewidth] <= 3.0

data/lib/rsyntaxtree/base_graph.rb

@@ -450,8 +450,10 @@ module RSyntaxTree
     end
 
     # `through` carries the connector chosen above a run of joints leaf
-    # alignment inserted, down that run to the child it reaches.
-    def draw_connector(id = 1, through = nil)
+    # alignment inserted, down that run to the child it reaches; `dashed`
+    # carries how far a dashed line has run so far, so that its dash goes on
+    # unbroken through each joint.
+    def draw_connector(id = 1, through = nil, dashed = 0)
       parent = @element_list.get_id(id)
       children = parent.children.map { |c| @element_list.get_id(c) }
 
@@ -466,23 +468,32 @@ module RSyntaxTree
 
       if through
         child = children.first
-        line_to_parent(parent, child) if through == :line
-        draw_connector(child.id, (through if child.inserted_joint))
+        draw_connector(child.id, (through if child.inserted_joint), dashed + draw_line(parent, child, through, dashed))
         return
       end
 
       chosen = children.map do |child|
         joints, target = past_inserted_joints(child)
         connector = connector_for(parent, target, children.size == 1)
+        connector = :dashed if connector == :line && @leafstyle == "dashed" && ETYPE_LEAF == target.type
+        run = 0
         case connector
         when :triangle then triangle_to_parent(parent, target, joints)
-        when :line then line_to_parent(parent, child)
+        when :line, :dashed then run = draw_line(parent, child, connector, 0)
         else no_connector(parent, target, joints)
         end
-        [child, connector]
+        [child, connector, run]
       end
 
-      chosen.each { |child, connector| draw_connector(child.id, (connector if child.inserted_joint)) }
+      chosen.each { |child, connector, run| draw_connector(child.id, (connector if child.inserted_joint), run) }
+    end
+
+    # A line, dashed when it is one of the lines leafstyle `dashed` draws down
+    # to a word. Returns how long it is, for the piece below to carry on from.
+    def draw_line(parent, child, connector, dashed)
+      return 0 unless %i[line dashed].include?(connector)
+
+      line_to_parent(parent, child, dash_from: (dashed if connector == :dashed)).to_f
     end
 
     # Leaf alignment puts joints between a node and the child it reaches. They
@@ -507,7 +518,7 @@ module RSyntaxTree
       case @leafstyle
       when "auto"
         forced || child.contains_phrase ? :triangle : :line
-      when "bar"
+      when "bar", "dashed"
         forced ? :triangle : :line
       when "nothing", "none"
         if forced

data/lib/rsyntaxtree/json_graph.rb

@@ -56,8 +56,11 @@ module RSyntaxTree
       @nodes << build_node(element)
     end
 
-    def line_to_parent(parent, child)
-      @edges << { from: parent.id, to: child.id, type: "dominance", connector: "line" }
+    def line_to_parent(parent, child, dash_from: nil)
+      edge = { from: parent.id, to: child.id, type: "dominance", connector: "line" }
+      edge[:dashed] = true if dash_from
+      @edges << edge
+      0
     end
 
     # A triangle spans from the parent to its child, through any joints leaf

data/lib/rsyntaxtree/notation_core.md

@@ -99,7 +99,7 @@ Options (the command line spells them --like-this):
 | fontsize   | 6–26 |
 | color      | modern, traditional, off, gray |
 | linewidth  | every line's weight, 0.5–3.0, as a ratio of the font size |
-| leafstyle  | auto, bar, nothing — what joins a node to its leaf |
+| leafstyle  | auto, bar, dashed, nothing — what joins a node to its leaf |
 | direction  | ttb, ltr, btt |
 | mirror     | flip the finished layout, for RTL scripts |
 | tidy       | off, symmetric, low, medium, high — how tightly subtrees pack |

data/lib/rsyntaxtree/notation_examples.md

@@ -1,4 +1,4 @@
-RSyntaxTree examples: 81 trees, every one verified to draw.
+RSyntaxTree examples: 85 trees, every one verified to draw.
 
 Each is the input behind a figure in the gallery at https://yohasebe.github.io/rsyntaxtree/examples.
 The settings line names the options the gallery records for that figure;
@@ -2488,7 +2488,7 @@ own(x,<>y)
 ]
 ```
 
-## 080 — Terminals levelled with pass-through joints
+## 080 — Terminals levelled by hand with pass-through joints
 
 Category: General
 Settings: fontstyle=noto-serif tidy=low vheight=1.0
@@ -2639,3 +2639,58 @@ SYN\t#(HEAD\t|1|#)#)
   ---\
   AGR\t|2|#)#)#) [bark]]]
 ```
+
+## 087 — Terminals levelled automatically: whole subtrees drop
+
+Category: General
+Settings: fontstyle=noto-serif leaf_align=subtrees polyline=on tidy=low vheight=1.0
+
+```
+[S
+  [NP [D the] [N cat]]
+  [VP
+    [V sat]
+    [PP [P on] [NP [D the] [N mat]]]]]
+```
+
+## 088 — Wh-movement with the terminals levelled
+
+Category: Generative Grammar
+Settings: fontstyle=noto-serif leaf_align=subtrees polyline=on tidy=low vheight=1.0
+
+```
+[CP
+  [DP what+>1]
+  [C' [C did]
+    [TP
+      [DP [D the] [NP [N child]]]
+      [T' [T t]
+        [VP [V find] [DP t+1]]]]]]
+```
+
+## 089 — A Japanese sentence with its words on one row
+
+Category: Multilingual
+Settings: fontstyle=noto-serif leaf_align=words leafstyle=dashed tidy=low vheight=1.0
+
+```
+[S
+  [NP [N 太郎] [P が]]
+  [VP
+    [NP [AdjP [Adj 古い]] [NP [N 本] [P を]]]
+    [V 読んだ]]]
+```
+
+## 090 — A summarised phrase deep in the tree, with the terminals levelled
+
+Category: General
+Settings: fontstyle=noto-serif leaf_align=words leafstyle=dashed tidy=low vheight=1.0
+
+```
+[TP
+  [DP [D the]
+    [NP [N man]
+      [PP [P with] [^DP the hat]]]]
+  [T' [T will]
+    [VP [V give] [DP [D the] [NP [N book]]]]]]
+```

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
@@ -387,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
@@ -402,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
@@ -444,13 +448,20 @@ module RSyntaxTree
 
     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, is moved outward past it: two paths whose rails coincide read as
-    # one line, and nothing tells which ends it joins.
+    # 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. The distance
-    # is compared with a little slack: a rail moved exactly one spacing past
+    # 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 ||= []
@@ -458,7 +469,7 @@ module RSyntaxTree
       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
+          r[:lo] < hi + close && lo < r[:hi] + close && (r[:at] - at).abs < close
         end
         break unless blocking
 
@@ -482,8 +493,38 @@ 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
@@ -496,14 +537,6 @@ module RSyntaxTree
       # 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"
@@ -545,8 +578,8 @@ module RSyntaxTree
         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],
@@ -960,6 +993,14 @@ module RSyntaxTree
         # 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
@@ -974,20 +1015,20 @@ module RSyntaxTree
           elsif /\A(?:>|<)(\d+)\z/ =~ tr
             tr = $1
             if path_pool_target[tr]
-              path_pool_target[tr] << [x1, path_y]
+              path_pool_target[tr] << [x1, path_y, across]
             else
-              path_pool_target[tr] = [[x1, path_y]]
+              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, path_y]
+              path_pool_other[tr] << [x1, path_y, across]
             else
-              path_pool_other[tr] = [[x1, path_y]]
+              path_pool_other[tr] = [[x1, path_y, across]]
             end
             path_flags << tr
           else
-            path_pool_source[tr] = [x1, path_y]
+            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 }
@@ -1008,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
@@ -1025,7 +1066,7 @@ 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
 
@@ -1033,8 +1074,9 @@ module RSyntaxTree
       # 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|
@@ -1102,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
@@ -1168,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}/>"
@@ -1372,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
@@ -1391,19 +1435,9 @@ module RSyntaxTree
           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
@@ -1418,25 +1452,38 @@ module RSyntaxTree
           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.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

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.5.0"
+  VERSION = "2.6.0"
 end

data/lib/rsyntaxtree.rb

@@ -55,7 +55,7 @@ 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],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsyntaxtree
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Yoichiro Hasebe