rsyntaxtree 1.13.0 → 1.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32cc6cec6f19c5fe62dc9a6de16493d6db35680f72e40b6bbd36f0b1e98add96
-  data.tar.gz: b6f928fd6919bb289765fac684ae3e98f7988103985deebcb6f73e7f8836e939
+  metadata.gz: aa35ea4c535165dcf70b1a1b6375ff32666ce42294219a9b3d59ba6cb614ee85
+  data.tar.gz: 23d80a1781dd85a41d349b670b7610981bba30a87fa90cd0847d91dc65356fe4
 SHA512:
-  metadata.gz: 50d8b1e91e3c71286406bf45e5e5cdeb2d8170f98a513a6662f0b593a7e077b7af2650057e6d9670469ed937b6ddc7c0073868df6833721c2ba3c81a8f691c46
-  data.tar.gz: 92df8d83ddbabcdd3cbeaa30f26868da4a13c168d5f97600475f552a197f7ebba70a80cc6ab272f98e2a68c1b8bd9d9a9094d3b01235ec556790f4a944337fee
+  metadata.gz: baa9e98752ce86da774ededc1228b6f588e69da5b381bc94112190f7198f8a2128d64760cc49114b9e3a8815d24e0984714cf562ebdb0e86572dc4c3790e0bab
+  data.tar.gz: ada76c5d30433a0652be01242c8da0225f63e84c3717accb0eeb3628567df9744b67c408405acc94e52dbd38288fe5352f3ceb2c789b41974184dd2443322f6b

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # 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
+- `^` at the head of a leaf draws the triangle it asks for. The mark may be
+  written on the node's label or on the leaf's own text — `[^NP cats]` and
+  `[NP ^cats]` — and the documentation, the notation reference and the gallery
+  all use both, but only the first was drawn: the second lost its caret to the
+  parser and then a bar was drawn under it. The two now produce the same figure
+  in every connector style, and LSIF records the edge as a triangle. Three
+  gallery figures change accordingly, each toward what it was written to show.
+- An option given as an empty string is read as an option not given, rather
+  than as a value no list contains. An HTML form posts a field for every
+  control it carries, and a control with nothing selected posts the empty
+  string, so a form that has outlived one of its own controls sends that field
+  empty alongside the rest. Since option validation arrived in 1.11.0 that
+  failed the whole request: the web UI's Download buttons answered 500 for
+  every input, because the form still read a `format` select the page no longer
+  had. A value that is actually wrong is still rejected.
+
 ## [1.13.0] - 2026-08
 
 ### Added

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/base_graph.rb

@@ -221,7 +221,12 @@ module RSyntaxTree
       else
         parent = @element_list.get_id(target.parent)
 
-        vertical_indent = if !target.triangle &&
+        # A leaf with nothing drawn over it is pulled up against its node; one
+        # with a triangle over it needs the room the triangle takes. Which is
+        # which is the same question the connector asks, so it is asked the same
+        # way — reading only the leaf's own mark left `[^NP cats]` a triangle
+        # squashed into a gap that had been closed.
+        vertical_indent = if !triangle_asked_for?(parent, target) &&
                              (@leafstyle == "nothing" || @leafstyle == "none") &&
                              ETYPE_LEAF == target.type && parent.children.size == 1
                             if @direction == "ltr"
@@ -395,6 +400,22 @@ module RSyntaxTree
       end
     end
 
+    # Whether a `^` has asked for a triangle over this leaf. It may be written
+    # at the head of the node's label or at the head of the leaf's own text —
+    # `[^NP cats]` and `[NP ^cats]` — and both forms are in the gallery. Only
+    # the first was honoured here, and the second was dropped without a word:
+    # the caret vanished from the text and a bar was drawn, so an example named
+    # for its triangles had none. The rest of the layout already reads the
+    # leaf's own flag — a leaf marked this way keeps the gap a triangle needs
+    # even when connectors are off — which is what left the two sides of one
+    # rule disagreeing.
+    #
+    # Asked of a leaf only. A `^` on an internal node is that node's own mark,
+    # and it is honoured when that node is in turn the parent here.
+    def triangle_asked_for?(parent, child)
+      parent.triangle || (ETYPE_LEAF == child.type && child.triangle)
+    end
+
     def draw_connector(id = 1)
       parent = @element_list.get_id(id)
       children = parent.children.map { |c| @element_list.get_id(c) }
@@ -410,21 +431,22 @@ module RSyntaxTree
 
       if children.size == 1
         child = children[0]
+        forced = triangle_asked_for?(parent, child)
         case @leafstyle
         when "auto"
-          if parent.triangle || child.contains_phrase
+          if forced || child.contains_phrase
             triangle_to_parent(parent, child)
           else
             line_to_parent(parent, child)
           end
         when "bar"
-          if parent.triangle
+          if forced
             triangle_to_parent(parent, child)
           else
             line_to_parent(parent, child)
           end
         when "nothing", "none"
