Belajar Ruby on Rails - Instalasi & Struktur Project

#Pendahuluan

Setelah di episode 2 kalian memahami arsitektur MVC Rails, episode 3 adalah momen hands-on pertama: menginstall Rails dan membangun project nyata. Di sinilah konsep abstrak menjadi struktur folder yang bisa kalian sentuh, jalankan, dan jelajahi.

Mengapa episode ini krusial? Karena struktur direktori Rails adalah manifestasi fisik dari konvensi yang sudah kita bahas — begitu kalian paham di mana file diletakkan dan peran tiap folder, kalian bisa masuk ke project Rails mana pun dan langsung tahu cara navigasinya. Episode ini juga memberi kalian dua command yang akan dipakai hampir setiap hari: bin/rails server dan bin/rails console.

#Menginstall Rails

Rails diinstall sebagai gem global (atau per-user). Pastikan Bundler sudah ada lalu install Rails 8.1.x:

gem install rails -v "~> 8.1.0"
rails --version

rails --version harus menampilkan Rails 8.1.3.1 atau setidaknya versi 8.1.x terbaru. Jika kalian memakai rbenv, gem diinstall per-versi Ruby — pastikan rbenv global mengarah ke Ruby 3.4.x yang sama seperti di episode 0.

#Membuat Project Pertama

Sekarang buat project blog. Kita pilih SQLite dulu agar bisa langsung jalan tanpa konfigurasi database:

rails new blog --database=sqlite3
cd blog

Untuk project yang nanti memakai PostgreSQL, gunakan --database=postgresql — kita akan melakukannya di episode 5. Opsi umum lainnya: --api (API only, episode 15), --css=bootstrap, dan --skip-javascript.

#Struktur Direktori

Inilah peta direktori yang paling sering kalian sentuh:

blog/
├── app/                # semua kode aplikasi
│   ├── controllers/    # controllers (MVC)
│   ├── models/         # models & Active Record
│   ├── views/          # templates (ERB, partials)
│   ├── jobs/           # Active Job
│   ├── mailers/        # Action Mailer
│   ├── channels/       # Action Cable
│   ├── helpers/        # view helpers
│   ├── assets/         # CSS, JS, images
│   └── javascript/     # Stimulus controllers (Hotwire)
├── config/             # routes, environments, database.yml
├── db/                 # migrations, schema.rb, seeds.rb
├── test/               # Minitest & fixtures
├── public/             # file statis
└── Gemfile             # dependency

Semua kode kalian tinggal di app/; config/ memegang pengaturan (termasuk config/routes.rb yang dibahas di episode 4); db/ memegang riwayat perubahan schema (episode 6). Gemfile.lock di root memastikan dependency reproducible.

#Menjalankan Server dan Console

#bin/rails server

bin/rails server

Server berjalan di http://localhost:3000 dengan auto-reload: perubahan kode langsung terlihat tanpa restart. Inilah kenapa bin/rails (bukan rails langsung) lebih disarankan — ia memakai versi gem dari project.

#bin/rails console

bin/rails console

Console adalah IRB yang me-load seluruh aplikasi — kalian bisa memanggil model, memeriksa route, dan mengeksekusi kode apa pun. Ini alat debugging utama sepanjang series:

Eksplorasi di console

> Rails.application.routes.routes.size
> puts ActiveRecord::Base.connection.adapter_name

#Generator

Generator (bin/rails g) adalah mesin konvensi: g model, g controller, g migration, g scaffold, dan g job — cek daftar lengkapnya dengan bin/rails generate --help. Kita akan pakai semuanya sepanjang series.

#Scaffold CRUD Pertama

Sekarang mari membangun CRUD lengkap hanya dengan satu perintah — ini demonstrasi paling jelas dari kekuatan konvensi Rails:

bin/rails generate scaffold Post title:string body:text
bin/rails db:migrate
bin/rails server

Buka http://localhost:3000/posts. Kalian sudah punya halaman index, show, new, edit, delete, dan form valid — semua dari satu generator. Yang dihasilkan generator ini:

app/controllers/posts_controller.rb
app/models/post.rb
app/views/posts/*.erb
db/migrate/*_create_posts.rb
test/models/post_test.rb
config/routes.rb  # + resources :posts

Mari kita periksa controller yang dihasilkan:

PostsController dari scaffold

class PostsController < ApplicationController
  before_action :set_post, only: %i[show edit update destroy]
 
  def index
    @posts = Post.all
  end
 
  def show
  end
 
  def new
    @post = Post.new
  end
 
  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post, notice: "Post was successfully created."
    else
      render :new, status: :unprocessable_entity
    end
  end
 
  private
 
  def set_post
    @post = Post.find(params[:id])
  end
 
  def post_params
    params.expect(post: [:title, :body])
  end
end

Perhatikan pola yang akan berulang di hampir semua controller: 7 action RESTful (index, show, new, create, edit, update, destroy), before_action untuk menyiapkan @post, dan params.expect untuk strong parameters. Detail before_action dan render/redirect kita bedah di episode 4, strong params di episode 8.

#Menjelajahi dengan Console

Console adalah cara terbaik memahami apa yang terjadi di balik layar. Coba tambahkan data manual:

CRUD pertama via console

post = Post.new(title: "Hello Rails", body: "Episode 3")
post.save
Post.count
Post.find_by(title: "Hello Rails")

post.save mengembalikan true jika tervalidasi, lalu baris dengan Post.count memverifikasi data masuk ke database SQLite. Dari sini kalian melihat bahwa model Rails adalah objek Ruby biasa yang di-persist ke database oleh Active Record.

#Penutup

Episode 3 adalah jembatan dari teori ke praktik: kalian menginstall Rails 8.1.x, membuat project blog dengan rails new, memahami peta direktori MVC, menjalankan bin/rails server dan bin/rails console, serta membangun CRUD lengkap dengan scaffold dalam hitungan detik.

Inti yang harus dibawa pulang:

• Install Rails dengan gem install rails; cek dengan rails --version.
• rails new blog --database=sqlite3 membuat project lengkap dengan struktur MVC.
• Folder app/ memegang semua kode; config/ dan db/ memegang pengaturan & schema.
• bin/rails server dan bin/rails console adalah dua command harian utama.
• bin/rails generate scaffold menghasilkan CRUD lengkap + pola 7 action RESTful.

Di episode 4 selanjutnya kita akan membedah routing & controllers — resources, nested routes, member/collection, constraints, dan namespaces, plus strong params, render/redirect, flash, dan filters before_action. Pastikan project blog kalian sudah berjalan, karena praktik episode ini berkelanjutan!