Sintaks Utama #

def hitung_total(harga, jumlah)
  diskon = 0.1                    # variabel lokal
  subtotal = harga * jumlah       # variabel lokal
  total = subtotal - (subtotal * diskon)
  total
end

# ANTI-PATTERN: mencoba akses variabel lokal dari luar scope-nya
puts diskon   # => NameError: undefined local variable or method 'diskon'

# BENAR: variabel lokal hanya hidup di dalam metodenya
puts hitung_total(100_000, 3)   # => 270000.0

# ANTI-PATTERN: camelCase untuk variabel lokal
firstName = "Budi"
totalHarga = 50_000

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

class Mahasiswa
  def initialize(nama, nim)
    @nama = nama    # variabel instance
    @nim  = nim     # variabel instance
  end

  def perkenalan
    # @nama bisa diakses di sini karena masih instance yang sama
    "Halo, saya #{@nama} dengan NIM #{@nim}."
  end

  def ubah_nama(nama_baru)
    @nama = nama_baru
  end
end

mhs1 = Mahasiswa.new("Rina", "20230001")
mhs2 = Mahasiswa.new("Bagas", "20230002")

puts mhs1.perkenalan  # => Halo, saya Rina dengan NIM 20230001.
puts mhs2.perkenalan  # => Halo, saya Bagas dengan NIM 20230002.

mhs1.ubah_nama("Rina Wijaya")
puts mhs1.perkenalan  # => Halo, saya Rina Wijaya dengan NIM 20230001.
puts mhs2.perkenalan  # => Halo, saya Bagas dengan NIM 20230002. (tidak terpengaruh)

class Koneksi
  @@jumlah_koneksi = 0   # variabel kelas, berbagi di semua instance

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

  def self.jumlah_aktif
    @@jumlah_koneksi
  end
end

k1 = Koneksi.new("db-primary")
k2 = Koneksi.new("db-replica")
k3 = Koneksi.new("cache")

puts Koneksi.jumlah_aktif   # => 3

# ANTI-PATTERN: variabel global membuat kode sulit diprediksi
$mode_debug = true

def proses_data(data)
  puts "[DEBUG] Memproses: #{data}" if $mode_debug
  # kode lain...
end

# BENAR: gunakan parameter atau konstanta sebagai alternatif
DEBUG_MODE = ENV["DEBUG"] == "true"   # baca dari environment

def proses_data(data, verbose: false)
  puts "[DEBUG] Memproses: #{data}" if verbose
  # kode lain...
end

nama   = "Dewi"
kota   = 'Jakarta'

# Kutip ganda: mendukung string interpolation dan escape sequence
puts "Halo, #{nama}! Kamu dari #{kota}."   # => Halo, Dewi! Kamu dari Jakarta.
puts "Baris baru:\nIni baris kedua."       # => newline aktif

# Kutip tunggal: literal, tidak ada interpolasi atau escape
puts 'Halo, #{nama}!'     # => Halo, #{nama}!  (dicetak apa adanya)
puts 'Baris baru:\n...'   # => Baris baru:\n...  (\n tidak diproses)

# ANTI-PATTERN: string concatenation dengan +
pesan = "Selamat datang, " + nama + "! Kamu dari " + kota + "."

# BENAR: gunakan interpolasi — lebih bersih dan lebih cepat
pesan = "Selamat datang, #{nama}! Kamu dari #{kota}."

teks = "  Ruby adalah bahasa yang menyenangkan!  "

teks.strip          # => "Ruby adalah bahasa yang menyenangkan!"
teks.upcase         # => "  RUBY ADALAH BAHASA YANG MENYENANGKAN!  "
teks.downcase       # => "  ruby adalah bahasa yang menyenangkan!  "
teks.include?("Ruby")  # => true
teks.split(" ")     # => ["Ruby", "adalah", "bahasa", "yang", "menyenangkan!"]
teks.gsub("Ruby", "Python")  # => "  Python adalah bahasa yang menyenangkan!  "

