Ruby & Rails Glossary

# A non-ActiveRecord class that includes ActiveModel modules
class Contact
  include ActiveModel::Model
  include ActiveModel::Validations

  attr_accessor :name, :email, :message

  validates :name, :email, :message, presence: true
  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }
end

# In the controller
def new
  @contact = Contact.new
end

def create
  @contact = Contact.new(contact_params)

  if @contact.valid?
    # Process the contact form...
    redirect_to root_path, notice: 'Message sent!'
  else
    render :new
  end
end

# In the view - works just like ActiveRecord models
<%= form_with(model: @contact, url: contacts_path) do |form| %>
  <% if @contact.errors.any? %>
    <div class="error-messages">
      <h2><%= pluralize(@contact.errors.count, "error") %> prohibited this message from being sent:</h2>
      <ul>
        <% @contact.errors.full_messages.each do |message| %>
          <li><%= message %></li>
        <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :name %>
    <%= form.text_field :name %>
  </div>

  <div class="field">
    <%= form.label :email %>
    <%= form.email_field :email %>
  </div>

  <div class="field">
    <%= form.label :message %>
    <%= form.text_area :message %>
  </div>

  <div class="actions">
    <%= form.submit "Send Message" %>
  </div>
<% end %>

# Instead of writing SQL like:
# SELECT * FROM users WHERE email = 'example@example.com' LIMIT 1;

# You can write Ruby code:
user = User.find_by(email: 'example@example.com')

# Basic ancestor chain
String.ancestors
# => [String, Comparable, Object, Kernel, BasicObject]

# Creating a class with mixins
module A; end
module B; end
module C; end

class Parent; include A; end
class Child < Parent
  include B
  prepend C
end

# The ancestor chain shows the lookup order
Child.ancestors
# => [C, Child, B, Parent, A, Object, Kernel, BasicObject]

# Prepended modules come before the class
# Included modules come after the class
# The chain continues with the parent class and its modules

# Creating an array
fruits = ['apple', 'banana', 'orange']

# Accessing elements
fruits[0] # => 'apple'

# Adding elements
fruits << 'grape' # => ['apple', 'banana', 'orange', 'grape']

# In config/application.rb
config.assets.enabled = true
config.assets.version = '1.0'

# In app/assets/javascripts/application.js
//= require jquery
//= require_tree .

# In app/assets/stylesheets/application.css
/*
 *= require_self
 *= require_tree .
 */

<!-- Image tag helper -->
<%= image_tag "logo.png", alt: "Logo", class: "header-logo", width: 100 %>
<!-- Generates: <img src="/assets/logo.png" alt="Logo" class="header-logo" width="100"> -->

<!-- JavaScript tag helper -->
<%= javascript_include_tag "application" %>
<!-- Generates: <script src="/assets/application.js"></script> -->

<!-- CSS tag helper -->
<%= stylesheet_link_tag "application", media: "all" %>
<!-- Generates: <link rel="stylesheet" media="all" href="/assets/application.css"> -->

<!-- Audio tag helper -->
<%= audio_tag "sound.mp3", autoplay: true, controls: true %>

<!-- Video tag helper -->
<%= video_tag "movie.mp4", controls: true, size: "640x480" %>

<!-- Favicon link tag -->
<%= favicon_link_tag "favicon.ico" %>

<!-- Preload link tag -->
<%= preload_link_tag "font.woff2", as: "font", type: "font/woff2" %>

# In config/database.yml
production:
  primary:
    database: my_primary_database
    adapter: mysql2
  primary_replica:
    database: my_primary_database_replica
    adapter: mysql2
    replica: true

# In app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  connects_to database: { writing: :primary, reading: :primary_replica }
end

# Rails automatically uses the appropriate connection
# Write operation - uses primary
Post.create!(title: "New Post")

# Read operation - uses replica
@posts = Post.all

# Block with do...end
[1, 2, 3].each do |number|
  puts number * 2
end

# Block with curly braces
[1, 2, 3].map { |number| number * 2 } # => [2, 4, 6]

# In your ApplicationController:
protect_from_forgery with: :exception

# In your forms (automatically included with form_with):
<%= form_with(model: @user) do |form| %>
  <!-- CSRF token is automatically included -->
<% end %>

# For JavaScript requests, include the token in headers:
$.ajax({
  url: '/users',
  method: 'POST',
  headers: {
    'X-CSRF-Token': $('meta[name="csrf-token"]').attr('content')
  }
});

# In a view template
<% cache @product do %>
  <%= render @product %>
  <% cache @product.reviews do %>
    <%= render @product.reviews %>
  <% end %>
<% end %>

# The cache key includes a digest of the template and its dependencies
# So if the 'reviews' partial changes, the outer cache is also invalidated

# Defining a class
class Dog
  def initialize(name, breed)
    @name = name
    @breed = breed
  end

  def bark
    "Woof! I'm #{@name} the #{@breed}."
  end
end

# Creating an instance
fido = Dog.new("Fido", "Labrador")
fido.bark # => "Woof! I'm Fido the Labrador."

def counter
  count = 0
  return -> { count += 1 }
end

increment = counter
increment.call # => 1
increment.call # => 2
increment.call # => 3

<!-- In a view template -->
<% content_for :head do %>
  <%= stylesheet_link_tag 'specific_page' %>
  <meta name="description" content="Page-specific description">
<% end %>

<% content_for :sidebar do %>
  <div class="sidebar-widget">
    <h3>Related Articles</h3>
    <ul>
      <% @related_articles.each do |article| %>
        <li><%= link_to article.title, article %></li>
      <% end %>
    </ul>
  </div>
<% end %>

<h1>Main Content</h1>
<p>This is the main content of the page.</p>

<!-- In the layout -->
<!DOCTYPE html>
<html>
  <head>
    <title><%= yield(:title) || 'Default Title' %></title>
    <%= stylesheet_link_tag 'application' %>
    <%= yield :head %> <!-- Content from the :head block will be inserted here -->
  </head>
  <body>
    <div class="container">
      <div class="main-content">
        <%= yield %> <!-- Main content goes here -->
      </div>
      <div class="sidebar">
        <%= yield :sidebar %> <!-- Sidebar content goes here -->
      </div>
    </div>
  </body>
