Ruby: Blocks, Enumerable, Mixins and Pattern Matching Reference Guide

# Install via rbenv (recommended) or asdf
brew install rbenv ruby-build
rbenv install 3.3.0
rbenv global 3.3.0

# Verify
ruby -v                                # ruby 3.3.0 ...
gem -v && bundler -v

# New project
mkdir myapp && cd myapp
bundle init                            # creates Gemfile
bundle add sinatra puma                # add deps
bundle install                         # install + write Gemfile.lock

# Daily commands
ruby script.rb                         # run a file
bundle exec rspec                      # run tests in the bundle's context
irb -r ./lib/myapp                     # REPL with your code loaded
bundle exec rubocop -A                 # auto-fix lints
gem install bundler                    # update bundler itself

# Blocks are the heart of Ruby — every method can take one

# yield invokes the block; block_given? checks
def each_word(text)
  text.split.each { |w| yield w if block_given? }
end

each_word("hello world from ruby") { |w| puts w.upcase }

# Convert block to a Proc with &
def benchmark(&blk)
  t0 = Time.now
  blk.call
  puts "elapsed: #{(Time.now - t0).round(3)}s"
end

benchmark { (1..1_000_000).inject(:+) }

# Procs vs lambdas — lambdas check arity and return locally
square = ->(x) { x * x }
puts square.call(5)        # 25
puts square.(5)            # alt call syntax
puts square[5]             # alt call syntax

# Symbol-to-proc — pass a method by name
%w[hello world].map(&:upcase).each(&method(:puts))

# Yielding with multiple values
def each_pair(h)
  h.each { |k, v| yield k, v }
end
each_pair(a: 1, b: 2) { |k, v| puts "#{k} → #{v}" }

# Modules as mixins — composition over inheritance
module Greetable
  def greet
    "hello, #{name}"
  end
end

# Comparable + <=> gives you ==, <, <=, >, >=, between?
class User
  include Greetable
  include Comparable
  attr_accessor :name, :score          # read + write accessors

  def initialize(name, score)
    @name, @score = name, score
  end

  def <=>(other)                       # define one operator → six come free
    score <=> other.score
  end

  def to_s = ""
end

ada   = User.new("Ada",   42)
grace = User.new("Grace", 99)

puts ada.greet
puts [ada, grace].max                  # uses <=>
puts ada.between?(grace, ada)          # false

# Pattern matching (Ruby 3+)
case ada
in { name:, score: } if score >= 50
  puts "#{name} qualifies"
in User(name:, score:)
  puts "#{name} below threshold (#{score})"
end

# Gemfile:
# source "https://rubygems.org"
# gem "async-http"
# gem "async"

require "async"
require "async/http/internet"
require "async/barrier"
require "json"

OWNERS = %w[ruby sinatra rails]

Async do
  internet = Async::HTTP::Internet.new
  barrier  = Async::Barrier.new
  results  = {}

  OWNERS.each do |owner|
    barrier.async do
      url  = "https://api.github.com/users/#{owner}/repos?per_page=5"
      resp = internet.get(url, [["User-Agent", "devshelf"]])
      data = JSON.parse(resp.read)
      results[owner] = data.first(5).map { |r| [r["name"], r["stargazers_count"]] }
    rescue => e
      results[owner] = e
    end
  end

  barrier.wait

  results.each do |owner, data|
    if data.is_a?(Exception)
      warn "#{owner}: #{data.message}"
    else
      data.each { |name, stars| puts "#{owner}/#{name} ★#{stars}" }
    end
  end
ensure
  internet&.close
end