# ANTI-PATTERN: pembagian integer menghasilkan hasil yang mengejutkan
puts 7 / 2     # => 3  (bukan 3.5!)
puts 7 % 2     # => 1  (sisa bagi)

# BENAR: gunakan Float jika butuh hasil desimal
puts 7.0 / 2   # => 3.5
puts 7 / 2.0   # => 3.5
puts 7.fdiv(2) # => 3.5  (cara idiomatik Ruby)

populasi_indonesia = 270_000_000   # jauh lebih mudah dibaca dari 270000000
harga_rumah = 1_500_000_000
pi_approx   = 3.141_592_653

# Symbol: dimulai dengan titik dua
status = :aktif
role   = :admin

# ANTI-PATTERN: menggunakan string sebagai key hash
user = {"nama" => "Andi", "role" => "admin"}

# BENAR: gunakan symbol sebagai key hash — lebih efisien
user = {nama: "Andi", role: :admin}
puts user[:nama]   # => Andi

# Symbol adalah singleton — objek yang sama di memori
puts :aktif.object_id == :aktif.object_id  # => true
puts "aktif".object_id == "aktif".object_id  # => false (dua objek berbeda)

# Membuat array
buah  = ["apel", "mangga", "jeruk"]
angka = [1, 2, 3, 4, 5]
campur = [1, "dua", :tiga, 4.0, true]

# Akses elemen
puts buah[0]     # => apel
puts buah[-1]    # => jeruk  (indeks negatif dari belakang)
puts buah[1..2]  # => ["mangga", "jeruk"]  (range)

# Method umum
buah.push("nanas")         # tambah di belakang
buah.unshift("durian")     # tambah di depan
buah.pop                   # hapus dan kembalikan elemen terakhir
buah.length                # => jumlah elemen

# Iterasi — cara idiomatik Ruby
buah.each { |b| puts b }
buah.map  { |b| b.upcase }    # => ["APEL", "MANGGA", "JERUK"]
buah.select { |b| b.length > 4 }  # => ["mangga", "jeruk"]
buah.reject { |b| b.start_with?("a") }  # => ["mangga", "jeruk"]

# Hash dengan symbol key (cara modern)
profil = {
  nama:  "Siti",
  umur:  28,
  kota:  "Bandung",
  aktif: true
}

puts profil[:nama]   # => Siti
puts profil[:umur]   # => 28

# Tambah atau ubah key
profil[:email] = "[email protected]"
profil[:umur]  = 29

# Cek keberadaan key
profil.key?(:email)    # => true
profil.key?(:telepon)  # => false

# Iterasi
profil.each do |kunci, nilai|
  puts "#{kunci}: #{nilai}"
end

# Transformasi
profil.map { |k, v| [k, v.to_s] }.to_h   # semua nilai jadi string
profil.select { |k, v| v.is_a?(String) }  # hanya nilai bertipe String

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

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

puts 1 <=> 2    # => -1  (kiri lebih kecil)
puts 2 <=> 2    # => 0   (sama)
puts 3 <=> 2    # => 1   (kiri lebih besar)

# Penggunaan praktis: sort dengan aturan kustom
nama = ["Citra", "Andi", "Bagas", "Devi"]
nama.sort { |a, b| a <=> b }  # => ["Andi", "Bagas", "Citra", "Devi"]
nama.sort { |a, b| b <=> a }  # => ["Devi", "Citra", "Bagas", "Andi"] (terbalik)

# ANTI-PATTERN: rentan NoMethodError jika user nil
def tampilkan_email(user)
  puts user.email.upcase
end

# BENAR: gunakan safe navigation operator
def tampilkan_email(user)
  puts user&.email&.upcase || "Email tidak tersedia"
end

# && dan || (lebih ketat, direkomendasikan untuk kondisi)
puts true && false   # => false
puts true || false   # => true
puts !true           # => false

# and, or, not (lebih longgar, hindari dalam ekspresi kondisi)
# Gunakan 'and' dan 'or' hanya untuk flow control, bukan ekspresi boolean

