Some Tools

... which tools?

Context: MyStruct

All the goodies of OpenStruct without the badies:

Immutable
Deconstructable (→ Patternmatchable)
Hashy Interface (fetch, merge, slice...)

Given an instance of MyStruct constructed from a Hash

  require 'ex_aequo/my_struct'
  let(:from_hash) { MyStruct.new(a: 1, b: 2) }

And an instance constructed by a reducer

    let(:incremented) { MyStruct.from_reduce(%i[a b c d e], 0) { _1.succ } }

Then they can be accessed like a Hash or OpenStruct

    expect(from_hash[:a]).to eq(1)
    expect(from_hash.fetch(:b)).to eq(2)
    expect(incremented[:e]).to eq(5)

And they are immutable

  expect { from_hash[:c] = 3 }
    .to raise_error(MyStruct::ImmutableError, 'cannot change values with []= in immutable instance of MyStruct')

And mutable operations just create new objects

  expect(from_hash.merge(c: 3)).to eq(MyStruct.new(a: 1, b: 2, c: 3))
  expect(from_hash.to_h).to eq(a: 1, b: 2)

And the hashy methods observer the same interface

    expect { from_hash.fetch(:c) }
      .to raise_error(KeyError, 'key :c not found in #<MyStruct a=1, b=2> and no default given to #fetch')

    expect(from_hash.fetch(:c, 42)).to eq(42)
    expect(from_hash.fetch(:c) { 43 }).to eq(43)

    expect(incremented.slice(:a, :c, :e)).to eq(MyStruct.new(a: 1, c: 3, e: 5))

Context: ArgsParser and Args

An expressive, yet simple argument parser that takes full advantage of Ruby 3 and returns a modern Args struct (with modern I mean MyStruct) as a result.

Given a simple example like this on

  let(:simple_parser) do
    ExAequo::ArgsParser.new(
      allowed: %w[alpha: beta: :help :verbose],
      aliases: {h: :help, v: :verbose, a: :alpha}
    )
  end

Then, as northing is required we can successfully parse empty arguments

  result = simple_parser.parse([])

  expect(result).to be_ok
  expect(result.missing).to be_empty
  expect(result.superflous).to be_empty
  expect(result.positionals).to be_empty
  expect(result.keywords).to eq(MyStruct.new)

And, we can also provide allowed values (N.B. ruby sytnax is default)

  result = simple_parser.parse(%w[alpha: 42 43])

  expect(result).to be_ok
  expect(result.missing).to be_empty
  expect(result.superflous).to be_empty
  expect(result.positionals).to eq(%w[43])
  expect(result.keywords).to eq(MyStruct.new(alpha: '42'))

Context: Colors

Given the inclusion of the Color module

  include ExAequo::Color

Then we can create ansi colored strings

  expect(ansi(:red)).to eq("\e[31m")

Or we can create 256 color strings

  expect(ansi256(100)).to eq("\e[38;5;100m")

Or we can use RGB colors

  expect(rgb(96,32,16)).to eq("\e[38;2;96;32;16m")
  expect(rgb('#602010')).to eq("\e[38;2;96;32;16m")

Context: Colorize Helper

And

  expect(colorize('red', ansi: :green)).to eq("\e[32mred\e[0m")

Or we can omit the reset

  expect(colorize('red', ansi: :green, reset: false)).to eq("\e[32mred")

Context: Colorize Text

Given we include the Color::Text module

  require 'ex_aequo/color/text'
  include ExAequo::Color::Text

Then we can obtain a colored text as follows

   expect(colorized_text(:red, 'green', :yellow, 'blue', :reset, 'white'))
    .to eq("\e[31mgreen\e[33mblue\e[0mwhite")

Other Tools are described here

LICENSE

Apache-2.0 c.f LICENSE