Image for post
Image for post

Ruby On Rails İle Blog Uygulaması

Merhabalar Ruby de rails framework nasıl kullanılır. Basit bir giriş yapacağız.

1. Rails Nedir?

  • Ruby On Rails ya da Rails, Ruby diliyle yazılmış, açık kaynak kodlu bir web uygulama geliştirme çerçevesidir. Web uygulamalarını programlamayı kolaylaştırmak için tasarlanmıştır. Daha az kod yazmamıza olanak sağlar.

Rails felsefesi iki ana yol gösterici ilkeyi içerir:

  • Kendini Tekrar Etme: Aynı kodları defalarca yazmayarak, kodumuz daha sürdürülebilir, daha genişletilebilir ve daha az hata ile karşılaşabilir yapabiliriz.
  • Konfigürasyon Üzerinden Konvansiyon: Uygulamaların değişebilecek parametrelerini ayırıp konfigürasyon dosyalarına taşır.

Yeni Bir Rails Projesi Oluşturma

  • Basit bir web uygulaması olan blog adlı bir Rails projesi oluşturacağız. Uygulamayı oluşturmaya başlamadan önce, Rails ’in ve diğer gerekli uygulamların kurulu olduğundan emin olmanız gerekir.

Rails için gerekli kurulumlar;

- Ruby

- PostgreSQL veya SQLite3

- Node.js

- Yarn

  • Ruby Yüklemek: Linux ve mac ‘te gerek yoktur. Ama windows üzerinde çalışıyorsanız Ruby Installer Development Kit ‘de yüklemelisiniz. Aşağıdaki komut ile versiyonunu öğrenebilir.

ruby -v

  • PostgreSQL veya SQLite3: PostgreSQL ‘i bu siteden, SQLite ise bu siteden indirebilirsiniz.
  • Node.js ve Yarn: Uygulamanızın JavaScript’ini yönetmek için Node.js ve Yarn’ın kurulu olması gerekir. Node.js ‘i bu siteden Node.js, yarn ‘ı ise Yarn siteden indirebilirsiniz. Versiyonlarını ve indirdiğinizden emin olmak için terminal ‘e aşağıdaki komutları yazabilirsiniz.

node --version

yarn -v

  • Rails Kurulumu: Rails kurmak için ruby ‘nin sağladığı gem install komutunu kullanın. Birinci komut ile kurulum, ikinci komut ile versiyonunu öğrenebilirsiniz.

gem install rails

rails --version

2. Blog Uygulaması Oluşturma

  • Rails, belirli bir görev üzerinde çalışmaya başlamak için gerekli olan her şeyi oluşturarak geliştirme hayatınızı kolaylaştırmak için tasarlandı. Aşağıdaki komut ile bize blog iskeletini ve blog için gerekli temel dosyaları oluşturacaktır. Şimdi çalışacağınız bir dosya açın ve terminale yolunu vererek aşağıdaki komutu çalıştırın.

rails new blog

cd blog

Image for post
Image for post
  • Yukarıdaki gibi bir kurulum olacaktır. Şu an yeni oluşan blog dosyasının içerisindesiniz. Genellikle yapılan işlemlerimizi bu dosya içerisinde gerçekleştireceğiz. Daha sonra visual studio da dosyanızı açabilirsiniz. Aşağıdaki şekilde olacaktır;

Not: Ayrıca rails için kullanacağınız komutları aşağıdaki komut ile görebilirisiz.

rails new -h

Image for post
Image for post
  • Blog dizini, bir Rails uygulamasının yapısını oluşturan bir dizi otomatik oluşturulmuş dosya ve klasöre sahiptir. Bu eğitimdeki çalışmaların çoğu app klasörde gerçekleşecek, ancak burada Rails’in varsayılan olarak oluşturduğu dosya ve klasörlerin her birinin işlevi hakkında aşağıda kısaca anlatışmıştır.
Image for post
Image for post
  • Ben PostgreSQL kullanacağım için Gemfile dosyasına gidip aşağıdaki gibi gem ‘i gem ‘pg’ olarak değiştirdim. Gemfile dosyasına her yeni gem yazdığınızda veya gem ‘leri güncellemek istediğinizde aşağıdaki komutuları kullanmanız gerekiyor.
Image for post
Image for post

bundle install

bundle update

  • Database ‘e bağlanmak için config/database.yml dosyasınıda aşağıdaki gibi değiştirmeniz gerekiyor.
Image for post
Image for post
  • Tüm bunları yaptıktan sonra sadece bir defa olmak üzere aşağıdaki komutu terminalde çalıştırıyoruz. Daha sonra veritabanınıza her eklediğiniz şey için diğer komutu kullanmanız gerekiyor.

rails db:create

rails db:migrate

Image for post
Image for post
  • Şimdi gidip veritabanınızda oluşturduğunuz database ‘i görebilirsiniz.
Image for post
Image for post
  • Artık server ‘ı aşağıdaki komutu terminale yazdırarak ayağa kaldırabilirsiniz.

rails s

  • Bu, varsayılan olarak Rails ile dağıtılan bir web sunucusu olan Puma’yı çalıştıracaktır. Uygulamanızı çalışırken görmek için bir tarayıcı penceresi açın ve http://localhost:3000/ adresine gidin . Aşağıdaki gibi rails varsayılan bilgi sayfasını görmelisiniz.
Image for post
Image for post

3. Rails ‘e MERHABA yazdırmak

  • Rails’in “Merhaba” demesini sağlamak için, en azından bir controller ve bir view oluşturmanız gerekir.
  • Bir Controller ‘ün amacı, uygulama için belirli talepleri almaktır. Yönlendirme, hangi denetleyicinin hangi istekleri alacağına karar verir. Genellikle, her bir controller ‘e giden birden fazla yol vardır ve farklı yollar farklı eylemlerle sunulabilir. Her eylemin amacı, bir view ‘e sahip olmak için bilgi toplamaktır.
  • Bir view ‘ın amacı, bu bilgileri insan tarafından okunabilir bir formatta görüntülemektir. Yapılması gereken önemli bir ayrım, bilginin toplandığı view değil, controller olmasıdır. Görünüm sadece bu bilgiyi göstermelidir. Varsayılan olarak, view şablonları, kullanıcıya gönderilmeden önce Rails’teki istek döngüsü tarafından işlenen eRuby (Embedded Ruby) adlı bir dilde yazılır.
  • Yeni bir controller oluşturmak için, “controller” oluşturucuyu çalıştırmanız ve ona “Welcome” adlı bir denetleyiciyi “index” adlı bir eylemle istediğinizi söylemeniz gerekir. Bunun için aşağıdaki komut satırını terminalde çalıştırmanız gerekir.

rails generate controller Welcome index

  • Aşağıda yanında create yazılan dosyalar ve route dosyası oluşacaktır. Bunlardan en önemlileri app/controllers/welcome_controller.rb ve app/views/welcome/index.html.erb dosyalarıdır.
Image for post
Image for post
  • app/views/welcome/index.html.erb dosyasını açıp içine aşağıdaki kodları yazabilirsiniz. Bu dosyada welcome sayfasında oluşturmak istediğiniz görüntünün html kodları yazılır.

