1) Lancer la console en mode sandbox

bin/rails console --sandbox

User.create!(email: "test@example.com")
exit # => rollback auto

2) Recharger le code sans quitter: reload!

reload!

# avant reload! : la méthode n'existe pas
Article.new.respond_to?(:published_at_human) # => false

reload!

# après : chargée si tu as édité le fichier
Article.new.respond_to?(:published_at_human) # => true

bin/spring stop

3) Tester un endpoint sans curl: app.get et les helpers

app.get "/status"
app.response.status     # => 200
app.response.media_type # => "application/json"
app.response.body       # => "{...}"

app.url_helpers.post_path(Post.first)
helpers.number_to_currency(42)

4) Faire taire le bruit SQL (ou l'afficher mieux)

ActiveRecord::Base.logger.level = :warn  # ou :error

ActiveRecord::Base.logger.level = :info

Rails.logger.silence do
  heavy_query
end

5) Eviter de charger 1 million de lignes en RAM

# 5a) Parcourir sans tout charger\ nUser.find_each(batch_size: 1000) { |u| u.touch }

# 5b) Travailler par paquets\ nUser.in_batches(of: 500) { |batch| batch.update_all(active: true) }

# 5c) Récupérer juste les colonnes utiles\ nUser.where(active: true).pluck(:id, :email)

# 5d) Voir la requête générée\ nUser.where(active: true).to_sql

6) Manipuler les résultats rapidement: pluck, pick, select vs map

• Un attribut

• User.where(active: true).pluck(:email)
  # => ["a@ex.com", "b@ex.com", ...]
  
  

• Plusieurs attributs (renvoie des paires/tuples)

• User.pluck(:id, :email)
  # => [[1, "a@ex.com"], [2, "b@ex.com"], ...]
  
  

• Besoin d'un hash id => email ?

• User.pluck(:id, :email).to_h
  # => {1=>"a@ex.com", 2=>"b@ex.com", ...}
  
  

• Avec distinct, order, limit

• User.distinct.order(:created_at).limit(10).pluck(:email)
  
  

• Pourquoi c'est mieux que map(&:email) ?
  map instancie chaque User en Ruby. pluck fait un SELECT email côté DB et renvoie des valeurs prêtes à l'emploi. C'est plus léger et souvent plus rapide.

User.where(email: "a@ex.com").pick(:id)
# => 42

User.where(email: "a@ex.com").pick(:id, :created_at)
# => [42, 2025-07-21 10:03:00 +0200]

• select(:id, :email) charge des objets AR mais uniquement avec les colonnes listées. Utile si tu dois appeler des méthodes ensuite.
• map(&:email) parcourt en Ruby ce qui est déjà en mémoire. Sur de gros volumes, privilégie find_each ou in_batches.

User.ids                  # ≈ User.pluck(:id)
User.where(active: true).pluck(:id, :email).map { |id, mail| { id: id, email: mail } }
user.slice(:id, :email)   # Hash avec seulement ces attributs
User.where(role: :admin).as_json(only: [:id, :email])

Happy coding ! 😄

🚀 Objectif de ce tutoriel

• Tu veux comprendre comment fonctionne une gem Ruby de l’intérieur
• Tu rêves de publier ton propre code réutilisable
• Tu aimes les projets pédagogiques bien guidés 😄

🧠 C'est quoi un "slug" ?

"C'est quoi Ruby ?" devient => "cest-quoi-ruby"

🏗️ Étape 1 - Générer la structure de la gem

bundle gem slugfy_me

• Test framework : rspec
• Licence : MIT
• README, changelog, code of conduct : oui

• lib/slugfy_me.rb → le cœur du code
• slugfy_me.gemspec → les infos de ta gem
• spec/ → les tests

✍️ Étape 2 - Écrire la méthode slugify

SlugfyMe.slugify("Crème brûlée au Café !")
# => "creme-brulee-au-cafe"

• Mettre en minuscules
• Supprimer les caractères spéciaux
• Remplacer les lettres accentuées
• Remplacer les espaces par un tiret (ou un séparateur custom)

