Usage & API

The public API lives at the module root (github.com/go-ruby-prettyprint/prettyprint). It is Ruby-shaped but Go-idiomatic: the methods mirror Ruby’s PrettyPrint (text/breakable/group/nest/fill_breakable), while the surface follows Go conventions — value types, callbacks for blocks, no global state.

Status: implemented

The library is built and importable as github.com/go-ruby-prettyprint/prettyprint, bound into rbgo as the layout backend; see Roadmap.

Install

go get github.com/go-ruby-prettyprint/prettyprint

Worked example

package main

import (
	"fmt"

	"github.com/go-ruby-prettyprint/prettyprint"
)

func main() {
	// PrettyPrint.format(''.dup, 10) { |q| ... }
	out := prettyprint.Format(10, "\n", nil, func(q *prettyprint.PrettyPrint) {
		q.Group(2, "[", 1, "]", 1, func() {
			q.TextString("111")
			q.BreakableString()
			q.TextString("222")
			q.BreakableString()
			q.TextString("333")
		})
	})
	fmt.Printf("%q\n", out) // "[111\n  222\n  333]"

	// The single-line formatter never breaks: breakables become their separator.
	flat := prettyprint.SingleLineFormat(func(q *prettyprint.SingleLine) {
		q.GroupDefault(func() {
			q.TextString("[")
			q.Breakable("", 0)
			q.TextString("1")
			q.BreakableString()
			q.TextString("2")
			q.TextString("]")
		})
	})
	fmt.Printf("%q\n", flat) // "[1 2]"
}

API map (MRI → Go)

Ruby (`PrettyPrint`)	Go
`PrettyPrint.new(out, maxwidth, nl, &gs)`	`New(maxwidth, newline, genspace)` / `NewDefault()`
`PrettyPrint.format(...)`	`Format(maxwidth, newline, genspace, fn)` / `FormatDefault`
`PrettyPrint.singleline_format(...)`	`SingleLineFormat(fn)`
`#text(obj, width)`	`Text(obj, width)` / `TextString(obj)`
`#breakable(sep, width)`	`Breakable(sep, width)` / `BreakableString()`
`#group(indent, open, close, ow, cw)`	`Group(indent, open, ow, close, cw, fn)` / `GroupDefault(fn)`
`#group_sub`	`GroupSub(...)` / `NestedGroup(fn)`
`#nest(indent)`	`Nest(indent, fn)`
`#fill_breakable(sep, width)`	`FillBreakable(sep, width)` / `FillBreakableString()`
`#current_group`	`CurrentGroup()`
`#break_outmost_groups`	`BreakOutmostGroups()`
`#flush`	`Flush()`
`PrettyPrint::VERSION`	`VERSION`

The default genspace is DefaultGenSpace (n ASCII spaces); pass nil to New / Format to use it.

Capabilities

Groups that print flat when they fit and break at their breakables when they overflow maxwidth — the exact break_outmost_groups / depth-bucketed GroupQueue algorithm MRI uses, so nested groups break outermost-first.
Breakables — breakable(sep, width) line-break hints that emit their separator when the line is not broken, with the width argument for multibyte or proportional separators.
Nesting / indentation — nest(indent) and the group(indent, …) indent argument, with a pluggable genspace block for the indentation string.
Open/close text — group(indent, open, close) wrapping the block in bracketing text counted toward the fit decision.
Fill mode — fill_breakable, where each break is decided individually.
The single-line formatter — singleline_format, where breakables become their separator text and nothing ever breaks.
Custom newline and custom maxwidth, matching MRI’s PrettyPrint.new / PrettyPrint.format signatures.

MRI conformance

Correctness is defined by reference Ruby. A differential oracle runs a shared corpus through both this package and a generated PrettyPrint.format / singleline_format script and asserts the output is identical, not approximated from memory. It binmodes stdout/stdin (so Windows text-mode never rewrites the bytes), skips when ruby is absent, and gates on RUBY_VERSION >= "4.0". The deterministic golden + white-box tests alone hold the 100% gate on every platform, including Windows and the qemu cross-arch lanes.

Relationship to Ruby

go-ruby-prettyprint/prettyprint is standalone and reusable, and is the layout backend bound into go-embedded-ruby by rbgo — the same way go-ruby-yaml and go-ruby-marshal are bound. The pp object inspector that drives it stays host-side; the dependency runs the other way, with no dependency on the Ruby runtime.

Why pure Go Roadmap