rsyntaxtree 1.12.0 → 1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 160b79f9047cb7674fe1c980dcf9e1a4044ca2c68eb3c758eabc9389d73d829a
-  data.tar.gz: 648c5297ccfbaefde5c2904cc5266ed56207487bc6ac64320041ac7e135e4814
+  metadata.gz: '0804e9119e0ebb089b4109ae05c9353180362bd6e86fddbf2e4da00db3b08e18'
+  data.tar.gz: '01867ffda61d7f81fd3d81a9f6ad44ba83eda4f7d89d1b3b05d53b196bc23fa1'
 SHA512:
-  metadata.gz: 5465a152a7de5a453731cee9595f5d98636640fc8f97f7a21320e3ac66d14cf9876c10941518f936b586e0e6613944c2eb6e05175b6740a49aab544c97008e54
-  data.tar.gz: 78c83cee893a040d10959508199f354d3c568aa2a65fcba7bb486ddce6839314f6fcbd7d094c759804a77df07df660811508949ab7ffb9a9a7e81559e0e85b89
+  metadata.gz: 990e4522fe0e0694d009eddebc2b3b2af98e5beda1f3e2daf9fbf1250199cef31b981215d1ae7db3b711d0030826e2445c7011f427223f8e081bffb8d76451ae
+  data.tar.gz: fe620d8c1fe64c289b18d853d6663ceaae5ea8a7486a5f0cf0ce578f8c0e9073e48251f0d7a933d0c7afa9ee7fce896dd6cbf00f3499c8d5314278e9cc0e0b57

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [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
+- 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

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,7 +122,8 @@ 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
@@ -131,7 +132,8 @@ opts = Optimist.options do
 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])

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
@@ -209,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"
@@ -234,9 +251,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?
@@ -301,27 +400,53 @@ 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) }
 
+      # 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]
+        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)
@@ -345,6 +470,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 +502,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 +577,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 +1066,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 +1085,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
 
@@ -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.
@@ -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,23 +69,35 @@ 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]
+        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)
@@ -275,6 +287,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],