pretty_tree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8901c02377ffae134b6db07c23e714032a9673464c7cbb866e4696f83aedd623
+  data.tar.gz: 1b4442d03bc01ffd6719f5ca509e985e3b1ea6b517c4043fb7abc62324b8284e
+SHA512:
+  metadata.gz: c9f0c54c4e0d93e65c2e3aadc15d352d8b51751c891c1be760fa59c633fea0c9d64b900b47a7544b2fe58ea5aadf8dd83d2433cd946131d7892d375ecac70492
+  data.tar.gz: 9708437a157ede479cc7ffe932bb4723124be884a24f3481b3d0aa55f780b18eb4016258d5dbfc96a3c2b0ec061d26080c8e726cf480f2103e2c9c97088986b9

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-30
+
+### Added
+
+- `PrettyTree.render` and `PrettyTree.print` draw a tree as an ASCII diagram.
+- Layouts for nodes with one, two, three or more children, with `nil` marking an
+  empty slot.
+- `Adapter` interface for rendering any node type, with a default `ArrayTree`
+  adapter for nested arrays.
+- `Formatter` interface for labels, with a default formatter that uses `#inspect`
+  and truncates long labels.
+- `PrettyTree.preview` prints example trees.
+- `PrettyTree::Error` is raised for invalid nested-array trees.
+
+[Unreleased]: https://github.com/riccardo-giomi/pretty_tree/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/riccardo-giomi/pretty_tree/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Riccardo Giomi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# PrettyTree
+
+Pretty-print tree-shaped data as readable ASCII diagrams — for `#inspect` output, log lines, or debugging.
+
+```ascii
+                 1
+       __________|__________
+      /          |          \
+     2           6          10
+   / | \       / | \       / | \
+  /  |  \     /  |  \     /  |  \
+ 3   4   5   7   8   9  11  12  13
+```
+
+## Installation
+
+```bash
+bundle add pretty_tree
+```
+
+Or, without Bundler:
+
+```bash
+gem install pretty_tree
+```
+
+## Usage
+
+Out of the box, PrettyTree understands nested arrays, where each node is
+`[value, *children]` and `nil` marks an empty child slot:
+
+```ruby
+require "pretty_tree"
+
+tree = ["a", ["b", nil, nil], ["c", ["d", nil, nil], nil]]
+
+PrettyTree.print(tree)
+# =>
+#    "a"
+#   /   \
+#  /     \
+#"b"     "c"
+#        /
+#       /
+#     "d"
+```
+
+`PrettyTree.render(tree)` returns the diagram as a `String` instead of printing
+it, for use in `#inspect` or logging:
+
+```ruby
+def inspect
+  PrettyTree.render(self)
+end
+```
+
+### Preview
+
+`PrettyTree.preview` will print a collection of example trees as a preview, call it from `irb` or a script:
+
+```ruby
+require "pretty_tree"
+
+PrettyTree.preview
+```
+
+### Custom node types
+
+Any tree shape can be rendered by providing an `Adapter` — an object that knows how to read a node's value and children:
+
+```ruby
+class MyAdapter < PrettyTree::Adapter
+  def value(node) = node.name
+  def children(node) = node.kids
+end
+
+PrettyTree.render(my_tree, adapter: MyAdapter.new)
+```
+
+An adapter must follow this contract:
+
+- `value(node)` returns the node's value: any object your `Formatter` can turn
+  into a label.
+- `children(node)` returns an object that responds to `#each` (an `Array`, a
+  `Set`, an `Enumerator`, any `Enumerable`), and never `nil`. It yields the
+  node's children in order, from left to right. Use `nil` for an empty slot: a
+  slot keeps its position, so `[left, nil]` and `[nil, right]` are different
+  trees. No children, or only `nil`s, makes the node a leaf.
+- The adapter is never called with `nil`: an empty slot is drawn as empty space
+  without asking the adapter about it.
+- Anything else is up to the adapter. PrettyTree does not look at the children
+  themselves, only at what `children` returns, and raises `PrettyTree::Error`
+  if that does not respond to `#each`.
+
+A `Formatter` controls how a value is turned into a label (defaults to
+`#inspect`). `label` receives the value and a `max_width:` keyword, which it can
+use to shorten long labels, and returns the label; whatever it returns is
+converted with `to_s`:
+
+```ruby
+class MyFormatter < PrettyTree::Formatter
+  def label(value, max_width: nil) = value.to_s.upcase
+end
+
+PrettyTree.render(my_tree, formatter: MyFormatter.new)
+```
+
+The structure must be a tree: PrettyTree does not detect cycles, so an adapter
+whose `children` leads back to an ancestor raises `SystemStackError`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, then run
+`bundle exec rake release`.
+
+`rake preview` will call `PrettyTree.preview`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/riccardo-giomi/pretty_tree.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+desc "Print example trees"
+task :preview do
+  require_relative "lib/pretty_tree"
+  PrettyTree.preview
+end
+
+task default: %i[test standard]

