I built a Ruby gem so I don't have to squint at hash dumps anymore

I love Ruby. I love the console. I do not love this:

{:name=>"Alice", :score=>100, :active=>true}
{:name=>"Bob", :score=>42, :active=>false}

When you have 20 of these in a row, good luck reading anything.

So I built a tiny gem called typed_print.

What does it do?

One thing. Just one.

It turns hashes into clean, aligned tables.

require 'typed_print'

data = [
  { name: "Alice", score: 100, active: true },
  { name: "Bob", score: 42, active: false }
]

TypedPrint.print(data)

Output

 Name  Score Active 
------+------+-------
Alice   100 true   
Bob      42 false

That's it. No magic. No mental parsing.

Why not just use pp or awesome_print?

pp is fine, but still hard to scan.
awesome_print is great, but sometimes you don't want colors, JSON support, or 10 dependencies.

I wanted something that:

Has zero required dependencies
Only does tables
Works everywhere (Rails, Rake tasks, plain Ruby scripts, even minimal Docker containers)

What can you do with it?

1. Align columns

TypedPrint.print(data, align: { score: :right })

2. Show only what you need

TypedPrint.print(data, only: [:name, :score])

3. Custom headers

TypedPrint.print(data, headers: { name: "User", score: "Points" })

4. Markdown output (great for docs)

TypedPrint.print(data, format: :markdown)

Outputs a proper markdown table you can copy into GitHub READMEs.

5. Colors! (v0.3.0)

TypedPrint.print(data, color: true)

Or full control:

TypedPrint.print(data, colors: { name: :cyan, score: :green, active: :yellow })

Pastel is optional. If you don't have it, colors are ignored. No errors.

Example with different data types

mixed = [
  { name: "Product A", price: 29.99, in_stock: true, notes: nil },
  { name: "Product B", price: 49.99, in_stock: false, notes: "Limited" }
]

TypedPrint.print(mixed)

Output:

   Name      Price In_stock Notes        
----------+-------+---------+-------------
Product A   29.99 true                  
Product B   49.99 false    Limited edition

It handles nil, booleans, numbers, and strings automatically.

What about performance?

It's lightweight. Zero dependencies means no hidden bloat.
I've tested it with 10,000 rows. Still fast enough for CLI tools and debugging.
For massive datasets? You probably shouldn't print them to the terminal anyway.

Who is this for?

Rails developers who debug in the console
CLI tool authors who want clean output
Anyone who logs hashes and wants them readable
People who are tired of pp

What's next?

I'm keeping it simple. No roadmap to become a bloated framework.

But if you have an idea that fits the "zero-dependency, just tables" philosophy – open an issue. I shipped markdown support within hours of a user request (that was v0.2.0).