rsyntaxtree 1.13.1 → 1.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0804e9119e0ebb089b4109ae05c9353180362bd6e86fddbf2e4da00db3b08e18'
-  data.tar.gz: '01867ffda61d7f81fd3d81a9f6ad44ba83eda4f7d89d1b3b05d53b196bc23fa1'
+  metadata.gz: aa35ea4c535165dcf70b1a1b6375ff32666ce42294219a9b3d59ba6cb614ee85
+  data.tar.gz: 23d80a1781dd85a41d349b670b7610981bba30a87fa90cd0847d91dc65356fe4
 SHA512:
-  metadata.gz: 990e4522fe0e0694d009eddebc2b3b2af98e5beda1f3e2daf9fbf1250199cef31b981215d1ae7db3b711d0030826e2445c7011f427223f8e081bffb8d76451ae
-  data.tar.gz: fe620d8c1fe64c289b18d853d6663ceaae5ea8a7486a5f0cf0ce578f8c0e9073e48251f0d7a933d0c7afa9ee7fce896dd6cbf00f3499c8d5314278e9cc0e0b57
+  metadata.gz: baa9e98752ce86da774ededc1228b6f588e69da5b381bc94112190f7198f8a2128d64760cc49114b9e3a8815d24e0984714cf562ebdb0e86572dc4c3790e0bab
+  data.tar.gz: ada76c5d30433a0652be01242c8da0225f63e84c3717accb0eeb3628567df9744b67c408405acc94e52dbd38288fe5352f3ceb2c789b41974184dd2443322f6b

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [1.13.2] - 2026-08
+
+### Fixed
+- A movement path is drawn as one stroke with its corners eased, in place of
+  three lines meeting at right angles. The dash of a non-directional path now
+  runs round each turn instead of restarting at it, and the arrowhead is the end
+  of the stroke rather than a marker on whichever line finished last. The radius
+  is held down to half of each run it joins, so a short leg cannot be swallowed
+  by its own turn, and to the length of an arrowhead where there is one, so the
+  head is never drawn onto the curve. Three gallery figures carry paths and
+  change with it.
+- Digits are set in the text face again on machines that have a colour emoji
+  font. The font chains named emoji families by name, and asking fontconfig for
+  one is asking for the generic `emoji` family, whose preference list fontconfig
+  then prepends to the whole pattern with a strong binding — so the emoji face
+  arrived ahead of the Noto text faces rather than behind them. A colour emoji
+  font carries the ASCII digits, for keycap sequences, so on an ordinary Linux
+  desktop `[N 20]` came out in the emoji face at more than twice the width.
+  Measurement and drawing read the same chain, so the figure held together; it
+  was simply not the figure the same input gives elsewhere. No emoji family is
+  named now: a codepoint no named family covers reaches fontconfig's own
+  fallback, which is the path this was duplicating. Emoji draw as before, and
+  the gallery is unchanged to the pixel — every raster figure is byte-identical
+  and the SVGs differ only in the family list they carry.
+
 ## [1.13.1] - 2026-08
 
 ### Fixed

data/README.md

@@ -2,6 +2,9 @@
 
 **RSyntaxTree** is a graphical syntax tree generator for linguistic research.
 
