rsyntaxtree 1.11.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6afa75eb042fe177454d387fa097c74fb6b44fd317ae709f91495f2f9b8df269
-  data.tar.gz: 60e201c577b1cf02d12f6506b10e62b1b21e419d6d37955e4a69a338b28bfd90
+  metadata.gz: 32cc6cec6f19c5fe62dc9a6de16493d6db35680f72e40b6bbd36f0b1e98add96
+  data.tar.gz: b6f928fd6919bb289765fac684ae3e98f7988103985deebcb6f73e7f8836e939
 SHA512:
-  metadata.gz: 27d3c6eaf4e9d892238f41c7cce05bea11a639351069e80e130af6ad809916e89794dd41bbaf32b407c8560e49b8dc45c243fe7724d4aa36a3a1ce727dc61321
-  data.tar.gz: c3744c0b738859a27699dc444f9d27d3169b5d8ee91bd04be2d9296deca560050f9f7cce8db69b7cb980342ef94a1dd2f29e627030b04f7de990cb4adf0850f9
+  metadata.gz: 50d8b1e91e3c71286406bf45e5e5cdeb2d8170f98a513a6662f0b593a7e077b7af2650057e6d9670469ed937b6ddc7c0073868df6833721c2ba3c81a8f691c46
+  data.tar.gz: 92df8d83ddbabcdd3cbeaa30f26868da4a13c168d5f97600475f552a197f7ebba70a80cc6ab272f98e2a68c1b8bd9d9a9094d3b01235ec556790f4a944337fee

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## [1.13.0] - 2026-08
+
+### Added
+- Derivations. A derivation puts the words first and the result last, and
+  joins what each step combines with one rule drawn across all of it rather
+  than with a line to each daughter. `derivation` draws the rules and
+  `direction: btt` turns the tree over; together they give the format
+  categorial grammar is written in, and `derivation` on its own marks the
+  spans of an ordinary tree. The name of each step rides in the label after a
+  column break and is set beside the end of its rule. A derivation runs down
+  the page and is drawn with its rules, so `direction: ltr` and hiding the
+  default connectors are refused rather than approximated.
+- `direction: btt`, the layout turned over, leaves first.
+
+### Fixed
+- Connectors follow the tree when it is turned over. They kept the ends they
+  have when the root is at the top, so every line ran from above the daughter,
+  through its label and the mother's, to below the mother.
+
+## [1.12.0] - 2026-08
+
+Everything needed to write this notation is now available as text, built from
+the files the tool itself reads, and a refusal says where that text is.
+
+### Added
+- `--examples` prints every published example with the options it was drawn
+  with. The gallery examples are checked against the parser that draws them,
+  so each one is known to be accepted.
+- The site carries the same material as plain text for a reader that can fetch
+  a URL but cannot run a command: `llms.txt` and `llms-full.txt`, the second
+  holding the reference, the manual and every example in one file. Both are
+  generated from their sources, and a test fails if they fall behind.
+- A refusal names where the notation is written down, once, alongside the
+  cause and the fix. A hint repairs the mistake in front of it and says
+  nothing about the rest, which is not enough for a caller that was guessing.
+
+### Changed
+- The angle bracket the reference recommends is U+27E8 and U+27E9, which it
+  had always named while writing U+3008 and U+3009 in its own examples. The
+  East Asian pair draws a full em wide, wider than a capital, and had spread
+  through the gallery and into the repair that corrects ASCII brackets. Both
+  pairs still parse; documents written before this are unaffected.
+- Two feature-structure figures are redrawn at the narrower bracket.
+
+### Fixed
+- `--notation` and `--examples` answer before the input is read. Reading first
+  meant waiting on a pipe that never closes when stdin is not a terminal,
+  which is how a script reaches them.
+
 ## [1.11.0] - 2026-08
 
 Every input the tool accepts now draws, and every input it refuses says why.

data/bin/rsyntaxtree

