Core Syntax #

def calculate_total(price, quantity)
  discount = 0.1                  # local variable
  subtotal = price * quantity     # local variable
  total = subtotal - (subtotal * discount)
  total
end

# ANTI-PATTERN: trying to access a local variable from outside its scope
puts discount   # => NameError: undefined local variable or method 'discount'

# CORRECT: local variables only live inside their method
puts calculate_total(100_000, 3)   # => 270000.0

# ANTI-PATTERN: camelCase for local variables
firstName = "Budi"
totalHarga = 50_000

# CORRECT: snake_case
first_name = "Budi"
total_harga = 50_000

class Student
  def initialize(name, nim)
    @name = name    # instance variable
    @nim  = nim     # instance variable
  end

  def introduction
    # @name is accessible here because it's the same instance
    "Hello, I'm #{@name} with NIM #{@nim}."
  end

  def change_name(new_name)
    @name = new_name
  end
end

student1 = Student.new("Rina", "20230001")
student2 = Student.new("Bagas", "20230002")

puts student1.introduction  # => Hello, I'm Rina with NIM 20230001.
puts student2.introduction  # => Hello, I'm Bagas with NIM 20230002.

student1.change_name("Rina Wijaya")
puts student1.introduction  # => Hello, I'm Rina Wijaya with NIM 20230001.
puts student2.introduction  # => Hello, I'm Bagas with NIM 20230002. (unaffected)

class Connection
  @@connection_count = 0   # class variable, shared across all instances

  def initialize(host)
    @host = host
    @@connection_count += 1
  end

  def self.active_count
    @@connection_count
  end
end

c1 = Connection.new("db-primary")
c2 = Connection.new("db-replica")
c3 = Connection.new("cache")

puts Connection.active_count   # => 3

# ANTI-PATTERN: global variables make code hard to predict
$debug_mode = true

def process_data(data)
  puts "[DEBUG] Processing: #{data}" if $debug_mode
  # other code...
end

# CORRECT: use parameters or constants instead
DEBUG_MODE = ENV["DEBUG"] == "true"   # read from the environment

def process_data(data, verbose: false)
  puts "[DEBUG] Processing: #{data}" if verbose
  # other code...
end

name = "Dewi"
city = 'Jakarta'

# Double quotes: support string interpolation and escape sequences
puts "Hello, #{name}! You're from #{city}."   # => Hello, Dewi! You're from Jakarta.
puts "New line:\nThis is the second line."    # => newline active

# Single quotes: literal, no interpolation or escaping
puts 'Hello, #{name}!'     # => Hello, #{name}!  (printed as-is)
puts 'New line:\n...'      # => New line:\n...  (\n not processed)

# ANTI-PATTERN: string concatenation with +
message = "Welcome, " + name + "! You're from " + city + "."

# CORRECT: use interpolation — cleaner and faster
message = "Welcome, #{name}! You're from #{city}."

text = "  Ruby is a fun language!  "

text.strip          # => "Ruby is a fun language!"
text.upcase         # => "  RUBY IS A FUN LANGUAGE!  "
text.downcase       # => "  ruby is a fun language!  "
text.include?("Ruby")  # => true
text.split(" ")     # => ["Ruby", "is", "a", "fun", "language!"]
text.gsub("Ruby", "Python")  # => "  Python is a fun language!  "

# ANTI-PATTERN: integer division produces a surprising result
puts 7 / 2     # => 3  (not 3.5!)
puts 7 % 2     # => 1  (remainder)

# CORRECT: use Float if you need a decimal result
puts 7.0 / 2   # => 3.5
puts 7 / 2.0   # => 3.5
puts 7.fdiv(2) # => 3.5  (the idiomatic Ruby way)

indonesia_population = 270_000_000   # far easier to read than 270000000
house_price = 1_500_000_000
pi_approx   = 3.141_592_653

# Symbol: starts with a colon
status = :active
role   = :admin

# ANTI-PATTERN: using strings as hash keys
user = {"name" => "Andi", "role" => "admin"}

# CORRECT: use symbols as hash keys — more efficient
user = {name: "Andi", role: :admin}
puts user[:name]   # => Andi

# Symbols are singletons — the same object in memory
puts :active.object_id == :active.object_id  # => true
puts "active".object_id == "active".object_id  # => false (two different objects)

