Ruby on Rails Uygulaması Nasıl İnşa Edilir: Kapsamlı Bir Rehber

Ruby on Rails Uygulaması Nasıl İnşa Edilir: Kapsamlı Bir Rehber

Ruby on Rails (genellikle “Rails” olarak anılır), web uygulamaları geliştirmek için kullanılan açık kaynaklı bir sunucu tarafı web uygulama çerçevesidir. Ruby programlama dili üzerine inşa edilmiş olup, geliştiricilere hızlı, verimli ve keyifli bir geliştirme deneyimi sunar. Rails, “Convention Over Configuration” (Yapılandırma Üzerine Kural) ve “Don’t Repeat Yourself” (Kendini Tekrar Etme – DRY) prensiplerini benimseyerek, geliştiricilerin kod yazmaya daha az, iş mantığına odaklanmaya daha çok zaman ayırmasına olanak tanır. Bu prensipler sayesinde, karmaşık web uygulamaları bile kısa sürede geliştirilebilir ve bakımı kolay hale gelir.

Bu kapsamlı rehberde, sıfırdan bir Ruby on Rails uygulaması oluşturma sürecini adım adım inceleyeceğiz. Geliştirme ortamının kurulumundan başlayarak, temel MVC (Model-View-Controller) mimarisini anlamaya, veritabanı etkileşimleri kurmaya, CRUD (Create, Read, Update, Delete) işlevselliği eklemeye ve hatta dağıtımın temel prensiplerine kadar birçok konuya değineceğiz. Amacımız, bu rehberi tamamladığınızda kendi Rails uygulamanızı inşa edebilecek temel bilgi ve becerilere sahip olmanızı sağlamaktır.

Ön Hazırlık ve Ortam Kurulumu

Bir Ruby on Rails uygulaması geliştirmeye başlamadan önce, gerekli yazılımların sisteminize doğru şekilde kurulduğundan emin olmalısınız. Bu bölüm, geliştirme ortamınızı hazırlamanız için gereken adımları detaylandıracaktır.

Ruby Kurulumu

Rails, Ruby dili üzerinde çalıştığı için ilk adım Ruby’yi kurmaktır. Ruby’nin farklı versiyonlarını yönetmek için rbenv veya RVM gibi araçlar kullanmak en iyi yaklaşımdır. Bu araçlar, farklı projeler için farklı Ruby versiyonlarını kolayca değiştirmenize olanak tanır ve olası bağımlılık çakışmalarını önler.

* macOS: Homebrew kullanarak brew install rbenv ruby-build komutuyla rbenv‘i kurabilir, ardından rbenv install 3.2.2 (veya istediğiniz güncel versiyon) ve rbenv global 3.2.2 komutlarıyla Ruby’yi yükleyebilirsiniz.
* Linux: Genellikle dağıtımınızın paket yöneticisi (apt, yum, dnf) ile rbenv ve ruby-build kurabilirsiniz. Ardından macOS’taki gibi Ruby’yi yükleyin.
* Windows: Windows Subsystem for Linux (WSL2) kullanılması şiddetle tavsiye edilir. WSL2 içinde bir Linux dağıtımı (örn. Ubuntu) kurarak, Linux ortamındaki kurulum adımlarını takip edebilirsiniz. Doğrudan Windows’a Ruby kurmak da mümkündür ancak bazı gem’lerin derlenmesi sorunlara yol açabilir.

Kurulumdan sonra, terminalinizde ruby -v komutunu çalıştırarak Ruby versiyonunu kontrol edin.

Veritabanı Kurulumu

Rails, varsayılan olarak SQLite3 ile gelir ancak üretim ortamları için PostgreSQL veya MySQL gibi daha güçlü veritabanları tercih edilir. Bu rehberde PostgreSQL‘i temel alacağız, çünkü Rails topluluğunda yaygın olarak kullanılır ve birçok modern uygulamanın ihtiyacını karşılar.

