rsyntaxtree 2.4.0 → 2.5.0

data/CITATION.cff

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

data/README.md

@@ -144,7 +144,7 @@ older setup still fails to build `gobject-introspection`, `cairo-gobject` or
 `gio2`, install those three first with
 `-- --with-ldflags="-Wl,-undefined,dynamic_lookup"` appended, then install
 RSyntaxTree; or skip the build entirely with the
-[Docker image](https://hub.docker.com/r/yohasebe/rsyntaxtree) or the
+[Docker image](https://github.com/yohasebe/rsyntaxtree_web) or the
 [web interface](https://yohasebe.com/rsyntaxtree).
 
 ## Usage
@@ -172,6 +172,7 @@ Usage:
 | `-c, --color` | Color mode: modern, traditional, gray (black text, grey lines), off | `modern` |
 | `-p, --polyline` | Polyline connectors: on, off | `off` |
 | `--hide-default-connectors` | Draw no parent-to-child lines, leaving only the ones written with `+-n`: on, off | `off` |
+| `--leaf-align` | Line the leaves up on one row: off, words (lower the words), subtrees (lower whole subtrees) | `off` |
 | `-d, --direction` | Tree layout direction: ttb, ltr, btt | `ttb` |
 | `--tidy` | Layout scale: off, symmetric, low, medium, high | `off` |
 | `--hspacing` | How far apart sisters sit, all layout modes (0.5-3.0) | `1.0` |

data/bin/rsyntaxtree

@@ -27,6 +27,7 @@ CONFIG_VALIDATORS = {
   transparent: ->(v) { /\A(on|off|true|false)\z/ =~ v.to_s ? nil : "must be on or off" },
   polyline: ->(v) { /\A(on|off|true|false)\z/ =~ v.to_s ? nil : "must be on or off" },
   hide_default_connectors: ->(v) { /\A(on|off|true|false)\z/ =~ v.to_s ? nil : "must be on or off" },
+  leaf_align: ->(v) { OPTION_VALUES[:leaf_align].include?(v.to_s) ? nil : "must be off, words, or subtrees" },
   mirror: ->(v) { /\A(on|off|true|false)\z/ =~ v.to_s ? nil : "must be on or off" },
   shear: ->(v) { v.is_a?(Numeric) && v >= -45 && v <= 45 ? nil : "must be in the range of -45-45" },
   vmargin: ->(v) { v.is_a?(Numeric) && v >= 0.1 && v <= 1.0 ? nil : "must be in the range of 0.1-1.0" },
@@ -118,6 +119,7 @@ opts = Optimist.options do
   opt :transparent, "Make background transparent: on or off", default: "off", short: :r
   opt :polyline, "draw polyline connectors: on or off", default: "off", short: :p
   opt :hide_default_connectors, "make default connectors transparent: on or off", default: "off", short: :none
+  opt :leaf_align, "line the leaves up on one row: off, words (lower the words), or subtrees (lower whole subtrees)", default: "off", short: :none
   opt :mirror, "flip the tree horizontally (RTL linguistics convention: first word at the right edge): on or off", default: "off"
   opt :shear, "Tilt the drawn figure, in degrees: -45 to 45, positive leaning the top to the right", default: 0.0, short: :none
   opt :shear_plane, "The plane behind a sheared figure: on, off, a colour name, or a hex colour", default: "on", short: :none
@@ -157,6 +159,7 @@ Optimist.die :vheight, "must be in the range of 0.5-5.0" if opts[:vheight] < 0.5
 Optimist.die :transparent, "must be either on or off" unless /\A(on|off|true|false)\z/ =~ opts[:transparent]
 Optimist.die :polyline, "must be either on or off" unless /\A(on|off|true|false)\z/ =~ opts[:polyline]
 Optimist.die :hide_default_connectors, "must be either on or off" unless /\A(on|off|true|false)\z/ =~ opts[:hide_default_connectors]
+Optimist.die :leaf_align, "must be off, words, or subtrees" unless OPTION_VALUES[:leaf_align].include?(opts[:leaf_align])
 Optimist.die :mirror, "must be either on or off" unless /\A(on|off|true|false)\z/ =~ opts[:mirror]
 Optimist.die :tidy, "must be off, symmetric, low, medium, or high" unless OPTION_VALUES[:tidy].include?(opts[:tidy])
 Optimist.die :hspacing, "must be in the range of 0.5-3.0" if opts[:hspacing] < 0.5 || opts[:hspacing] > 3.0

data/lib/rsyntaxtree/base_graph.rb

@@ -67,6 +67,7 @@ module RSyntaxTree
       @fontsize = params[:fontsize]
       @mirror = params[:mirror] == true
       @derivation = params[:derivation] == true
+      @leaf_align = !params[:leaf_align].nil? && params[:leaf_align].to_s != "off"
       # 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
@@ -247,7 +248,43 @@ module RSyntaxTree
         end
         target.height = accum_array.max - target.vertical_indent
         accum_array.max
-      end.tap { level_derivation_rows if id == 1 && @derivation }
+      end.tap do
+        level_derivation_rows if id == 1 && @derivation
+        level_leaf_rows if id == 1 && @leaf_align && !@derivation
+      end
+    end
+
+    # Leaf alignment gives every leaf the same depth, but equal depth is not
+    # an equal row: each label is set below its own parent, so a taller parent
+    # (a label of two lines) or a shorter drop (a leaf pulled up under
+    # leafstyle nothing) leaves the words of one depth at different heights.
+    # Drawn left to right it is worse, a level being as wide as the label
+    # standing in it. Every depth is therefore given one row: it starts below
+    # the tallest label of the row above, by the largest drop any of its
+    # elements had, so each connector keeps at least the room it was given.
+    # Worked in the swapped coordinates the left-to-right layout runs in,
+    # where a column is a row.
+    def level_leaf_rows
+      elements = @element_list.get_elements
+      drop = Hash.new(0.0)
+      elements.each do |e|
+        next unless e.parent.to_i.positive?
+
+        parent = @element_list.get_id(e.parent)
+        drop[e.level] = [drop[e.level], e.vertical_indent - parent.vertical_indent - parent.content_height].max
+      end
+      tallest = Hash.new(0.0)
+      elements.each { |e| tallest[e.level] = [tallest[e.level], e.content_height].max }
+
+      top = {}
+      y = 0.0
+      tallest.keys.sort.each do |level|
+        y += drop[level]
+        top[level] = y
+        y += tallest[level]
+      end
+
+      elements.each { |e| e.vertical_indent = top[e.level] }
     end
 
     # In a derivation every premise is given at the start, so the words stand in
@@ -412,7 +449,9 @@ module RSyntaxTree
       parent.triangle || (ETYPE_LEAF == child.type && child.triangle)
     end
 
-    def draw_connector(id = 1)
+    # `through` carries the connector chosen above a run of joints leaf
+    # alignment inserted, down that run to the child it reaches.
+    def draw_connector(id = 1, through = nil)
       parent = @element_list.get_id(id)
       children = parent.children.map { |c| @element_list.get_id(c) }
 
@@ -425,40 +464,65 @@ module RSyntaxTree
         return
       end
 
-      if children.size == 1
-        child = children[0]
-        forced = triangle_asked_for?(parent, child)
-        case @leafstyle
-        when "auto"
-          if forced || child.contains_phrase
-            triangle_to_parent(parent, child)
-          else
-            line_to_parent(parent, child)
-          end
-        when "bar"
-          if forced
-            triangle_to_parent(parent, child)
-          else
-            line_to_parent(parent, child)
-          end
-        when "nothing", "none"
-          if forced
-            triangle_to_parent(parent, child)
-          elsif ETYPE_LEAF != child.type
-            line_to_parent(parent, child)
-          end
-        end
-      else
-        children.each do |child|
-          line_to_parent(parent, child)
+      if through
+        child = children.first
+        line_to_parent(parent, child) if through == :line
+        draw_connector(child.id, (through if child.inserted_joint))
+        return
+      end
+
+      chosen = children.map do |child|
+        joints, target = past_inserted_joints(child)
+        connector = connector_for(parent, target, children.size == 1)
+        case connector
+        when :triangle then triangle_to_parent(parent, target, joints)
+        when :line then line_to_parent(parent, child)
+        else no_connector(parent, target, joints)
         end
+        [child, connector]
       end
 
-      parent.children.each do |c|
-        draw_connector(c)
+      chosen.each { |child, connector| draw_connector(child.id, (connector if child.inserted_joint)) }
+    end
+
+    # Leaf alignment puts joints between a node and the child it reaches. They
+    # are there to place the child, not to change how it is joined, so the
+    # connector is chosen for the node and the child past them and carried
+    # through them: a triangle runs from the node down to the words, a line
+    # passes through each joint, and where no line is drawn none is drawn at
+    # all. Joints written into the input are nodes like any other.
+    def past_inserted_joints(child)
+      joints = []
+      while child.inserted_joint
+        joints << child
+        child = @element_list.get_id(child.children.first)
       end
+      [joints, child]
     end
 
+    def connector_for(parent, child, only_child)
+      return :line unless only_child
+
+      forced = triangle_asked_for?(parent, child)
+      case @leafstyle
+      when "auto"
+        forced || child.contains_phrase ? :triangle : :line
+      when "bar"
+        forced ? :triangle : :line
+      when "nothing", "none"
+        if forced
+          :triangle
+        elsif ETYPE_LEAF != child.type
+          :line
+        else
+          :none
+        end
+      end
+    end
+
+    # A child joined to its parent by nothing at all: no mark to draw.
+    def no_connector(_parent, _child, _joints = []); end
+
     def get_leftmost(id = 1)
       target = @element_list.get_id(id)
       target_indent = target.horizontal_indent

data/lib/rsyntaxtree/element.rb

@@ -13,7 +13,7 @@ require_relative "color_names"
 
 module RSyntaxTree
   class Element
-    attr_accessor :ink_top, :ink_bottom, :rule_name, :label_with_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
+    attr_accessor :ink_top, :ink_bottom, :rule_name, :label_with_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, :inserted_joint
 
     # 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

data/lib/rsyntaxtree/elementlist.rb

@@ -99,5 +99,100 @@ module RSyntaxTree
       end
       maxlevel + 1
     end
+
+    # Add invisible `<>` joints to put every leaf at the deepest leaf level.
+    def align_leaves(mode, fontset, fontsize, global)
+      leaves = @elements.select { |e| e.type == ETYPE_LEAF && e.children.empty? }
+      return if leaves.size < 2
+
+      next_id = @elements.map(&:id).max + 1
+
+      if mode == "subtrees"
+        root = @elements.find { |element| element.parent.zero? }
+        add_high_joints(root, next_id, fontset, fontsize, global) if root
+      else
+        deepest = leaves.map(&:level).max
+
+        leaves.each do |leaf|
+          joints = deepest - leaf.level
+          next unless joints.positive?
+
+          next_id = insert_empty_joints(leaf, joints, next_id, fontset, fontsize, global)
+        end
+      end
+
+      renumber_preorder
+    end
+
+    private
+
+    def add_high_joints(parent, next_id, fontset, fontsize, global)
+      children = parent.children.map { |id| get_id(id) }
+      heights = children.map { |child| subtree_height(child) }
+      deepest = heights.max
+
+      children.zip(heights).each do |child, height|
+        joints = deepest - height
+        if joints.positive?
+          next_id = insert_empty_joints(child, joints, next_id, fontset, fontsize, global)
+          shift_subtree_levels(child, joints)
+        end
+        next_id = add_high_joints(child, next_id, fontset, fontsize, global) unless child.children.empty?
+      end
+      next_id
+    end
+
+    def subtree_height(element)
+      return 0 if element.children.empty?
+
+      1 + element.children.map { |id| subtree_height(get_id(id)) }.max
+    end
+
+    def insert_empty_joints(child, count, next_id, fontset, fontsize, global)
+      parent = get_id(child.parent)
+      return next_id unless parent
+
+      count.times do
+        joint = Element.new(next_id, parent.id, WHITESPACE_BLOCK, parent.level + 1, fontset, fontsize, global)
+        joint.inserted_joint = true
+        next_id += 1
+        @elements << joint
+        insert_between(parent, child, joint)
+        parent = joint
+      end
+      next_id
+    end
+
+    def shift_subtree_levels(element, count)
+      element.level += count
+      element.children.each { |id| shift_subtree_levels(get_id(id), count) }
+    end
+
+    def insert_between(parent, child, joint)
+      parent.children[parent.children.index(child.id)] = joint.id
+      joint.add_child(child.id)
+      joint.type = ETYPE_NODE
+      child.parent = joint.id
+    end
+
+    def renumber_preorder
+      root = @elements.find { |element| element.parent.zero? }
+      return unless root
+
+      ordered = []
+      visit = lambda do |element|
+        ordered << element
+        element.children.each { |id| visit.call(get_id(id)) }
+      end
+      visit.call(root)
+
+      ids = ordered.each_with_index.to_h { |element, index| [element.id, index + 1] }
+      ordered.each do |element|
+        element.parent = ids.fetch(element.parent, 0)
+        element.children = element.children.map { |id| ids.fetch(id) }
+        element.id = ids.fetch(element.id)
+      end
+      @elements = ordered
+    end
   end
 end

data/lib/rsyntaxtree/json_graph.rb

@@ -60,58 +60,32 @@ module RSyntaxTree
       @edges << { from: parent.id, to: child.id, type: "dominance", connector: "line" }
     end
 
-    def triangle_to_parent(parent, child)
-      @edges << { from: parent.id, to: child.id, type: "dominance", connector: "triangle" }
+    # A triangle spans from the parent to its child, through any joints leaf
+    # alignment put between them; each edge it crosses is recorded as part of
+    # it, so the joints keep their place in the tree.
+    def triangle_to_parent(parent, child, joints = [])
+      chain_edges(parent, joints, child, "triangle")
     end
 
-    # Override draw_connector to capture all edges including "none" connector
-    def draw_connector(id = 1)
-      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
+    # Recorded rather than left out: this format carries how the figure was
+    # drawn, and a child with no mark under it is part of that.
+    def no_connector(parent, child, joints = [])
+      chain_edges(parent, joints, child, "none")
+    end
 
-      if children.size == 1
-        child = children[0]
-        forced = triangle_asked_for?(parent, child)
-        case @leafstyle
-        when "auto"
-          if forced || child.contains_phrase
-            triangle_to_parent(parent, child)
-          else
-            line_to_parent(parent, child)
-          end
-        when "bar"
-          if forced
-            triangle_to_parent(parent, child)
-          else
-            line_to_parent(parent, child)
-          end
-        when "nothing", "none"
-          if forced
-            triangle_to_parent(parent, child)
-          elsif ETYPE_LEAF != child.type
-            line_to_parent(parent, child)
-          else
-            @edges << { from: parent.id, to: child.id, type: "dominance", connector: "none" }
-          end
-        end
-      else
-        children.each do |child|
-          line_to_parent(parent, child)
-        end
+    # 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.
+    def rule_to_parent(parent, children)
+      children.each do |child|
+        @edges << { from: parent.id, to: child.id, type: "dominance", connector: "rule" }
       end
+    end
 
-      parent.children.each { |c| draw_connector(c) }
+    def chain_edges(parent, joints, child, connector)
+      ([parent] + joints).zip(joints + [child]).each do |from, to|
+        @edges << { from: from.id, to: to.id, type: "dominance", connector: connector }
+      end
     end
 
     def draw_paths
@@ -331,6 +305,7 @@ module RSyntaxTree
               # before 2.0 carry a separate symmetrize flag beside it; the
               # scale is what it meant, and it is all that is written now.
               tidy: @params[:tidy] || "off",
+              leaf_align: @params[:leaf_align],
               mirror: @params[:mirror] == true,
               direction: @params[:direction] || "ttb",
               # Degrees, positive leaning the top right. The geometry below

data/lib/rsyntaxtree/notation_core.md

@@ -107,6 +107,7 @@ Options (the command line spells them --like-this):
 | vheight    | how far apart levels sit, 0.5–5.0 |
 | polyline   | draw each connector as two right angles rather than a slanted line |
 | hide_default_connectors | draw no parent-to-child lines, leaving only the ones written with +-n — how a lattice or a network is drawn |
+| leaf_align | line the leaves up on one row: off, words (lower the words) or subtrees (lower whole subtrees) |
 | transparent | leave the background clear instead of painting it white |
 | derivation | one rule across the daughters, categorial-grammar style |
 | hyphen     | markup (hyphens underline) or literal (hyphens are hyphens) |