<h1> Merhaba, Rails </h1>

  • Daha Sonra rails ‘e gerçek ana sayfasının nerede olduğunu göstermemiz gerekiyor. Bunun için config/routes.rb dosyasına gidip aşağıdaki komutları değiştirmemiz gerekiyor. İlk önce böyle kod satırlarıyla karşılaşacaksınız:
Rails.application.routes.draw do
get ‘welcome/index’
end
  • Daha sonra kodları aşağıdaki gibi düzenlemeniz gerekiyor.
Rails.application.routes.draw do
get ‘welcome/index’
root ‘welcome#index’end
  • root ‘welcome#index’ komutu controller ‘a istekleri karşılama denetleyicisinin dizin eylemiyle uygulamanın ve ‘welcome/index’ almasını söyler. Artık http://localhost:3000/ linkine tıkladığınızda aşağıdaki gibi bir sayfa ile karşılaşacaksınız.
Image for post
Image for post

Not: Eğer Server ‘ı durdurduysanız tekrar server ‘ı çalıştırmanız gerekir. Aşağıdaki komut ile;

rails s

Hadi Uygulamamızı Geliştirelim

  • Artık Bir controller ve view gibi dosyaları nasıl oluşturacağımızı öğrendik. Şimdi uygulamamızı geliştirelim.
  • Blog uygulamasında, şimdi yeni bir kaynak oluşturacaksınız, bir kaynak için öğeler oluşturulabilir, okunabilir, güncelleyebilir ve sililebilirsiniz (Create, Read, Update and Delete) bu işlemlere CRUD işlemleri adı verilir.
  • Rails, standart bir REST kaynağı bildirmek için kullanılabilecek bir kaynak yönetimi sağlar. Dosya aşağıdaki gibi görünmesi için config/routes.rb dosyasını articles kaynağı eklememiz gerekir. config/routes.rb dosyası aşağıdaki gibi olacaktır.
Image for post
Image for post
  • routes.rb dosyasına bir şeyler eklediğinizde terminalde aşağıdaki komutu çalıştırmanız gerekiyor.

rails routes

Image for post
Image for post
  • Bir sonraki bölümde, uygulamanıza yeni articles oluşturma ve bunları görüntüleme yeteneği ekleyeceksiniz. Bu CRUD’dan “C” ve “R” dir: create (oluşturun) ve (read) okuyun. Bunu yapmak için form şu şekilde görünecektir:
Image for post
Image for post

4 . Temelin Atılması

  • Öncelikle yeni bir article oluşturmak için uygulama içinde yeni bir yere ihtiyacımız var. Artık /articles/new uygulamada istekler yapılabilir. http://localhost:3000/new adresine gidince yönlendirme hatası göreceksiniz.
  • Bu hata, isteğin yerine getirilmesi için yolun tanımlanmış bir denetleyiciye sahip olması gerektiğinden oluşur. Bu özel sorunun çözümü basittir: ArticleController adında bir controller oluşturun. Bunu şu komutu çalıştırarak yapabilirsiniz:

rails generate controller Articles

  • Aşağıdaki dosyalar oluşacaktır.
Image for post
Image for post
  • Bir controller, ApplicationController’dan miras almak üzere tanımlanan bir sınıftır. Bu sınıfın içinde, bu controller için eylemler olacak yöntemleri tanımlayacaksınız. Bu işlemler, sistemimizdeki makaleler üzerinde CRUD işlemlerini gerçekleştirecektir.
  • http://localhost:3000/new linkini çalıştırdığınızda bu sefer farklı bir hata ile karşılaşacaksınız.
  • Bu hata, Rails’in yeni oluşturduğunuz ArticleController içinde yeni eylemi bulamadığını gösterir. Bunun nedeni, controller ‘lar Rails’te oluşturulduğunda, üretim işlemi sırasında istediğiniz eylemleri ona söylemediğiniz sürece, varsayılan olarak boş olmalarıdır.
  • Bir denetleyicinin içinde bir eylemi manuel olarak tanımlamak için yapmanız gereken tek şey, denetleyici içinde yeni bir yöntem tanımlamaktır. App/controllers/Articles_controller.rb dosyasını açın ve ArticleController sınıfının içinde yeni yöntemi tanımlayın, böylece controller ‘ınız artık şu şekilde görünür:
Image for post
Image for post
Image for post
Image for post
  • Bu hatayı şimdi alıyorsunuz çünkü Rails bunun gibi basit eylemlerin bilgilerini görüntülemek için kendileriyle ilişkili views ‘lere sahip olmasını bekliyor. Görüntü olmadığında, Rails bir istisna oluşturacaktır.
  • Hata. hangi şablonun eksik olduğunu gösterir. Bu durumda articles/new, rails ilk önce bu şablonu arayacaktır. Bulunmazsa, ArticlesController ApplicationController ‘dan miras aldığı için application/new adlı bir template yüklemeye çalışır.
  • Daha sonra mesaj, yanıt olarak sunulacak template biçimini belirten request.formats içerir. Tarayıcı aracılığıyla bu sayfayı istediğimiz gibi text/html olarak ayarlandı, bu nedenle Rails HTML şablonunu arıyor.
  • Bu durumda app/views/articles/new.html.erb şablonunu oluşturmamız gerekir. Bu dosya adının uzantısı önemlidir: ilk uzantı şablonun formatıdır ve ikinci uzantı, şablonu oluşturmak için kullanılacak işleyicidir (ruby uzantısıdır). Rails uygulama için app/views içinde articles/new bulmaya çalışıyor. Yeni bir HTML formu oluşturmak istediğimizden, Ruby ‘yi HTML içine yerleştirmek için tasarlanmış ERB dilini kullanacaksınız.
  • Bu nedenle, dosya articles/new.html.erb olarak adlandırmalı ve uygulamanın app/views dizininde yer almalıdır.
  • Şimdi app/views/articles/new.html.erb ‘de yeni bir dosya oluşturun ve aşağıdaki kodu içine yazın.

<h1>New Article</h1>

Image for post
Image for post

İlk Form

  • Bu template içinde bir form oluşturmak için bir form oluşturucu kullanacaksınız. Rails için birincil form oluşturucu, form_with adlı bir yardımcı yöntem tarafından sağlanır. Bu yöntemi kullanmak için bu kodu app/views/articles/ new.html.erb içine ekleyin:
<%= form_with scope: :article, local: true do |form| %>
<p>
<%= form.label :title %><br> <%= form.text_field :title %> </p> <p> <%= form.label :text %><br> <%= form.text_area :text %> </p> <p> <%= form.submit %> </p>
<% end %>
  • Sayfayı yenilerseniz, yukarıda örnekteki formu göreceksiniz.
  • Form_with’i çağırdığınızda, ona bu form için tanımlayıcı bir kapsam iletirsiniz. Bu durumda, bu sembol: article, Bu, form_with helper’a bu formun ne için olduğunu söyler. Bu yöntemin bloğunun içinde, formla temsil edilen FormBuilder nesnesi, her biri bir article ‘ın başlığı ve metni için olmak üzere iki etiket ve iki metin alanı oluşturmak için kullanılır. Son olarak, form nesnesindeki bir gönderme çağrısı, form için bir gönder düğmesi oluşturur.
  • Yine de bu formla ilgili bir sorun var. Oluşturulan HTML’yi sayfanın kaynağını görüntüleyerek incelerseniz, formun eylem özniteliğinin /articles/new ’e işaret ettiğini göreceksiniz. Bu bir sorundur çünkü bu route o anda tam da bulunduğunuz sayfaya gider ve bu route yalnızca yeni bir article ‘ın formunu görüntülemek için kullanılmalıdır.
  • Formun başka bir yere gitmek için farklı bir URL kullanması gerekir. Bu, form_with: url seçeneğiyle oldukça basit bir şekilde yapılabilir. Tipik olarak Rails’de, bunun gibi yeni form gönderimleri için kullanılan işleme “create” adı verilir ve bu nedenle form, bu eyleme işaret edilmelidir.
  • App/views/articles/new.html.erb içindeki form_with satırını aşağıdaki gibi düzenleyin:
<%= form_with scope: :article, url: articles_path, local: true do |form| %>
  • Rails’in bununla ne yapacağını görmek için ray routes ‘in çıkışına geri dönüp bakıyoruz. Bakmak için terminale aşağıdaki komutu yazabilirsiniz.

rails routes

Image for post
Image for post
  • Article_path helper , Rails’e formu articles önekiyle ilişkili URI Modeline yönlendirmesini söyler; ve form (varsayılan olarak) bu route bir POST isteği gönderir. Bu, geçerli denetleyicinin, ArticleController’ın yaratma eylemi ile ilişkilidir.
  • Form ve ilgili yol tanımlandığında, formu doldurabilir ve ardından yeni bir article oluşturma sürecini başlatmak için gönder düğmesini tıklayabilirsiniz. Aşağıdaki hata ile karşılaşacaksınız.
Image for post
Image for post
  • Şimdi bunun çalışması için ArticleController içinde create eylemini oluşturmanız gerekir.

Creating Articles

  • “Unknown action” ortadan kaldırmak için, gösterildiği gibi, app/controllers/Articles_controller.rb ‘deki ArticleController sınıfı içinde yeni eylemin altında bir oluşturma eylemi tanımlayabilirsiniz:
Image for post
Image for post
  • Formu şimdi yeniden gönderirseniz, sayfada herhangi bir değişiklik göremeyebilirsiniz. Bunun nedeni, yanıtın ne olması gerektiğini belirtmezsek, Rails varsayılan olarak bir eylem için 204 İçerik Yok yanıtı döndürmesidir. Oluşturma eylemini ekledik ancak yanıtın nasıl olması gerektiği konusunda hiçbir şey belirtmedik. Bu durumda, oluşturma eylemi yeni makalemizi veritabanına kaydetmelidir.
  • Bir form gönderildiğinde, formun alanları parametre olarak Rails’e gönderilir. Bu parametrelere daha sonra, tipik olarak belirli bir görevi gerçekleştirmek için controller eylemleri içinde başvurulabilir. Bu parametrelerin neye benzediğini görmek için oluşturma eylemini aşağıdaki gibi değiştirin:
Image for post
Image for post
  • Buradaki render yöntemi, bir anahtar ile çok basit bir hash :plain ve params [:article] .inspect değeri alıyor. Params yöntemi, formdan gelen parametreleri (veya alanları) temsil eden nesnedir. Params yöntemi bir ActionController::Parameters nesnesi döndürür, bu da karmanın anahtarlarına dizeleri veya sembolleri kullanarak erişmenize olanak tanır. Bu durumda, önemli olan tek parametreler formdaki parametrelerdir.
  • Bu kez formu yenidiğinizde aşağıya benzer bir hata ile karşılaşacaksınız:
<ActionController::Parameters {"title"=>"s", "text"=>"sddf"} permitted: false>
  • Bu eylem artık formdan gelen article için parametreleri görüntülemektedir. Ancak, bu gerçekten o kadar da yardımcı olmuyor. Evet, parametreleri görebilirsiniz ama özellikle onlarla hiçbir şey yapılmıyor.

Article Model Oluşturma

  • Rails’teki modeller tekil bir ad kullanır (Article gibi..) ve karşılık gelen veritabanı tabloları çoğul bir ad kullanır (articles gibi..). Rails, çoğu Rails geliştiricisinin yeni modeller oluştururken kullanma eğiliminde olduğu modeller oluşturmak için bir generator sağlar. Yeni modeli oluşturmak için terminalinizde şu komutu çalıştırın:

rails generate model Article title:string text:text

Image for post
Image for post
  • Bu komutla Rails’e, string türünde bir başlık niteliği ve metin türünde bir metin niteliği ile birlikte bir Article modeli istediğimizi söyledik. Bu öznitelikler otomatik olarak veritabanındaki makaleler tablosuna eklenir ve Article modeline eşlenir.
  • Rails, bir grup dosya oluşturarak yanıt verdi. Şimdilik sadece app/models/article.rb ve db/migrate/20200917085824_create_articles.rb ile ilgileniyoruz (dosyanızın isimleri bunlardan farklı olabilir). İkincisi, daha sonra bakacağımız şey olan veritabanı yapısını oluşturmaktan sorumludur.

Migration Çalıştırma

  • Az önce gördüğümüz gibi, generate oluşturma modeli, db/migrate dizini içinde bir veritabanı geçiş dosyası oluşturdu. Geçişler, veritabanı tablolarının oluşturulmasını ve değiştirilmesini kolaylaştırmak için tasarlanmış Ruby sınıflarıdır. Rails, geçişleri çalıştırmak için rake komutlarını kullanır ve veri tabanınıza uygulandıktan sonra bir geçişi geri almak mümkündür. Taşıma dosya adları, oluşturuldukları sırayla işlenmelerini sağlamak için bir zaman damgası içerir.
  • Db/ migrate/YYYYMMDDHHMMSS_create_articles.rb dosyasına bakarsanız, bulacağınız şeyler:
Image for post
Image for post
  • Yukarıdaki geçiş, bu geçişi çalıştırdığınızda çağrılacak olan change adlı bir yöntem oluşturur. Bu yöntemde tanımlanan eylem de tersine çevrilebilir, yani Rails, daha sonra tersine çevirmek istemeniz durumunda, bu geçiş tarafından yapılan değişikliği nasıl tersine çevireceğini bilir. Bu geçişi çalıştırdığınızda, bir dize sütunu ve bir metin sütunu içeren bir articles ‘lar tablosu oluşturacaktır. Ayrıca, Rails’in article oluşturma ve güncelleme zamanlarını izlemesine izin vermek için iki zaman damgası alanı oluşturur.
  • Bu noktada, geçişi çalıştırmak için bir rails komutu kullanabilirsiniz:
rails db:migrate

Rails bu geçiş komutunu çalıştıracak ve size Articles tablosunu oluşturduğunu söyleyecektir.

Image for post
Image for post

Varsayılan olarak geliştirme ortamında çalıştığınız için, bu komut config/database.yml dosyanızın geliştirme bölümünde tanımlanan veritabanı için geçerli olacaktır. Başka bir ortamda, örneğin üretimde geçiş yapmak istiyorsanız, şu komutu çalıştırırken bunu açıkça iletmelisiniz:

rails db:migrate RAILS_ENV = production

Verilerin Controller ‘e Kaydedilmesi

ArticlesController’a geri döndüğümüzde, verileri veritabanına kaydetmek için yeni Article modelini kullanmak için oluşturma eylemini değiştirmemiz gerekiyor. App/controllers/Articles_controller.rb dosyasını açın ve oluşturma eylemini aşağıdaki gibi değiştirin:

def create   @article = Article.new(params[:article])   @article.save   redirect_to @articleend
  • Her Rails modeli, ilgili veritabanı sütunlarına otomatik olarak eşlenen ilgili öznitelikleriyle başlatılabilir. İlk satırda tam olarak bunu yapıyoruz (params [:article] ‘nın ilgilendiğimiz öznitelikleri içerdiğini unutmayın). Ardından, modeli veritabanına kaydetmekten @article.save sorumludur. Son olarak, kullanıcıyı daha sonra tanımlayacağımız gösteri eylemine yönlendiriyoruz.

Yukarıda Article.new’deki A harfinin neden büyük harfle yazıldığını merak ediyor olabilirsiniz, oysa bu kılavuzdaki article ‘lere yapılan diğer atıfların çoğunda küçük harf kullanılmıştır. Bu bağlamda, app/models/article.rb ’de tanımlanan Article isimli sınıfa atıfta bulunuyoruz. Ruby’deki sınıf adları büyük harfle başlamalıdır.

Daha sonra göreceğimiz gibi, @article.save, article ‘nın kaydedilip kaydedilmediğini belirten bir mantıksal değer döndürür.

Image for post
Image for post
  • Rails, güvenli uygulamalar yazmanıza yardımcı olan çeşitli güvenlik özelliklerine sahiptir ve şimdi bunlardan biriyle karşılaşıyorsunuz. Buna güçlü parametreler denir, bu da bizim controller eylemlerimizde hangi parametrelere izin verildiğini Rails’e tam olarak söylememizi gerektirir.
  • Neden uğraşmak zorundasın? Tüm controller parametrelerini tek seferde modelinize alma ve otomatik olarak atama yeteneği, programcının işini kolaylaştırır, ancak bu kolaylık aynı zamanda kötü niyetli kullanıma da izin verir. Sunucuya yapılan bir istek, yeni bir makale formu gönderimi gibi görünecek şekilde hazırlanmışsa, ancak aynı zamanda uygulamanızın bütünlüğünü ihlal eden değerlere sahip fazladan alanlar içeriyorsa? Modelinize ‘toplu olarak atanacaklar’ ve ardından iyi şeylerle birlikte veritabanına stuff-potentially olarak uygulamanızı bozabilir.
  • Yanlış kitle atamasını önlemek için izin verilen controller ‘e parametrelerimizi tanımlamamız gerekir. Bu durumda, create öğesinin geçerli kullanımı için title ve başlık parametrelerine hem izin vermek hem de gerekli kılmak istiyoruz. Bunun için sözdizimi gerektirir ve izin verir. Değişiklik, oluşturma eyleminde bir satır içerecektir:
@article = Article.new(params.require(:article).permit(:title, :text))

Bu genellikle kendi yöntemine dahil edilir, böylece aynı denetleyicideki birden fazla eylem tarafından yeniden kullanılabilir, örneğin oluşturma ve güncelleme. Toplu atama konularının ötesinde, yöntem genellikle amaçlanan bağlamın dışında çağrılamayacağından emin olmak için özel yapılır. İşte sonuç:

def create   @article = Article.new(article_params)   @article.save   redirect_to @articleendprivatedef article_params    params.require(:article).permit(:title, :text)end
  • Şimdi show articles ile ilgili aşağıdaki gibi bir hata ile karşılaşacaksınız.
Image for post
Image for post

Showing Articles

  • Show eylemini ekleyelim. Rails routes çıkışında gördüğümüz gibi eylemi gösterme route aşağıdaki gibidir:
article GET /articles/:id(.:format) articles#show
  • Özel sözdizimi: id, rails ‘lara bu route ‘nin bir :id parametresi beklediğini söyler, bu bizim durumumuzda article kimliği olacaktır.
  • Daha önce yaptığımız gibi, show eylemini app/controllers/article_controller.rb ve ilgili views ‘e eklememiz gerekiyor.

Sık uygulama, standart CRUD eylemlerini her bir controller ‘e şu sırayla yerleştirmektir: index, show, new, edit, create, update ve destroy. Seçtiğiniz herhangi bir sırayı kullanabilirsiniz, ancak bunların genel yöntemler olduğunu unutmayın; Bu kılavuzda daha önce belirtildiği gibi, denetleyicide özel görünürlük bildirilmeden önce yerleştirilmeleri gerekir.

  • Buna göre, show kodlarını aşağıdaki gibi ekleyelim:
class ArticlesController < ApplicationController    def show       @article = Article.find(params[:id])    end    def new    end

Dikkat edilmesi gereken birkaç nokta: İlgilendiğimiz article ‘ı bulmak için Article.find kullanıyoruz, istekten: id parametresini almak için params [: id] ‘i geçiyoruz. Ayrıca article nesnesine bir referansı tutmak için bir örnek değişkeni kullanırız. Bunu yapıyoruz çünkü Rails tüm örnek değişkenlerini görünüme aktaracak.

  • Şimdi, aşağıdaki içeriğe sahip yeni bir dosya app/views/articles/show.html.erb oluşturun
Image for post
Image for post
  • Bu değişiklikle, nihayet yeni makaleler oluşturabilmelisiniz. Http://localhost:3000/articles/new adresini ziyaret edin ve deneyin!
  • Çıktıları aşağıdaki gibi olacaktır.
Image for post
Image for post
Image for post
Image for post

Makalelerin Listelenmesi

  • Hala tüm makalelerimizi listelemek için bir yola ihtiyacımız var, öyleyse bunu yapalım. Rails yollarının çıkışına göre bunun routes:

articles GET /articles(.:format) articles#index

  • Bu routes için ilgili dizin eylemini, app/controllers/Articles_controller.rb dosyasındaki ArticleController içine ekleyin. Bir indeks eylemi yazdığımızda, olağan uygulama, onu controller ‘e ilk yöntem olarak yerleştirmektir. controller dosyasını aşağıdaki gibi düzenleyeceğiz.
Image for post
Image for post
  • Ve son olarak, app/views/articles/index.html.erb konumunda bulunan bu eylemin görünümünü ekleyin:
Image for post
Image for post
Image for post
Image for post

Bağlantı Ekleme

  • Artık makaleler oluşturabilir, gösterebilir ve listeleyebilirsiniz. Şimdi sayfalarda gezinmek için bazı bağlantılar ekleyelim.
  • App/views /welcome/index.html.erb dosyasını açın ve aşağıdaki gibi değiştirin:
<h1>Hello, Rails!</h1><%= link_to 'My Blog', controller: 'articles' %>
Image for post
Image for post
  • Bu bağlantı, yeni bir article oluşturmanıza izin veren formu açmanıza izin verecektir.
  • Şimdi, dizin eylemine geri dönmek için formun altına app/views/articles/new.html.erb’de başka bir bağlantı ekleyin:
<%= form_with scope: :article, url: articles_path, local: true do |form| %>      ...<% end %><%= link_to 'Back', articles_path %>

Son olarak, dizin eylemine de geri dönmek için app/views/articles/show.html.erb şablonuna bir bağlantı ekleyin, böylece tek bir makaleyi görüntüleyen kişiler geri dönüp tüm listeyi yeniden görebilir:

Image for post
Image for post

Aynı controller ‘ları bir eyleme bağlanmak istiyorsanız, Rails varsayılan olarak geçerli controller ‘ı kullanacağından: controller seçeneğini belirtmeniz gerekmez.