module SlugfyMe
  def self.slugify(string, separator: '-')
    string = remove_accents(string)
    string.downcase
          .gsub(/[^a-z0-9\s]/, '')
          .strip
          .gsub(/\s+/, separator)
  end

  def self.remove_accents(string)
    accents = {
      'àáâãäå' => 'a',
      'ç'      => 'c',
      'èéêë'   => 'e',
      'ìíîï'   => 'i',
      'ñ'      => 'n',
      'òóôõö'  => 'o',
      'ùúûü'   => 'u',
      'ýÿ'     => 'y'
    }

    accents.each do |group, replacement|
      string = string.gsub(/[#{group}]/i, replacement)
    end

    string
  end
end

🧪 Étape 3 - Tester avec RSpec

RSpec.describe SlugfyMe do
  it "transforme une chaîne simple" do
    expect(SlugfyMe.slugify("Ruby rocks!")).to eq("ruby-rocks")
  end

  it "supprime les accents" do
    expect(SlugfyMe.slugify("Crème brûlée au Café")).to eq("creme-brulee-au-cafe")
  end

  it "utilise un séparateur personnalisé" do
    expect(SlugfyMe.slugify("Ruby est top", separator: '_')).to eq("ruby_est_top")
  end
end

bundle exec rspec

📄 Étape 4 - Préparer la publication

spec.name        = "slugfy_me"
spec.version     = SlugfyMe::VERSION
spec.authors     = ["francilobbie"]
spec.email       = ["ton.email@email.com"]
spec.summary     = "An educational Ruby gem to generate clean slugs from strings"
spec.description = "SlugfyMe is a minimalist gem created for Captain Ruby, to help you learn how to build and publish a gem."
spec.homepage    = "https://github.com/francilobbie/slugfy_me"
spec.license     = "MIT"

🔑 Étape 5 - Générer une clé API RubyGems.org

1. Va sur rubygems.org/profile/edit
2. Descends jusqu'à API access > clique sur New API Key
3. Donne un nom (ex : dev-laptop) et valide
4. Ensuite, dans ton terminal :

gem signin

🚢 Étape 6 - Publier la gem sur RubyGems

1. Build la gem :

gem build slugfy_me.gemspec

1. Push vers RubyGems :

gem push slugfy_me-0.1.0.gem

📦 Code source sur GitHub

🎒 Aller plus loin

bundle open slugfy_me

• Ajouter d’autres options (:upcase, :max_length, etc.)
• Supporter plus d’accents (ou utiliser I18n.transliterate pour déléguer)
• Ajouter une CLI (bin/slugfy) pour l’utiliser depuis le terminal
• Ajouter une doc avec yard

🧠 Conclusion

• Créer une gem Ruby from scratch
• Ajouter une logique utile
• Écrire des tests
• Documenter proprement
• Publier sur RubyGems

Introduction 🚀

Pourquoi it ? 🤔

numbers.map { |n| n * 2 }

numbers.map { it * 2 }

Avant / Après détaillé 🪄

• each_with_object

• data.each_with_object({}) { it.process!(...) }
  
  

• tap pour du debug express

• result.tap { puts "DEBUG => #{it.inspect}" }
  
  

• Injections simples avec inject / reduce

• prices.reduce(0) { _1 + it.taxed }
  # mélange possible avec _1 (1er param) + it (2ᵉ param)
  
  

Limites à connaître ⚠️

1. 
   
2. Un seul paramètre implicite. Si ton block prend plusieurs arguments, it ne couvre que le premier ; les autres doivent être déclarés normalement.
3. Lambdas “stabby”. Pas dispo dans -> { ... } si tu n’indiques pas les paramètres :

4. # ❌ Ne marche pas
   add = -> { it + 2 }
   
   # ✅ OK
   add = ->(it) { it + 2 }
   
   

5. Lisibilité long format. Sur un block multi‑lignes avec plusieurs références à l’argument, un nom explicite reste roi.

Performances : zéro overhead 🏎️

# Installer la preview (si besoin)
rbenv install 3.4.0-preview1
rbenv shell 3.4.0-preview1
irb

["café", "ruby", "rocks"].map { it.upcase }
# => ["CAFÉ", "RUBY", "ROCKS"]

Happy coding ! 😄

Introduction 🔧

1. friendly_id : des URLs humaines

# Gemfile
gem "friendly_id", "~> 5.4"

# Terminal
rails generate friendly_id
rails db:migrate

class Article < ApplicationRecord
  extend FriendlyId
  friendly_id :title, use: :slugged
end

2. pagy : la pagination la plus légère du Far West

# Gemfile
gem "pagy"

# Controller
include Pagy::Backend

def index
  @pagy, @articles = pagy(Article.all)
end

# View (ERB)
<%= pagy_nav(@pagy) %>

3. font_awesome5_rails : des icônes en deux lignes

# Gemfile
gem "font_awesome5_rails"

# Layout (application.html.erb)
<%= stylesheet_link_tag "font_awesome5" %>

# Vue
<%= fa_icon "edit" %>

Conclusion ☕

Trois gems, trois commandes, un gros gain de confort sur tous mes projets. Et toi, c'est quoi tes indispensables ? Balance tes pépites en commentaire, je suis toujours preneur.

Happy Coding ! 🚀

 “There are two ways to write error-free programs; only the third one works.” — Alan J. Perlis 

Introduction ⚙️

• Comment elles fonctionnent ?
• Quelles sont les plus courantes ?
• Comment les lire intelligemment ?
• Comment les gérer proprement ?
• Comment créer ses propres erreurs utiles pour ton app ?

Avec des exemples concrets, des bonnes pratiques, des nouveautés de Ruby 3.4.1, et même quelques retours de devs glanés sur Reddit. Bref, tout ce qu’il faut pour que les erreurs ne te fassent plus peur.

I. C’est quoi une exception en Ruby ? 🧩

begin
  # code potentiellement problématique
rescue
  # code exécuté en cas d’erreur
end

• Silencieuses : capturées et gérées
• Fatales : non capturées, le programme s’arrête

II. Lire un message d’erreur : le stack trace expliqué 🐛

• le fichier concerné
• la ligne où ça a planté
• le type d’erreur
• le message explicite

main.rb:12:in `calculate': divided by 0 (ZeroDivisionError)

NameError: undefined local variable or method `usr' for main:Object
Did you mean?  user

III. Les erreurs les plus fréquentes 🧱

puts total_price
# => NameError: undefined local variable or method 'total_price'

user = nil
user.name
# => NoMethodError: undefined method `name` for nil:NilClass

def greet(name, age); end
greet("Alice")
# => ArgumentError: wrong number of arguments (given 1, expected 2)

if true
  puts "ok"
# => SyntaxError: unexpected end-of-input, expecting keyword_end

[1, 2, 3] + "salut"
# => TypeError: no implicit conversion of String into Array

10 / 0
# => ZeroDivisionError: divided by 0

File.read("/path/to/missing/file")
# => Errno::ENOENT: No such file or directory

IV. Comment gérer les erreurs proprement 🛠️

begin
  risky_code
rescue => e
  puts e.class       # Type d'erreur
  puts e.message     # Message associé
  puts e.backtrace   # Détail des appels
end

• else s’exécute si aucune erreur n’est levée
• ensure s’exécute dans tous les cas, erreur ou pas

begin
  puts "On tente un truc"
rescue => e
  puts "Erreur capturée : #{e.message}"
else
  puts "Tout s'est bien passé !"
ensure
  puts "Nettoyage systématique"
end

tries = 0
begin
  fetch_remote_data
rescue NetworkTimeout => e
  tries += 1
  retry if tries < 3
  raise "Échec après 3 tentatives"
end

V. Lever ses propres exceptions 🚨

raise "Ce nom est invalide"

class PermissionDenied < StandardError; end

def delete_user(user)
  raise PermissionDenied, "Vous n'avez pas le droit de faire ça" unless user.admin?
end

class ApiError < StandardError
  attr_reader :code

  def initialize(message, code)
    super(message)
    @code = code
  end
end

VI. L’arbre des exceptions Ruby 🌳

Exception
├── NoMemoryError
├── ScriptError
│   ├── LoadError
│   ├── SyntaxError
├── SignalException
│   └── Interrupt
├── StandardError
│   ├── ArgumentError
│   ├── ZeroDivisionError
│   ├── RuntimeError
│   ├── NoMethodError
│   ├── etc.

VII. Nouveautés et changements dans Ruby 3.4.1 🧪

rescue => e
  puts e.full_message(highlight: true)

begin
  raise "Erreur A"
rescue => e
  raise "Erreur B"
end

VIII. Bonnes pratiques ✅

• Ne fais jamais rescue nil : tu masques l’erreur, tu ne la règles pas.
• Ne rescue pas Exception sauf cas ultra spécifiques (comme un moteur de sandbox).
• Loggue toujours ce que tu interceptes (au moins e.message).
• Utilise ensure pour nettoyer après une opération critique (fichier, DB, etc.).
• Crée des erreurs personnalisées avec des noms clairs : InvalidCredentials, RateLimitExceeded, etc.

IX. Bonus : outils de debug Ruby 🧰

• pry-rescue : ouvre un REPL automatiquement dès qu'une exception se produit.
• byebug : très utile pour mettre un breakpoint dans un rescue.
• binding.irb ou binding.pry : explore l'état du programme en live.
• exception.full_message(highlight: true) : affiche le message d’erreur avec couleurs et contexte.
• Sentry / Rollbar / Bugsnag : pour suivre les exceptions en production.

Conclusion 🎬

Happy coding ! 🚀

🚀 Introduction

📄 ERB vs HAML : présentation

<% if user.admin? %>
  <p>Bienvenue, admin <%= user.name %> !</p>
<% end %>

• Syntaxe simple et familière pour les développeurs web
• Flexibilité totale sur le HTML
• Aucune dépendance externe
• Intégration native dans tous les helpers Rails
• Compatible avec tous les éditeurs et outils front (ex. Tailwind, Hotwire, Stimulus)

"ERB parce que c'est du HTML. Pas besoin d’apprendre un nouveau DSL." -- r/rails
"Plus proche du métal. Je n’ai jamais ressenti le besoin d’un autre langage de template." -- BananafestDestiny

- if user.admin?
  %p Bienvenue, admin #{user.name} !

• Code plus lisible et aéré
• Moins de bruit visuel (pas de balises HTML explicites à fermer)
• Moins d’erreurs de nesting et balises non fermées
• Structure visuelle claire facilitant la relecture
• Très apprécié dans des équipes expérimentées ou sur des bases de code legacy

"Je ne supporte plus les % partout, je suis passé à Slim." -- pupdogg007
"HAML, tout simplement parce que je ne veux plus jamais fermer une balise à la main." -- GozerDestructor
"J'ai utilisé HAML pendant des années avant de revenir à ERB pour sa simplicité." -- Katafrakt

✅ Productivité & lisibilité

• HAML améliore la relecture des PRs, surtout dans les gros projets
• ERB est plus tolérant et plus proche du HTML natif, facilitant la collaboration avec des profils non Ruby
• Le copier-coller depuis des ressources HTML (StackOverflow, Tailwind docs…) est beaucoup plus naturel en ERB

"ERB est verbeux, mais je peux y coller du HTML directement sans me poser de questions." -- katafrakt"HAML est génial jusqu’à ce que je doive convertir manuellement un snippet HTML copié sur un site." -- u/[supprimé]

• ERB compile plus rapidement car intégré nativement via erubi
• HAML et Slim utilisent temple, ce qui ajoute une couche de compilation

• haml-slim-erb benchmark
• La dernière version de HAML est beaucoup plus performante qu’avant (voir release notes HAML 6.0)

"Le nombre d’objets alloués explose avec HAML dans les logs dev, mais en prod, c’est négligeable." — Icy_Mathematician182

- if user.admin?
  p Bienvenue, admin #{user.name} !

• Syntaxe ultra minimaliste
• Parsing très rapide
• Compatible Tailwind, Turbo et Hotwire

"Chaque fois que je commence une nouvelle app avec ERB, je finis par revenir à Slim."

"Slim est un HAML raffiné : plus lisible, plus rapide."

"Le parser Slim est frustrant : la moindre erreur d’indentation renvoie une page blanche."

• Votre équipe est expérimentée
• Vous souhaitez une syntaxe minimaliste
• Vous utilisez beaucoup de composants et de partials

"Phlex est plus rapide qu’ERB. C’est fun, mais pas fait pour tout le monde.""Si je veux écrire du HTML avec des classes Ruby, je fais du markdown ou j’utilise des composants."

🎯 À surveiller de près : Phlex est jeune, mais prometteur pour des projets orientés composants ou des librairies design systems maison.

🔢 Synthèse

🚀 Conclusion

• ERB : simple, fiable, universel
• HAML : lisible, élégant, adapté aux gros projets
• Slim : minimaliste, rapide, pour les amoureux de la concision

rails new my_api_app --api

# config/initializers/cors.rb
Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
    origins '*'
    resource '*', headers: :any, methods: [:get, :post, :patch, :put, :delete, :options]
  end
end

namespace :api do
  namespace :v1 do
    resources :articles
  end
end

class Api::V1::ArticlesController < ApplicationController
  def index
    articles = Article.all
    render json: ArticleSerializer.new(articles).serializable_hash
  end
end

• Ajoutez une couche de services (e.g. ArticleFetcherService) pour isoler la logique métier.
• Utilisez des policies (Pundit) pour sécuriser l'accès aux données.

• Blueprinter (rapide, lisible, flexible)
• ActiveModel::Serializers (plus verbeux, mais structurant)
• 
  

include Pagy::Backend
@pagy, @articles = pagy(Article.all)

Article.ransack(title_cont: "Rails").result

bundle add graphql
rails generate graphql:install

class Types::ArticleType < Types::BaseObject
  field :id, ID, null: false
  field :title, String
  field :content, String
end

query {
  articles { id title content }
}

• Flexibilité du client
• Moins de sur-fetching
• Documentation générée automatiquement (GraphiQL)
• 
  

• Implémentation plus lourde côté backend
• Caching plus complexe

class NotificationsChannel < ApplicationCable::Channel
  def subscribed
    stream_from "notifications_#{current_user.id}"
  end
end

Turbo::StreamsChannel.broadcast_append_to(
  "notifications_#{user.id}",
  target: "notifications",
  partial: "notifications/item",
  locals: { notification: Notification.last }
)

<%= turbo_frame_tag "comment_form" do %>
  <%= form_with model: @comment %>
<% end %>

<%= turbo_stream.append "comments" do %>
  <%= render @comment %>
<% end %>

• UX fluide sans JS custom
• Requête standard HTTP
• Moins de logique côté frontend

class Api::V1::BaseController < ApplicationController
  before_action :authenticate_user!
end

• rack-attack pour limiter les abus
• secure_headers pour durcir la sécurité HTTP
• auditing/logging des accès sensibles

describe "GET /api/v1/articles" do
  it "returns articles" do
    get "/api/v1/articles"
    expect(response).to have_http_status(:ok)
  end
end

• FactoryBot pour la fabrication de données
• JSON helpers pour simplifier les assertions
• rswag pour documenter l’API en Swagger
• VCR/WebMock pour mocker les appels externes

Happy coding !

rails new captain_ruby_notifications --skip-active-storage --skip-action-mailbox  --css=tailwind 
cd captain_ruby_notifications

bundle add devise
rails generate devise:install
rails generate devise User

rails generate scaffold Post title:string content:text
rails generate scaffold Comment content:text post:references user:references
rails db:migrate

Par la suite, nous allons ajuster notre fichier config/routes.rb

3. Ajout du gem Noticed dans le Gemfile

Ouvrez le fichier Gemfile et ajoutez :

gem "noticed", "~> 1.6"

1. Puis exécutez :

2. bundle install

rails generate noticed:model Notification
rails generate noticed:notification CommentNotification
rails db:migrate

class CommentNotification < Noticed::Base
  deliver_by :database
  deliver_by :action_cable, format: :to_action_cable

  # On attend un paramètre :message (chaîne de caractères)
  param :message

  # Après la livraison, nous diffusons la notification via Turbo Streams
  after_deliver :broadcast_notification

  def to_database
    { message: params[:message] }
  end

  def to_action_cable
    { title: "Nouveau commentaire", message: params[:message], id: record.id }
  end

  private

  def broadcast_notification
    recipient.broadcast_prepend_later_to(
      "notifications_#{recipient.id}_dropdown_list",
      target: "notification-dropdown-list",
      partial: "notifications/notification",
      locals: { notification: self.record }
    )

    recipient.broadcast_replace_later_to(
      "notifications_#{recipient.id}_counter",
      target: "notification-counter",
      partial: "notifications/notification_counter",
      locals: { user: recipient }
    )
  end
end

class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  has_many :posts, dependent: :destroy
  has_many :comments, dependent: :destroy

  # Note : le modèle est généré sous le nom Notification
  has_many :notifications, as: :recipient, dependent: :destroy, class_name: "Notification"
end

class Comment < ApplicationRecord
  belongs_to :post
  belongs_to :user

  validates :content, presence: true

  # Après création, déclencher la notification (sauf si l'auteur commente son propre article)
  after_create_commit :notify_post_user

  private

  def notify_post_user
    return if post.user == user

    CommentNotification.with(
      message: "#{user.email} à commenté votre article : #{post.title}"
    ).deliver_later(post.user)
  end
end

1. 6. Une fois les modèles définis, nous allons maintenant mettre à jour le contrôleur des commentaires (CommentController.rb)
2. 
   
3.   Voici un exemple mis à jour pour app/controllers/comments_controller.rb qui gère le streaming via Turbo Streams :  

Puis créer un fichier Turbo Stream pour la méthode "create".

code app/views/comments/create.turbo_stream.erb

 

<div id="notification-<%= notification.id %>" class="notification group relative flex flex-col sm:flex-row items-start sm:items-center bg-white hover:bg-gray-50 border border-gray-100 rounded-lg p-4 mb-2 shadow-sm transition-all duration-300 ease-in-out">
  <div class="flex-grow w-full sm:pr-4">
    <p class="text-gray-800 text-sm sm:text-base mb-1.5">
      <%= notification.params[:message] %>
    </p>
    <p class="text-xs text-gray-500 mb-2">
      <%= time_ago_in_words(notification.created_at) %>
    </p>
  </div>
</div>

<% unread_count = user.notifications.unread.count %>
<% if unread_count.positive? %>
  <span class="absolute -top-1 -right-1 bg-red-500 text-white text-xs font-bold px-1.5 py-0.5 rounded-full">
    <%= unread_count %>
  </span>
<% end %> 

<%= turbo_stream.prepend "notification-dropdown-list", partial: "notifications/notification", locals: { notification: notification } %>
<%= turbo_stream.replace "notification-counter", partial: "notifications/notification_counter", locals: { user: notification.recipient } %>

<!-- app/views/layouts/_navbar.html.erb -->
<nav class="bg-white shadow">
  <div class="max-w-7xl mx-auto px-4">
    <div class="flex justify-between items-center py-4">
      <!-- Logo et liens principaux -->
      <div class="flex items-center space-x-4">
        <a href="<%= root_path %>" class="flex items-center text-gray-700">
          <span class="font-bold text-xl">Captain Ruby Notifications</span>
        </a>
        <div class="hidden md:flex items-center space-x-1">
          <%= link_to "Articles", posts_path, class: "py-2 px-3 text-gray-700 hover:text-gray-900" %>
          <!-- Ajoutez d'autres liens si nécessaire -->
        </div>
      </div>

      <!-- Section droite : notifications et authentification -->
      <div class="flex items-center space-x-4">
        <% if user_signed_in? %>
          <div class="relative group">
            <div class="cursor-pointer p-2">
              <!-- Icône de notifications -->
              <svg class="h-6 w-6 text-gray-700" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" 
                      d="M15 17h5l-1.405-1.405A2.032 2.032 0 0118 14.158V11a6 6 0 10-12 0v3.159c0 .538-.214 1.055-.595 1.436L4 17h5m6 0v1a3 3 0 11-6 0v-1"/>
              </svg>
              <!-- Compteur de notifications -->
              <%= turbo_stream_from "notifications_#{current_user.id}_counter", id: "notification_counter_stream" %> 
              <div id="notification-counter">
                <%= render "notifications/notification_counter", user: current_user %>
              </div>
            </div>
            <!-- Liste des notifications -->
            <%= turbo_stream_from "notifications_#{current_user.id}_dropdown_list", id: "notification_dropdown_stream" %> 
            <div id="notification-dropdown-list" class="absolute right-0 mt-2 w-80 bg-white shadow-lg rounded hidden group-hover:block z-50">
              <div class="p-4 space-y-2">
                <% if @notifications.any? %>
                  <%= render @notifications.order(created_at: :desc) %>
                <% else %>
                  <p class="text-gray-500">Aucune notification pour le moment.</p>
                <% end %>
              </div>
            </div>
          </div>
          <%= link_to "Déconnexion", destroy_user_session_path, method: :delete, class: "py-2 px-3 text-gray-700 hover:text-gray-900" %>
        <% else %>
          <%= link_to "Connexion", new_user_session_path, class: "py-2 px-3 text-gray-700 hover:text-gray-900" %>
          <%= link_to "Inscription", new_user_registration_path, class: "py-2 px-3 bg-yellow-400 text-yellow-900 rounded hover:bg-yellow-300 transition duration-300" %>
        <% end %>
      </div>
    </div>
  </div>
</nav>

 
      e.  Ouvrez votre fichier app/views/layouts/application.html.erb et insérez-y le rendu du partial de la navbar. Par exemple, juste après l'ouverture de la balise <body> :

8.  Dans app/controllers/application_controller.rb, ajoutez un before_action pour charger les notifications globalement dans l'environement si l'utilisateur est connecté :

9.  Vérification et tests

Démarrez le serveur avec :

bin/dev