</html>

# Vulnerable to XSS:
<%= raw user_input %> # NEVER DO THIS!
<%= user_input.html_safe %> # ALSO DANGEROUS!

# Safe from XSS (automatic escaping):
<%= user_input %>

# For trusted HTML content, use sanitize:
<%= sanitize user_input %>

# RSpec is a DSL for testing
describe User do
  it "validates email presence" do
    user = User.new(email: nil)
    expect(user).not_to be_valid
  end
end

# ActiveRecord migrations use a DSL
create_table :users do |t|
  t.string :name
  t.string :email
  t.timestamps
end

# Define a Data class
Point = Data.define(:x, :y)

# Create instances
p1 = Point.new(1, 2)
p2 = Point.new(1, 2)
p3 = Point.new(3, 4)

# Data objects with the same values are equal
p1 == p2  # => true
p1 == p3  # => false

# Data objects are immutable
begin
  p1.x = 5  # This will raise an error
rescue => e
  puts "Error: #{e.message}"
end

# But you can create new instances based on existing ones
p4 = p1.with(x: 5)
puts "p1: (#{p1.x}, #{p1.y}), p4: (#{p4.x}, #{p4.y})"

# Data objects can be used in pattern matching
case p4
in Point[x: 5, y: y_val]
  puts "Found a point with x=5 and y=#{y_val}"
else
  puts "No match"
end

# Switch to the reading role
ActiveRecord::Base.connected_to(role: :reading) do
  # All code in this block uses the reading database
  @posts = Post.all
end

# Switch to the writing role
ActiveRecord::Base.connected_to(role: :writing) do
  # All code in this block uses the writing database
  Post.create!(title: "New Post")
end

# Switch to a specific database
ActiveRecord::Base.connected_to(database: :animals_primary) do
  Dog.create!(name: "Fido")
end

<!-- Basic date formatting -->
<%= date_select :person, :birth_date %>

<!-- Time ago in words -->
<p>Posted <%= time_ago_in_words(article.created_at) %> ago</p>
<!-- Outputs: "Posted 3 hours ago" or "Posted 2 days ago" -->

<!-- Date formatting -->
<%= article.published_at.strftime("%B %d, %Y") %> <!-- Standard Ruby -->
<%= l article.published_at, format: :long %> <!-- Rails I18n localization -->

<!-- Distance of time in words -->
<p>This will take <%= distance_of_time_in_words(Time.now, Time.now + 3.hours + 30.minutes) %></p>
<!-- Outputs: "This will take about 4 hours" -->

<!-- Select date and time -->
<%= datetime_select :event, :starts_at %>
<%= time_select :event, :starts_at %>

<!-- Time zone select -->
<%= time_zone_select :user, :time_zone %>

# These classes have nothing in common except the 'speak' method
class Dog
  def speak
    "Woof!"
  end
end

class Cat
  def speak
    "Meow!"
  end
end

# This method doesn't care about the class, only that 'speak' exists
def make_noise(animal)
  animal.speak
end

make_noise(Dog.new) # => "Woof!"
make_noise(Cat.new) # => "Meow!"

<!-- Basic ERB syntax -->
<% ruby_code_here %> <!-- Executes Ruby code but doesn't output anything -->
<%= ruby_code_here %> <!-- Executes Ruby code and outputs the result -->

<!-- Examples -->
<% if user.admin? %>
  <h1>Welcome, Admin!</h1>
<% else %>
  <h1>Welcome, <%= user.name %>!</h1>
<% end %>

<!-- Iteration example -->
<ul>
  <% @users.each do |user| %>
    <li><%= user.name %></li>
  <% end %>
</ul>

numbers = [1, 2, 3, 4, 5]

# Map transforms each element
numbers.map { |n| n * 2 } # => [2, 4, 6, 8, 10]

# Select filters elements
numbers.select { |n| n.even? } # => [2, 4]

# Reduce combines elements
numbers.reduce(0) { |sum, n| sum + n } # => 15

# Without error highlighting, you might see:
# example.rb:3:in `+': nil can't be coerced into Integer (TypeError)

# With error highlighting in Ruby 3.3.0, you'll see something like:
# example.rb:3:in `+': nil can't be coerced into Integer (TypeError)
# 
# value + 10
#   ^^^^^
# 
# The ^^^^^ marks clearly highlight which part of the expression is nil

# This is especially helpful for complex expressions:
def calculate(a, b, c)
  a * (b + c) / (b - c)
end

calculate(10, 5, 5)  # Division by zero error

# The error highlighting would show:
# example.rb:2:in `/': divided by 0 (ZeroDivisionError)
# 
# a * (b + c) / (b - c)
#               ^^^^^^^
# 
# Clearly showing that (b - c) is the problem

# Raising an exception
raise ArgumentError, "Invalid argument"

# Handling exceptions
begin
  # Code that might raise an exception
  1 / 0
rescue ZeroDivisionError => e
  puts "Error: #{e.message}"
ensure
  # This code always runs
  puts "Cleanup code"
end

# Define a custom fiber scheduler
class MyScheduler
  def fiber(&block)
    Fiber.new(blocking: false, &block)
  end

  def kernel_sleep(duration)
    # Non-blocking implementation of sleep
    fiber = Fiber.current
    Thread.new do
      sleep duration
      fiber.resume
    end
    Fiber.yield
  end

  # Implement other required methods...
end

# Set the scheduler
Fiber.set_scheduler(MyScheduler.new)

# Now regular sleep becomes non-blocking
Fiber.schedule do
  puts "Starting sleep"
  sleep 1  # This won't block the entire thread
  puts "Finished sleep"
end

puts "Main fiber continues immediately"

# In config/environments/production.rb
config.assets.digest = true

# In your view, this:
<%= image_tag "logo.png" %>

# Generates HTML like this:
<img src="/assets/logo-908e25f4bf641868d8683022a5b62f54.png" />