@@ -32,7 +32,7 @@ CONFIG_VALIDATORS = {
   tidy: ->(v) { OPTION_VALUES[:tidy].include?(v.to_s) ? nil : "must be off, symmetric, low, medium, or high" },
   hspacing: ->(v) { v.is_a?(Numeric) && v >= 0.5 && v <= 3.0 ? nil : "must be in the range of 0.5-3.0" },
   tidy_spacing: ->(v) { v.is_a?(Numeric) && v >= 0.5 && v <= 3.0 ? nil : "must be in the range of 0.5-3.0" },
-  direction: ->(v) { OPTION_VALUES[:direction].include?(v.to_s) ? nil : "must be ttb or ltr" },
+  direction: ->(v) { OPTION_VALUES[:direction].include?(v.to_s) ? nil : "must be one of: #{OPTION_VALUES[:direction].join(', ')}" },
   hyphen: ->(v) { OPTION_VALUES[:hyphen].include?(v.to_s) ? nil : "must be markup or literal" }
 }.freeze
 
@@ -122,15 +122,18 @@ opts = Optimist.options do
   opt :tidy, "tidy tree layout: off, symmetric (radical symmetrization), low (packed, strict leaf positions), medium (packed; leaves may overlap but never swap order), or high (packed; leaf order kept per row only)", default: "off", short: :none
   opt :hspacing, "Horizontal spacing factor (counterpart of vheight): 0.5-3.0", default: 1.0, short: :none
   opt :tidy_spacing, "DEPRECATED alias of --hspacing: 0.5-3.0", default: 1.0, short: :none
-  opt :direction, "Tree layout direction: ttb (top-to-bottom) or ltr (left-to-right)", default: "ttb", short: :d
+  opt :direction, "Tree layout direction: ttb (top-to-bottom), ltr (left-to-right) or btt (bottom-to-top, the root last)", default: "ttb", short: :d
+  opt :derivation, "Join each node to its daughters with one rule drawn across them, as a derivation is written, rather than with a line to each: on, off", default: "off", short: :none
   opt :hyphen, "How a hyphen in a label reads: markup (-underline-) or literal (a hyphen; \-underline\- then underlines)", default: "markup", short: :none
   opt :validate, "Validate the input without drawing or writing a file: print a machine-readable diagnosis (JSON) to stdout and report the result in the exit code", short: :none
   opt :notation, "Print the notation reference to stdout and exit", short: :none
+  opt :examples, "Print every gallery example, with the options each needs, to stdout and exit", short: :none
   opt :help, "This is a custom help message", short: :h
 end
 
 Optimist.die :outdir, "must be an exsting directory path" unless FileTest.directory?(opts[:outdir])
-Optimist.die :direction, "must be ttb or ltr" unless OPTION_VALUES[:direction].include?(opts[:direction])
+Optimist.die :direction, "must be one of: #{OPTION_VALUES[:direction].join(', ')}" unless OPTION_VALUES[:direction].include?(opts[:direction])
+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])
@@ -171,6 +174,21 @@ if %w[jpg gif].include?(string_opts[:format])
   warn "Warning: #{string_opts[:format].upcase} output is deprecated and will be removed in RSyntaxTree 2.0. Use PNG instead."
 end
 
+# These print and exit, so they answer before the input is read. Reading
+# first meant waiting on a pipe that never closes when stdin is not a
+# terminal, which is how they are reached from a script.
+if opts[:notation]
+  puts File.read(File.expand_path("../lib/rsyntaxtree/notation_core.md", __dir__))
+  exit 0
+end
+
+# The examples are the reference's counterpart: the rules in brief there, and
+# here every published tree with the options it was drawn with.
+if opts[:examples]
+  puts File.read(File.expand_path("../lib/rsyntaxtree/notation_examples.md", __dir__))
+  exit 0
+end
+
 # An argument names a file only if it really is one: File.exist? on an
 # expanded empty string answers for the current directory, and reading that
 # as the tree ended the run with a Ruby error.