* macOS: Homebrew ile brew install postgresql komutuyla kolayca kurabilirsiniz.
* Linux: Dağıtımınızın paket yöneticisi ile sudo apt install postgresql postgresql-contrib (Ubuntu/Debian) veya sudo yum install postgresql-server (CentOS/Fedora) komutlarını kullanabilirsiniz. Kurulumdan sonra veritabanı servisini başlatmanız gerekebilir.
* Windows (WSL2): WSL2 içindeki Linux dağıtımında Linux kurulum adımlarını takip edin.

PostgreSQL’i kurduktan sonra, genellikle bir kullanıcı ve veritabanı oluşturmanız gerekebilir. Rails, database.yml dosyasındaki ayarlar ile bu işlemleri otomatikleştirebilir.

Node.js ve Yarn Kurulumu

Rails 6 ve üzeri versiyonlar, front-end varlıklarını (JavaScript kütüphaneleri, CSS çerçeveleri) yönetmek için Node.js ve Yarn’a (veya npm’e) ihtiyaç duyar. Node.js, JavaScript’i sunucu tarafında çalıştırmanıza olanak tanırken, Yarn bir JavaScript paket yöneticisidir.

* Tüm İşletim Sistemleri: Node.js’in resmi web sitesinden (nodejs.org) veya NVM (Node Version Manager) gibi bir araç kullanarak kurabilirsiniz. NVM, Ruby versiyon yöneticilerine benzer şekilde farklı Node.js versiyonlarını yönetmenizi sağlar.
* Node.js kurulduktan sonra, npm install -g yarn komutuyla Yarn’ı kurabilirsiniz.
* Kurulumu node -v ve yarn -v komutlarıyla doğrulayın.

Rails Gem Kurulumu

Tüm bağımlılıklar kurulduktan sonra, Rails gem’ini kurabiliriz. Gem, Ruby paketlerine verilen isimdir.

* Terminalinizde gem install rails komutunu çalıştırın. Bu komut, RubyGems.org’dan Rails’in en son kararlı versiyonunu indirip kuracaktır.
* Kurulumdan sonra, rails -v komutuyla Rails versiyonunu kontrol edin.

Yeni Bir Rails Uygulaması Oluşturma

Geliştirme ortamınız hazır olduğuna göre, ilk Rails uygulamanızı oluşturmaya başlayabiliriz.

Uygulama Oluşturma Komutu

Yeni bir Rails uygulaması oluşturmak için rails new komutunu kullanırız. Bu komut, uygulamanın ismini ve bazı isteğe bağlı parametreleri alır. Örneğin, PostgreSQL kullanmak istediğimizi belirtmek için:

rails new my_first_app --database=postgresql
cd my_first_app

Bu komut:
* my_first_app adında yeni bir dizin oluşturur.
* Bu dizin içinde Rails’in standart dosya ve dizin yapısını kurar.
* Gerekli gem’leri içeren bir Gemfile oluşturur.
* --database=postgresql parametresi sayesinde, config/database.yml dosyasını PostgreSQL’e göre yapılandırır.
* Komutun sonunda bundle install çalıştırılarak Gemfile‘da belirtilen tüm bağımlılık gem’leri yüklenir.

Proje Yapısına Genel Bakış

my_first_app dizinine girdiğinizde, Rails’in düzenli ve tahmin edilebilir dosya yapısını göreceksiniz. En önemli dizinlerden bazıları şunlardır:

* app/: Uygulamanızın ana kodunu içerir (Models, Views, Controllers, Helpers, Assets vb.).
* bin/: Rails komut dosyalarını içerir (örn. rails, rake).
* config/: Uygulamanızın yapılandırma dosyalarını içerir (routes, database, environment settings).
* db/: Veritabanı şeması ve migration dosyalarını içerir.
* lib/: Uygulamanıza özel modüller veya kütüphaneler için.
* public/: Statik dosyalar (HTML, CSS, JavaScript) ve hata sayfaları.
* test/: Uygulamanızın testlerini içerir.
* vendor/: Üçüncü taraf kodları için.
* Gemfile: Uygulamanızın bağımlılıklarını (gem’ler) listeler.

