Ruby & Rails Glossary

# 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')

# 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 .
 */

# 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

# 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

# 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

# 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!"

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

# 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

# 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 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'

# 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

# 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

# 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"

# 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")

// 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"

# 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

# 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

# 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, !"

# 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

# 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

# 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

# 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

# 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'

# 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

# 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()

# 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