Geliştirme modunda (varsayılan olarak çalıştığınız şey budur), Rails uygulamanızı her tarayıcı isteğinde yeniden yükler, böylece bir değişiklik yapıldığında web sunucusunu durdurup yeniden başlatmanıza gerek kalmaz.

Bazı Validation Ekleme

Model dosyası, app/models/articles.rb kadar basittir.

class Article < ApplicationRecordend
  • Yukarıdaki dosyada birşey yok. Ancak Article sınıfının ApplicationRecord’dan miras aldığını unutmayın. ApplicationRecord, temel veritabanı CRUD (create, read, update ve destroy) işlemleri, validation, ayrıca gelişmiş arama desteği ve ilişkilendirme yeteneği dahil olmak üzere Rails modellerinize ücretsiz olarak büyük bir işlevsellik sağlayan ActiveRecord :: Base’den miras alır.
  • Rails, modellere gönderdiğiniz verileri doğrulamanıza yardımcı olacak yöntemler içerir. App/models/article.rb dosyasını açın ve düzenleyin:
class Article < ApplicationRecord     validates :title, presence: true,     length: { minimum: 5 }end

Bu değişiklikler, tüm article ‘ların en az beş karakter uzunluğunda bir başlığa sahip olmasını sağlayacaktır. Raylar, bir modeldeki sütunların varlığı veya benzersizliği, formatları ve ilişkili nesnelerin varlığı dahil olmak üzere çeşitli koşulları doğrulayabilir. Doğrulamalar, Aktif Kayıt Doğrulamalarında ayrıntılı olarak ele alınmaktadır.

validation şimdi yürürlükte olduğunda, geçersiz bir article için @article.save’i çağırdığınızda, yanlış döndürecektir. App/controllers/article_controller.rb ’yi tekrar açarsanız, create eylemi içinde @article.save çağrısının sonucunu kontrol etmediğimizi fark edeceksiniz. Bu durumda @article.save başarısız olursa, formu kullanıcıya geri göstermemiz gerekir. Bunu yapmak için, yeniyi değiştirin ve app/controllers/Articles_controller.rb içinde eylemler oluşturun:

def new   @article = Article.newenddef create   @article = Article.new(article_params)   if @article.save     redirect_to @article   else     render 'new'   endendprivatedef article_params   params.require(:article).permit(:title, :text)end

Yeni eylem şimdi @article adında yeni bir örnek değişkeni yaratıyor ve bunun nedenini birkaç dakika içinde göreceksiniz.

Create eyleminin içinde, save false döndürdüğünde redirect_to yerine render kullandığımıza dikkat edin. Oluşturma yöntemi, @article nesnesinin işlendiğinde yeni şablona geri gönderilmesi için kullanılır. Bu işleme, form gönderimi ile aynı istek içinde yapılır, oysa redirect_to tarayıcıya başka bir istek göndermesini söyler.

Image for post
Image for post

http://localhost:3000/articles/new ’i yeniden yüklerseniz ve bir makaleyi başlıksız kaydetmeye çalışırsanız, Rails sizi forma geri gönderir, ancak bu pek kullanışlı değildir. Kullanıcıya bir şeylerin ters gittiğini söylemeniz gerekir. Bunu yapmak için, hata mesajlarını kontrol etmek için app/views/Articles/new.html.erb dosyasını değiştireceksiniz:

<%= form_with scope: :article, url: articles_path, local: true do |form| %>   <% if @article.errors.any? %>   <div id="error_explanation"><h2>   <%= pluralize(@article.errors.count, "error") %>   prohibited   this article from being saved:</h2><ul>  <% @article.errors.full_messages.each do |msg| %><li><%= msg %></li><% end %></ul></div><% end %>  <p>     <%= form.label :title %><br>     <%= form.text_field :title %>  </p>  <p>     <%= form.label :text %><br>     <%= form.text_area :text %> </p> <p>    <%= form.submit %> </p><% end %><%= link_to 'Back', articles_path %>
Image for post
Image for post

Birkaç şey oluyor. @Article.errors.any? İle herhangi bir hata olup olmadığını kontrol ederiz ve bu durumda @article.errors.full_messages ile tüm hataların bir listesini gösteririz.

pluralize, argümanları olarak bir sayı ve bir dizeyi alan bir rails yardımcıdır. Sayı birden büyükse, dizi otomatik olarak çoğullaşacaktır.

ArticleController’a @article = Article.new eklememizin nedeni, aksi takdirde @article’ın bizim görüşümüze göre sıfır olması ve @article.errors.any ’yi çağırmasıdır. Şimdi başlığı 5 karakterden aşağı girerseniz aşağıdaki gibi hata atabilirsiniz.

Image for post
Image for post

Article ‘ları Güncelleme

  • CRUD’nin “CR” bölümünü ele aldık. Şimdi article ‘ları güncelleyen “U” kısmına odaklanalım.
  • Atacağımız ilk adım, gösterildiği gibi, ArticleController’a genellikle yeni ve create eylemleri arasında bir düzenleme eylemi eklemektir:
def new   @article = Article.newenddef edit   @article = Article.find(params[:id])enddef create   @article = Article.new(article_params)   if @article.save     redirect_to @article   else     render 'new'   endend
Image for post
Image for post
  • View, yeni article oluştururken kullandığımıza benzer bir form içerecektir. App/views/Articles/edit.html.erb adında bir dosya oluşturun ve aşağıdaki gibi görünmesini sağlayın:
<h1>Edit Article</h1><%= form_with(model: @article, local: true) do |form| %>    <% if @article.errors.any? %>    <div id="error_explanation"><h2>   <%= pluralize(@article.errors.count, "error") %> prohibited   this article from being saved:</h2><ul>   <% @article.errors.full_messages.each do |msg| %>   <li><%= msg %></li><% end %></ul></div><% end %><p>   <%= form.label :title %><br>   <%= form.text_field :title %></p><p>
<%= form.label :text %><br>
<%= form.text_area :text %></p><p> <%= form.submit %></p><% end %><%= link_to 'Back', articles_path %>
Image for post
Image for post
  • Bu sefer formu, henüz tanımlanmamış ancak çok yakında olacak olan güncelleme işlemine yönlendiriyoruz.
  • Makale nesnesini form_with yöntemine aktarmak, düzenlenen article formunu göndermek için URL’yi otomatik olarak ayarlayacaktır. Bu seçenek, Rails’e bu formun REST protokolüne göre kaynakları güncellemek için kullanmanız beklenen HTTP yöntemi olan PATCH HTTP yöntemi aracılığıyla gönderilmesini istediğimizi söyler.
  • Ayrıca, yukarıdaki düzenleme görünümünde model: @article gibi bir model nesnesinin form_with’e iletilmesi, form yardımcılarının form alanlarını nesnenin karşılık gelen değerleriyle doldurmasına neden olacaktır. Yeni görünümde yapıldığı gibi scope: :article gibi bir sembol kapsamına geçmek, yalnızca boş form alanları oluşturur.
  • Şimdi, app/controllers/Articles_controller.rb dosyasında güncelleme eylemini oluşturmamız gerekiyor. Bunu oluşturma eylemi ve özel yöntem arasına ekleyin:
def create    @article = Article.new(article_params)    if @article.save       redirect_to @article    else       render 'new'    endenddef update    @article = Article.find(params[:id])    if @article.update(article_params)       redirect_to @article    else      render 'edit'    endendprivatedef article_params    params.require(:article).permit(:title, :text)end
Image for post
Image for post
  • Yeni yöntem olan güncelleme, zaten var olan bir kaydı güncellemek istediğinizde kullanılır ve güncellemek istediğiniz öznitelikleri içeren bir karma kabul eder. Daha önce olduğu gibi, article güncellenirken bir hata oluşursa, formu kullanıcıya tekrar göstermek istiyoruz.
  • Oluşturma eylemi için daha önce tanımladığımız article_params yöntemini yeniden kullanıyoruz.
  • Son olarak, tüm makaleler listesinde düzenleme işlemine bir bağlantı göstermek istiyoruz, bu nedenle şimdi bunu “show” butonunun yanında görünmesi için app/views/articles/index.html.erb dosyasına ekleyelim:
<table><tr>    <th>Title</th>    <th>Text</th>    <th colspan="2"></th></tr><% @articles.each do |article| %><tr>    <td><%= article.title %></td>    <td><%= article.text %></td>    <td><%= link_to 'Show', article_path(article) %></td>    <td><%= link_to 'Edit', edit_article_path(article) %></td></tr><% end %></table>
Image for post
Image for post
Image for post
Image for post
Image for post
Image for post
  • Ayrıca app/views/Articles/show.html.erb şablonuna da bir tane ekleyeceğiz, böylece bir article sayfasında “Edit” bağlantısı da olacak. Aşağıdaki kodları şablonun altına ekleyin:
<%= link_to 'Edit', edit_article_path(@article) %> |<%= link_to 'Back', articles_path %>
Image for post
Image for post

View ‘lerde Çoğaltmayı Temizlemek İçin Partial ‘ların Kullanılması

  • Edit sayfamız new sayfaya çok benziyor; aslında, her ikisi de formu görüntülemek için aynı kodu paylaşır. Bu çoğaltmayı partial bir görünüm kullanarak kaldıralım. Dosyamızı oluştururken dosya adının önüne “_” ekleyeceğiz. Bu dosyalar partial dosyası, diğer dosyalar path dosyası olur.
  • Yeni app/views/articles/_form.html.erb dosyasını oluşturup aşağıdaki kodları yazalım:
<%= form_with model: @article, local: true do |form| %>    <% if @article.errors.any? %>      <div id="error_explanation">       <h2>         <%= pluralize(@article.errors.count, "error") %> prohibited         this article from being saved:     </h2>     <ul>        <% @article.errors.full_messages.each do |msg| %>         <li><%= msg %></li>        <% end %>    </ul>  </div> <% end %>  <p>   <%= form.label :title %><br>   <%= form.text_field :title %>  </p>
<p>
<%= form.label :text %><br> <%= form.text_area :text %> </p> <p> <%= form.submit %> </p><% end %>
Image for post
Image for post
  • Form_with bildirimi dışında her şey aynı kaldı. Bu daha kısa, daha basit form_with bildirimini diğer biçimlerden herhangi biri için kullanabilmemizin nedeni, @article’ın tam bir RESTful yol kümesine karşılık gelen bir kaynak olması ve Rails’in hangi URI’yi ve metodu kullanacağını çıkarabilmesidir.
  • Şimdi, bu yeni parçayı (partial) kullanmak için app/views/Articles/new.html.erb görünümünü güncelleyelim ve tamamen yeniden aşağıdaki gibi yazalım:
<h1>New Article</h1><%= render 'form' %><%= link_to 'Back', articles_path %>
  • Ve app/views/articles/edit.html.erb dosyasınıda tamamen silip aşağıdaki gibi yazıyoruz:
<h1>Edit Article</h1><%= render 'form' %><%= link_to 'Back', articles_path %>

Article ‘ları Silme

Artık CRUD’nin “D” bölümünü veri tabanından article ‘ları silerek ele almaya hazırız. REST kuralının ardından, rails yollarının çıkışına göre makaleleri (articles) silme yolu şöyledir:

DELETE /articles/:id(.:format)      articles#destroy

Yönlendirme silme yöntemi, kaynakları yok eden yollar için kullanılmalıdır. Bu tipik bir alma yolu olarak bırakılırsa, insanların aşağıdaki gibi kötü amaçlı URL’ler oluşturmaları mümkün olabilir:

<a href='http://example.com/articles/1/destroy'>look at this cat!</a>

Yazdığımız article ‘ları yok etmek için silme yöntemini kullanıyoruz ve bu yol, henüz uygulamamızda olmayan app/controllers/article_controller.rb içindeki yok etme eylemiyle eşleştiriliyor. Yok etme yöntemi genellikle controller ‘lardaki son CRUD eylemidir ve diğer genel CRUD eylemleri gibi, article_controller.rb dosyasına herhangi bir private or protected methods önce yerleştirilmelidir. Ekleyelim:

def destroy@article = Article.find(params[:id])@article.destroyredirect_to articles_pathend
Image for post
Image for post
  • Veritabanından silmek istediğinizde Active Record nesnelerini silme çağrısı yapabilirsiniz. Dizin eylemine yeniden yönlendirdiğimiz için bu eylem için bir görünüm eklememiz gerekmediğini unutmayın. Aynı sayfa içerisinde size silmek isteyip istemediğinizi soracaktır.
  • Son olarak, her şeyi bir araya getirmek için dizin eylem şablonunuza (app/views/articles/index.html.erb) bir ‘Silme’ bağlantısı ekleyin.
<td><%= link_to 'Destroy', article_path(article),method: :delete,data: { confirm: 'Emin misiniz?' } %></td>
Image for post
Image for post

Burada link_to ’yu farklı bir şekilde kullanıyoruz. İkinci argüman olarak adlandırılmış route ‘yi ve ardından seçenekleri başka bir argüman olarak iletiyoruz. Method: :delete ve data: {confirm: ‘Emin misiniz?’ } seçenekleri HTML5 öznitelikleri olarak kullanılır, böylece bağlantı tıklandığında, Rails önce kullanıcıya bir onaylama iletişim kutusu gösterir ve ardından bağlantıyı yöntem silme ile birlikte gönderir. Bu, uygulamayı oluşturduğunuzda uygulamanızın düzenine (app/views/layouts/application.html.erb) otomatik olarak dahil edilen JavaScript dosyası rails-ujs aracılığıyla yapılır. Bu dosya olmadan, onay iletişim kutusu görünmez. Çıktı aşağıdaki şekilde olacaktır;

Image for post
Image for post

5. İkinci Bir Model Ekleme

İkinci bir model ekleyeceğiz. Bu model makaleler hakkında bize gösterecektir.

Model Oluşturma

Daha önce Article modelini oluştururken kullandığımız gibi generator göreceğiz. Bu sefer bir makaleye referans tutmak için bir Yorum modeli oluşturacağız. Aşağıdaki komutu terminalinizde çalıştırın:

rails generate model Comment commenter:string body:text article:references

Image for post
Image for post
  • Bu komuttan sonra 4 dosya oluşacaktır.
Image for post
Image for post
  • İlk önce app/models/comment.rb dosyasına bakalım:
class Comment < ApplicationRecord  belongs_to :articleend
  • Bu, daha önce yaptığımız article model ‘ e benzerdir. Aradaki fark, bir Active Record ilişkisi kuran belong_to:article satırıdır.
  • Bash komutunda kullanılan (:reference) anahtar sözcüğü, modeller için özel bir veri türüdür. Veritabanı tablonuzda, sağlayan model adı ve tamsayı değerini tutabilen an_id ile eklenen yeni bir sütun oluşturur. Daha iyi anlamak için db/schema.rb dosyasını analiz edin.
  • Modele ek olarak, Rails ayrıca ilgili veritabanı tablosunu oluşturmak için geçiş yaptı:
ActiveRecord::Schema.define(version: 2020_09_17_085824) do    enable_extension "plpgsql"    ActiveRecord::Schema.define(version: 2020_09_17_085824) do    enable_extension "plpgsql"    create_table "articles", force: :cascade do |t|         t.string "title"         t.text "text"         t.datetime "created_at", precision: 6, null: false         t.datetime "updated_at", precision: 6, null: false    endend
  • t.reference satırı, article_id adında bir tamsayı sütunu, onun için bir index ve article tablosunun id sütununa işaret eden bir yabancı (foreign) anahtar kısıtlaması oluşturur. Yapılanları veritabanına eklemek için aşağıdaki komutu terminalde çalıştırın.
rails db:migrate

Modellerin İlişkilendirilmesi

Active record ilişkilendirmeleri, iki model arasındaki ilişkiyi kolayca beyan etmemize olanak sağlar. comments(yorumlar) ve articles (makaleler) söz konusu olduğunda, ilişkilileri şu şekilde yaparız.

  • Her yorum bir article ‘a aittir.
  • Bir article birçok yoruma sahip olabilir.

Aslında bu, Rails ‘in bu ilişkiyi bildirmek için kullandığı söz dizimine çok yakındır. Yorum modelinde (app/models/comment.rb) her yorumun bir makaleye ait olmasını sağlayan kodu aşağıda görüyorsunuz:

class Comment < ApplicationRecord  belongs_to :articleend
  • app/model/article.rb dosyasını aşağıdaki gibi düzenlemiz gerekiyor.
class Article < ApplicationRecord   has_many :comments   validates :title, presence: true,              length: { minimum: 5 }end
  • Bu iki bildirim, bir makale içeren bir @article örnek değişkeniniz varsa, o article ‘a ait tüm yollar @article.comments kullanarak bir index olarak alabilirsiniz.

Comments ‘leri Route ‘a Ekleme

  • Elinizdeki model ile dikkatinizi eşleşen bir controller oluşturmaya çevirebilirsiniz. Yine, daha önce kullandığımız aynı generator kullanacağız:
rails generate controller Comments

Aşağıdaki tablolar oluşacaktır:

Image for post
Image for post
  • Dosyaların işlevleri;
Image for post
Image for post
  • Herhangi bir blogda olduğu gibi, okuyucularımız makaleyi okuduktan sonra yorumlarını doğrudan oluşturacaklar ve yorumları ekledikten sonra, yorumlarının şimdi listelendiğini görmek için bir article show sayfasına geri gönderilecekler. Bu nedenle, CommentsController ‘ımız, yorumlar oluşturmak, geldiklerinde spam yorumları silmek ve yöntem sağlamak için oradadır.
  • İlk olarak, yeni bir yorum yapmamıza izin vermek için Article show şablonuna (app/views/articles/show.html.erb) aşağıdaki kodları yazacağız:
<p>   <strong>Title:</strong>   <%= @article.title %> </p><p>   <strong>Text:</strong>     <%= @article.text %></p><h2>Add a comment:</h2><%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>  <p>     <%= form.label :commenter %><br>     <%= form.text_field :commenter %>  </p>  <p>     <%= form.label :body %><br>     <%= form.text_area :body %>  </p>  <p>     <%= form.submit %>  </p><% end %><%= link_to 'Edit', edit_article_path(@article) %> |<%= link_to 'Back', articles_path %>
  • Bu, article show sayfasına CommentsController oluşturma eylemini çağırmak yeni bir yorum oluşturan bit form ekler. Buradaki form_with çağrısı /articles/1/comments gibi iç içe bir yol oluşturacak bir index kullanır.

Oluşturmayı app/controllers/comments_controller.rb içine aşağıdaki kodları yazalım:

class CommentsController < ApplicationController  def create    @article = Article.find(params[:article_id])    @comment = @article.comments.create(comment_params)    redirect_to article_path(@article)  end  private    def comment_params      params.require(:comment).permit(:commenter, :body)  endend
  • Burada, article için controller ‘da yaptığımızdan biraz daha fazla karmaşıklık göreceksiniz. Bu, kurduğunuz yuvanın bir yan etkisidir. Her yorum talebi, comment ‘in eklediği article için article modelinin bulma yöntemine yapılan ilk çağrıyı takip etmelidir.
  • Ek olarak, kod bir ilişkilendirme için mevcut olan bazı yöntemlerden yararlanır. Yorumu oluşturmak ve kaydetmek için @article.comments’ta oluşturma yöntemini kullanıyoruz. Bu, yorumu otomatik olarak o makaleye ait olacak şekilde bağlayacaktır.
  • Yeni yorumu yaptıktan sonra, makale_path (@article) yardımcısını kullanarak kullanıcıyı orijinal makaleye geri göndeririz. Daha önce gördüğümüz gibi, bu daha sonra show.html.erb şablonunu oluşturan ArticleController’ın show eylemini çağırır. Comment ‘i gösterilmesini istediğimiz yer burasıdır, bu yüzden bunu app/views/Articles/show.html.erb dosyasına aşağıdaki kodu yazalım:
<p>   <strong>Title:</strong>   <%= @article.title %></p><p>   <strong>Text:</strong>   <%= @article.text %></p><h2>Comments</h2><% @article.comments.each do |comment| %>  <p>     <strong>Commenter:</strong>     <%= comment.commenter %>  </p>    <p>     <strong>Comment:</strong>     <%= comment.body %>  </p><% end %><h2>Add a comment:</h2><%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>  <p>     <%= form.label :commenter %><br>     <%= form.text_field :commenter %>  </p>  <p>     <%= form.label :body %><br>     <%= form.text_area :body %>  </p>  <p>     <%= form.submit %>  </p><% end %><%= link_to 'Edit', edit_article_path(@article) %> |<%= link_to 'Back', articles_path %>

Artık bloğunuza makaleler ve aşağıdaki gibi yorumlar ekleyebilirsiniz.

Image for post
Image for post

REFACTORING (YENİDEN DÜZENLEME)

  • Artık çalışan yorumlarımız ve makalelerimiz olduğuna göre, app/views/Articles/show.html.erb şablonuna bakarsanız uzayıp ve tuhaflaştığını fark edesiniz. Temizlemek için partials ‘lar kullanabiliriz.

Rendering Partial Collections (partial koleksiyon oluşturması)

  • İlk olarak, article ilişkin tüm yorumları gösteren bir özet yorum yapacağız. app/views/comments/_comment.html.erb dosyasını oluşturun ve içine aşağıdakileri koyun:
<p>   <strong>Commenter:</strong>   <%= comment.commenter %></p><p>   <strong>Comment:</strong>   <%= comment.body %></p>
  • Sonra app/views/Articles/show.html.erb dosyasını aşağıdaki gibi değiştirebilirsiniz:
<p>   <strong>Title:</strong>   <%= @article.title %></p><p>   <strong>Text:</strong>   <%= @article.text %></p><h2>Comments</h2><%= render @article.comments %>
<h2>Add a comment:</h2><%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %><p><%= form.label :commenter %><br><%= form.text_field :commenter %> </p> <p> <%= form.label :body %><br> <%= form.text_area :body %> </p> <p> <%= form.submit %> </p><% end %><%= link_to 'Edit', edit_article_path(@article) %> |<%= link_to 'Back', articles_path %>
  • Bu, artık @article.comments koleksiyonundaki her yorum için app/views/comments/_comment.html.erb’deki patial ‘ı bir kez oluşturacaktır. Oluşturma yöntemi @article.comments koleksiyonu üzerinde yinelendiğinde, her yorumu partial ile aynı olan yerel bir değişkene atar, bu durumda yorum, daha sonra göstermemiz için partial (kısmi) olarak kullanılabilir.

Partial Formunu Oluşturma

  • Bu yeni yorum bölümünü de kendi kısmına taşıyalım. Yine, şunları içeren bir app/views/comments/_form.html.erb dosyası oluşturun ve aşağıdaki kodları yazın:
<%= form_with(model: [ @article, @article.comments.build ], local: true) do |form| %>  <p>     <%= form.label :commenter %><br>     <%= form.text_field :commenter %>  </p>  <p>     <%= form.label :body %><br>     <%= form.text_area :body %>  </p>  <p>     <%= form.submit %>  </p><% end %>
  • Daha sonra app/views/articles/show.html.erb dosyasını aşağıdaki gibi değiştirin.
<p>   <strong>Title:</strong>   <%= @article.title %></p><p>   <strong>Text:</strong>   <%= @article.text %></p><h2>Comments</h2><%= render @article.comments %><h2>Add a comment:</h2><%= render 'comments/form' %><%= link_to 'Edit', edit_article_path(@article) %> |<%= link_to 'Back', articles_path %>
  • İkinci render sadece render etmek istediğimiz kısmi şablonu, comments/form tanımlar. Rails, bu dizedeki eğik çizgiyi fark edecek ve app/views/comments dizininde _form.html.erb dosyasını oluşturmak istediğinizi anlayacak kadar akıllıdır.
  • @article nesnesi, onu bir örnek değişkeni olarak tanımladığımız için görünümde işlenen tüm parçalar için kullanılabilir.

Yorumları Silme (Deleting Comments)

  • Bir blogun bir diğer önemli özelliği de spam yorumları silebilmesidir. Bunu yapmak için, görünümde bir tür bağlantı ve CommentsController’da bir yok etme eylemi uygulamamız gerekir.
  • Öncelikle, app/views/comments/_comment.html.erb kısmına silme bağlantısını ekleyelim:
<p>   <strong>Commenter:</strong>   <%= comment.commenter %></p><p>   <strong>Comment:</strong>   <%= comment.body %></p><p>   <%= link_to 'Destroy Comment', [comment.article, comment],                method: :delete,                data: { confirm: 'Are you sure?' } %></p>
  • Bu yeni “Yorumu Yok Et” bağlantısına tıklamak bir SİLME tetikleyecektir.
  • /articles/:article_id /comments/:id CommentsController, daha sonra silmek istediğimiz yorumu bulmak için bunu kullanabilir, bu yüzden Controller ‘imize bir yok etme eylemi ekleyelim, aşağıdaki kodları yazalım (app/controllers/comments_controller.rb):
class CommentsController < ApplicationController   def create     @article = Article.find(params[:article_id])     @comment = @article.comments.create(comment_params)     redirect_to article_path(@article)   end   def destroy     @article = Article.find(params[:article_id])     @comment = @article.comments.find(params[:id])     @comment.destroy     redirect_to article_path(@article)   end   private   def comment_params     params.require(:comment).permit(:commenter, :body)   end
end
  • Yok etme eylemi baktığımız article ‘ı bulacak, comment ‘i @article.comments koleksiyonu içinde bulacak ve ardından onu veritabanından kaldıracak ve bizi article ‘ın show sayfasına geri gönderecektir.

İlişkili Nesneleri Silme

  • Bir makaleyi silerseniz, ilgili yorumların da silinmesi gerekir, aksi taktirde veritabanınızda yer kaplarlar. Rails, bunu başarmak için bir ilişkilendirmenin bağımlı (dependent) seçeneğini kullanmanıza izin verir. Makale modeli, app/models/article.rb aşağıdaki gibi değiştirin:
class Article < ApplicationRecord   has_many :comments, dependent: :destroy   validates :title, presence: true,   length: { minimum: 5 }end

Güvenlik

Temel Kimlik ( Authentication) Doğrulama

Blogunuzu çevrimiçi yayınlarsanız, herkes article ekleyebilir, düzenleyebilir, silebilir veya yorumları silebilir.

Rails, bu durumda iyi çalışacak çok basit bir HTTP kimlik doğrulama sistemi sağlar.

Makaleler Kontrolöründe, kişinin kimliği doğrulanmamışsa çeşitli eylemlere erişimi engellemenin bir yolunu bulmamız gerekir. Burada Rails http_basic_authenticate_with metodu kullanabiliriz, bu yöntem izin veriyorsa istenen eyleme erişime izin verir.

Kimlik doğrulama sistemini kullanmak için, app/controllers/articles_controller.rb ’deki ArticleController ’ımızın aşağıdaki gibi en üstünde belirtiyoruz. Bizim durumumuzda, kullanıcının indeks ve show hariç her işlemde kimliğinin doğrulanmasını istiyoruz, bu yüzden şunu yazıyoruz:

class ArticlesController < ApplicationControllerhttp_basic_authenticate_with name: "dhh", password: "secret", except: [:index, :show]def index@articles = Article.allend
  • Ayrıca, yalnızca kimliği doğrulanmış kullanıcıların yorumları silmesine izin vermek istiyoruz, bu nedenle CommentsController’da (app/controllers/comments_controller.rb) şunu yazıyoruz:
class CommentsController < ApplicationControllerhttp_basic_authenticate_with name: "dhh", password: "secret", only: :destroydef create@article = Article.find(params[:article_id])# ...end
  • Şimdi yeni bir makale oluşturmaya çalışırsanız, aşağıdaki gibi temel bir HTTP Kimlik Doğrulaması karşılaşacaksınız:
Image for post
Image for post
  • New sayfasına geçebilmek için Username: dhh ve Password: secret girebilirisniz. Değiştirmek isterseniz, comment_controller.rb ‘den düzenliyebilirsiniz.
  • Rails uygulamaları için başka kimlik doğrulama yöntemleri mevcuttur. Rails için iki popüler kimlik doğrulama eklentisi, Devise rails motoru ve Authlogic gem yanı sıra bir dizi başka eklentidir.

Diğer Güvenlik Hususları

  • Güvenlik, özellikle web uygulamalarında, geniş ve ayrıntılı bir alandır. Rails uygulamanızdaki güvenlik, Ruby on Rails Güvenlik Kılavuzun da daha ayrıntılı olarak ele alınmıştır.

Uygulamamızın sonuna geldik. Takıldığınız kısımda her zaman yardım isteyebilirsiniz. Umarım sizin için verimli bir yazı olmuştur.

Kaynak

https://guides.rubyonrails.org/getting_started.html

Written by

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store