Bu yapı, “Convention Over Configuration” prensibinin bir sonucudur; geliştiricilerin çoğu şeyi baştan yapılandırmak yerine, Rails’in önerdiği yola uyması beklenir.

Veritabanı Yapılandırması

config/database.yml dosyası, uygulamanızın farklı ortamlar (development, test, production) için veritabanı bağlantı ayarlarını içerir. rails new komutunu --database=postgresql ile çalıştırdığımız için bu dosya zaten PostgreSQL’e göre yapılandırılmıştır.

Uygulamanızın veritabanlarını oluşturmak için aşağıdaki komutları çalıştırın:

rails db:create

Bu komut, development ve test ortamları için veritabanlarını oluşturacaktır. Henüz bir tablo oluşturmadığımız için rails db:migrate komutu şu an için herhangi bir işlem yapmayacaktır, ancak veritabanı şemasını oluşturmak için ileride kullanacağız.

Temel MVC Mimarisi ve İlk Adımlar

Rails, Model-View-Controller (MVC) mimarisini benimser. Bu mimari, bir uygulamanın farklı katmanlarını ayırarak kodun daha düzenli, okunabilir ve bakımı kolay olmasını sağlar.

Model-View-Controller (MVC) Nedir?

* Model: Uygulamanızın veri katmanını ve iş mantığını temsil eder. Veritabanıyla etkileşime girer, verileri doğrular, kaydeder ve alır. Rails’te modeller Active Record ile temsil edilir.
* View: Kullanıcı arayüzünü temsil eder. Modellerden gelen verileri alarak kullanıcıya gösterilecek HTML (veya diğer formatlar) oluşturur. Rails’te View’lar genellikle ERB (Embedded Ruby) şablonlarıdır.
* Controller: Model ve View arasındaki aracıdır. Kullanıcının isteklerini (HTTP request) alır, Model’den veri ister, bu verileri işler ve View’a göndererek bir yanıt (HTTP response) oluşturur.

Routing (Yönlendirme)

Rails’te bir web isteği geldiğinde, bu isteğin hangi Controller’daki hangi metoda yönlendirileceğini config/routes.rb dosyası belirler. Bu dosya, uygulamanızın “trafik polisi” gibidir.

config/routes.rb dosyasını açın ve basit bir ana sayfa rotası tanımlayalım:

# config/routes.rb
Rails.application.routes.draw do
  root 'pages#home' # Uygulamanın kök dizinine gelen istekleri PagesController'daki home metoduna yönlendirir.
end

Bu root rotası, tarayıcınızda http://localhost:3000/ adresine gittiğinizde PagesController içindeki home adında bir metodu çalıştırmasını söyler.

Controller Oluşturma

Şimdi PagesController‘ı oluşturalım. Rails generator’ı kullanarak hızlıca bir controller oluşturabiliriz:

rails generate controller Pages home about

Bu komut:
* app/controllers/pages_controller.rb dosyasını oluşturur.
* home ve about adında iki boş metod ekler.
* app/views/pages/home.html.erb ve app/views/pages/about.html.erb adında iki view dosyası oluşturur.

pages_controller.rb dosyası şöyle görünecektir:

# app/controllers/pages_controller.rb
class PagesController < ApplicationController
  def home
    # Burada ana sayfa için gerekli verileri hazırlayabiliriz.
  end

  def about
    # Burada "Hakkımızda" sayfası için gerekli verileri hazırlayabiliriz.
  end
end

View Oluşturma

Controller'lar verileri hazırlar, View'lar ise bu verileri kullanarak HTML çıktısını oluşturur. rails generate controller komutuyla oluşturulan view dosyalarını düzenleyelim.

app/views/pages/home.html.erb dosyasını açın ve içine basit bir HTML içeriği ekleyin:

+erb


Bu benim ilk Rails uygulamamın ana sayfası.
<%= link_to 'Hakkımızda', pages_about_path %>

app/views/pages/about.html.erb dosyasına da benzer bir içerik ekleyin:

+erb


