rsyntaxtree 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 160b79f9047cb7674fe1c980dcf9e1a4044ca2c68eb3c758eabc9389d73d829a
-  data.tar.gz: 648c5297ccfbaefde5c2904cc5266ed56207487bc6ac64320041ac7e135e4814
+  metadata.gz: 32cc6cec6f19c5fe62dc9a6de16493d6db35680f72e40b6bbd36f0b1e98add96
+  data.tar.gz: b6f928fd6919bb289765fac684ae3e98f7988103985deebcb6f73e7f8836e939
 SHA512:
-  metadata.gz: 5465a152a7de5a453731cee9595f5d98636640fc8f97f7a21320e3ac66d14cf9876c10941518f936b586e0e6613944c2eb6e05175b6740a49aab544c97008e54
-  data.tar.gz: 78c83cee893a040d10959508199f354d3c568aa2a65fcba7bb486ddce6839314f6fcbd7d094c759804a77df07df660811508949ab7ffb9a9a7e81559e0e85b89
+  metadata.gz: 50d8b1e91e3c71286406bf45e5e5cdeb2d8170f98a513a6662f0b593a7e077b7af2650057e6d9670469ed937b6ddc7c0073868df6833721c2ba3c81a8f691c46
+  data.tar.gz: 92df8d83ddbabcdd3cbeaa30f26868da4a13c168d5f97600475f552a197f7ebba70a80cc6ab272f98e2a68c1b8bd9d9a9094d3b01235ec556790f4a944337fee

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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

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
@@ -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
 
@@ -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,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_examples.md

@@ -276,73 +276,24 @@ Source: Radford 2004
 ]
 ```
 
-## 011 — CCG sample
+## 011 — CCG derivation: forward and backward application
 
 Category: Combinatory Categorial Grammar
-Settings: color=none fontstyle=noto-serif leafstyle=nothing tidy=low
+Settings: color=none derivation=on direction=btt fontstyle=noto-serif leafstyle=nothing tidy=low vheight=0.7
+Source: Steedman 2000
 
 ```