data/lib/pretty_tree/adapter/array_tree.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../adapter"
+
+# Adapter for trees represented as nested arrays.
+#
+# Example, binary tree:
+#
+#        c
+#      /   \
+#     b     d
+#   /      /  \
+# a       e    f
+#
+# ["c",
+#   ["b",
+#     ["a", nil, nil]
+#   ],
+#   ["d",
+#     ["e", nil, nil],
+#     ["f", nil, nil]
+#   ]
+# ]
+#
+module PrettyTree
+  class Adapter
+    class ArrayTree < PrettyTree::Adapter
+      def validate(node)
+        unless node.is_a?(Array) && !node.empty?
+          got = node.is_a?(Array) ? "[]" : node.class.name
+          raise PrettyTree::Error, "invalid tree node, expected non-empty Array, got #{got}"
+        end
+      end
+
+      def value(node)
+        validate(node)
+        node.first
+      end
+
+      def children(node)
+        validate(node)
+        children = node[1...]
+
+        children.each { |node| validate(node) unless node.nil? }
+
+        children
+      end
+    end
+  end
+end

data/lib/pretty_tree/adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Reads a tree node's value and children.
+#
+# Adapters are never called with nil: the renderer treats a nil node as an empty
+# slot and does not ask the adapter about it.
+#
+# #value(node)    - anything the Formatter can turn into a label.
+# #children(node) - responds to #each, never nil. Yields the child nodes in
+#                   order, with nil marking an empty slot.
+module PrettyTree
+  class Adapter
+    def value(node)
+      raise NotImplementedError, "#{self.class} must implement #value"
+    end
+
+    def children(node)
+      raise NotImplementedError, "#{self.class} must implement #children"
+    end
+  end
+end

data/lib/pretty_tree/box.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# A rectangular block of text: some lines, all the same width, plus an `anchor
+# column`. It represents a rendered sub-tree.
+#
+# The anchor column is the column (within that block) where the node's label is
+# centered.
+#
+module PrettyTree
+  # lines:   Array<String>, each exactly :width characters
+  # anchor:  0-indexed column
+  Box = Struct.new(:lines, :width, :anchor, :empty) do
+    def self.leaf(label, anchor: label.size / 2, empty: false)
+      new(lines: [label], width: label.size, anchor:, empty:)
+    end
+
+    # An empty box can still have a label if the layout renders it as empty
+    # spaces for spacing.
+    def self.empty(label, anchor: label.size / 2)
+      leaf(label, anchor:, empty: true)
+    end
+
+    def height = lines.size
+    def empty? = !!empty
+  end
+end

data/lib/pretty_tree/formatter/default.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Defines how a node label is formatted in the string ouput.
+#
+# This is the default behaviour:
+# - for labels call #inspect on the value, then truncate to min_width.
+module PrettyTree
+  class Formatter
+    class Default < PrettyTree::Formatter
+      # Format as inspect, then truncate with "..." if max_width allows.
+      def label(value, max_width: nil)
+        text = value.inspect
+        return text if max_width.nil? || text.length <= max_width
+        return text[0, max_width] if max_width <= 3
+        "#{text[0, max_width - 3]}..."
+      end
+    end
+  end
+end