@@ -187,11 +205,6 @@ data = if ARGV[0] && !ARGV[0].empty? && File.file?(File.expand_path(ARGV[0]))
 # Auto-convert Penn TreeBank format to bracket notation
 data = RSyntaxTree::FormatConverter.to_bracket(data) if data
 
-if opts[:notation]
-  puts File.read(File.expand_path("../lib/rsyntaxtree/notation_core.md", __dir__))
-  exit 0
-end
-
 # Validate without drawing or writing anything: the diagnosis goes to stdout
 # as JSON and the exit code carries the verdict.
 if opts[:validate]

data/lib/rsyntaxtree/base_graph.rb

@@ -67,6 +67,7 @@ module RSyntaxTree
       @fontset = params[:fontset]
       @fontsize = params[:fontsize]
       @mirror = params[:mirror] == true
+      @derivation = params[:derivation] == true
       # tidy is one layout scale: "symmetric" (radical symmetrization) |
       # "off" | "low" (packing, strict leaf positions) | "medium" (packing
       # with cross-row tucking as long as no two leaves swap left-right
@@ -182,6 +183,17 @@ module RSyntaxTree
                         accum_array.sum
                       end
 
+        # The name of the step hangs past the right end of its rule, and the
+        # rule reaches the full width of what the step combines. With no room
+        # kept for it the name lands on the next subtree's rule and two steps
+        # read as one, so the node claims that much more width. The label is
+        # drawn from the left edge and does not move.
+        #
+        # Doubled: the children sit centred in the width their mother claims,
+        # so half of whatever is added lands on the left where nothing needs
+        # it, and only the other half reaches the side the name is on.
+        accum_width += rule_name_room(target) * 2
+
         if target.content_width > accum_width
           # Parent label is wider than children's total width.
           # Distribute the excess equally among children to prevent
@@ -234,9 +246,91 @@ module RSyntaxTree
         end
         target.height = accum_array.max - target.vertical_indent
         accum_array.max
+      end.tap { level_derivation_rows if id == 1 && @derivation }
+    end
+
+    # In a derivation every premise is given at the start, so the words stand in
+    # one row and each step sits below everything it draws on. A node's row is
+    # therefore its distance from the words rather than its distance from the
+    # root: a step joining a category to a derivation three deep goes below
+    # both. Placed by depth from the root instead, the words come out in a
+    # staircase, each at the depth of its own branch.
+    #
+    # Run after the ordinary placement, so the row heights and the drop between
+    # them are the ones that pass settled on.
+    # Levelled twice, and the two are not the same pass. The first runs inside
+    # the layout, because tidy packs subtrees by their contours and a contour is
+    # read off the vertical positions: rows it has not seen levelled pack as
+    # though the figure were a tree, and two rules of one row come out
+    # overlapping. The second runs after the layout has been turned over, since
+    # turning it over sets each box against its own bottom edge, which leaves a
+    # tall label — a feature matrix, say — standing proud of its row. Counting
+    # rows from the end the words are at is what makes the second pass the same
+    # reckoning as the first, read the other way up.
+    def level_derivation_rows(flipped: false)
+      root_height = subtree_height(1)
+      rows = {}
+      tallest = Hash.new(0.0)
+      @element_list.get_elements.each do |e|
+        height = subtree_height(e.id)
+        row = flipped ? height : root_height - height
+        rows[e.id] = row
+        tallest[row] = [tallest[row], e.content_height].max
+      end
+
+      drop = @global[:height_connector].to_f
+      top = {}
+      y = 0.0
+      tallest.keys.sort.each do |row|
+        top[row] = y
+        y += tallest[row] + drop
+      end
+
+      @element_list.get_elements.each { |e| e.vertical_indent = top[rows[e.id]] }
+
+      # Which row each element ended up in, kept for the drawing: a rule belongs
+      # between two rows, not between two labels. Placed from the label instead,
+      # a step whose result is taller than its neighbours — a feature matrix
+      # among plain categories — had its rule drawn at a height of its own while
+      # the rules beside it stayed on the row.
+      @derivation_rows = rows
+    end
+
+    # How far a row reaches, read from the labels as they stand. Taken when the
+    # rows were levelled it would be the measured height, and the drawing works
+    # to a slightly different one.
+    def derivation_row_extent(row)
+      @derivation_extents ||= {}
+      @derivation_extents[row] ||= begin
+        members = @element_list.get_elements.select { |e| @derivation_rows[e.id] == row }
+        [members.map(&:vertical_indent).min,
+         members.map { |e| e.vertical_indent + e.content_height }.max]
       end
     end
 
