Ruby cheat sheet

module Billing
  class InvalidAmount < StandardError; end
 
  class Money
    include Comparable
 
    SYMBOLS = { gbp: "£", usd: "$" }.freeze
 
    attr_reader :pence, :currency
 
    def initialize(pence, currency: :gbp)
      raise InvalidAmount, "pence must be an Integer" unless pence.is_a?(Integer)
 
      @pence = pence
      @currency = currency
    end
 
    def self.from_pounds(pounds, **options)
      new((pounds * 100).round, **options)
    end
 
    def +(other)
      check_currency!(other)
      Money.new(pence + other.pence, currency:)
    end
 
    def <=>(other)
      check_currency!(other)
      pence <=> other.pence
    end
 
    def to_s = format("%s%.2f", SYMBOLS.fetch(currency), pence / 100.0)
 
    private
 
    def check_currency!(other)
      return if other.currency == currency
 
      raise ArgumentError, "cannot mix #{currency} and #{other.currency}"
    end
  end
end
 
price = Billing::Money.new(1999)
puts price + Billing::Money.from_pounds(5) # £24.99
puts [price, Billing::Money.new(500)].max  # £19.99

def with_timing(label)
  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
  result = yield
  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
  puts format("%s took %.3fs", label, elapsed)
  result
end
 
total = with_timing("sum") { (1..1_000_000).sum }
 
# A lambda checks its arguments, like a method does.
add = ->(a, b) { a + b }
add.(1, 2)  # 3
add.(1)     # ArgumentError
 
# A proc fills gaps with nil and ignores extras.
loose = proc { |a, b| [a, b] }
loose.call(1)       # [1, nil]
loose.call(1, 2, 3) # [1, 2]
 
# Any object with to_proc can stand in for a block.
%w[ada grace].map(&:capitalize) # ["Ada", "Grace"]

require "json"
 
response = JSON.parse(body, symbolize_names: true)
 
message =
  case response
  in { status: 200, data: { user: { name: String => name } } }
    "Welcome back, #{name}"
  in { status: 404 }
    "No such user"
  in { status: 500.. => status, error: }
    "Server error #{status}: #{error}"
  in { status: }
    "Unexpected status #{status}"
  end

Point = Data.define(:x, :y) do
  def +(other) = with(x: x + other.x, y: y + other.y)
  def to_s = "(#{x}, #{y})"
end
 
a = Point.new(x: 1, y: 2)
b = Point.new(3, 4)      # positional arguments work too
puts a + b               # (4, 6)
a == Point.new(x: 1, y: 2) # true, compared by value
a.to_h                   # {x: 1, y: 2}
 
case a
in { x: 0 } then "on the y axis"
in Point(x:, y:) then "at #{x}, #{y}"
end
 
Person = Struct.new(:name, :email)
ada = Person.new(name: "Ada")
ada.email = "ada@example.com" # Struct members can be changed

def welcome_email(user)
  <<~TEXT
    Hi #{user.name},
 
    Thanks for signing up. Your username is #{user.username}.
  TEXT
end
 
query = <<~'SQL'
  SELECT * FROM users WHERE name LIKE '#{not interpolated}'
SQL

# Gemfile
source "https://rubygems.org"
 
ruby "~> 4.0"
 
gem "rack", "~> 3.1"
gem "puma", "~> 8.0"
 
group :development, :test do
  gem "rspec", "~> 3.13"
end

require "bundler/inline"
 
gemfile do
  source "https://rubygems.org"
  gem "rack", "~> 3.1"
end
 
puts Rack.release