data/lib/pretty_tree/formatter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PrettyTree
+  class Formatter
+    def label(value, max_width: nil)
+      raise NotImplementedError, "#{self.class} must implement #label"
+    end
+  end
+end

data/lib/pretty_tree/layout.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require_relative "box"
+
+module PrettyTree
+  module Layout
+    GAP = 1
+
+    def self.empty_box(parent_arity:)
+      layout_class_for(parent_arity).empty_box
+    end
+
+    def self.node_box(label, child_boxes, parent_arity:, position:)
+      return layout_class_for(parent_arity).leaf_box(label, position:) if child_boxes.all?(&:empty?)
+
+      label = Base.pad_label(label)
+
+      layout = layout_for(child_boxes)
+      lines, width, offsets = layout.merge
+
+      anchor = layout.label_anchor(offsets)
+      lines, width, offsets, anchor = layout.accommodate_parent_label(lines, width, offsets, anchor, label.length)
+
+      label_line = layout.render_label_line(label, width, anchor)
+      connector_lines = layout.render_connector_lines(label, anchor, offsets, width)
+
+      new_lines = [label_line] + connector_lines + lines
+      Box.new(lines: new_lines, width:, anchor:, empty: false)
+    end
+
+    def self.layout_class_for(size)
+      case size
+      when 1
+        Unary
+      when 2
+        Binary
+      when 3
+        Ternary
+      else
+        Generic
+      end
+    end
+
+    def self.layout_for(boxes)
+      layout_class_for(boxes.size).new(boxes)
+    end
+
+    class Base
+      MIN_LEAF_SIZE = 3 # Required to allow space for connector symbols
+
+      def self.pad_label(label) = label.to_s.center(MIN_LEAF_SIZE)
+
+      def self.leaf_box(label, position:) = Box.leaf(pad_label(label))
+      def self.empty_box = Box.empty(pad_label(nil))
+
+      def initialize(boxes)
+        @boxes = boxes
+      end
+
+      def merge
+        height = @boxes.map(&:height).max
+
+        lines = Array.new(height) { "" }
+        offsets = []
+        @boxes.each_with_index do |box, i|
+          offsets << lines.first.length + box.anchor
+
+          padded_lines(box, height).each_with_index do |line, j|
+            lines[j] += line
+            # Do not gap the last box
+            lines[j] += " " * GAP unless i == @boxes.size - 1
+          end
+        end
+
+        [lines, lines.first.length, offsets]
+      end
+
+      def padded_lines(box, height)
+        return box.lines if box.height == height
+
+        padding = Array.new(height - box.height) { " " * box.width }
+        box.lines + padding
+      end
+
+      def render_label_line(label, width, anchor)
+        label_start = anchor - label.length / 2
+        line = " " * width
+        line[label_start, label.length] = label
+        line
+      end
+
+      # Ensures that the box created by merging the children subtrees is not
+      # smaller than the parent label, including the fact that the label does not
+      # start from the beginning of its line.
+      def accommodate_parent_label(lines, width, offsets, anchor, label_length)
+        label_left = label_length / 2
+        label_right = label_length - label_left
+
+        left_pad = [label_left - anchor, 0].max
+        anchor += left_pad
+        right_pad = [anchor + label_right - (width + left_pad), 0].max
+
+        return [lines, width, offsets, anchor] if left_pad.zero? && right_pad.zero?
+
+        lines = lines.map { |line| (" " * left_pad) + line + (" " * right_pad) }
+        [lines, width + left_pad + right_pad, offsets.map { |o| o + left_pad }, anchor]
+      end
+
+      def render_left_branch(lines, parent_label, parent_anchor, offsets)
+        anchor = offsets.first
+        first_parent_label_char = parent_anchor - parent_label.length / 2
+        labels_distance = first_parent_label_char - (anchor + 2)
+        anchors_distance = parent_anchor - (anchor + 2)
+
+        if labels_distance > 1
+          lines[0][anchor + 2, anchors_distance + 1] = "_" * anchors_distance + "|"
+        else
+          lines[0][anchor + 2] = "/"
+        end
+        lines[1][anchor + 1] = "/"
+
+        lines
+      end
+
+      def render_middle_branch(lines, anchor)
+        lines[0][anchor] = "|"
+        lines[1][anchor] = "|"
+
+        lines
+      end
+
+      def render_right_branch(lines, parent_label, parent_anchor, offsets)
+        anchor = offsets.last
+        last_parent_label_char = parent_anchor + parent_label.length / 2
+        anchors_distance = anchor - 2 - parent_anchor
+        labels_distance = (anchor - 2) - last_parent_label_char
+        if labels_distance > 1
+          lines[0][parent_anchor, anchors_distance + 1] = "|" + "_" * anchors_distance
+        else
+          lines[0][anchor - 2] = "\\"
+        end
+        lines[1][anchor - 1] = "\\"
+
+        lines
+      end
+    end
+
+    class Unary < Base
+      def label_anchor(offsets)
+        offsets.first
+      end
+
+      def render_connector_lines(_parent_label, _parent_anchor, offsets, width)
+        lines = Array.new(2) { " " * width }
+
+        lines = render_middle_branch(lines, offsets.first) unless @boxes.first.empty?
+
+        lines
+      end
+    end
+
+    class Binary < Base
+      CONNECTOR_SPAN = 3
+      MIN_ANCHORS_DISTANCE = 2 * CONNECTOR_SPAN
+
+      # Binary leaves require more space for connector symbols
+      def self.leaf_box(label, position:)
+        padded = pad_label(label)
+        return Box.leaf(padded + " ", anchor: padded.size / 2) if position == 0
+
+        Box.leaf(" " + padded, anchor: padded.size / 2 + 1)
+      end
+
+      def self.empty_box = Box.empty("")
+
+      def label_anchor(offsets)
+        return offsets.last - CONNECTOR_SPAN if @boxes.first.empty?
+        return offsets.first + CONNECTOR_SPAN if @boxes.last.empty?
+
+        offsets.first + (offsets.last - offsets.first) / 2
+      end
+
+      def merge
+        lines, width, offsets = super
+        return [lines, width, offsets] if @boxes.any?(&:empty?)
+
+        spread = MIN_ANCHORS_DISTANCE - (offsets.last - offsets.first)
+        return [lines, width, offsets] unless spread.positive?
+
+        lines = lines.map { |line| line.dup.insert(@boxes.first.width, " " * spread) }
+        [lines, width + spread, [offsets.first, offsets.last + spread]]
+      end
+
+      def render_connector_lines(parent_label, parent_anchor, offsets, width)
+        lines = Array.new(2) { " " * width }
+
+        lines = render_left_branch(lines, parent_label, parent_anchor, offsets) unless @boxes.first.empty?
+        lines = render_right_branch(lines, parent_label, parent_anchor, offsets) unless @boxes.last.empty?
+
+        lines
+      end
+    end
+
+    class Ternary < Base
+      def label_anchor(offsets)
+        offsets[1]
+      end
+
+      def render_connector_lines(parent_label, parent_anchor, offsets, width)
+        lines = Array.new(2) { " " * width }
+
+        lines = render_left_branch(lines, parent_label, parent_anchor, offsets) unless @boxes.first.empty?
+        lines = render_middle_branch(lines, offsets[1]) unless @boxes[1].empty?
+        lines = render_right_branch(lines, parent_label, parent_anchor, offsets) unless @boxes.last.empty?
+
+        lines
+      end
+    end
+
+    class Generic < Base
+      def initialize(boxes)
+        super(boxes.reject(&:empty?))
+      end
+
+      def label_anchor(offsets)
+        middle_or_middle_right_index = offsets.size / 2
+        middle_or_middle_right_offset = offsets[middle_or_middle_right_index]
+
+        return middle_or_middle_right_offset if offsets.size.odd?
+
+        middle_left_offset = offsets[middle_or_middle_right_index - 1]
+
+        middle_left_offset + ((middle_or_middle_right_offset - middle_left_offset) / 2)
+      end
+
+      def render_connector_lines(parent_label, parent_anchor, offsets, width)
+        lines = Array.new(2) { " " * width }
+
+        return render_middle_branch(lines, offsets.first) if offsets.size == 1
+
+        # Single line from (first adjusted anchor + 1) to (last adjusted anchor - 1)
+        from = offsets.first + 1
+        to = offsets.last
+        lines[0][from...to] = "_" * (to - from)
+        # With a single | breaking the line under the parent anchor
+        lines[0][parent_anchor] = "|"
+
+        # Second line is just a "|" over each adjusted anchor
+        offsets.each do |offset|
+          lines[1][offset] = "|"
+        end
+
+        lines
+      end
+    end
+  end
+end