# ANTI-PATTERN: and/or dalam kondisi bisa mengejutkan
nilai = true and false   # nilai = true (bukan false!)
nilai = true && false    # nilai = false (seperti yang diharapkan)

nilai = 75

# Bentuk standar
if nilai >= 80
  puts "Lulus dengan nilai bagus"
elsif nilai >= 60
  puts "Lulus"
else
  puts "Tidak lulus"
end

# Inline if — untuk kondisi sederhana satu baris
puts "Lulus" if nilai >= 60
puts "Tidak lulus" unless nilai >= 60   # unless = if not

# Ternary — untuk assignment kondisional
status = nilai >= 60 ? "Lulus" : "Tidak lulus"

# ANTI-PATTERN: ternary bertumpuk — sulit dibaca
hasil = a > b ? (a > c ? a : c) : (b > c ? b : c)

# BENAR: gunakan if-elsif untuk kondisi bertumpuk
hasil = if a > b && a > c
           a
         elsif b > c
           b
         else
           c
         end

nilai = 85

# Matching dengan range
grade = case nilai
        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 dengan kelas
def deskripsikan(objek)
  case objek
  when String  then "Ini adalah String: #{objek}"
  when Integer then "Ini adalah Integer: #{objek}"
  when Array   then "Ini adalah Array dengan #{objek.length} elemen"
  when NilClass then "Ini adalah nil"
  else "Tipe tidak dikenal: #{objek.class}"
  end
end

puts deskripsikan("Ruby")    # => Ini adalah String: Ruby
puts deskripsikan(42)        # => Ini adalah Integer: 42
puts deskripsikan([1, 2, 3]) # => Ini adalah Array dengan 3 elemen

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

# BENAR: gunakan .each atau .times
5.times { |i| puts i }
(0..4).each { |i| puts i }

# Iterasi array
produk = ["laptop", "mouse", "keyboard"]

# ANTI-PATTERN: akses via indeks manual
i = 0
while i < produk.length
  puts produk[i]
  i += 1
end

# BENAR: each
produk.each { |p| puts p }

# Jika butuh indeks sekaligus nilai:
produk.each_with_index do |p, i|
  puts "#{i + 1}. #{p}"
end
# => 1. laptop
# => 2. mouse
# => 3. keyboard

# Loop dengan while dan until
hitung = 0
while hitung < 5
  hitung += 1
end

hitung = 0
until hitung == 5
  hitung += 1
end

# loop dengan break — untuk loop tak terbatas
loop do
  input = gets.chomp
  break if input == "keluar"
  puts "Kamu ketik: #{input}"
end

# Sintaks blok: do...end atau { }
# Gunakan do...end untuk blok multi-baris:
[1, 2, 3].each do |n|
  kuadrat = n ** 2
  puts "#{n}^2 = #{kuadrat}"
end

# Gunakan { } untuk blok satu baris:
[1, 2, 3].map { |n| n ** 2 }   # => [1, 4, 9]

# Membuat metode yang menerima blok:
def jalankan_dua_kali
  yield   # panggil blok yang diteruskan
  yield
end

jalankan_dua_kali { puts "Halo!" }
# => Halo!
# => Halo!

# Meneruskan nilai ke blok via yield:
def sapa(nama)
  yield nama if block_given?
end

sapa("Dewi") { |n| puts "Selamat datang, #{n}!" }
# => Selamat datang, Dewi!

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

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

# Proc bisa diteruskan ke metode dengan &
angka = [-2, -1, 0, 1, 2, 3]
positif = angka.select(&validasi_positif)
puts positif.inspect   # => [1, 2, 3]

# PENTING: return di dalam Proc keluar dari metode yang memanggilnya
def cek_nilai
  validasi = Proc.new { return "keluar dari metode" }
  validasi.call
  puts "Baris ini tidak akan dieksekusi"  # tidak pernah sampai sini
end

puts cek_nilai   # => keluar dari metode

# Sintaks lambda
kalikan = ->(a, b) { a * b }
sapa    = lambda { |nama| "Halo, #{nama}!" }