-[S\
- \<
-  [NP\
-   \>
-    [NP/N\
-    ---\
-     *the*
-    ]
-    [N\
-    ---\
-     *dog*
-    ]
-  ]
-  [S\\NP\
-    \>
-    [(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 sample
+## 012 — CCG derivation: a relative clause
 
 Category: Combinatory Categorial Grammar
-Settings: color=none fontstyle=noto-serif leafstyle=nothing tidy=low vheight=1.5
+Settings: color=none derivation=on direction=btt fontstyle=noto-serif leafstyle=nothing tidy=low vheight=0.7
+Source: Steedman 2000
 
 ```
-[S\
-    \>
-  [S/NP\
-   B_\>_
-    [S/(S\\NP)\
-     T_\>_
-      [NP\
-         \>
-        [NP/N\
-         ---\
-         *the*
-        ]
-        [N\
-         ---\
-         *dog*
-        ]
-      ]
-    ]
-    [(S\\NP)/NP\
-     ---\
-     *bit*
-    ]    
-  ]
-  [NP\
-   ---\
-   *John*
-  ]
-]
+[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

data/lib/rsyntaxtree/string_parser.rb

@@ -41,7 +41,6 @@ module RSyntaxTree
       end
 
       @data = string # Store it for later...
-      fontset[:family] = fontset[:family_cjk] if @data.contains_cjk?
       @elist = ElementList.new # Initialize internal element list
       @pos = 0 # Position in the sentence
       @id = 1 # ID for the next element
@@ -149,7 +148,13 @@ module RSyntaxTree
           else
             token += ch
           end
-        when /[nt{}<>^+*_=~|%-]/
+        # The characters a backslash may take, which is the grammar's own list
+        # (Markup's `escaped` rule) plus the two letters that name a break. A
+        # backslash before anything else is dropped here, and '#' was missing:
+        # `\#` arrived at the grammar as a bare '#', which opens an enclosure,
+        # so a label written with a hash in it lost the hash and everything
+        # after it went inside brackets instead.
+        when /[nt{}<>^+*_=~|%\-#]/
           if escape
             token += '\\' + ch
             escape = false
@@ -202,7 +207,7 @@ module RSyntaxTree
               parts[1] = token_r[spaceat, tl - spaceat].join
 
               element = begin
-                Element.new(@id, parent, parts[0], @level, @fontset, @fontsize, @global)
+                Element.new(@id, parent, parts[0], @level, @fontset, @fontsize, @global, true)
               rescue RSTError => e
                 # The first raw space splits a token into the node's label
                 # and its children (that split is the notation's core rule,
@@ -227,7 +232,7 @@ module RSyntaxTree
               @id += 1
             else
               joined = token_r.join
-              element = Element.new(@id, parent, joined, @level, @fontset, @fontsize, @global)
+              element = Element.new(@id, parent, joined, @level, @fontset, @fontsize, @global, true)
               @id += 1
               newparent = element.id
             end

data/lib/rsyntaxtree/svg_graph.rb

@@ -469,7 +469,7 @@ module RSyntaxTree
         style += "font-style: italic; " if e[:decoration].include?(:italic) || e[:decoration].include?(:bolditalic)
         style += "\""
 
-        fontstyle = FontFamily.for_svg(@fontstyle, cjk_priority: e[:cjk])
+        fontstyle = FontFamily.for_svg(@fontstyle)
 
         if e[:decoration].include?(:box) || e[:decoration].include?(:circle) || e[:decoration].include?(:bar)
           # Measured around the enclosed marks in Element#setup; the line
@@ -878,6 +878,105 @@ module RSyntaxTree
     # (see Element#empty_label?) is a pass-through joint: the line runs to
     # its center instead of stopping at its (invisible) text box, so the
     # segments on both sides connect without a gap.
+    # One rule across all the premises, in place of a line to each. The rule
+    # runs the width of what it combines — the span from the leftmost child's
+    # left edge to the rightmost child's right edge — because that span is what
+    # the step applies to, and reading it off the children is what keeps it
+    # right when the layout moves.
+    #
+    # Drawn at the parent's edge facing the children, so it sits between the
+    # material above it and the result below in a derivation, and between a
+    # node and its daughters in an ordinary tree.
+    def rule_to_parent(parent, children)
+      return if children.empty?
+
+      # The whole of what the step combines, not the labels of its premises:
+      # a premise stands over a derivation of its own, and the rule is drawn
+      # across all of it. Taken from the subtree extents, which is what the
+      # layout already computes for the same purpose.
+      left = children.map { |c| get_leftmost(c.id) }.min
+      right = children.map { |c| get_rightmost(c.id) }.max
+      # The parent may be wider than everything it combines, which happens when
+      # a category is longer than the words under it. The rule covers both, so
+      # that the label it belongs to is never wider than its own rule.
+      left = [left, parent.horizontal_indent].min
+      right = [right, parent.horizontal_indent + parent.content_width].max
+
+      hctt = @global[:height_connector_to_text]
+      above, below = derivation_rule_band(parent)
+      y = if above
+            (above + hctt + below) / 2.0
+          else
+            child_edge = children.map { |c| c.vertical_indent + c.content_height }.max
+            parent_top = parent.vertical_indent
+            if parent_top >= child_edge
+              # The parent sits below: the rule goes between the two.
+              (child_edge + hctt + parent_top) / 2.0
+            else
+              # The parent sits above (an ordinary top-to-bottom tree).
+              (parent.vertical_indent + parent.content_height + hctt +
+               children.map(&:vertical_indent).min) / 2.0
+            end
+          end
+
+      @tree_data += @line_styles.sub(/X1/, left.to_s).sub(/Y1/, y.to_s)
+                                .sub(/X2/, right.to_s).sub(/Y2/, y.to_s)
+
+      draw_rule_name(parent, right, y)
+    end
+
+    # The name of the rule, set beside the end of its own line and smaller than
+    # the categories, which is where a derivation puts it and how it keeps the
+    # name from reading as part of either row.
+    def draw_rule_name(parent, right, y)
+      name = parent.rule_name
+      return if name.nil? || name.empty?
+
+      size = (@fontsize * 0.8).round(2)
+      # Level with the rule, by the same reckoning an enclosure uses to sit
+      # level with what it encloses.
+      baseline = y + FontMetrics.visual_centre(@fontset[:family], size)
+      x = right + @global[:width_half_x]
+      # The name is the one thing drawn outside every element's own box, so the
+      # canvas has to be told where it ends or the last step's name is cut off
+      # at the edge of the image.
+      edge = x + FontMetrics.get_metrics(name, @fontset[:family], size, :normal, :normal).width
+      @rule_name_edge = edge if edge > @rule_name_edge.to_f
+      @tree_data += @text_styles.sub(/COLOR/, @col_line)
+                                .sub(/fontsize/, size.to_s + "px;")
+                                .sub(/X_VALUE/, x.to_s)
+                                .sub(/Y_VALUE/, baseline.round(2).to_s)
+                                .sub(/CONTENT/) { CGI.escapeHTML(name) }
+    end
+
+    # Where a connector meets each box in a vertical layout: the underside of
+    # whichever sits higher and the top of whichever sits lower. Turned over,
+    # the parent is the lower of the two, and keeping the top-to-bottom edges
+    # sent the line back up through both labels. An empty label has no text to
+    # clear, so the line runs to its middle.
+    def connector_edges(child, parent)
+      hctt = @global[:height_connector_to_text]
+      child_above = child.vertical_indent <= parent.vertical_indent
+
+      child_y = if child.empty_label?
+                  child.vertical_indent + child.content_height / 2
+                elsif child_above
+                  child.vertical_indent + child.content_height + hctt
+                else
+                  child.vertical_indent + hctt / 2
+                end
+
+      parent_y = if parent.empty_label?
+                   parent.vertical_indent + parent.content_height / 2
+                 elsif child_above
+                   parent.vertical_indent + hctt / 2
+                 else
+                   parent.vertical_indent + parent.content_height + hctt
+                 end
+
+      [child_y, parent_y]
+    end
+
     def line_to_parent(parent, child)
       return if child.horizontal_indent.zero?
 
@@ -915,10 +1014,8 @@ module RSyntaxTree
         # TTB: parent's bottom → child's top
         if @polyline
           chi_x = child.horizontal_indent + child.content_width / 2
-          chi_y = child.empty_label? ? child.vertical_indent + child.content_height / 2 : child.vertical_indent + @global[:height_connector_to_text] / 2
-
           par_x = parent.horizontal_indent + parent.content_width / 2
-          par_y = parent.empty_label? ? parent.vertical_indent + parent.content_height / 2 : parent.vertical_indent + parent.content_height + @global[:height_connector_to_text]
+          chi_y, par_y = connector_edges(child, parent)
 
           mid_x1 = chi_x
           mid_y1 = par_y + (chi_y - par_y) / 2
@@ -936,9 +1033,8 @@ module RSyntaxTree
                                         .sub(/PARY/, par_y.to_s)
         else
           x1 = child.horizontal_indent + child.content_width / 2
-          y1 = child.empty_label? ? child.vertical_indent + child.content_height / 2 : child.vertical_indent + @global[:height_connector_to_text] / 2
           x2 = parent.horizontal_indent + parent.content_width / 2
-          y2 = parent.empty_label? ? parent.vertical_indent + parent.content_height / 2 : parent.vertical_indent + parent.content_height + @global[:height_connector_to_text]
+          y1, y2 = connector_edges(child, parent)
 
           line_data   = @line_styles.sub(/X1/, x1.to_s)
           line_data   = line_data.sub(/Y1/, y1.to_s)

data/lib/rsyntaxtree/tikz_generator.rb

@@ -24,6 +24,22 @@ module RSyntaxTree
     def initialize(element_list, params)
       @element_list = element_list
       @params = params
+
+      # forest draws a tree: a parent joined to each daughter by an edge of
+      # its own, the root at the top. A derivation is neither — one rule
+      # across all the daughters at once, the root last — so the code this
+      # backend would emit is a correct tree of the same structure, which is
+      # a different figure rather than this one with something missing. What
+      # it drops elsewhere (colour, enclosures, decoration) leaves a figure
+      # that still says what the tree is. These two do not.
+      if params[:derivation] == true || params[:direction] == "btt"
+        what = params[:derivation] == true ? "a derivation" : "a tree drawn bottom to top"
+        raise RSTError.new(+"Error: TikZ output cannot draw #{what}",
+                           code: :invalid_option,
+                           hint: "forest joins each daughter with its own edge and puts the root " \
+                                 "at the top. Use png, svg or pdf for this figure.",
+                           retryable: false)
+      end
     end
 
     # Generate TikZ forest code

data/lib/rsyntaxtree/utils.rb

@@ -61,30 +61,29 @@ FONT_FAMILIES = {
 }.freeze
 
 module FontFamily
-  # cjk_priority: put the JP font first (mirrors the e[:cjk] branch in
-  # SVGGraph#draw_element). No-op for the :cjk style, which has no variant.
-  def list(style, cjk_priority: false)
-    families = FONT_FAMILIES.fetch(style.to_sym).dup
-    families[0], families[1] = families[1], families[0] if cjk_priority && style.to_sym != :cjk
-    families
+  # One order, used by the measuring and by the drawing alike. There was a
+  # second, with the CJK face moved to the front, which measurement switched to
+  # as soon as any character outside ASCII appeared anywhere in the figure while
+  # the drawing kept to this one — so Latin text was measured in a face it was
+  # not set in. Fontconfig reaches the CJK faces through this order anyway, the
+  # scripts that need them measuring the same either way, so the second order
+  # bought nothing and is gone.
+  def list(style)
+    FONT_FAMILIES.fetch(style.to_sym)
   end
 
-  def for_svg(style, cjk_priority: false)
-    list(style, cjk_priority: cjk_priority).map { |name| name.include?(" ") ? "'#{name}'" : name }.join(", ")
+  def for_svg(style)
+    list(style).map { |name| name.include?(" ") ? "'#{name}'" : name }.join(", ")
   end
 
-  def for_pango(style, cjk_priority: false)
-    list(style, cjk_priority: cjk_priority).join(", ")
+  def for_pango(style)
+    list(style).join(", ")
   end
 
   module_function :list, :for_svg, :for_pango
 end
 
 class String
-  def contains_cjk?
-    !!(gsub(WHITESPACE_BLOCK, "") =~ /\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}|[^\x01-\x7E]/)
-  end
-
   def contains_emoji?
     !!(gsub(WHITESPACE_BLOCK, "").gsub(/\d/, "") =~ /\p{Emoji}/)
   end
@@ -127,6 +126,19 @@ module FontMetrics
   # 1.25x, so mixed-language documents had inconsistent spacing).
   LINE_HEIGHT_FACTOR = 1.4
 
+  # How far below the baseline the visual centre of a line of text sits.
+  #
+  # Text is placed by its baseline, so anything meant to sit level with it — a
+  # box drawn around it, a rule beside it — has to know where the middle of the
+  # marks is. The answer is half the height of a capital, not half of whatever
+  # is written: centring on the marks themselves puts the middle of an `s`
+  # lower than the middle of a `G`, and centring on the whole cap-to-descender
+  # band sits low around digits and capitals, which reach nothing below the
+  # baseline and are most of what a label holds.
+  def visual_centre(font, fontsize)
+    get_metrics("X", font, fontsize, :normal, :normal).ink_above / 2.0
+  end
+
   # Measures text with Pango, the same engine (and the same font fallback
   # resolution) that librsvg uses to render the SVG output, so widths stay
   # consistent with the drawn output for any script. `font` is a
@@ -152,5 +164,5 @@ module FontMetrics
     @pango_layout ||= Pango::Layout.new(Pango::CairoFontMap.default.create_context)
   end
 
-  module_function :get_metrics, :pango_layout
+  module_function :get_metrics, :pango_layout, :visual_centre
 end

data/lib/rsyntaxtree/version.rb

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

data/lib/rsyntaxtree.rb

@@ -58,8 +58,9 @@ OPTION_VALUES = {
   fontstyle: ["sans", "serif", "cjk", "mono", "noto-sans", "noto-serif", "noto-sans-mono", "cjk zenhei"],
   color: %w[modern traditional gray grey off none on true false],
   tidy: %w[off symmetric low medium high on compact true false],
-  direction: %w[ttb ltr],
-  hyphen: %w[markup literal]
+  direction: %w[ttb ltr btt],
+  hyphen: %w[markup literal],
+  derivation: %w[on off true false yes no 0 1 none]
 }.freeze
 
 NUMERIC_RANGES = {
@@ -86,7 +87,8 @@ DEFAULT_OPTS = {
   tidy: "off",
   hspacing: 1.0,
   direction: "ttb",
-  hyphen: "markup"
+  hyphen: "markup",
+  derivation: "off"
 }.freeze
 
 # A parse or generation failure. `message` is the human-readable text the
@@ -202,7 +204,7 @@ module RSyntaxTree
                             else
                               "off"
                             end
-        when :tidy_nest, :symmetrize, :transparent, :polyline, :hide_default_connectors, :mirror
+        when :tidy_nest, :symmetrize, :transparent, :polyline, :hide_default_connectors, :mirror, :derivation
           new_params[key] = switched_on?(value)
         when :color
           new_params[key] = case value.to_s
@@ -234,7 +236,6 @@ module RSyntaxTree
                   else :sans
                   end
           fontset[:family] = FontFamily.for_pango(style)
-          fontset[:family_cjk] = FontFamily.for_pango(style, cjk_priority: style != :cjk)
           new_params[:fontstyle] = style.to_s
         else
           new_params[key] = value
@@ -256,12 +257,43 @@ module RSyntaxTree
       # fall back to the merged default style otherwise
       if fontset[:family].nil?
         fontset[:family] = FontFamily.for_pango(@params[:fontstyle])
-        fontset[:family_cjk] = FontFamily.for_pango(@params[:fontstyle], cjk_priority: true)
       end
       @params[:fontset] = fontset
       single_x_metrics = FontMetrics.get_metrics("X", fontset[:family], @params[:fontsize], :normal, :normal)
       @global = {}
+      # A derivation is written down the page: the rule that joins the
+      # premises is a horizontal line across them, and the result sits under
+      # it. Laid out left to right there is nothing for that line to span, and
+      # the drawing came out with rules struck through the categories. There
+      # is no left-to-right convention for a derivation to fall back on, so
+      # the combination is refused rather than approximated.
+      if @params[:derivation] == true && @params[:direction] == "ltr"
+        raise RSTError.new(+"Error: a derivation cannot be drawn left to right",
+                           code: :invalid_option,
+                           hint: "A derivation runs down the page. Use direction ttb or btt, " \
+                                 "or turn derivation off.",
+                           retryable: false)
+      end
+
+      # Hiding the default connectors draws them in the background colour
+      # rather than skipping them. A derivation's rules are drawn as connectors
+      # but they are the figure itself, not a default the drawing adds, so
+      # hiding them leaves rows of categories floating with nothing joining
+      # them. Refused for the same reason as left to right.
+      if @params[:derivation] == true && @params[:hide_default_connectors] == true
+        raise RSTError.new(+"Error: a derivation's rules cannot be hidden",
+                           code: :invalid_option,
+                           hint: "The rules are what a derivation is drawn with, not a " \
+                                 "connector added to it. Turn off hide default connectors, " \
+                                 "or turn derivation off.",
+                           retryable: false)
+      end
+
       @global[:single_x_metrics] = single_x_metrics
+      # A derivation labels each step with the rule it applied, written at the
+      # right end of the line. Elements need to know, because the name is taken
+      # out of the label before it is measured.
+      @global[:derivation] = @params[:derivation] == true
       @global[:height_connector_to_text] = single_x_metrics.height / 2.0
       @global[:single_line_height] = single_x_metrics.height * 2.0
       @global[:width_half_x] = single_x_metrics.width / 2.0

data/rsyntaxtree.gemspec

@@ -12,10 +12,18 @@ Gem::Specification.new do |s|
   s.description = "Syntax tree generator made with Ruby"
   s.licenses    = ["MIT"]
   s.required_ruby_version = ">= 3.2.0"
-  # Exclude the documentation site (gallery assets), development tools and
-  # tests from the installed gem; they live in the repository.
+  # What the gem carries is what someone installing it needs: the library, the
+  # command, the notation reference the command prints, and the files that say
+  # what this is, how to cite it and under what licence. The rest of the
+  # repository is for working on it — the documentation site and its gallery,
+  # the scripts that build them, the tests, the CI and container setup, the
+  # bundle and the rake tasks — and whoever wants those clones the repository.
+  development = ["docs/", "dev/", "img/", "test/", ".github/"]
+  development_files = [".gitattributes", ".gitignore", ".ruby-version",
+                       "Dockerfile", "Gemfile", "Rakefile"]
   s.files         = `git ls-files`.split("\n").reject do |path|
-                      path.start_with?("docs/", "dev/", "img/", "test/")
+                      development.any? { |dir| path.start_with?(dir) } ||
+                        development_files.include?(path)
                     end
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsyntaxtree
 version: !ruby/object:Gem::Version
-  version: 1.12.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Yoichiro Hasebe
@@ -143,18 +143,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitattributes"
-- ".github/FUNDING.yml"
-- ".github/workflows/test.yml"
-- ".gitignore"
-- ".ruby-version"
 - CHANGELOG.md
 - CITATION.cff
-- Dockerfile
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - bin/rsyntaxtree
 - lib/rsyntaxtree.rb
 - lib/rsyntaxtree/base_graph.rb

data/.gitattributes

@@ -1,10 +0,0 @@
-# Text files are stored with LF and checked out with LF, whatever the
-# editor on the machine does. Two of the documentation pages had drifted
-# to CRLF, which turned a three-line edit into a whole-file diff.
-* text=auto eol=lf
-
-*.png binary
-*.jpg binary
-*.gif binary
-*.pdf binary
-*.gem binary

data/.github/FUNDING.yml

@@ -1,6 +0,0 @@
-# These are supported funding model platforms
-
-github: [yohasebe]
-ko_fi: yohasebe
-buy_me_a_coffee: yohasebe
-# custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

data/.github/workflows/test.yml

@@ -1,35 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ["3.2", "3.4"]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            libpango1.0-dev librsvg2-dev libmagickwand-dev \
-            libgirepository1.0-dev gobject-introspection \
-            fonts-noto-core fonts-noto-cjk
-          sudo fc-cache -f
-
-      - name: Set up Ruby ${{ matrix.ruby-version }}
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true
-
-      - name: Run tests
-        run: bundle exec rake test

data/.gitignore

@@ -1,25 +0,0 @@
-pkg/
-tmp/
-doc/
-.DS_Store
-Gemfile.lock
-
-*.bak
-*.~
-*.log
-*.gem
-log/
-logs/
-
-bin/rsync_code
-bin/linktree.rb
-tags
-.tags
-.rubocop.yml
-.rubocop_todo.yml
-.solargraph.yml
-
-CLAUDE.md
-
-# git filter-branch leaves this behind; it is machinery, not source.
-.git-rewrite/

data/.ruby-version

@@ -1 +0,0 @@
-4.0.1

data/Dockerfile

@@ -1,41 +0,0 @@
-FROM ruby:3.3-alpine
-ENV WORKSPACE=/rsyntaxtree
-WORKDIR $WORKSPACE
-
-RUN apk update && \
-    apk upgrade && \
-    apk add --no-cache linux-headers libxml2-dev make gcc libc-dev bash && \
-    apk add --no-cache librsvg librsvg-dev pango-dev imagemagick imagemagick-dev xz-dev libbz2 && \
-    apk add --no-cache gobject-introspection gobject-introspection-dev && \
-    apk add --no-cache -t .build-packages --no-cache build-base curl-dev wget gcompat && \
-    apk add --no-cache font-noto font-noto-cjk font-noto-cjk-extra \
-        font-noto-arabic font-noto-naskh-arabic font-noto-hebrew \
-        font-noto-devanagari font-noto-thai font-noto-khmer \
-        font-dejavu
-
-# Noto Sans Math (pulled in by font-noto) claims the Arabic block but carries no
-# joining rules, and fontconfig ranks it above Noto Sans Arabic — Arabic then
-# renders as isolated letterforms. Keep the font, since trees use its
-# mathematical alphanumerics (the little v of vP), but drop Arabic from it.
-COPY dev/fontconfig/99-noto-math-no-arabic.conf /etc/fonts/conf.d/99-noto-math-no-arabic.conf
-
-# Emoji: the monochrome Noto Emoji, not Alpine's font-noto-emoji (which is the
-# colour NotoColorEmoji). Cairo does not rasterise its bitmap glyphs in this
-# pipeline, so emoji would silently fall back to whatever outline font happens
-# to cover them. Pinned to a google/fonts commit so the gallery stays stable.
-ARG NOTO_EMOJI_SHA=b979dba422e445492b0eb9951ac52ee0b4d648c3
-ARG NOTO_EMOJI_SHA256=de6c18832938afc99caf132b39d6a30a19bac7f2e812e28db2535b4608d27551
-RUN mkdir -p /usr/share/fonts/noto-emoji && \
-    wget -q -O /usr/share/fonts/noto-emoji/NotoEmoji-Regular.ttf \
-      "https://raw.githubusercontent.com/google/fonts/${NOTO_EMOJI_SHA}/ofl/notoemoji/NotoEmoji%5Bwght%5D.ttf" && \
-    echo "${NOTO_EMOJI_SHA256}  /usr/share/fonts/noto-emoji/NotoEmoji-Regular.ttf" | sha256sum -c -
-
-
-ADD Gemfile $WORKSPACE
-ADD rsyntaxtree.gemspec $WORKSPACE
-RUN bundle install -j4
-
-RUN fc-cache -fv
-
-ADD . $WORKSPACE
-CMD ["/bin/bash"]

data/Gemfile

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gem "optimist"
-gem "pango"
-gem "parslet"
-gem "rmagick"
-gem "rsvg2"
-
-group :development, :test do
-  gem "minitest"
-  gem "nokogiri"
-  gem "rake"
-end

data/Rakefile

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rake/testtask"
-require "yaml"
-require_relative 'lib/rsyntaxtree'
-require_relative 'lib/rsyntaxtree/utils'
-
-# task default: "test"
-
-Rake::TestTask.new do |task|
-    task.pattern = "test/*_test.rb"
-    task.warning = false
-end
-
-# Gem packaging preserves on-disk file modes. Owner-only permissions (which a
-# Dropbox-synced checkout tends to produce) ship files that are unreadable, and
-# a CLI that is unexecutable, for anyone but the owner after `sudo gem install`.
-# Normalize every tracked file before the gem is built: a file is executable
-# only if it is a command (bin/, exe/) or a script with a shebang; everything
-# else is data and gets 0644. Deciding by path/content rather than by the
-# current mode also drops stray executable bits picked up from the filesystem.
-task :normalize_permissions do
-    `git ls-files -z`.split("\x0").each do |f|
-        next unless File.file?(f)
-
-        executable = f.start_with?("bin/", "exe/") ||
-                     File.open(f, "rb") { |io| io.read(2) } == "#!"
-        File.chmod(executable ? 0o755 : 0o644, f)
-    end
-end
-
-Rake::Task["build"].enhance([:normalize_permissions])
-
-# For trying something out. It does NOT reproduce the committed gallery:
-# fontconfig resolves a family to whatever this machine has, so the same input
-# measures differently here than in the image the figures were drawn with. Run
-# over docs/assets it rewrites every PNG and about half the SVGs, none of it an
-# intended change. Use docker_generate to update the gallery.
-desc "Generate SVG and PNG example images locally (not for updating the gallery)"
-task :generate do
-    require_relative "dev/generate_examples"
-end
-
-# What a language model is given: the reference, the manual and every example,
-# built from the files those already live in. Run it after changing any of
-# them; llm_payload_test.rb fails if the built files are out of date.
-desc "Build the notation payload for language models (gem and site)"
-task :llm_payload do
-    ruby "dev/generate_llm_payload.rb"
-end
-
-desc "Record the pixel size of each gallery figure for the examples page"
-task :figure_sizes do
-    ruby "dev/stamp_figure_sizes.rb"
-end
-
-desc "Docker image Build"
-task :docker_build do
-    `docker build ./ -t rsyntaxtree_devel`
-end
-
-# The gallery is drawn here and nowhere else, so that a figure depends on the
-# input and the options rather than on the fonts of whoever regenerated it.
-desc "Generate SVG and PNG example images using Docker image (the gallery)"
-task :docker_generate do
-    docpath = File.expand_path(File.join(__dir__, "docs"))
-    `docker build ./ -t rsyntaxtree_devel`
-    `docker run --rm -v #{docpath}:/rsyntaxtree/hostdocs rsyntaxtree_devel ruby /rsyntaxtree/dev/generate_examples.rb /rsyntaxtree/hostdocs`
-    `cat #{docpath}/generate_examples.log`
-end
-
-# The examples page scales every figure by the size recorded here, so the
-# record has to be refreshed whenever the figures are.
-["generate", "docker_generate"].each do |name|
-    Rake::Task[name].enhance { Rake::Task["figure_sizes"].invoke }
-end
-
-# Add new task for macOS environment configuration
-
-desc "Configure Bundler build options for macOS"
-task :setup_macos do
-    require "rbconfig"
-    host_os = RbConfig::CONFIG['host_os']
-
-    # Check if the host OS is macOS (Darwin)
-
-    if host_os =~ /darwin/
-        puts "macOS detected. Setting up build options for native extensions..."
-
-        gems_with_options = {
-            "gobject-introspection" => '--with-ldflags=-Wl,-undefined,dynamic_lookup',
-            "cairo-gobject"         => '--with-ldflags=-Wl,-undefined,dynamic_lookup',
-            "gio2"                  => '--with-ldflags=-Wl,-undefined,dynamic_lookup'
-        }
-
-        # Configure each gem with the necessary ldflags option using Bundler config command
-
-        gems_with_options.each do |gem_name, flags|
-            command = "bundle config build.#{gem_name} \"#{flags}\""
-            puts "Executing: #{command}"
-            unless system(command)
-                abort("Failed to execute command: #{command}")
-            end
-        end
-
-        puts "macOS setup complete. Please run 'bundle install' after this."
-    else
-        puts "This setup task is intended for macOS environments. Current OS: #{host_os}"
-    end
-end