# In your ApplicationController
class ApplicationController < ActionController::Base
  force_ssl
end

# With options
class CheckoutController < ApplicationController
  force_ssl only: [:new, :create, :update, :destroy]
end

# In config/environments/production.rb
Rails.application.configure do
  # Force all access to the app over SSL, use Strict-Transport-Security,
  # and use secure cookies
  config.force_ssl = true
end

# Default form builder usage
<%= form_with(model: @article) do |form| %>
  <%= form.text_field :title %>
  <%= form.text_area :body %>
  <%= form.submit %>
<% end %>

# Custom form builder
class LabeledFormBuilder < ActionView::Helpers::FormBuilder
  def text_field(attribute, options={})
    label(attribute) + super
  end

  def text_area(attribute, options={})
    label(attribute) + super
  end
end

# Using custom form builder
<%= form_with(model: @article, builder: LabeledFormBuilder) do |form| %>
  <%= form.text_field :title %> <!-- Automatically includes label -->
  <%= form.text_area :body %>   <!-- Automatically includes label -->
  <%= form.submit %>
<% end %>

<!-- Basic form_with usage with model -->
<%= form_with(model: @article) do |form| %>
  <div>
    <%= form.label :title %>
    <%= form.text_field :title %>
    <% @article.errors.full_messages_for(:title).each do |message| %>
      <div><%= message %></div>
    <% end %>
  </div>

  <div>
    <%= form.label :body %>
    <%= form.text_area :body %>
  </div>

  <div>
    <%= form.submit %>
  </div>
<% end %>

<!-- form_with with URL instead of model -->
<%= form_with(url: search_path, method: :get) do |form| %>
  <%= form.label :query, "Search for:" %>
  <%= form.text_field :query %>
  <%= form.submit "Search" %>
<% end %>

<!-- Basic select with options -->
<%= select_tag 'country', options_for_select(['USA', 'Canada', 'Mexico']) %>

<!-- Select with pre-selected option -->
<%= select_tag 'country', options_for_select([['USA', 'us'], ['Canada', 'ca'], ['Mexico', 'mx']], 'ca') %>

<!-- Select from a collection of objects -->
<%= select_tag 'product', options_from_collection_for_select(@products, 'id', 'name') %>

<!-- Grouped options -->
<%= select_tag 'continent', grouped_options_for_select({
  'North America' => [['USA', 'us'], ['Canada', 'ca'], ['Mexico', 'mx']],
  'Europe' => [['UK', 'uk'], ['France', 'fr'], ['Germany', 'de']]
}) %>

<!-- Time zone select -->
<%= time_zone_select :user, :time_zone %>

<!-- Date select -->
<%= date_select :event, :starts_on %>

<!-- Collection of checkboxes -->
<%= collection_check_boxes :article, :category_ids, Category.all, :id, :name %>

# In a view template
<% cache @product do %>
  <div class="product">
    <h2><%= @product.name %></h2>
    <p><%= @product.description %></p>

    <% cache "product_pricing_#{@product.id}_#{@product.updated_at.to_i}" do %>
      <!-- Expensive pricing calculations -->
      <div class="pricing">$<%= @product.calculate_price %></div>
    <% end %>
  </div>
<% end %>

string = "Hello"
string.freeze

# This will raise a RuntimeError
# string << " World"

# Creating a frozen string literal
# frozen_string_literal: true
CONSTANT = "I am immutable"

# Ruby handles memory management automatically
def create_objects
  1000.times { Object.new }
end

create_objects
# After this method returns, the objects are no longer referenced
# and will be garbage collected

# You can force garbage collection
GC.start

# Installing a gem
gem install rails

# Using a gem in your code
require 'rails'

# Listing installed gems
gem list

# Using Bundler to manage gems
# In Gemfile:
gem 'rails', '~> 7.0.0'
gem 'pg', '~> 1.1'

# Despite creating multiple threads, only one can execute Ruby code at a time due to the GVL
threads = 4.times.map do |i|
  Thread.new do
    # CPU-intensive work (affected by GVL)
    result = 0
    1_000_000.times { result += 1 }
    puts "Thread #{i} completed CPU work: #{result}"

    # I/O operations (GVL is released during I/O)
    sleep 0.1  # During this time, other threads can execute
    puts "Thread #{i} completed I/O work"
  end
end

threads.each(&:join)

# Ways to work around GVL limitations:

# 1. Use processes instead of threads for CPU-bound work
require 'parallel'
result = Parallel.map(1..10, in_processes: 4) do |i|
  # Each process has its own GVL
  # This will use all CPU cores
  compute_intensive_task(i)
end

# 2. Use C extensions (which can release the GVL)
# Native extensions can release the GVL during computation
# require 'fast_computation'  # Hypothetical C extension
# FastComputation.process_data(data)  # Runs without GVL

# In your controller
class AdminController < ApplicationController
  http_basic_authenticate_with name: "admin", password: "secret", except: :index

  # Or more flexible approach
  before_action :authenticate

  private

  def authenticate
    authenticate_or_request_with_http_basic do |username, password|
      username == "admin" && password == ENV["ADMIN_PASSWORD"]
    end
  end
end

# Creating a hash
person = { name: 'John', age: 30, city: 'New York' }

# Accessing values
person[:name] # => 'John'

# Adding or updating values
person[:email] = 'john@example.com'
person[:age] = 31

# Iterating over a hash
person.each do |key, value|
  puts "#{key}: #{value}"
end

# Built-in helper methods
<%= link_to 'Home', root_path %>
<%= image_tag 'logo.png', alt: 'Logo' %>
<%= number_to_currency(product.price) %>

# Custom helper in app/helpers/application_helper.rb
module ApplicationHelper
  def page_title(title = nil)
    base_title = "My Awesome App"
    title ? "#{title} | #{base_title}" : base_title
  end

  def active_class(path)
    current_page?(path) ? 'active' : ''
  end
end

# Using custom helpers in a view
<title><%= page_title(@article&.title) %></title>
<nav>
  <a href="/" class="<%= active_class(root_path) %>">Home</a>