+    # The rule for a step runs between the row its result sits in and the row
+    # holding the last of its premises — always the next row along, since a step
+    # is one taller than the tallest thing it draws on.
+    def derivation_rule_band(parent)
+      return nil unless @derivation_rows
+
+      row = @derivation_rows[parent.id]
+      neighbour = row + (@direction == "btt" ? -1 : 1)
+      return nil unless @derivation_rows.value?(neighbour)
+
+      here = derivation_row_extent(row)
+      there = derivation_row_extent(neighbour)
+      @direction == "btt" ? [there[1], here[0]] : [here[1], there[0]]
+    end
+
+    # Steps from +id+ down to the furthest word under it. A word is zero.
+    def subtree_height(id)
+      node = @element_list.get_id(id)
+      return 0 if node.children.empty?
+
+      1 + node.children.map { |c| subtree_height(c) }.max
+    end
+
     def make_balance(id = 1)
       target = @element_list.get_id(id)
       if target.children.empty?
@@ -305,6 +399,15 @@ module RSyntaxTree
       parent = @element_list.get_id(id)
       children = parent.children.map { |c| @element_list.get_id(c) }
 
+      # A derivation joins its premises with one rule drawn across all of them,
+      # not with a line to each. The rule replaces the lines, so a tree is drawn
+      # this way throughout or not at all.
+      if @derivation && !children.empty?
+        rule_to_parent(parent, children)
+        parent.children.each { |c| draw_connector(c) }
+        return
+      end
+
       if children.size == 1
         child = children[0]
         case @leafstyle
@@ -345,6 +448,20 @@ module RSyntaxTree
       (children_indent << target_indent).min
     end
 
+    # Width to keep clear to the right of a step's rule for the name beside it,
+    # with a gap between the name and whatever follows. Zero unless the tree is
+    # drawn as a derivation and the step has a name.
+    def rule_name_room(element)
+      return 0 unless @derivation
+
+      name = element.rule_name
+      return 0 if name.nil? || name.empty?
+
+      size = (@fontsize * 0.8).round(2)
+      width = FontMetrics.get_metrics(name, @fontset[:family], size, :normal, :normal).width
+      width + @global[:width_half_x]
+    end
+
     def get_rightmost(id = 1)
       target = @element_list.get_id(id)
       target_right_end = target.horizontal_indent + target.content_width
@@ -363,6 +480,19 @@ module RSyntaxTree
       end
     end
 
+    # Flip the laid-out tree vertically: the root ends up at the bottom and the
+    # leaves at the top, which is how a derivation is written — the words at the
+    # top, each step below the material it combines. Done after the layout is
+    # final, like the horizontal flip, so connectors, triangles, paths and
+    # region shades follow from the coordinates without knowing about it.
+    def flip_vertical
+      elements = @element_list.get_elements
+      max_bottom = elements.map { |e| e.vertical_indent + e.content_height }.max
+      elements.each do |e|
+        e.vertical_indent = max_bottom - (e.vertical_indent + e.content_height)
+      end
+    end
+
     # Flip the laid-out tree horizontally (RTL linguistics convention: the
     # first word sits at the right edge). Connectors, triangles, polylines,
     # movement paths, and region shades all derive from element coordinates,