# Creating arrays
fruits  = ["apple", "mango", "orange"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", :three, 4.0, true]

# Accessing elements
puts fruits[0]     # => apple
puts fruits[-1]    # => orange  (negative index counts from the end)
puts fruits[1..2]  # => ["mango", "orange"]  (range)

# Common methods
fruits.push("pineapple")         # add to the end
fruits.unshift("durian")         # add to the front
fruits.pop                       # remove and return the last element
fruits.length                    # => number of elements

# Iteration — the idiomatic Ruby way
fruits.each { |f| puts f }
fruits.map  { |f| f.upcase }    # => ["APPLE", "MANGO", "ORANGE"]
fruits.select { |f| f.length > 4 }  # => ["mango", "orange"]
fruits.reject { |f| f.start_with?("a") }  # => ["mango", "orange"]

# Hash with symbol keys (the modern way)
profile = {
  name:  "Siti",
  age:   28,
  city:  "Bandung",
  active: true
}

puts profile[:name]   # => Siti
puts profile[:age]    # => 28

# Add or change keys
profile[:email] = "[email protected]"
profile[:age]  = 29

# Check key existence
profile.key?(:email)    # => true
profile.key?(:phone)    # => false

# Iteration
profile.each do |key, value|
  puts "#{key}: #{value}"
end

# Transformation
profile.map { |k, v| [k, v.to_s] }.to_h   # all values become strings
profile.select { |k, v| v.is_a?(String) }  # only String values

# Arithmetic
puts 10 + 3   # => 13
puts 10 - 3   # => 7
puts 10 * 3   # => 30
puts 10 / 3   # => 3   (integer division)
puts 10 % 3   # => 1   (modulo)
puts 10 ** 3  # => 1000 (power)

# Comparison
puts 10 > 3    # => true
puts 10 < 3    # => false
puts 10 >= 10  # => true
puts 10 == 10  # => true
puts 10 != 3   # => true

puts 1 <=> 2    # => -1  (left is smaller)
puts 2 <=> 2    # => 0   (equal)
puts 3 <=> 2    # => 1   (left is greater)

# Practical use: sort with custom rules
names = ["Citra", "Andi", "Bagas", "Devi"]
names.sort { |a, b| a <=> b }  # => ["Andi", "Bagas", "Citra", "Devi"]
names.sort { |a, b| b <=> a }  # => ["Devi", "Citra", "Bagas", "Andi"] (reversed)

# ANTI-PATTERN: vulnerable to NoMethodError if user is nil
def display_email(user)
  puts user.email.upcase
end

# CORRECT: use the safe navigation operator
def display_email(user)
  puts user&.email&.upcase || "Email not available"
end

# && and || (stricter, recommended for conditions)
puts true && false   # => false
puts true || false   # => true
puts !true           # => false

# and, or, not (looser, avoid in condition expressions)
# Use 'and' and 'or' only for flow control, not boolean expressions

# ANTI-PATTERN: and/or in conditions can surprise you
value = true and false   # value = true (not false!)
value = true && false    # value = false (as expected)

score = 75

# Standard form
if score >= 80
  puts "Passed with a good grade"
elsif score >= 60
  puts "Passed"
else
  puts "Failed"
end

# Inline if — for simple one-line conditions
puts "Passed" if score >= 60
puts "Failed" unless score >= 60   # unless = if not

# Ternary — for conditional assignment
status = score >= 60 ? "Passed" : "Failed"

# ANTI-PATTERN: nested ternary — hard to read
result = a > b ? (a > c ? a : c) : (b > c ? b : c)

# CORRECT: use if-elsif for nested conditions
result = if a > b && a > c
           a
         elsif b > c
           b
         else
           c
         end

score = 85

# Matching with ranges
grade = case score
        when 90..100 then "A"
        when 80..89  then "B"
        when 70..79  then "C"
        when 60..69  then "D"
        else              "E"
        end
puts grade   # => B

# Matching with classes
def describe(object)
  case object
  when String  then "This is a String: #{object}"
  when Integer then "This is an Integer: #{object}"
  when Array   then "This is an Array with #{object.length} elements"
  when NilClass then "This is nil"
  else "Unknown type: #{object.class}"
  end
end

puts describe("Ruby")    # => This is a String: Ruby
puts describe(42)        # => This is an Integer: 42
puts describe([1, 2, 3]) # => This is an Array with 3 elements

# ANTI-PATTERN: C-style for loop
for i in 0..4
  puts i
end

# CORRECT: use .each or .times
5.times { |i| puts i }
(0..4).each { |i| puts i }

# Iterating over an array
products = ["laptop", "mouse", "keyboard"]

# ANTI-PATTERN: manual index access
i = 0
while i < products.length
  puts products[i]
  i += 1
end

# CORRECT: each
products.each { |p| puts p }

# If you need the index along with the value:
products.each_with_index do |p, i|
  puts "#{i + 1}. #{p}"
end
# => 1. laptop
# => 2. mouse
# => 3. keyboard

# Looping with while and until
count = 0
while count < 5
  count += 1
end

count = 0
until count == 5
  count += 1
end

# loop with break — for infinite loops
loop do
  input = gets.chomp
  break if input == "exit"
  puts "You typed: #{input}"
end

# Block syntax: do...end or { }
# Use do...end for multi-line blocks:
[1, 2, 3].each do |n|
  square = n ** 2
  puts "#{n}^2 = #{square}"
end

# Use { } for one-line blocks:
[1, 2, 3].map { |n| n ** 2 }   # => [1, 4, 9]

# Creating a method that accepts a block:
def run_twice
  yield   # call the passed block
  yield
end

run_twice { puts "Hello!" }
# => Hello!
# => Hello!

# Passing values to the block via yield:
def greet(name)
  yield name if block_given?
end

greet("Dewi") { |n| puts "Welcome, #{n}!" }
# => Welcome, Dewi!

positive_check = Proc.new { |n| n > 0 }

puts positive_check.call(5)    # => true
puts positive_check.call(-3)   # => false

# Procs can be passed to methods with &
numbers = [-2, -1, 0, 1, 2, 3]
positive = numbers.select(&positive_check)
puts positive.inspect   # => [1, 2, 3]

# IMPORTANT: return inside a Proc exits the calling method
def check_value
  validation = Proc.new { return "exiting the method" }
  validation.call
  puts "This line will never execute"  # never reached
end

puts check_value   # => exiting the method

# Lambda syntax
multiply = ->(a, b) { a * b }
greet    = lambda { |name| "Hello, #{name}!" }

puts multiply.call(4, 5)   # => 20
puts greet.call("Rudi")    # => Hello, Rudi!

# Lambdas are strict about arguments
multiply.call(4)       # => ArgumentError: wrong number of arguments (given 1, expected 2)

# CORRECT: return from a lambda doesn't exit the method
def check_lambda
  calculate = ->(n) { return n * 2 }
  result = calculate.call(10)
  puts "Result: #{result}"  # this line STILL executes
end

check_lambda   # => Result: 20

# ANTI-PATTERN: verbose manual getters and setters
class Product
  def name
    @name
  end

  def name=(value)
    @name = value
  end

  def price
    @price
  end
end

# CORRECT: use attr_accessor
class Product
  attr_reader   :id       # read-only
  attr_writer   :stock    # write-only
  attr_accessor :name, :price  # read and write

  def initialize(id, name, price)
    @id    = id
    @name  = name
    @price = price
    @stock = 0
  end

  def info
    "#{@name} - Rp #{@price}"
  end
end

p = Product.new(1, "Keyboard", 350_000)
puts p.name    # => Keyboard
puts p.price   # => 350000
p.name = "Mechanical Keyboard"
p.price = 500_000
puts p.info    # => Mechanical Keyboard - Rp 500000

# Default arguments
def send_email(to, subject = "No Subject", format = :html)
  puts "Send to #{to} | Subject: #{subject} | Format: #{format}"
end

send_email("[email protected]")
send_email("[email protected]", "Welcome")

# Keyword arguments — more explicit and order doesn't matter
def create_user(name:, email:, role: :user, active: true)
  puts "User: #{name} (#{email}) | Role: #{role} | Active: #{active}"
end

create_user(name: "Rina", email: "[email protected]")
create_user(email: "[email protected]", name: "Admin", role: :admin)

def divide(a, b)
  begin
    result = a / b
    puts "Result: #{result}"
  rescue ZeroDivisionError => e
    puts "Error: cannot divide by zero — #{e.message}"
  rescue TypeError => e
    puts "Error: wrong data type — #{e.message}"
  ensure
    puts "Operation finished."  # always runs
  end
end

divide(10, 2)    # => Result: 5 \n Operation finished.
divide(10, 0)    # => Error: cannot divide by zero... \n Operation finished.
divide(10, "a")  # => Error: wrong data type... \n Operation finished.

# ANTI-PATTERN: catching every exception without knowing its type
begin
  # risky code
rescue Exception => e
  puts "There was an error: #{e}"  # too broad — this even catches Ctrl+C!
end

# CORRECT: catch specific exceptions
begin
  # risky code
rescue ActiveRecord::RecordNotFound => e
  # handle record not found
rescue Net::TimeoutError => e
  # handle timeout
rescue StandardError => e
  # fallback for common errors
end

# Raising your own exceptions
def validate_age(age)
  raise ArgumentError, "Age cannot be negative" if age < 0
  raise ArgumentError, "Age is unrealistic" if age > 150
  age
end

begin
  validate_age(-5)
rescue ArgumentError => e
  puts "Validation failed: #{e.message}"  # => Validation failed: Age cannot be negative
end

# retry — try again after an error
attempts = 0
begin
  attempts += 1
  puts "Attempt #{attempts}"
  raise "Connection failed" if attempts < 3
  puts "Success!"
rescue RuntimeError => e
  retry if attempts < 3
  puts "Giving up after 3 attempts: #{e.message}"
end