</nav>

# In config/database.yml
production:
  primary:
    database: my_primary_db
    adapter: mysql2
  primary_shard_one:
    database: my_primary_shard_one
    adapter: mysql2
  primary_shard_two:
    database: my_primary_shard_two
    adapter: mysql2

# In app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  connects_to shards: {
    default: { writing: :primary, reading: :primary },
    shard_one: { writing: :primary_shard_one, reading: :primary_shard_one },
    shard_two: { writing: :primary_shard_two, reading: :primary_shard_two }
  }
end

# Using a specific shard
Customer.connected_to(shard: :shard_one) do
  Customer.create!(name: "Customer in shard one")
end

# Start IRB
$ irb

# As you type, press Tab to see suggestions
> "hello".
# Pressing Tab here will show all String methods

> "hello".up
# Pressing Tab here will complete to "upcase"

> File.open(
# Pressing Tab here will show parameter information

> require 'net/
# Pressing Tab here will show available modules

# IRB also supports multi-line editing and syntax highlighting
> def example_method
    puts "This is a multi-line method"
  end

# Superclass
class Animal
  def speak
    "Some generic animal sound"
  end
end

# Subclass
class Dog < Animal
  def speak
    "Woof!"
  end
end

animal = Animal.new
animal.speak # => "Some generic animal sound"

dog = Dog.new
dog.speak # => "Woof!"

class Person
  def initialize(name)
    @name = name # Instance variable
  end

  def greet
    "Hello, my name is #{@name}"
  end
end

person = Person.new("Alice")
person.greet # => "Hello, my name is Alice"

<!-- app/views/layouts/application.html.erb -->
<!DOCTYPE html>
<html>
  <head>
    <title><%= yield(:title) || 'Default Title' %></title>
    <%= csrf_meta_tags %>
    <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>
  <body>
    <header>
      <h1>My Application</h1>
      <nav>
        <!-- Navigation links -->
      </nav>
    </header>

    <main>
      <%= yield %> <!-- This is where the view content is inserted -->
    </main>

    <footer>
      <p>&copy; <%= Time.current.year %> My Company</p>
    </footer>
  </body>
</html>

# Specifying a different layout in a controller
class AdminController < ApplicationController
  layout 'admin'

  # Actions...
end

# Specifying a layout for a specific action
def show
  render layout: 'special'
end

# In config/initializers/filter_parameter_logging.rb
# Default Rails setup filters passwords
Rails.application.config.filter_parameters += [:password]

# Add more parameters to filter
Rails.application.config.filter_parameters += [
  :password, :password_confirmation, :credit_card_number, :ssn, :api_key
]

# Using regular expressions
Rails.application.config.filter_parameters += [/token$/, /password/]

# In logs, filtered parameters appear as [FILTERED]
# Started POST "/users" for 127.0.0.1
# Parameters: {"user"=>{"email"=>"user@example.com", "password"=>"[FILTERED]", "credit_card_number"=>"[FILTERED]"}}

# Basic usage
Rails.cache.fetch("weather-data") do
  # Expensive API call or computation
  WeatherService.fetch_forecast
end

# With expiration
Rails.cache.fetch("weather-data", expires_in: 30.minutes) do
  WeatherService.fetch_forecast
end

# With version/cache key
Rails.cache.fetch(["user", user.id, "posts", Post.maximum(:updated_at)]) do
  user.posts.to_a
end

# Explicit cache operations
Rails.cache.write("key", value, expires_in: 1.hour)
value = Rails.cache.read("key")
Rails.cache.delete("key")

# Historical note: Ruby 1.8.x used MRI
# You can check the Ruby implementation with:
RUBY_DESCRIPTION  # In Ruby 1.8: "ruby 1.8.7 (2012-02-08 patchlevel 358) [i686-darwin12.2.0]"

# MRI had different performance characteristics
# For example, in Ruby 1.8 (MRI), regular expressions used a different engine
/regex/ =~ "string"  # Different implementation in MRI vs YARV

# MRI also had different thread behavior
# In MRI 1.8, threads were "green threads" managed entirely by the Ruby interpreter
Thread.new { sleep 1 }  # In MRI 1.8, this didn't use native OS threads

// app/assets/javascripts/application.js
//= require jquery
//= require jquery_ujs
//= require_tree .

/* app/assets/stylesheets/application.css */
/*
 *= require reset
 *= require_self
 *= require_tree .
 */

# Defining methods dynamically
class Person
  [:name, :age, :email].each do |attribute|
    define_method("#{attribute}=") do |value|
      instance_variable_set("@#{attribute}", value)
    end

    define_method(attribute) do
      instance_variable_get("@#{attribute}")
    end
  end
end

person = Person.new
person.name = "Alice" # Calls the dynamically defined method
person.name # => "Alice"

# Basic method lookup example
class Parent
  def speak
    "Parent speaking"
  end
end

class Child < Parent
  def speak
    "Child speaking"
  end
end

child = Child.new
child.speak  # => "Child speaking" (found in Child class)

# More complex example with modules
module Speakable
  def speak
    "Module speaking"
  end
end

class Animal
  def speak
    "Animal speaking"
  end
end

class Dog < Animal
  include Speakable

  # No speak method defined here
end

dog = Dog.new
dog.speak  # => "Module speaking" (found in Speakable module)

# Adding a singleton method
fido = Dog.new
def fido.speak
  "Fido speaking"
end

fido.speak  # => "Fido speaking" (found in singleton class)

# Two mixins
module Swimmable
  def swim
    "I'm swimming!"
  end
end

module Flyable
  def fly
    "I'm flying!"
  end
end

# Using mixins in classes
class Duck
  include Swimmable
  include Flyable
end

class Penguin
  include Swimmable
end

duck = Duck.new
duck.swim # => "I'm swimming!"
duck.fly # => "I'm flying!"

penguin = Penguin.new
penguin.swim # => "I'm swimming!"
# penguin.fly would raise NoMethodError

# Defining a module
module Loggable
  def log(message)
    puts "[LOG] #{message}"
  end
end

# Including a module in a class
class User
  include Loggable

  def save
    log("User saved")
  end
end

user = User.new
user.save # => [LOG] User saved

# In config/database.yml
production:
  primary:
    database: my_primary_database
    username: root
    password: <%= ENV['DATABASE_PASSWORD'] %>
    adapter: mysql2
  primary_replica:
    database: my_primary_database_replica
    username: root_readonly
    password: <%= ENV['DATABASE_READONLY_PASSWORD'] %>
    adapter: mysql2
    replica: true
  animals:
    database: my_animals_database
    username: animals_root
    password: <%= ENV['ANIMALS_DATABASE_PASSWORD'] %>
    adapter: mysql2
    migrations_paths: db/animals_migrate

# In app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  connects_to database: { writing: :primary, reading: :primary_replica }
end

# In app/models/animal_record.rb
class AnimalRecord < ApplicationRecord
  self.abstract_class = true

  connects_to database: { writing: :animals, reading: :animals }
end

<!-- Currency formatting -->
<%= number_to_currency(1234.56) %>
<!-- Outputs: $1,234.56 -->
<%= number_to_currency(1234.56, unit: "€", separator: ",", delimiter: ".") %>
<!-- Outputs: €1.234,56 -->

<!-- Percentage formatting -->
<%= number_to_percentage(75) %>
<!-- Outputs: 75.000% -->
<%= number_to_percentage(75, precision: 0) %>
<!-- Outputs: 75% -->

<!-- Phone number formatting -->
<%= number_to_phone(1234567890) %>
<!-- Outputs: 123-456-7890 -->
<%= number_to_phone(1234567890, area_code: true, delimiter: " ") %>
<!-- Outputs: (123) 456 7890 -->

<!-- Human-readable numbers -->
<%= number_to_human(1234) %>
<!-- Outputs: 1.23 Thousand -->
<%= number_to_human(1234567) %>
<!-- Outputs: 1.23 Million -->

<!-- File size formatting -->
<%= number_to_human_size(1234567) %>
<!-- Outputs: 1.18 MB -->

<!-- Precision control -->
<%= number_with_precision(123.456, precision: 2) %>
<!-- Outputs: 123.46 -->

<!-- Delimiter formatting -->
<%= number_with_delimiter(1234567890) %>
<!-- Outputs: 1,234,567,890 -->

# Everything is an object
42.class # => Integer
"hello".class # => String
[1, 2, 3].class # => Array

# Objects respond to methods
42.even? # => true
"hello".upcase # => "HELLO"
[1, 2, 3].length # => 3

# In your controller
class ProductsController < ApplicationController
  caches_page :index, :show

  def index
    @products = Product.all
  end

  def show
    @product = Product.find(params[:id])
  end

  # When content changes, you need to expire the cache
  def update
    @product = Product.find(params[:id])
    if @product.update(product_params)
      expire_page action: 'show', id: @product.id
      redirect_to @product
    else
      render 'edit'
    end
  end
end

# Default behavior in Rails
# GET requests use query parameters
# /search?query=ruby+on+rails

# POST, PATCH, PUT, and DELETE requests use the request body
# Content-Type: application/x-www-form-urlencoded
# query=ruby+on+rails

# Customizing parameter encoding for a specific URL
<%= form_with url: search_path(format: :json), method: :get, 
              local: true, skip_encoding: true do |form| %>
  <%= form.text_field :query %>
  <%= form.submit "Search" %>
<% end %>

# Customizing parameter encoding globally
# In config/initializers/form_with_params.rb
Rails.application.config.action_view.form_with_generates_remote_forms = false
Rails.application.config.action_view.form_with_generates_ids = true

<!-- Creating a partial: app/views/shared/_user.html.erb -->
<div class="user-card">
  <h3><%= user.name %></h3>
  <p><%= user.email %></p>
  <% if user.admin? %>
    <span class="badge">Admin</span>
  <% end %>
</div>

<!-- Rendering a partial for a single object -->
<%= render 'shared/user', user: @user %>

<!-- Rendering a partial for a collection -->
<%= render partial: 'shared/user', collection: @users %>

<!-- Shorthand for rendering a collection -->
<%= render @users %>

<!-- Partial with local variables -->
<%= render 'form', article: @article, categories: @categories %>

<!-- Rendering a partial inside another partial -->
<!-- In _article.html.erb -->
<article>
  <h2><%= article.title %></h2>
  <%= render 'shared/author', author: article.author %>
  <div class="content">
    <%= article.body %>
  </div>
</article>

# Define a Data class
Customer = Data.define(:name, :age, :city)

# Create some customers
customer1 = Customer.new("Alice", 30, "New York")
customer2 = Customer.new("Bob", 25, "Boston")
customer3 = Customer.new("Charlie", 35, "Chicago")

# Use pattern matching with Data objects
def process_customer(customer)
  case customer
  in Customer[name: "Alice", age:, city:]
    puts "Alice is #{age} years old and lives in #{city}"
  in Customer[name:, age: 20..29, city:]
    puts "#{name} is in their 20s and lives in #{city}"
  in Customer[name:, age:, city: /^C.*/]
    puts "#{name} is #{age} years old and lives in a city starting with C"
  else
    puts "No match found"
  end
end

process_customer(customer1) # "Alice is 30 years old and lives in New York"
process_customer(customer2) # "Bob is in their 20s and lives in Boston"
process_customer(customer3) # "Charlie is 35 years old and lives in a city starting with C"

# A .scss file (Sass preprocessor)
$primary-color: #4a90e2;

.button {
  background-color: $primary-color;
  &:hover {
    background-color: darken($primary-color, 10%);
  }
}

# A .coffee file (CoffeeScript preprocessor)
class User
  constructor: (@name) ->

  sayHello: ->
    "Hello, #{@name}!"

# Using Prism to parse Ruby code
require 'prism'

# Parse a string of Ruby code
source = "puts 'Hello, world!'"
result = Prism.parse(source)

# Check if parsing was successful
if result.success?
  # Access the AST (Abstract Syntax Tree)
  ast = result.value

  # Work with the parsed representation
  puts ast.inspect
else
  # Handle parsing errors
  puts "Error: #{result.error}"
end

# Creating a Proc
square = Proc.new { |x| x * x }

# Calling a Proc
square.call(5) # => 25

# Passing a Proc to a method
[1, 2, 3].map(&square) # => [1, 4, 9]

# Converting a block to a Proc
def with_logging(&block)
  puts "Before"
  result = block.call
  puts "After"
  result
end

with_logging { puts "During"; 42 } # => 42

# Enable RJIT when starting Ruby
$ ruby --rjit program.rb

# Or enable it in your code
RubyVM::RJIT.enable

# Check if RJIT is enabled
RubyVM::RJIT.enabled?

# You can also set compilation options
ENV['RUBY_RJIT_OPTIONS'] = '--trace=insns'

# Using Rack::Builder to create a middleware stack
app = Rack::Builder.new do
  use Rack::CommonLogger
  use Rack::ShowExceptions

  map '/api' do
    run ApiApp.new
  end

  map '/' do
    run WebApp.new
  end
end

# The above is equivalent to this in a config.ru file:
use Rack::CommonLogger
use Rack::ShowExceptions

map '/api' do
  run ApiApp.new
end

map '/' do
  run WebApp.new
end

# A simple Rack middleware
class Logger
  def initialize(app)
    @app = app
  end

  def call(env)
    # Process request before passing to the next middleware
    puts "Request: #{env['REQUEST_METHOD']} #{env['PATH_INFO']}"

    # Call the next middleware in the stack
    status, headers, body = @app.call(env)

    # Process response before returning
    puts "Response: #{status}"

    # Return the response
    [status, headers, body]
  end
end

# Using the middleware in a Rails application
# In config/application.rb
module MyApp
  class Application < Rails::Application
    config.middleware.use Logger
  end
end

# A simple Rack application
class HelloWorld
  def call(env)
    # Return [status, headers, body]
    [200, { 'Content-Type' => 'text/plain' }, ['Hello, World!']]
  end
end

# Using the application with Rack
require 'rack'
Rack::Handler::WEBrick.run HelloWorld.new

# Create a Ractor that computes a value
r = Ractor.new do
  # This code runs in parallel with the main thread
  result = 0
  10_000_000.times { result += 1 }
  result  # Return value to be sent back
end

# Continue doing work in the main thread
puts "Main thread is working..."

# Get the result from the Ractor when ready
result = r.take
puts "Ractor computed: #{result}"

# Ractors can also communicate via messages
r1 = Ractor.new do
  msg = Ractor.receive  # Wait for a message
  "Processed: #{msg}"
end

# Send a message to the Ractor
r1.send("Hello from main")

# Get the response
puts r1.take

# Rails application entry point (config.ru)
require_relative 'config/environment'
run Rails.application

# Inspecting the middleware stack
$ rails middleware

# Adding custom middleware in config/application.rb
module MyApp
  class Application < Rails::Application
    config.middleware.use MyCustomMiddleware

    # Insert at a specific position
    config.middleware.insert_before Rack::Runtime, MyMiddleware

    # Remove a middleware
    config.middleware.delete Rack::Runtime
  end
end

# In config/database.yml
production:
  primary:
    database: my_primary_database
    adapter: mysql2
  primary_replica:
    database: my_primary_database_replica
    adapter: mysql2
    replica: true

# In app/models/application_record.rb
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  connects_to database: { writing: :primary, reading: :primary_replica }
end

# Rails automatically uses the appropriate connection
# Write operation - uses primary
Post.create!(title: "New Post")

# Read operation - uses replica
@posts = Post.all

# Force a specific role
ActiveRecord::Base.connected_to(role: :writing) do
  # This will use the primary database even for reads
  @posts = Post.all
end

<!-- Creating a div for a specific record -->
<%= content_tag_for :div, @post do %>
  <h2><%= @post.title %></h2>
  <p><%= @post.body %></p>
<% end %>
<!-- Generates: <div id="post_1" class="post">...</div> -->

<!-- Creating multiple elements for a collection -->
<%= div_for @posts do |post| %>
  <h2><%= post.title %></h2>
  <p><%= post.body %></p>
<% end %>
<!-- Generates multiple divs with IDs like "post_1", "post_2", etc. -->

<!-- Using dom_id helper directly -->
<div id="<%= dom_id(@post) %>">
  <!-- Content here -->
</div>
<!-- Generates: <div id="post_1">...</div> -->

<!-- Using dom_class helper directly -->
<div class="<%= dom_class(@post) %>">
  <!-- Content here -->
</div>
<!-- Generates: <div class="post">...</div> -->

# Set a global timeout for all regexp operations
Regexp.timeout = 1.0  # 1 second timeout

# This will raise Regexp::TimeoutError if it takes too long
begin
  # A potentially problematic regexp that could cause catastrophic backtracking
  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab" =~ /a+a+a+a+a+b/
rescue Regexp::TimeoutError
  puts "Regexp matching timed out"
end

# Set timeout for a specific regexp
pattern = Regexp.new('(a+)+b', timeout: 0.5)  # 0.5 second timeout

# Use timeout in a block scope
Regexp.timeout(2.0) do
  # All regexp operations in this block have a 2-second timeout
  "some text" =~ /complex pattern/
end

# In your controller or ApplicationController
class ApplicationController < ActionController::Base
  rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
  rescue_from User::NotAuthorized, with: :user_not_authorized

  private

  def record_not_found
    render plain: "404 Not Found", status: 404
  end

  def user_not_authorized
    flash[:error] = "You don't have access to this section."
    redirect_to root_path
  end
end

# You can also use a block directly
rescue_from ActiveRecord::RecordInvalid do |exception|
  render json: { errors: exception.record.errors }, status: :unprocessable_entity
end

// Example C extension for Ruby
#include <ruby.h>

// Function to be called from Ruby
static VALUE hello_world(VALUE self) {
  return rb_str_new_cstr("Hello from C!");
}

// Initialization function
void Init_hello() {
  // Define a module
  VALUE mHello = rb_define_module("Hello");

  // Define a method in the module
  rb_define_singleton_method(mHello, "world", hello_world, 0);
}

// In Ruby, you would use it like:
// require 'hello'
// Hello.world  # => "Hello from C!"

# Creating and using a basic fiber
fiber = Fiber.new do
  puts "Fiber started"
  x = Fiber.yield "First yield"  # Pause and return a value
  puts "Fiber resumed with value: #{x}"
  "Fiber completed"  # Final return value
end

puts fiber.resume  # Start the fiber, prints "Fiber started" and returns "First yield"
puts fiber.resume("Hello")  # Resume with argument, prints message and returns "Fiber completed"

# Using fibers as generators
def fibonacci_generator(max)
  Fiber.new do
    a, b = 0, 1
    while a < max
      Fiber.yield a
      a, b = b, a + b
    end
  end
end

fib = fibonacci_generator(100)
10.times { puts fib.resume if fib.alive? }

# Classes are objects too
String.class # => Class
Class.class # => Class

# The superclass chain
String.superclass # => Object
Object.superclass # => BasicObject
BasicObject.superclass # => nil

# Classes have ancestors (including mixed-in modules)
String.ancestors # => [String, Comparable, Object, Kernel, BasicObject]

# Objects have a singleton class (eigenclass)
obj = "hello"
def obj.custom_method
  "This method only exists on this specific object"
end

# The method is stored in the object's singleton class
obj.singleton_class.instance_methods(false) # => [:custom_method]

# Creating multiple Ruby threads
threads = []

5.times do |i|
  threads << Thread.new do
    puts "Thread #{i} starting"
    # Simulate work with sleep
    sleep rand(0.1..0.5)
    puts "Thread #{i} finished"
  end
end

# Wait for all threads to complete
threads.each(&:join)

# Thread synchronization with Mutex
counter = 0
mutex = Mutex.new

threads = 10.times.map do
  Thread.new do
    1000.times do
      mutex.synchronize do
        counter += 1
      end
    end
  end
end

threads.each(&:join)
puts "Final counter: #{counter}" # Should be 10,000

# Installing a gem
gem install rails

# Using Bundler to manage gems
# In Gemfile:
source 'https://rubygems.org'
gem 'rails', '~> 7.0.0'
gem 'pg', '~> 1.1'

# Then run:
bundle install

# Basic Russian Doll Caching example
<% cache ['v1', @post] do %>
  <%= render @post %>
  <% cache ['v1', @post, :comments] do %>
    <%= render @post.comments %>
    <% @post.comments.each do |comment| %>
      <% cache ['v1', comment] do %>
        <%= render comment %>
      <% end %>
    <% end %>
  <% end %>
<% end %>

# SQL caching is enabled by default in production
# and can be manually enabled in development:

# In a controller action
def index
  # First time: executes the SQL query
  @posts = Post.all

  # Second time: uses the cached result, no SQL query
  @same_posts = Post.all
end

# You can also manually control the cache
Post.cache do
  # All queries inside this block are cached
  Post.find(1)
  Post.find(1) # Uses cached result
end

# Clear the query cache
ActiveRecord::Base.clear_query_cache

# Vulnerable to SQL Injection:
User.where("username = '#{params[:username]}'") # NEVER DO THIS!

# Safe from SQL Injection (using parameterized queries):
User.where("username = ?", params[:username])

# Even better, use hash conditions:
User.where(username: params[:username])

obj = Object.new

# Adding a method to obj's singleton class
def obj.hello
  "Hello from this specific object"
end

# Alternative syntax using the singleton class directly
class << obj
  def goodbye
    "Goodbye from this specific object"
  end
end

obj.hello # => "Hello from this specific object"
obj.goodbye # => "Goodbye from this specific object"

# Other objects of the same class don't have these methods
another_obj = Object.new
# another_obj.hello would raise NoMethodError

# In Gemfile
gem 'sprockets-rails'

# In config/initializers/assets.rb
Rails.application.config.assets.precompile += %w( admin.js admin.css )

# In a JavaScript file using Sprockets directives
//= require jquery
//= require_tree ./modules

# Streaming a template
def index
  @users = User.all
  render stream: true
end

# Streaming a file download
def download
  response.headers['Content-Type'] = 'text/plain'
  response.headers['Content-Disposition'] = 'attachment; filename="large_file.txt"'

  self.response_body = Enumerator.new do |y|
    10.times do |i|
      y << "Line #{i}\n"
      sleep 0.1 # Simulate slow processing
    end
  end
end

# Streaming a CSV file
def export
  response.headers['Content-Type'] = 'text/csv'
  response.headers['Content-Disposition'] = 'attachment; filename="users.csv"'

  self.response_body = Enumerator.new do |y|
    y << "ID,Name,Email\n"
    User.find_each do |user|
      y << "#{user.id},#{user.name},#{user.email}\n"
    end
  end
end

# Creating symbols
:name
:"complex name"

# Symbols vs strings
"string".object_id == "string".object_id # => false
:symbol.object_id == :symbol.object_id # => true

# Using symbols as hash keys
person = { name: 'John', age: 30 }
person[:name] # => 'John'

<!-- Truncating text -->
<%= truncate(article.body, length: 100) %>
<!-- Outputs the first 100 characters followed by '...' -->

<!-- Creating excerpts around a phrase -->
<%= excerpt(article.body, 'Ruby on Rails', radius: 30) %>
<!-- Outputs: '...text before Ruby on Rails and text after...' -->

<!-- Highlighting text -->
<%= highlight(article.body, 'Ruby', highlighter: '<strong>\1</strong>') %>
<!-- Wraps all occurrences of 'Ruby' with <strong> tags -->

<!-- Word wrapping -->
<%= word_wrap(article.body, line_width: 80) %>
<!-- Wraps text at 80 characters -->

<!-- Pluralization -->
<%= pluralize(2, 'comment') %> <!-- Outputs: '2 comments' -->
<%= pluralize(1, 'person', 'people') %> <!-- Outputs: '1 person' -->

<!-- Converting to cycles -->
<% [1, 2, 3, 4].each do |n| %>
  <tr class="<%= cycle('odd', 'even') %>">...</tr>
<% end %>
<!-- Creates alternating odd/even classes -->

<!-- Simple formatting -->
<%= simple_format(article.body) %>
<!-- Converts line breaks to <br> and wraps in <p> tags -->

# Creating a thread
thread = Thread.new do
  # Code to run in the thread
  puts "Thread started"
  sleep 2
  puts "Thread finished"
end

# Main thread continues executing
puts "Main thread continues"

# Wait for the thread to finish
thread.join

# Thread-local variables
Thread.current[:user_id] = 42

# The M:N Thread Scheduler works automatically
# when you create Ruby threads

# Create 100 Ruby threads that perform I/O operations
threads = 100.times.map do |i|
  Thread.new do
    # Simulate I/O operation
    sleep(rand * 0.1)
    puts "Thread #{i} completed"
  end
end

# Wait for all threads to complete
threads.each(&:join)

# With the M:N scheduler, these 100 Ruby threads
# might be executed using only 8-16 OS threads,
# reducing overhead and improving performance

# Basic translation
<%= t('hello') %>

# Translation with variables
<%= t('welcome', name: current_user.name) %>

# Translation with pluralization
<%= t('inbox.message', count: unread_messages.count) %>

# Translation with a different scope
<%= t('button.submit', scope: 'helpers') %>

# Translation with a fallback
<%= t('might.not.exist', default: 'Default text') %>

# Localizing dates and times
<%= l(Time.now) %>
<%= l(Date.today, format: :short) %>

# In your locale files (config/locales/en.yml)
en:
  hello: "Hello"
  welcome: "Welcome, %{name}!"
  inbox:
    message:
      one: "You have 1 unread message"
      other: "You have %{count} unread messages"
  helpers:
    button:
      submit: "Save"

# In your controller, setting the locale
class ApplicationController < ActionController::Base
  before_action :set_locale

  def set_locale
    I18n.locale = params[:locale] || I18n.default_locale
  end
end

# Basic path and URL helpers
<%= link_to 'All Articles', articles_path %>
<%= link_to 'View Article', article_path(@article) %>
<%= link_to 'Edit Article', edit_article_path(@article) %>

# With query parameters
<%= link_to 'Filtered Articles', articles_path(category: 'ruby', sort: 'recent') %>

# With anchor tags
<%= link_to 'Jump to Comments', article_path(@article, anchor: 'comments') %>

# With data attributes
<%= link_to 'Delete', article_path(@article), 
            method: :delete, 
            data: { confirm: 'Are you sure?' } %>

# URL helpers in controllers
def create
  @article = Article.new(article_params)

  if @article.save
    redirect_to article_path(@article), notice: 'Article created!'
  else
    render :new
  end
end

# Polymorphic URLs
<%= link_to 'View', polymorphic_path([@user, @post]) %>

# Named routes
# In config/routes.rb
# get 'dashboard', to: 'dashboard#show', as: 'user_dashboard'

<%= link_to 'Dashboard', user_dashboard_path %>

# In a config.ru file
map '/api' do
  run ApiApp.new
end

map '/admin' do
  use AdminAuth
  run AdminApp.new
end

map '/' do
  run MainApp.new
end

# This routes requests to:
# - /api/* to ApiApp
# - /admin/* to AdminApp (with AdminAuth middleware)
# - All other requests to MainApp

# Local variable
name = "John"

# Instance variable
@age = 30

# Class variable
@@count = 0

# Global variable
$config = { debug: true }

# Constant
MAX_USERS = 100

# In a Rails application with Webpacker

# JavaScript files are typically in app/javascript
# app/javascript/packs/application.js is the entry point

# In your views, you can include the pack:
<%= javascript_pack_tag 'application' %>
<%= stylesheet_pack_tag 'application' %>

# Import modules in your JavaScript files
import Rails from '@rails/ujs'
import Turbolinks from 'turbolinks'

Rails.start()
Turbolinks.start()

# YARV is the default VM in Ruby 1.9 and later
# You can see it in the Ruby description
puts RUBY_DESCRIPTION
# Example output: "ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x86_64-darwin21]"

# YARV compiles Ruby code to bytecode before execution
# You can see the bytecode with RubyVM::InstructionSequence
code = <<~RUBY
  def hello(name)
    puts "Hello, #{name}!"
  end

  hello("World")
RUBY

# Disassemble the code to see YARV bytecode instructions
iseq = RubyVM::InstructionSequence.compile(code)
puts iseq.disasm

# Output will show YARV bytecode instructions like:
# 0000 definemethod                           :hello, hello
# 0003 putself                              
# 0004 putstring                              "World"
# 0006 opt_send_without_block                <callinfo!mid:hello, argc:1>

# Enable YJIT when starting Ruby
$ ruby --yjit program.rb

# Or enable it in your code
RubyVM::YJIT.enable

# Check if YJIT is enabled
RubyVM::YJIT.enabled?

# Get YJIT statistics
stats = RubyVM::YJIT.runtime_stats
puts "Compiled methods: #{stats[:compiled_methods]}"
puts "Executed instructions: #{stats[:executed_instructions]}"

# In Ruby 3.3.0, you can also enable YJIT with reduced memory usage
ENV['RUBY_YJIT_ENABLE'] = '1'
ENV['RUBY_YJIT_COMPACT_MEMPOOL'] = '1'

# A method that uses yield
def greet
  puts "Before the yield"
  yield
  puts "After the yield"
end

# Calling the method with a block
greet { puts "Hello from the block!" }

# Output:
# Before the yield
# Hello from the block!
# After the yield

# Yield with parameters
def with_value
  yield(42)
end

with_value { |value| puts "The value is #{value}" }

# With Zeitwerk, you don't need to require files explicitly

# If you have a file app/models/user.rb with:
class User
  # ...
end

# You can use it anywhere without requiring it:
user = User.new

# Zeitwerk also handles namespaces:
# app/services/payment/processor.rb maps to Payment::Processor