puts kalikan.call(4, 5)   # => 20
puts sapa.call("Rudi")    # => Halo, Rudi!

# Lambda ketat soal argumen
kalikan.call(4)       # => ArgumentError: wrong number of arguments (given 1, expected 2)

# BENAR: return dari lambda tidak keluar dari metode
def cek_lambda
  hitung = ->(n) { return n * 2 }
  hasil = hitung.call(10)
  puts "Hasil: #{hasil}"  # baris ini TETAP dieksekusi
end

cek_lambda   # => Hasil: 20

# ANTI-PATTERN: getter dan setter manual yang verbose
class Produk
  def nama
    @nama
  end

  def nama=(nilai)
    @nama = nilai
  end

  def harga
    @harga
  end
end

# BENAR: gunakan attr_accessor
class Produk
  attr_reader   :id       # hanya bisa dibaca
  attr_writer   :stok     # hanya bisa diubah
  attr_accessor :nama, :harga  # bisa dibaca dan diubah

  def initialize(id, nama, harga)
    @id    = id
    @nama  = nama
    @harga = harga
    @stok  = 0
  end

  def info
    "#{@nama} - Rp #{@harga}"
  end
end

p = Produk.new(1, "Keyboard", 350_000)
puts p.nama    # => Keyboard
puts p.harga   # => 350000
p.nama = "Mechanical Keyboard"
p.harga = 500_000
puts p.info    # => Mechanical Keyboard - Rp 500000

# Default argument
def kirim_email(tujuan, subjek = "Tanpa Subjek", format = :html)
  puts "Kirim ke #{tujuan} | Subjek: #{subjek} | Format: #{format}"
end

kirim_email("[email protected]")
kirim_email("[email protected]", "Selamat Datang")

# Keyword argument — lebih eksplisit dan urutan tidak penting
def buat_user(nama:, email:, role: :user, aktif: true)
  puts "User: #{nama} (#{email}) | Role: #{role} | Aktif: #{aktif}"
end

buat_user(nama: "Rina", email: "[email protected]")
buat_user(email: "[email protected]", nama: "Admin", role: :admin)

def bagi(a, b)
  begin
    hasil = a / b
    puts "Hasil: #{hasil}"
  rescue ZeroDivisionError => e
    puts "Error: tidak bisa membagi dengan nol — #{e.message}"
  rescue TypeError => e
    puts "Error: tipe data salah — #{e.message}"
  ensure
    puts "Operasi selesai."  # selalu dijalankan
  end
end

bagi(10, 2)    # => Hasil: 5 \n Operasi selesai.
bagi(10, 0)    # => Error: tidak bisa membagi dengan nol... \n Operasi selesai.
bagi(10, "a")  # => Error: tipe data salah... \n Operasi selesai.

# ANTI-PATTERN: menangkap semua exception sekaligus tanpa tahu jenisnya
begin
  # kode berisiko
rescue Exception => e
  puts "Ada error: #{e}"  # terlalu lebar — akan menangkap bahkan Ctrl+C!
end

# BENAR: tangkap exception yang spesifik
begin
  # kode berisiko
rescue ActiveRecord::RecordNotFound => e
  # tangani record tidak ditemukan
rescue Net::TimeoutError => e
  # tangani timeout
rescue StandardError => e
  # fallback untuk error umum
end

# Raise exception sendiri
def validasi_umur(umur)
  raise ArgumentError, "Umur tidak boleh negatif" if umur < 0
  raise ArgumentError, "Umur tidak realistis" if umur > 150
  umur
end

begin
  validasi_umur(-5)
rescue ArgumentError => e
  puts "Validasi gagal: #{e.message}"  # => Validasi gagal: Umur tidak boleh negatif
end

# retry — coba ulang setelah error
percobaan = 0
begin
  percobaan += 1
  puts "Percobaan ke-#{percobaan}"
  raise "Koneksi gagal" if percobaan < 3
  puts "Berhasil!"
rescue RuntimeError => e
  retry if percobaan < 3
  puts "Menyerah setelah 3 percobaan: #{e.message}"
end