Bu uygulama Ruby on Rails ile geliştirilmiştir.
<%= link_to 'Ana Sayfa', root_path %>

<%= ... %> etiketleri, Ruby kodunun çıktısını HTML içine yerleştirmek için kullanılır. link_to ise Rails'in bir helper metodudur ve belirtilen rota için bir HTML bağlantısı oluşturur. root_path ve pages_about_path ise Rails'in otomatik olarak oluşturduğu rota helper'larıdır.

Uygulamanızı başlatmak için terminalde rails server (veya rails s) komutunu çalıştırın. Tarayıcınızda http://localhost:3000/ adresine giderek ana sayfanızı görebilirsiniz.

Veritabanı ve Model Katmanı

Web uygulamalarının çoğu, verileri kalıcı olarak depolamak için bir veritabanına ihtiyaç duyar. Rails'te bu işlem, Active Record adı verilen ORM (Object-Relational Mapping) aracı sayesinde kolaylaşır. Active Record, Ruby nesneleri ile veritabanı tabloları arasında bir köprü görevi görür.

Model Oluşturma

Bir blog uygulaması yaptığımızı varsayalım ve gönderileri (posts) depolamak isteyelim. Bir Post modeli oluşturalım:

rails generate model Post title:string content:text

Bu komut iki önemli şey yapar:
1. app/models/post.rb adında bir model dosyası oluşturur.
2. db/migrate/YYYYMMDDHHMMSS_create_posts.rb adında bir migration dosyası oluşturur. Migration dosyaları, veritabanı şemasındaki değişiklikleri (tablo oluşturma, sütun ekleme vb.) yönetmek için kullanılır.

post.rb dosyası başlangıçta boş olacaktır, ancak Active Record sayesinde veritabanı tablosuyla etkileşim kurma yeteneğine sahiptir.

create_posts.rb migration dosyası şöyle görünecektir:

# db/migrate/YYYYMMDDHHMMSS_create_posts.rb
class CreatePosts < ActiveRecord::Migration[7.0] # Rails versiyonuna göre değişebilir
  def change
    create_table :posts do |t|
      t.string :title
      t.text :content

      t.timestamps # created_at ve updated_at sütunlarını otomatik ekler
    end
  end
end

Bu migration dosyasını çalıştırarak veritabanımızda posts tablosunu oluşturalım:

rails db:migrate

Artık veritabanımızda posts adında, id, title, content, created_at ve updated_at sütunlarına sahip bir tablo var.

Active Record

Active Record, veritabanı etkileşimlerini Ruby nesneleri üzerinden yapmamızı sağlar.

* Veri Oluşturma (Create):

post = Post.new(title: "İlk Gönderi", content: "Bu benim ilk blog gönderim.")
    post.save # Veritabanına kaydeder
    # Veya daha kısası:
    Post.create(title: "İkinci Gönderi", content: "Bu da ikinci gönderi.")

* Veri Okuma (Read):

all_posts = Post.all # Tüm gönderileri alır
    first_post = Post.first # İlk gönderiyi alır
    specific_post = Post.find(1) # ID'si 1 olan gönderiyi alır
    search_posts = Post.where("title LIKE ?", "%ilk%") # Başlığında "ilk" geçen gönderileri bulur

* Veri Güncelleme (Update):

post = Post.find(1)
    post.title = "Güncellenmiş Başlık"
    post.save # Değişiklikleri kaydeder
    # Veya daha kısası:
    post.update(content: "Güncellenmiş içerik.")

* Veri Silme (Delete):

post = Post.find(1)
    post.destroy # Gönderiyi veritabanından siler

Validasyonlar

Modeller, veritabanına kaydedilmeden önce verilerin doğruluğunu sağlamak için validasyonlara sahip olabilir. Örneğin, bir gönderinin başlığının boş olmamasını isteyebiliriz:

# app/models/post.rb
class Post < ApplicationRecord
  validates :title, presence: true, length: { minimum: 5 }
  validates :content, presence: true
end