@@ -425,9 +555,23 @@ module RSyntaxTree
         x0 -= ext
         x1 += ext
       end
+      # A step's name is drawn past the right end of its rule, and the rule
+      # reaches the full width of what the step combines. Packing sees only the
+      # labels, so without this the neighbour is pulled up against the name and
+      # two steps read as one long rule.
+      x1 = [x1, subtree_right(node.id) + rule_name_room(node)].max if @derivation
       [node.vertical_indent, node.vertical_indent + node.content_height, x0, x1]
     end
 
+    # Right edge of the subtree rooted at +id+, from wherever the layout has
+    # put things so far.
+    def subtree_right(id)
+      node = @element_list.get_id(id)
+      right = node.horizontal_indent + node.content_width
+      node.children.each { |c| right = [right, subtree_right(c)].max }
+      right
+    end
+
     # Effective-rect list of the subtree rooted at +id+, as [y0, y1, x0, x1].
     # A region-shaded (%) node additionally contributes the shade's padded
     # bounding rect so that neighboring subtrees keep clear of the plane.
@@ -900,6 +1044,10 @@ module RSyntaxTree
       finalize_ltr if @direction == "ltr"
 
       # RTL flip (mirror option): after the layout is final, before drawing
+      # btt is the top-to-bottom layout turned over, so the layout runs as
+      # usual and the flip comes after it.
+      flip_vertical if @direction == "btt"
+      level_derivation_rows(flipped: true) if @derivation && @direction == "btt"
       mirror_layout if @mirror
 
       draw_elements
@@ -915,6 +1063,9 @@ module RSyntaxTree
         max_x = r if r > max_x
         max_y = b if b > max_y
       end
+      # A rule's name is set beside the rule, past the right edge of every box
+      # the loop above measured.
+      max_x = @rule_name_edge if @rule_name_edge.to_f > max_x
       width = max_x + @global[:h_gap_between_nodes]
       height = max_y
       height = @height if @height > height

data/lib/rsyntaxtree/element.rb

@@ -13,9 +13,14 @@ require_relative "color_names"
 
 module RSyntaxTree
   class Element
-    attr_accessor :id, :parent, :type, :level, :width, :height, :content, :content_width, :text_width, :content_height, :horizontal_indent, :vertical_indent, :triangle, :enclosure, :children, :font, :fontsize, :contains_phrase, :path, :color, :raw_content, :region, :region_color
-
-    def initialize(id, parent, content, level, fontset, fontsize, global)
+    attr_accessor :rule_name, :id, :parent, :type, :level, :width, :height, :content, :content_width, :text_width, :content_height, :horizontal_indent, :vertical_indent, :triangle, :enclosure, :children, :font, :fontsize, :contains_phrase, :path, :color, :raw_content, :region, :region_color
+
+    # names_a_rule says the content is a mother's label rather than a leaf's
+    # text. Only a mother has a step under it for a name to sit beside, and a
+    # leaf's `a\tb` is a row of two columns, so the name is read out of the one
+    # and left alone in the other.
+    def initialize(id, parent, content, level, fontset, fontsize, global,
+                   names_a_rule = false)
       @global = global
       @type = ETYPE_LEAF
       @id = id                 # Unique element id
@@ -36,6 +41,20 @@ module RSyntaxTree
 
       @fontset = fontset
       @fontsize = fontsize
+      # In a derivation the label may carry the name of the rule that produced
+      # it, written after a column break: `S/NP\t\>B`. The name belongs beside
+      # the rule rather than beside the result, so it comes out of the label
+      # here, before the label is measured, and BaseGraph draws it at the end
+      # of the rule.
+      if global && global[:derivation] && names_a_rule
+        at = rule_name_break(content)
+        name = at && content[(at + 2)..].to_s.strip
+        if name && !name.empty?
+          @rule_name = name
+          content = content[0...at]
+        end
+      end
+
       @raw_content = content.sub(/\^?(?:\+-?>?<?\d+)+\^?\z/, '')
 
       parsed = Markup.parse(prepare_markup(content))