data/lib/pretty_tree/preview.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PrettyTree
+  class Preview
+    def initialize(...)
+      @renderer = Renderer.new(...)
+    end
+
+    def render(tree)
+      puts
+      puts tree.inspect
+      puts
+      puts @renderer.call(tree)
+      puts
+    end
+
+    def run
+      render(nil)
+      render(["a"])
+      render(["morethan10chars"])
+      render([1, [2, nil, nil]])
+      render([1, [2, [3, nil, nil]]])
+      render(["a", ["b", nil, nil], nil])
+      render(["a", nil, ["c", nil, nil]])
+      render(["a", ["b", nil, nil], ["c", nil, nil]])
+      render([1, [2, [3, [4]]], [5, [6]]])
+      render(["a", ["b", nil, nil], ["c", nil, nil], ["d", nil, nil]])
+      render([1, ["a", ["b", nil, nil], ["c", nil, nil], ["d", nil, nil]], nil])
+      render([1, nil, ["a", ["b", nil, nil], ["c", nil, nil], ["d", nil, nil]]])
+      render([1, nil, ["a", ["b", nil, nil], ["c", nil, nil], ["d", nil, nil]], nil])
+      render([123456789012, [2, nil, nil], [6, nil, nil], [7, nil, nil]])
+      render([1, ["a", ["b", nil, nil], ["c", nil, nil]], ["d", ["e", nil, nil], ["f", nil, nil]]])
+      render([1, ["a", ["b", nil, nil], ["c", nil, nil], ["d", nil, nil]], ["e", ["f", nil, nil], ["g", nil, nil], ["h", nil, nil]]])
+      render([1, [2, [3, nil, nil], [4, nil, nil], [5, nil, nil]], [6, [7, nil, nil], [8, nil, nil], [9, nil, nil]], [10, [11, nil, nil], [12, nil, nil], [13, nil, nil]]])
+      render([1, [2, nil, nil], [6, [7, nil, nil], [8, nil, nil], [9, nil, nil]], [10, [11, nil, nil], [12, nil, nil], [13, nil, nil]]])
+      render([1337, ["aaaa", ["bbbb", nil, nil], ["cccc", nil, nil], ["dddd", nil, nil]], ["eeee", ["ffff", nil, nil], ["gggg", nil, nil], ["hhhh", nil, nil]]])
+      render(["a" * 1, ["b" * 10, nil, nil], ["c" * 10, nil, nil]])
+      render(["a" * 10, ["b" * 10, nil, nil], ["c" * 10, nil, nil]])
+      render(["a" * 1, ["b" * 10, ["c" * 10, nil, nil], ["d" * 10, nil, nil]], ["e" * 10, ["f" * 10, nil, nil], ["g" * 10, nil, nil]]])
+      render(["a" * 10, ["b" * 10, ["c" * 10, nil, nil], ["d" * 10, nil, nil]], ["e" * 10, ["f" * 10, nil, nil], ["g" * 10, nil, nil]]])
+      render(["root", ["leftlongsubtree", ["a", nil, nil], ["b", nil, nil]], ["r", nil, nil]])
+      render(["root", ["l", nil, nil], ["rightlongsubtree", ["a", nil, nil], ["b", nil, nil]]])
+      render(["root", ["leftlongsubtree", ["a", nil, nil], ["b", nil, nil]], ["m", nil, nil], ["rightlongsubtree", ["c", nil, nil], ["d", nil, nil]]])
+      render([786494, ["dvy", nil, nil, ["", nil, [true, nil, nil], ["cmv", nil]]]])
+      render(["root", [1, nil, nil, nil, nil]])
+      render(["root", [1, nil, nil, nil, nil], [2, nil, nil, nil, nil], [3, nil, nil, nil, nil], [4, nil, nil, nil, nil]])
+      render(["root", [1, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [2, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [3, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [4, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]]])
+      render(["root", [1, nil, nil, nil, nil, nil], [2, nil, nil, nil, nil, nil], [3, nil, nil, nil, nil, nil], [4, nil, nil, nil, nil, nil], [5, nil, nil, nil, nil, nil]])
+      render(["root", [1, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [2, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [3, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [4, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]], [5, ["a", ["A"]], ["b", ["B"]], ["c", ["C"]]]])
+    end
+  end
+end

data/lib/pretty_tree/renderer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "layout"
+
+module PrettyTree
+  class Renderer
+    LABEL_WIDTH = 12
+
+    def initialize(adapter:, formatter:, max_width: LABEL_WIDTH)
+      @adapter = adapter
+      @formatter = formatter
+      @max_width = max_width
+    end
+
+    def call(tree) = box_for(tree).lines.join("\n")
+
+    def box_for(node, parent_arity: 1, position: 0)
+      return Layout.empty_box(parent_arity:) if node.nil?
+
+      label = @formatter.label(@adapter.value(node), max_width: @max_width)
+      children = @adapter.children(node)
+
+      raise Error, "children must respond to #each" unless children.respond_to?(:each)
+
+      # Visit all children, merge getting back from the recursion
+      children = children.to_a
+      child_boxes = children.each_with_index.map do |node, i|
+        box_for(node, parent_arity: children.size, position: i)
+      end
+
+      Layout.node_box(label, child_boxes, parent_arity:, position:)
+    end
+  end
+end

data/lib/pretty_tree/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PrettyTree
+  VERSION = "0.1.0"
+end

data/lib/pretty_tree.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "pretty_tree/version"
+
+require_relative "pretty_tree/adapter"
+require_relative "pretty_tree/adapter/array_tree"
+require_relative "pretty_tree/formatter"
+require_relative "pretty_tree/formatter/default"
+
+require_relative "pretty_tree/renderer"
+
+module PrettyTree
+  class Error < StandardError; end
+
+  def self.render(tree, adapter: Adapter::ArrayTree.new, formatter: Formatter::Default.new)
+    Renderer.new(adapter:, formatter:).call(tree)
+  end
+
+  def self.print(tree, adapter: Adapter::ArrayTree.new, formatter: Formatter::Default.new)
+    puts render(tree, adapter:, formatter:)
+  end
+
+  # Prints some example trees as a preview of the output.
+  def self.preview(adapter: Adapter::ArrayTree.new, formatter: Formatter::Default.new)
+    require_relative "pretty_tree/preview"
+    Preview.new(adapter:, formatter:).run
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: pretty_tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Riccardo Giomi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  PrettyTree renders tree-shaped data as readable ASCII diagrams.
+
+  Useful in #inspect output, log lines, or anywhere you want to see a tree's structure at a glance instead of a nested inspect dump.
+
+  Works out of the box with nested-array trees, and extends to any node type via a small Adapter/Formatter interface.
+email:
+- riccardo.giomi.contact@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pretty_tree.rb
+- lib/pretty_tree/adapter.rb
+- lib/pretty_tree/adapter/array_tree.rb
+- lib/pretty_tree/box.rb
+- lib/pretty_tree/formatter.rb
+- lib/pretty_tree/formatter/default.rb
+- lib/pretty_tree/layout.rb
+- lib/pretty_tree/preview.rb
+- lib/pretty_tree/renderer.rb
+- lib/pretty_tree/version.rb
+homepage: https://github.com/riccardo-giomi/pretty_tree
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/riccardo-giomi/pretty_tree
+  source_code_uri: https://github.com/riccardo-giomi/pretty_tree
+  changelog_uri: https://github.com/riccardo-giomi/pretty_tree/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.22
+specification_version: 4
+summary: Renders a tree as a string, prettily.
+test_files: []