Şimdi bir Post objesi oluşturup kaydetmeye çalıştığımızda, eğer başlık boşsa post.save metodu false dönecek ve post.errors.full_messages ile hata mesajlarına erişebileceğiz.

İlişkiler

Rails'te modeller arasında ilişkiler tanımlamak çok kolaydır. Örneğin, bir User modelimiz olsaydı ve bir kullanıcının birden fazla gönderi yazabileceğini belirtmek isteseydik:

# app/models/user.rb
class User < ApplicationRecord
  has_many :posts # Bir kullanıcının birden fazla gönderisi olabilir
end

app/models/post.rb
class Post < ApplicationRecord
  belongs_to :user # Bir gönderi bir kullanıcıya aittir
end

Bu ilişkileri kurmak için posts tablosuna user_id adında bir foreign key eklememiz gerekir (yeni bir migration ile).

Seed Verileri

Geliştirme ortamınız için veya testler için örnek veriler oluşturmak isteyebilirsiniz. db/seeds.rb dosyası bunun için kullanılır.

# db/seeds.rb
Post.destroy_all # Mevcut tüm gönderileri sil (isteğe bağlı)

Post.create(title: "Seed ile Oluşturulan İlk Gönderi", content: "Bu bir seed verisidir.")
Post.create(title: "İkinci Seed Gönderisi", content: "Daha fazla içerik.")

Bu dosyayı çalıştırarak örnek verileri veritabanına ekleyebilirsiniz:

rails db:seed

CRUD İşlevselliği Geliştirme

Artık bir Post modelimiz olduğuna ve temel veritabanı etkileşimlerini anladığımıza göre, bir blog uygulamasının temelini oluşturan CRUD (Create, Read, Update, Delete) işlevselliğini Rails'in sunduğu araçlarla nasıl geliştireceğimizi görelim.

Resourceful Routing

Rails, RESTful mimariye uygun olarak kaynak tabanlı (resourceful) yönlendirmeler sağlar. Bir kaynak için (örneğin posts) tüm standart CRUD işlemlerini kapsayan rotaları tek bir satırda tanımlayabiliriz:

# config/routes.rb
Rails.application.routes.draw do
  root 'pages#home'
  resources :posts # Bu tek satır, 7 farklı rota oluşturur!
end

resources :posts komutu aşağıdaki rotaları otomatik olarak oluşturur:

| HTTP Metodu | Yol | Controller#Action | Amaç | Rota Helper |
| :---------- | :------------------ | :---------------- | :--------------------------------- | :------------------ |
| GET | /posts | posts#index | Tüm gönderileri listele | posts_path |
| GET | /posts/:id | posts#show | Belirli bir gönderiyi göster | post_path(post) |
| GET | /posts/new | posts#new | Yeni bir gönderi oluşturma formu | new_post_path |
| POST | /posts | posts#create | Yeni gönderiyi kaydet | posts_path |
| GET | /posts/:id/edit | posts#edit | Mevcut gönderiyi düzenleme formu | edit_post_path(post) |
| PATCH/PUT | /posts/:id | posts#update | Mevcut gönderiyi güncelle | post_path(post) |
| DELETE | /posts/:id | posts#destroy | Belirli bir gönderiyi sil | post_path(post) |

Bu rotaları görmek için rails routes komutunu çalıştırabilirsiniz.

Controller Actions

Yukarıdaki rotalara karşılık gelen PostsController'ı oluşturalım:

rails generate controller Posts

Şimdi app/controllers/posts_controller.rb dosyasını düzenleyerek CRUD aksiyonlarını ekleyelim:

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  before_action :set_post, only: [:show, :edit, :update, :destroy]

  # GET /posts
  def index
    @posts = Post.all
  end

  # GET /posts/:id
  def show
    # @post, set_post metodunda ayarlandı
  end

  # GET /posts/new
  def new
    @post = Post.new
  end

  # POST /posts
  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post, notice: 'Gönderi başarıyla oluşturuldu.'
    else
      render :new, status: :unprocessable_entity
    end
  end

  # GET /posts/:id/edit
  def edit
    # @post, set_post metodunda ayarlandı
  end

  # PATCH/PUT /posts/:id
  def update
    if @post.update(post_params)
      redirect_to @post, notice: 'Gönderi başarıyla güncellendi.'
    else
      render :edit, status: :unprocessable_entity
    end
  end

  # DELETE /posts/:id
  def destroy
    @post.destroy
    redirect_to posts_url, notice: 'Gönderi başarıyla silindi.'
  end

  private

  # Tekrar eden kodu önlemek için DRY prensibi
  def set_post
    @post = Post.find(params[:id])
  end

  # Güvenlik için strong parameters kullanılır
  def post_params
    params.require(:post).permit(:title, :content)
  end
