Shannon Skipper havenwood

## irc_example.rb
chars = str
  .split
  .map(&:chars)
  .reduce(&:zip)
  .each_slice(2)
  .map(&:join)
  .map(&:chars)

chars.map { |char| char.map(&HASH) }

## object.rb
foo = Object.new

def foo.value
  42
end

foo.value
#=> 42

bar = Object.new

## optional.rb
# frozen_string_literal: true

class Optional
  attr_reader :value

  def initialize(value)
    @value = value
  end

  def then(&block)

## async.rb
require 'async'

condition = Async::Condition.new

Async do
  task_one = Async do
    loop do
      puts 'task one before waiting'
      condition.wait
    end

## node.rb
# frozen_string_literal: true

class Node
  attr_reader :value
  attr_reader :parent

  def initialize(value:, parent: nil)
    @value = value
    @parent = parent
  end

## erb.rb
require 'erb'
require 'psych'

topic = :users
users = %w[wombat fox poodle]

template = ERB.new <<~END, trim_mode: '-'
---
:<%= topic %>:
<%- users.each do |user| %>

## make_it_work.rb
class Foo
  def initialize(a, b, c:)
    puts 'Foo!'
  end
end

class MakeItWork < Foo
  def initialize(*args, **kwargs, &block)
    parameters = method(__method__).super_method.parameters

## response_enumerator.rb
class ResponseEnumerator < Enumerator
  DEFAULT_PER_PAGE = 25

  attr_accessor :per_page

  def initialize(square, http_verb:, path:, data:,
                 fields:, parameters: {}, memoize: true, per_page: nil)
    @per_page = per_page || DEFAULT_PER_PAGE
    @memoized_responses = []
    @params = parameters.fetch :params

## cipher.rb

secret = 'cicada'
key = 'wombat'

cipher = OpenSSL::Cipher::AES256.new :CBC
cipher.encrypt
salt = OpenSSL::Random.random_bytes 16
cipher.key = OpenSSL::PKCS5.pbkdf2_hmac_sha1 key, salt, 20000, 32
iv = cipher.random_iv

## delegate_class.rb
class FerretString < String
  def to_s
    'Successfully overrode ...'
  end
end

class WombatString < DelegateClass(String)
  def initialize
    super('')
  end