+[![Test](https://github.com/yohasebe/rsyntaxtree/actions/workflows/test.yml/badge.svg)](https://github.com/yohasebe/rsyntaxtree/actions/workflows/test.yml)
+[![Gem Version](https://img.shields.io/gem/v/rsyntaxtree)](https://rubygems.org/gems/rsyntaxtree)
+
 <p>
   <a href="https://yohasebe.com/rsyntaxtree"><strong>Web App</strong></a> ·
   <a href="https://yohasebe.github.io/rsyntaxtree/examples"><strong>Example Gallery</strong></a> ·

data/lib/rsyntaxtree/svg_graph.rb

@@ -108,6 +108,9 @@ module RSyntaxTree
             <marker id="arrow" markerUnits="userSpaceOnUse" viewBox="0 0 10 10" refX="10" refY="5" markerWidth="#{as2}" markerHeight="#{as2}" orient="auto">
               <path d="M 0 0 L 10 5 L 0 10" fill="#{@col_extra}"/>
             </marker>
+            <marker id="arrowStart" markerUnits="userSpaceOnUse" viewBox="0 0 10 10" refX="0" refY="5" markerWidth="#{as2}" markerHeight="#{as2}" orient="auto">
+              <path d="M 10 0 L 0 5 L 10 10" fill="#{@col_extra}"/>
+            </marker>
             <marker id="arrowBackward" markerUnits="userSpaceOnUse" viewBox="0 0 10 10" refX="5" refY="5" markerWidth="#{as2}" markerHeight="#{as2}" orient="auto">
               <path d="M 0 0 L 10 5 L 0 10 z" fill="#{@col_extra}"/>
             </marker>
@@ -259,9 +262,83 @@ module RSyntaxTree
       b
     end
 
+    # A point the given distance from `from` along the line towards `to`.
+    def along(from, to, distance)
+      dx = to[0] - from[0]
+      dy = to[1] - from[1]
+      length = Math.sqrt((dx * dx) + (dy * dy))
+      return from.dup if length.zero?
+
+      [from[0] + (dx / length * distance), from[1] + (dy / length * distance)]
+    end
+
+    # The `d` of a polyline whose corners are eased into quarter turns.
+    #
+    # The radius is clamped to half of each of the two runs meeting at a corner,
+    # so a short leg can never be swallowed by its own turn and two adjacent
+    # corners can never overlap — which is the whole of the arithmetic that
+    # rounding a right angle needs, and why it can be a constant everywhere
+    # else.
+    def rounded_polyline_d(points, radius)
+      return +"" if points.size < 2
+
+      at = ->(p) { "#{p[0].round(3)},#{p[1].round(3)}" }
+      d = +"M#{at.call(points[0])}"
+      points.each_cons(3) do |before, corner, after|
+        r = [radius,
+             Math.sqrt(((corner[0] - before[0])**2) + ((corner[1] - before[1])**2)) / 2.0,
+             Math.sqrt(((after[0] - corner[0])**2) + ((after[1] - corner[1])**2)) / 2.0].min
+        if r < 0.01
+          d << " L#{at.call(corner)}"
+        else
+          d << " L#{at.call(along(corner, before, r))}" \
+               " Q#{at.call(corner)} #{at.call(along(corner, after, r))}"
+        end
+      end
+      d << " L#{at.call(points.last)}"
+    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
+    # happens to finish last.
+    def generate_path(points, col, dashed: false, radius: 0, start_arrow: false, end_arrow: false)
+      # An arrowhead is drawn back along the run it ends, so the corner before
+      # it has to leave that run its full length. Without this the shorter of
+      # the two end runs — which is only as long as the path's bulge — lost half
+      # of itself to the turn and the head came out sitting on the curve.
+      arrow_length = @global[:h_gap_between_nodes]
+      leg = ->(a, b) { Math.sqrt(((a[0] - b[0])**2) + ((a[1] - b[1])**2)) }
+      radius = [radius, leg.call(points[0], points[1]) - arrow_length].min if start_arrow
+      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}' " : ""
+      markers = +""
+      markers << "marker-start='url(#arrowStart)' " if start_arrow
+      markers << "marker-end='url(#arrow)' " if end_arrow
+
+      # A round cap is half the stroke's width of ink past the point the stroke
+      # ends at, and an arrowhead has its tip at exactly that point — so the
+      # line came through the tip: 13% ink on the pixel beyond the head of a
+      # path, and 81% beyond its tail, where the marker's apex sits on the
+      # anchor rather than behind it. Squared off, the stroke stops where the
+      # head begins. Only where there is a head: a path without one is the
+      # dashed form, and every dash of it wants its round ends.
+      linecap = start_arrow || end_arrow ? "butt" : "round"
+
+      "<path d='#{rounded_polyline_d(points, radius)}' style='fill: none; stroke: #{col}; " \
+        "stroke-width:#{@global[:stroke_normal]}; stroke-linecap:#{linecap}; stroke-linejoin:round;' " \
+        "#{dasharray}#{markers}/>"
+    end
+
     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]
+      # 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}"
@@ -288,20 +365,11 @@ module RSyntaxTree
         new_s_y = s_y + s_offset
         new_t_y = t_y + t_offset
 
-        case target_arrow
-        when :single
-          @extra_lines << generate_line(s_x, new_s_y, new_x, new_s_y, @col_path, dashed)
-          @extra_lines << generate_line(new_x, new_s_y, new_x, new_t_y, @col_path, dashed)
-          @extra_lines << generate_line(new_x, new_t_y, t_x, new_t_y, @col_path, dashed, true)
-        when :double
-          @extra_lines << generate_line(new_x, new_s_y, s_x, new_s_y, @col_path, dashed, true)
-          @extra_lines << generate_line(new_x, new_s_y, new_x, new_t_y, @col_path, dashed)
-          @extra_lines << generate_line(new_x, new_t_y, t_x, new_t_y, @col_path, dashed, true)
-        else
-          @extra_lines << generate_line(s_x, new_s_y, new_x, new_s_y, @col_path, dashed)
-          @extra_lines << generate_line(new_x, new_s_y, new_x, new_t_y, @col_path, dashed)
-          @extra_lines << generate_line(new_x, new_t_y, t_x, new_t_y, @col_path, dashed)
-        end
+        @extra_lines << generate_path([[s_x, new_s_y], [new_x, new_s_y],
+                                       [new_x, new_t_y], [t_x, new_t_y]],
+                                      @col_path, dashed: dashed, radius: corner_radius,
+                                      start_arrow: target_arrow == :double,
+                                      end_arrow: target_arrow != :none)
         @width = new_x if new_x > @width
       else
         # TTB: route BELOW the tree (U shape)
@@ -315,20 +383,11 @@ module RSyntaxTree
         new_s_x = s_x - s_offset
         new_t_x = t_x - t_offset
 
-        case target_arrow
-        when :single
-          @extra_lines << generate_line(new_s_x, s_y, new_s_x, new_y, @col_path, dashed)
-          @extra_lines << generate_line(new_s_x, new_y, new_t_x, new_y, @col_path, dashed)
-          @extra_lines << generate_line(new_t_x, new_y, new_t_x, t_y, @col_path, dashed, true)
-        when :double
-          @extra_lines << generate_line(new_s_x, new_y, new_s_x, s_y, @col_path, dashed, true)
-          @extra_lines << generate_line(new_s_x, new_y, new_t_x, new_y, @col_path, dashed)
-          @extra_lines << generate_line(new_t_x, new_y, new_t_x, t_y, @col_path, dashed, true)
-        else
-          @extra_lines << generate_line(new_s_x, s_y, new_s_x, new_y, @col_path, dashed)
-          @extra_lines << generate_line(new_s_x, new_y, new_t_x, new_y, @col_path, dashed)
-          @extra_lines << generate_line(new_t_x, new_y, new_t_x, t_y, @col_path, dashed)
-        end
+        @extra_lines << generate_path([[new_s_x, s_y], [new_s_x, new_y],
+                                       [new_t_x, new_y], [new_t_x, t_y]],
+                                      @col_path, dashed: dashed, radius: corner_radius,
+                                      start_arrow: target_arrow == :double,
+                                      end_arrow: target_arrow != :none)
         @height = new_y if new_y > @height
       end
     end

data/lib/rsyntaxtree/utils.rb

@@ -28,14 +28,22 @@ SCRIPT_FAMILIES_SANS = ["Noto Sans Arabic", "Noto Sans Hebrew", "Noto Sans Devan
 # Arabic behind it for systems that ship one but not the other.
 SCRIPT_FAMILIES_SERIF = ["Noto Naskh Arabic", "Noto Sans Arabic", "Noto Serif Hebrew", "Noto Serif Devanagari", "Noto Serif Thai", "Noto Serif Khmer"].freeze
 
-# Monochrome emoji faces only. Colour emoji fonts carry their glyphs as bitmap
-# or COLR tables, which Pango happily measures but librsvg does not draw, so a
-# colour font in this list would give a figure whose emoji are blank or blobbed.
+# No emoji family is named in the chains below, and naming one was a mistake.
 #
-# This holds only where Pango resolves through fontconfig. On macOS it goes
-# through CoreText, which answers every emoji codepoint with Apple Color Emoji
-# whatever the chain asks for; emoji figures have to be generated elsewhere.
-EMOJI_FAMILIES = ["OpenMoji", "OpenMoji Color", "OpenMoji Black", "Noto Emoji"].freeze
+# Asking for an emoji face by name is asking fontconfig for it, and fontconfig
+# aliases the name to the generic `emoji` family, whose preference list it then
+# prepends to the whole pattern with a strong binding. The requested face
+# arrives at the head of the chain rather than at the tail, ahead of the Noto
+# text faces — and a colour emoji font carries ASCII digits, for the keycap
+# sequences. So on any machine with one installed, which is every ordinary
+# Linux desktop, `[N 20]` was set in the emoji face at more than twice the
+# width. Measurement and drawing read the same chain, so the figure held
+# together; it was simply not the figure the same input gives anywhere else.
+#
+# Emoji still draw. A codepoint no named family covers reaches fontconfig's own
+# fallback, which finds the emoji font — that is the path this list was
+# duplicating, and it was already the path taken wherever these families were
+# not installed.
 
 # Mathematical alphanumerics (U+1D400–) label heads such as the little v of vP.
 # Neither Noto Sans nor Noto Serif covers the block, so without these entries
@@ -49,15 +57,15 @@ MATH_FAMILIES_SANS = ["Noto Sans Math"].freeze
 MATH_FAMILIES_SERIF = ["DejaVu Serif", "Noto Sans Math"].freeze
 
 FONT_FAMILIES = {
-  sans:  (["Noto Sans", "Noto Sans JP", "Noto Sans CJK JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + EMOJI_FAMILIES + ["sans-serif"]).freeze,
-  serif: (["Noto Serif", "Noto Serif JP", "Noto Serif CJK JP"] + SCRIPT_FAMILIES_SERIF + MATH_FAMILIES_SERIF + EMOJI_FAMILIES + ["serif"]).freeze,
+  sans:  (["Noto Sans", "Noto Sans JP", "Noto Sans CJK JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + ["sans-serif"]).freeze,
+  serif: (["Noto Serif", "Noto Serif JP", "Noto Serif CJK JP"] + SCRIPT_FAMILIES_SERIF + MATH_FAMILIES_SERIF + ["serif"]).freeze,
   # Noto ships no monospaced faces for these scripts, so the mono style borrows
   # the proportional ones rather than dropping to the generic fallback.
-  mono:  (["Noto Sans Mono", "Noto Sans JP", "Noto Sans Mono CJK JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + EMOJI_FAMILIES + ["monospace"]).freeze,
+  mono:  (["Noto Sans Mono", "Noto Sans JP", "Noto Sans Mono CJK JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + ["monospace"]).freeze,
   # The cjk style puts a full-coverage CJK family first, for text that mixes
   # Han, Hangul and kana. Latin falls back to the same Noto faces the sans
   # style uses. (Before 1.8.0 this was WQY Zen Hei.)
-  cjk:   (["Noto Sans CJK JP", "Noto Sans", "Noto Sans JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + EMOJI_FAMILIES + ["sans-serif"]).freeze
+  cjk:   (["Noto Sans CJK JP", "Noto Sans", "Noto Sans JP"] + SCRIPT_FAMILIES_SANS + MATH_FAMILIES_SANS + ["sans-serif"]).freeze
 }.freeze
 
 module FontFamily

data/lib/rsyntaxtree/version.rb

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

metadata

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