@@ -65,12 +84,21 @@ module RSyntaxTree
     # enclosure. Such nodes act as pass-through joints: connectors run
     # continuously through them, which lets a `<>` chain push a leaf down
     # to align with deeper leaves while the line stays unbroken.
+    #
+    # A label that is one whole feature matrix keeps its text inside the
+    # matrix and leaves none of it here, and the matrix is a decoration on the
+    # run rather than the element's own enclosure. Counted as empty, such a
+    # node was joined as a pass-through joint and the connectors were run to
+    # the middle of it — through the matrix and the rows written in it.
     def empty_label?
       return false if @enclosure && @enclosure != :none
 
       @content.all? do |c|
         c[:type] == :text &&
-          c[:elements].all? { |e| e[:text].gsub(WHITESPACE_BLOCK, "").strip.empty? }
+          c[:elements].all? do |e|
+            !e[:decoration].to_a.include?(:matrix) &&
+              e[:text].gsub(WHITESPACE_BLOCK, "").strip.empty?
+          end
       end
     end
 
@@ -133,8 +161,8 @@ module RSyntaxTree
        ->(s) { s.sub(/\A%?@(?:#[0-9a-zA-Z]+|[a-zA-Z]+)?:/, "") },
        "A color is @name: with a CSS color name, or @#rgb: / @#rrggbb: with 3 or 6 hex digits (e.g. @blue:VP, @#3af:VP)."],
       [:angle_brackets,
-       ->(s) { s.gsub(/(?<!\\)<([^<>]*[^<>\d][^<>]*)>/) { "〈#{$1}〉" } },
-       "'<' and '>' mark whitespace here, not a list. Write the angle bracket characters themselves: 〈NP〉, 'hand〈SUBJ,OBJ〉'."],
+       ->(s) { s.gsub(/(?<!\\)<([^<>]*[^<>\d][^<>]*)>/) { "⟨#{$1}⟩" } },
+       "'<' and '>' mark whitespace here, not a list. Write the angle bracket characters themselves: ⟨NP⟩, 'hand⟨SUBJ,OBJ⟩'."],
       [:bare_hyphen,
        ->(s) { Element.escape_hyphens(s) },
        "A hyphen opens an underline. Escape it (e.g. f\\-structure, V\\-bar) or set the hyphen option to literal."],
@@ -146,6 +174,16 @@ module RSyntaxTree
       [:unclosed_matrix,
        ->(s) { s.scan("#(").size > s.scan("#)").size ? s + "#)" : s },
        "A matrix opened with '#(' is never closed with '#)'."],
+      # A derivation writes the name of each step after a column break, and
+      # the combinators it is written with are made of the same characters as
+      # the whitespace marker. Read as an ordinary tree such a label is
+      # unclosed markup, and the advice below is about spaces — the opposite of
+      # what the writer needs. Asked here, before those, so that a derivation
+      # written without the option on is told so.
+      [:rule_name_without_derivation,
+       ->(s) { s.include?('\\n') ? s : s.sub(/(?<!\\)\\t.*\z/m, "") },
+       "This label names a rule after a column break, the way a derivation " \
+       "does. Turn derivation on to draw it as one, or escape the break as \\\\t."],
       # Neutralising every occurrence of one character, rather than adding a
       # closing one, locates the culprit wherever it sits in the label — an
       # opener left unclosed halfway down a matrix is not fixed by appending.
@@ -175,7 +213,7 @@ module RSyntaxTree
       # away, one of them starting the split and the next ending it.
       if label.strip.empty?
         return details.merge(code: :label_split,
-                             hint: "Raw spaces left this label empty. Write a space inside a label as <> (e.g. 〈<>NP<>〉).",
+                             hint: "Raw spaces left this label empty. Write a space inside a label as <> (e.g. ⟨<>NP<>⟩).",
                              retryable: true)
       end
 
@@ -195,7 +233,7 @@ module RSyntaxTree
       # a hint that admits no one cause was found rather than naming a wrong
       # one. retryable: false is for what no rewriting reaches.
       details.merge(code: :invalid_markup,
-                    hint: "No single cause fits, which usually means more than one mistake in this label. Check that *, _, =, ~, |, { and #(...#) are paired, that hyphens are escaped, and that 〈 〉 are the angle bracket characters.",
+                    hint: "No single cause fits, which usually means more than one mistake in this label. Check that *, _, =, ~, |, { and #(...#) are paired, that hyphens are escaped, and that ⟨ ⟩ are the angle bracket characters.",
                     retryable: true)
     end
 
@@ -282,7 +320,8 @@ module RSyntaxTree
               # the padding and the second is what actually separates the
               # bracket from the descenders of the line above it.
               content[:top_room] = matrix_vertical_room * 2
-              elements_height << e[:height]
+              elements_height << with_first_row_margin(e[:height], one_bvm_given)
+              one_bvm_given = true
               row_width += e[:width]
               next
             end
@@ -313,7 +352,12 @@ module RSyntaxTree
             standard_metrics = FontMetrics.get_metrics('X', font, fontsize, :normal, :normal)
 
             height = standard_metrics.height
-            line_height = height
+            # The rhythm a row advances by belongs to the label, not to the size
+            # a run inside it happens to be set at. Taken from the run, a label
+            # that is nothing but a subscript measured a subscript tall and came
+            # out shorter than the text drawn in it, so its daughters were
+            # placed up into it.
+            line_height = @global[:single_x_metrics].height
             if /\A[<>]+\z/ =~ text
               width = standard_metrics.width * text.size / 2
             elsif text.contains_emoji?
@@ -356,7 +400,7 @@ module RSyntaxTree
               # ENCLOSURE_SIZE only for content that will not fit.
               band = FontMetrics.get_metrics("Xg", font, fontsize, :normal, :normal)
               descender = band.ink_height - band.ink_above
-              centre = standard_metrics.ink_above / 2.0
+              centre = FontMetrics.visual_centre(font, fontsize)
 
               ink = FontMetrics.get_metrics(text, font, fontsize, style, weight)
               ink_height = ink.ink_height.to_f
@@ -399,14 +443,8 @@ module RSyntaxTree
             # the height of the nodes above it, so a node measured short of the
             # rhythm pulls its own children up and off the row its cousins sit
             # on.
-            measured = [height, line_height].max
-
-            if one_bvm_given
-              elements_height << measured
-            else
-              one_bvm_given = true
-              elements_height << measured + @global[:box_vertical_margin]
-            end
+            elements_height << with_first_row_margin([height, line_height].max, one_bvm_given)
+            one_bvm_given = true
 
             e[:width] = width
             row_width += width
@@ -431,6 +469,48 @@ module RSyntaxTree
       @global[:width_half_x] * MATRIX_BRACKET_ROOM
     end
 
+    # Where the break that names the rule is, or nil if the label does not name
+    # one. It is the break at the top level of the label: a feature matrix is
+    # written with breaks of its own and those belong to its columns, so a step
+    # whose category is a matrix can still name the rule that produced it.
+    #
+    # Exactly one, and no line break outside a matrix: a rule has one name, and
+    # a label written over several lines is a matrix rather than a step. A
+    # break the writer escaped is theirs and is not a break here.
+    def rule_name_break(content)
+      depth = 0
+      breaks = []
+      lined = false
+      index = 0
+      while index < content.length
+        case content[index, 2]
+        when '\\t' then breaks << index if depth.zero?
+        when '\\n' then lined = true if depth.zero?
+        when "#(" then depth += 1
+        when "#)" then depth -= 1
+        else
+          # A backslash takes the character after it, whatever that character
+          # is. Only the two breaks above are read here; every other escape is
+          # the notation's, and `\#` is a hash that opens no matrix — counted as
+          # one it left the depth wrong and the break that names the rule was
+          # looked for in the wrong place.
+          index += content[index] == "\\" ? 2 : 1
+          next
+        end
+        index += 2
+      end
+      breaks.first if !lined && breaks.size == 1
+    end
+
+    # The first row of a label carries a margin above it that holds the text
+    # clear of the connector coming down to the node. Every row is entered
+    # through here so that the one holding a feature matrix is given it too: it
+    # used to be measured without, and a matrix node came out shorter than the
+    # rows drawn in it, which sat its daughters up inside the matrix.
+    def with_first_row_margin(height, already_given)
+      already_given ? height : height + @global[:box_vertical_margin]
+    end
+
     # Vertical room a nested matrix keeps between itself and the rows above and
     # below it.
     def matrix_vertical_room

data/lib/rsyntaxtree/lsif_graph.rb

@@ -69,6 +69,17 @@ module RSyntaxTree
       parent = @element_list.get_id(id)
       children = parent.children.map { |c| @element_list.get_id(c) }
 
+      # A derivation joins a node to its daughters with one rule across all of
+      # them. Recorded as what it is: this format states that it carries how
+      # the figure was drawn, so calling these lines would be a false record.
+      if @derivation && !children.empty?
+        children.each do |child|
+          @edges << { from: parent.id, to: child.id, type: "dominance", connector: "rule" }
+        end
+        parent.children.each { |c| draw_connector(c) }
+        return
+      end
+
       if children.size == 1
         child = children[0]
         case @leafstyle
@@ -275,6 +286,7 @@ module RSyntaxTree
               font_size: (@params[:fontsize] / FONT_SCALING).round,
               color: @params[:color],
               connector: @params[:leafstyle],
+              derivation: @params[:derivation] == true,
               connector_height: @params[:vheight],
               horizontal_spacing: @params[:hspacing] || 1.0,
               line_width: @params[:linewidth],

data/lib/rsyntaxtree/notation_core.md

@@ -16,10 +16,10 @@ Within a label:
 
 Four traps, because these characters already mean something:
 - `<` and `>` are never angle brackets in this notation: `<>` is one space,
-  `<3>` is three. Wherever linguistics uses angle brackets — a list 〈NP〉,
-  an argument structure like 'hand〈SUBJ,OBJ〉', anything — write the
-  characters 〈 and 〉 themselves (U+27E8 and U+27E9):
-  SPR\t〈<>NP<>〉    PRED\t'hand〈SUBJ,OBJ〉'
+  `<3>` is three. Wherever linguistics uses angle brackets — a list ⟨NP⟩,
+  an argument structure like 'hand⟨SUBJ,OBJ⟩', anything — write the
+  characters ⟨ and ⟩ themselves (U+27E8 and U+27E9):
+  SPR\t⟨<>NP<>⟩    PRED\t'hand⟨SUBJ,OBJ⟩'
 - `-` opens and closes an underline, so a bare hyphen in ANY word is an
   error: V-bar, f-structure, HEAD-DTR. Write `V'`, or escape the hyphen:
   `V\-bar`, `f\-structure`, `HEAD\-DTR`.
@@ -35,14 +35,14 @@ An attribute-value matrix is columns plus an enclosure:
 
     [#*word*\
       HEAD\t*verb*\
-      SPR\t〈<>NP<>〉\
-      COMPS\t〈<>〉
+      SPR\t⟨<>NP<>⟩\
+      COMPS\t⟨<>⟩
     ]
 
 A value can be another matrix. Nest it with `#( ... #)`, never with square
 brackets — those are read as tree structure:
 
-    [#PRED\t'hand〈SUBJ,OBJ〉'\
+    [#PRED\t'hand⟨SUBJ,OBJ⟩'\
       TENSE\tpast\
       SUBJ\t#(PRED\t'David'#)
     ]