end

Yukarıdaki kodda:
* before_action :set_post, only: [...]: Belirtilen aksiyonlar çalışmadan önce set_post metodunu çalıştırır ve @post değişkenini ayarlar. Bu, kod tekrarını önler.
* post_params: Güvenlik için "strong parameters" adı verilen bir Rails özelliğidir. Bu, sadece izin verilen parametrelerin (burada title ve content) controller'a ulaşmasını sağlar ve Mass Assignment zafiyetini önler.
* redirect_to: İşlem başarılı olduğunda kullanıcıyı başka bir sayfaya yönlendirir.
* render: Bir view dosyasını doğrudan render eder, tarayıcıya yeni bir HTTP isteği göndermez.
* status: :unprocessable_entity: HTTP 422 durum kodunu gönderir, bu da isteğin anlaşıldığı ancak işlenemediği anlamına gelir (örn. validasyon hataları).

Form Oluşturma

Kullanıcıların yeni gönderi oluşturması ve mevcut gönderileri düzenlemesi için formlara ihtiyacımız var. Rails, bu formları oluşturmak için form_with helper'ını sağlar.

Öncelikle app/views/posts dizini altında index.html.erb (tüm gönderileri listelemek için), show.html.erb (tek bir gönderiyi göstermek için), new.html.erb (yeni gönderi formu için) ve edit.html.erb (gönderiyi düzenleme formu için) dosyalarını oluşturalım.

app/views/posts/index.html.erb:

+erb

<%= link_to 'Yeni Gönderi Oluştur', new_post_path %>

<% if notice %>
  
<%= notice %>
<% end %>

<% @posts.each do |post| %>
  

    
<%= link_to post.title, post_path(post) %>
    
<%= post.content.truncate(150) %>
    <%= link_to 'Düzenle', edit_post_path(post) %> |
    <%= link_to 'Sil', post_path(post), data: { turbo_method: :delete, turbo_confirm: 'Emin misiniz?' } %>
    

  
<% end %>

app/views/posts/show.html.erb:

+erb

<%= @post.content %>

<%= link_to 'Düzenle', edit_post_path(@post) %> |
<%= link_to 'Geri', posts_path %>

app/views/posts/new.html.erb:

+erb

<%= render 'form', post: @post %>
<%= link_to 'Geri', posts_path %>

app/views/posts/edit.html.erb:

+erb

<%= render 'form', post: @post %>
<%= link_to 'Göster', post_path(@post) %> |
<%= link_to 'Geri', posts_path %>

Partial'lar

new.html.erb ve edit.html.erb dosyalarında form kodunun tekrar ettiğini fark edeceksiniz. Rails, bu tür tekrar eden kod bloklarını partial adı verilen küçük şablonlara ayırmamızı sağlar. _form.html.erb adında bir partial oluşturalım:

app/views/posts/_form.html.erb:

+erb
<%= form_with(model: post) do |form| %>
  <% if post.errors.any? %>
    

      
<%= pluralize(post.errors.count, "hata") %> bu gönderinin kaydedilmesini engelledi:
      

        <% post.errors.full_messages.each do |message| %>
          
<%= message %>
        <% end %>
      
    
  <% end %>

  

    <%= form.label :title, "Başlık" %>
    <%= form.text_field :title %>
  

  

    <%= form.label :content, "İçerik" %>
    <%= form.text_area :content %>
  

  

    <%= form.submit "Kaydet" %>
  