-          if parent.triangle
+          if forced
             triangle_to_parent(parent, child)
           elsif ETYPE_LEAF != child.type
             line_to_parent(parent, child)

data/lib/rsyntaxtree/lsif_graph.rb

@@ -82,21 +82,22 @@ module RSyntaxTree
 
       if children.size == 1
         child = children[0]
+        forced = triangle_asked_for?(parent, child)
         case @leafstyle
         when "auto"
-          if parent.triangle || child.contains_phrase
+          if forced || child.contains_phrase
             triangle_to_parent(parent, child)
           else
             line_to_parent(parent, child)
           end
         when "bar"
-          if parent.triangle
+          if forced
             triangle_to_parent(parent, child)
           else
             line_to_parent(parent, child)
           end
         when "nothing", "none"
-          if parent.triangle
+          if forced
             triangle_to_parent(parent, child)
           elsif ETYPE_LEAF != child.type
             line_to_parent(parent, child)

data/lib/rsyntaxtree/notation_examples.md

@@ -1,4 +1,4 @@
-RSyntaxTree examples: 75 trees, every one verified to draw.
+RSyntaxTree examples: 76 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;
@@ -279,21 +279,36 @@ Source: Radford 2004
 ## 011 — CCG derivation: forward and backward application
 
 Category: Combinatory Categorial Grammar
-Settings: color=none derivation=on direction=btt fontstyle=noto-serif leafstyle=nothing tidy=low vheight=0.7
+Settings: color=none derivation=on direction=btt fontstyle=noto-serif hspacing=2.0 leafstyle=nothing tidy=low vheight=0.5
 Source: Steedman 2000
 
 ```
-[S\t< [NP\t> [NP/N the] [N dog]] [S\\NP\t> [(S\\NP)/NP bit] [NP John]]]
+[S\t<
+  [NP\t>
+    [NP/N the]
+    [N dog]]
+  [S\\NP\t>
+    [(S\\NP)/NP bit]
+    [NP John]]]
 ```
 
 ## 012 — CCG derivation: a relative clause
 
 Category: Combinatory Categorial Grammar
-Settings: color=none derivation=on direction=btt fontstyle=noto-serif leafstyle=nothing tidy=low vheight=0.7
+Settings: color=none derivation=on direction=btt fontstyle=noto-serif hspacing=2.0 leafstyle=nothing tidy=low vheight=0.5
 Source: Steedman 2000
 
 ```
-[NP\t> [NP/N the] [N\t< [N man] [N\\N\t> [(N\\N)/(S/NP) that] [S/NP\t>B [S/(S\\NP)\t>T [NP Mary]] [(S\\NP)/NP saw]]]]]
+[NP\t>
+  [NP/N the]
+  [N\t<
+    [N man]
+    [N\\N\t>
+      [(N\\N)/(S/NP) that]
+      [S/NP\t>B
+        [S/(S\\NP)\t>T
+          [NP Mary]]
+        [(S\\NP)/NP saw]]]]]
 ```
 
 ## 013 — HPSG sample
@@ -2485,3 +2500,24 @@ Settings: fontstyle=noto-serif tidy=low vheight=1.0
     [V [<> [<> sat]]]
     [PP [P [<> on]] [NP [D the] [N mat]]]]]
 ```
+
+## 081 — CCG derivation: right node raising
+
+Category: Combinatory Categorial Grammar
+Settings: color=none derivation=on direction=btt fontstyle=noto-serif hspacing=2.0 leafstyle=nothing tidy=low vheight=0.5
+Source: Steedman 2000
+
+```
+[S\t>
+  [S/NP\t<Φ>
+    [S/NP\t>B
+      [S/(S\\NP)\t>T
+        [NP Mary]]
+      [(S\\NP)/NP likes]]
+    [conj and]
+    [S/NP\t>B
+      [S/(S\\NP)\t>T
+        [NP Bill]]
+      [(S\\NP)/NP hates]]]
+  [NP London]]
+```

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.0"
+  VERSION = "1.13.2"
 end

data/lib/rsyntaxtree.rb

@@ -151,6 +151,18 @@ module RSyntaxTree
       fontset = {}
       params.each do |keystr, value|
         key = keystr.to_sym
+        # An option given as an empty string is an option not given. An HTML
+        # form posts a field for every control it carries, and a control with
+        # nothing selected posts the empty string — so a form that has outlived
+        # one of its own controls sends `format=` and every other option along
+        # with it. Read as a value, that is a choice nobody can have made, and
+        # it failed the whole request: the web UI's three Download buttons
+        # returned 500 for every input, with the reason nowhere the user could
+        # see it. Read as silence, the default stands, which is what the sender
+        # meant.
+        next if (OPTION_VALUES.key?(key) || NUMERIC_RANGES.key?(key)) &&
+                (value.nil? || value.to_s.strip.empty?)
+
         if OPTION_VALUES.key?(key) && !OPTION_VALUES[key].include?(value.to_s)
           raise RSTError.new(+"Error: invalid value for option '#{key}': #{value.inspect}",
                              code: :invalid_option,

metadata

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