<% end %>

Bu partial'ı diğer view dosyalarında <%= render 'form', post: @post %> şeklinde çağırabiliriz. form_with(model: post) helper'ı, post objesinin yeni mi yoksa mevcut bir obje mi olduğuna göre otomatik olarak doğru HTTP metodunu (POST veya PATCH) ve URL'yi ayarlar. Ayrıca validasyon hatalarını da otomatik olarak işler ve gösterir.

Uygulamanızı tekrar çalıştırın (rails s) ve http://localhost:3000/posts adresine giderek blog uygulamanızın CRUD işlevselliğini test edin.

Kullanıcı Arayüzü ve Varlık Yönetimi

Modern web uygulamaları sadece işlevsellikten ibaret değildir; kullanıcı deneyimi de kritik öneme sahiptir. Rails, CSS ve JavaScript gibi front-end varlıklarını yönetmek için güçlü mekanizmalar sunar.

CSS ve JavaScript

Rails'in farklı versiyonları, front-end varlıklarını yönetmek için farklı yaklaşımlar benimsemiştir:

* Asset Pipeline (Rails 6 öncesi): Sprockets gem'i aracılığıyla CSS (Sass/SCSS), JavaScript (CoffeeScript) ve resim dosyalarını ön derler, sıkıştırır ve birleştirir. app/assets dizini altında dosyalarınızı tutarsınız.
* Webpacker (Rails 6): Modern JavaScript araç zincirlerini (Webpack) Rails'e entegre etti. app/javascript dizini altında React, Vue, Angular gibi kütüphaneleri kullanmanızı kolaylaştırdı.
* Importmap (Rails 7+): Webpacker'ın yerini aldı ve daha hafif bir yaklaşımla, tarayıcıda doğrudan ES modüllerini kullanmayı teşvik eder. Genellikle app/javascript dizini altında JavaScript dosyalarınızı tutarsınız ve config/importmap.rb ile bağımlılıkları yönetirsiniz.

Örnek: Tailwind CSS Entegrasyonu (Rails 7 ile Importmap)
Rails 7, yeni bir uygulama oluştururken Tailwind CSS'i kolayca entegre etmenize olanak tanır:

rails new my_app --css=tailwind

Eğer mevcut bir uygulamaya eklemek isterseniz:

bin/bundle add tailwindcss-rails
bin/rails tailwindcss:install

Bu komutlar, Tailwind CSS'i uygulamanıza kurar ve app/assets/stylesheets/application.tailwind.css dosyasını oluşturur. Buraya özel Tailwind sınıflarınızı veya @apply direktiflerinizi ekleyebilirsiniz.

JavaScript Modülleri:
Importmap ile bir JavaScript modülü eklemek için:

bin/importmap pin chartkick

Bu, config/importmap.rb dosyasına pin "chartkick" satırını ekler. Ardından JavaScript dosyanızda import Chartkick from "chartkick" şeklinde kullanabilirsiniz.

Helper Metotları

Rails helper'ları, view'lerdeki karmaşık mantığı basitleştirmek ve kod tekrarını azaltmak için kullanılır. app/helpers dizini altında tanımlanır. Örneğin, bir gönderinin oluşturulma tarihini güzel bir formatta göstermek için bir helper yazabiliriz:

# app/helpers/posts_helper.rb
module PostsHelper
  def formatted_date(date)
    date.strftime("%d %B %Y, %H:%M")
  end
end

Ardından view dosyanızda <%= formatted_date(@post.created_at) %> şeklinde kullanabilirsiniz.

Linkler ve Yönlendirmeler

Daha önce de gördüğümüz gibi, Rails link_to ve redirect_to gibi helper'lar sunar:

* <%= link_to 'Ana Sayfa', root_path %>: Bir HTML etiketi oluşturur. root_path gibi rota helper'ları sayesinde URL'ler dinamik olarak oluşturulur.
* redirect_to posts_path: Bir HTTP yönlendirmesi yapar, tarayıcıya yeni bir URL'ye gitmesini söyler.