dsfr_accessible_skip_links 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4afbed35674b0ec24dfc35c348b73396f4ed4ffba52f4924aec310eb876e0a3
-  data.tar.gz: 26577cd195e55cb9e7dc0d732c121b1f6fca3f71dd1bd8a8fed0690082f5ae76
+  metadata.gz: cde36b7db7ed5759c035c760be7723d3c06e3912182688148c1adf62a59b827d
+  data.tar.gz: 1df51f6f597f5811c5b42cf66a9a1960cc7c307eb46140781f056581dc22edf2
 SHA512:
-  metadata.gz: c642f22b47fbb7df60a42dbe1c9155792feb0c81243d407f6e8870511d56a07acd66fe0439fb8729562fea46c6351ba3ec2aa1ec13bf477c901ca76d0e71e467
-  data.tar.gz: ef4bf61ee5484dd794b73dbcbee89a9f4dd72d06dd4525849bfe34c19d86e32020a2843272e380a13bc31c102256478a2d46304a7e265cc280f2e9ba3051361a
+  metadata.gz: 35aa47a41dcee7700f425b87436042d71504532aace7a6316621a7da99e510ee090567d0ee3fae28a53414be0c24e1615e7b831c2ed744eb66dc208e9d0545a3
+  data.tar.gz: 9351451e96a6859ea8f35934e99222c4f90d3685f11eb684a031e8a7bfe18d69fd9172606d3d33cd80b0d3e9fb94b2736571bc92b25e80beb5fff9ad0c9940ed

data/CHANGELOG.md

@@ -7,11 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-08-28
+### Added
+- **SkipLinksImplementedChecker**: New validation service to ensure skip links are properly implemented across applications
+- **Configuration system**: Allow users to configure whitelisted routes that are exempt from validation
+- **Disable validation option**: New `disable_validation` configuration for projects with existing validation systems
+- Comprehensive test coverage for validation functionality
+
+### Changed
+- Improved README documentation with clearer installation and usage instructions
+- Enhanced generator functionality and reliability
+- Updated README with complete documentation for validation features and configuration options
+
+## [0.1.3] - 2025-08-27
+### Fixed
+- Generator now uses `copy_file` instead of `template` to avoid evaluating ERB in the partial during generation. This prevents `NameError` for `skip_links_content`.
+- Ensure DsfrAccessibleSkipLinks::SkipLinks is automatically included using `ActiveSupport.on_load` hooks:
+- Included into `ActionController::Base` (controller-side) and exposed as view helpers
+- Included into `ActionView` (view-side) so helpers are available in templates without manual setup
+
 ## [0.1.2] - 2025-08-27
 ### Added
 - Rails generator `dsfr_accessible_skip_links:install` to copy the skip links partial and inject the render call into the application layout.
 - README updated with installation instructions using the generator.
 
+## [0.1.1] - 2025-08-27
+### Fixed
+- Minor bug fixes and improvements
+
 ## [0.1.0] - 2025-08-27
 
 ### Added

data/README.md

@@ -1,70 +1,76 @@
 # DsfrAccessibleSkipLinks
 
-A Ruby gem that helps projects implement accessible skip links according to the French government design system (DSFR - Système de design de l'État français). This gem provides helpers and utilities for creating navigation skip links that improve web accessibility.
+Une gem Ruby qui aide les projets à implémenter des liens d’évitement accessibles conformément au Système de design de l’État français (DSFR). Cette gem fournit des helpers et utilitaires pour créer des liens d’évitement de navigation qui améliorent l’accessibilité du web.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Ajoutez cette ligne au Gemfile de votre application :
 
 ```ruby
 gem 'dsfr_accessible_skip_links'
 ```
 
-Then install the gem:
+Puis installez la gem :
 
     $ bundle install
 
-Run the installer to set up the skip links in your Rails app (copies the partial and injects the render in your layout):
+Lancez l’installateur pour configurer les liens d’évitement dans votre application Rails :
 
     $ bin/rails g dsfr_accessible_skip_links:install
 
-You can also install the gem itself directly as:
+Cela va :
+- Copier le partial des liens d’évitement vers `app/views/shared/_skip_links.html.erb`
+- Afficher des instructions pour l’ajouter à votre layout
 
-    $ gem install dsfr_accessible_skip_links
+**Étape suivante :** Ajoutez l’appel à `render` dans votre layout (généralement `app/views/layouts/application.html.erb`) :
+
+```erb
+<body>
+  <%= render 'shared/skip_links' %>
+  <!-- le reste de votre contenu -->
+</body>
+```
 
-## Usage
+**Option d’installation rapide :** utilisez l’option `--inject-layout` pour ajouter automatiquement l’appel à `render` :
+
+    $ bin/rails g dsfr_accessible_skip_links:install --inject-layout
+
+Vous pouvez aussi installer directement la gem :
+
+    $ gem install dsfr_accessible_skip_links
 
-### Rails Integration
+## Utilisation
 
-The gem automatically integrates with Rails through a Rails Engine. The `SkipLinks` module is automatically included in `ApplicationController`.
+### Éléments requis
 
-In your layout file (e.g., `app/views/layouts/application.html.erb`), add the skip links at the top:
+Assurez‑vous que votre layout contient ces éléments avec les bons identifiants (ID) :
 
 ```erb
-<!DOCTYPE html>
-<html>
-  <head>
-    <!-- head content -->
-  </head>
-  <body>
-    <%= render partial: 'shared/skip_links' %>
-    
-    <!-- rest of your layout -->
-    <header id="header">
-      <!-- your navigation -->
-    </header>
-    
-    <main id="content">
-      <%= yield %>
-    </main>
-    
-    <footer id="footer">
-      <!-- your footer -->
-    </footer>
-  </body>
-</html>
+<header id="header">
+  <!-- votre navigation -->
+</header>
+
+<main id="content">
+  <%= yield %>
+</main>
+
+<footer id="footer">
+  <!-- votre pied de page -->
+</footer>
 ```
 
-### Default Skip Links
+La gem s’intègre automatiquement à Rails via un Rails Engine. Les méthodes helper sont disponibles automatiquement dans tous les contrôleurs et vues.
+
+### Liens d’évitement par défaut
 
-By default, the gem provides three skip links:
-- **"Aller au contenu"** → `#content`
-- **"Menu"** → `#header`  
-- **"Pied de page"** → `#footer`
+Par défaut, la gem fournit trois liens d’évitement :
+- **« Aller au contenu »** → `#content`
+- **« Menu »** → `#header`  
+- **« Pied de page »** → `#footer`
 
-### Custom Skip Links
+### Liens d’évitement personnalisés
 
-You can customize skip links on a per-page basis using Rails' `content_for`:
+Vous pouvez personnaliser les liens d’évitement page par page grâce à `content_for` de Rails :
 
 ```erb
 <% content_for :skip_links do %>
@@ -74,44 +80,44 @@ You can customize skip links on a per-page basis using Rails' `content_for`:
 <% end %>
 ```
 
-### Custom Content Link Text
+### Texte du lien vers le contenu
 
-You can customize the main content link text:
+Vous pouvez personnaliser le texte du lien vers le contenu principal :
 
 ```erb
-<% content_for :content_skip_link_text, 'Go to main content' %>
+<% content_for :content_skip_link_text, 'Aller au contenu principal' %>
 ```
 
-### Tab-Prefixed Links
+### Liens préfixés par « tab- »
 
-For links that need JavaScript interaction, use the `tab-` prefix:
+Pour les liens nécessitant une interaction JavaScript, utilisez le préfixe `tab-` :
 
 ```erb
-<%= skip_link('Tab Navigation', 'tab-special-section') %>
+<%= skip_link('Navigation par onglet', 'tab-special-section') %>
 ```
 
-This will add a `data-anchor` attribute for JavaScript handling.
+Cela ajoutera un attribut `data-anchor` pour la gestion côté JavaScript.
 
-### Helper Methods
+### Méthodes helper
 
-The gem provides these helper methods (automatically available in controllers and views):
+La gem fournit ces méthodes helper (disponibles automatiquement dans les contrôleurs et vues) :
 
-- `skip_link(text, anchor)` - Creates a single skip link
-- `default_skip_links` - Returns the default set of skip links
-- `skip_links_content` - Returns either custom or default skip links
-- `content_skip_link_text` - Returns the content link text
+- `skip_link(text, anchor)` - Crée un lien d’évitement
+- `default_skip_links` - Renvoie l’ensemble par défaut de liens d’évitement
+- `skip_links_content` - Renvoie les liens personnalisés ou, à défaut, les liens par défaut
+- `content_skip_link_text` - Renvoie le texte du lien vers le contenu
 
-### CSS Classes
+### Classes CSS
 
-The gem uses official DSFR CSS classes:
-- `.fr-skiplinks` - Main container
-- `.fr-container` - DSFR container wrapper
-- `.fr-skiplinks__list` - List container
-- `.fr-link` - Individual link styling
+La gem utilise les classes CSS officielles du DSFR :
+- `.fr-skiplinks` - Conteneur principal
+- `.fr-container` - Conteneur DSFR
+- `.fr-skiplinks__list` - Liste des liens
+- `.fr-link` - Style du lien individuel
 
-### HTML Structure
+### Structure HTML
 
-The generated HTML follows this structure:
+Le HTML généré suit cette structure :
 
 ```html
 <div class="fr-skiplinks">
@@ -125,104 +131,246 @@ The generated HTML follows this structure:
 </div>
 ```
 
-## Accessibility Features
+## Validation des liens d’évitement
+
+La gem inclut un service de validation pour s’assurer que les liens d’évitement sont correctement implémentés dans votre application pendant les tests.
+
+### SkipLinksImplementedChecker
+
+Le service `SkipLinksImplementedChecker` vérifie automatiquement que les pages :
+- ont des liens d’évitement personnalisés définis via `content_for(:skip_links)`, ou
+- sont incluses dans votre configuration de routes en liste blanche (whitelist)
+
+Cette validation s’exécute automatiquement en environnement de test lorsque les liens d’évitement sont rendus.
+
+### Configuration
+
+Configurez les routes qui doivent être exemptées de la validation des liens d’évitement :
+
+```ruby
+# config/initializers/dsfr_accessible_skip_links.rb
+DsfrAccessibleSkipLinks.configure do |config|
+  config.whitelisted_routes = [
+    'pages#home',
+    'pages#about',
+    'admin/dashboard#index',
+    'users#show',
+    'posts#index'
+  ]
+end
+```
+
+### Désactiver la validation
 
-This gem implements skip links following WCAG 2.2 guidelines and DSFR specifications:
+Si votre projet dispose déjà de son propre système de validation des liens d’évitement, vous pouvez désactiver la validation intégrée de la gem :
 
-- Proper semantic HTML structure with `nav` element and `role="navigation"`
-- Descriptive `aria-label` for screen readers
-- Keyboard navigation support
-- Focus management
-- Compatible with DSFR CSS for visual styling
+```ruby
+# config/initializers/dsfr_accessible_skip_links.rb
+DsfrAccessibleSkipLinks.configure do |config|
+  config.disable_validation = true
+end
+```
+
+Lorsque `disable_validation` est défini à `true` :
+- `SkipLinksImplementedChecker` ne s’exécute pas automatiquement dans les tests
+- Vous pouvez toujours utiliser les helpers de la gem pour générer les liens d’évitement
+- Aucune erreur de validation n’est levée, vous gardez la main sur les contrôles d’accessibilité
+
+### Utilisation manuelle
+
+Vous pouvez aussi utiliser le vérificateur manuellement dans vos tests ou votre application :
+
+```ruby
+# Dans un contrôleur ou un test
+checker = DsfrAccessibleSkipLinks::SkipLinksImplementedChecker.new(
+  controller_name: 'posts',
+  action_name: 'show',
+  has_skip_links: content_for?(:skip_links)
+)
+
+begin
+  checker.perform!
+  # Les liens d’évitement sont correctement configurés
+rescue DsfrAccessibleSkipLinks::SkipLinksImplementedChecker::SkipLinksNotDefinedError => e
+  # Gérer l’absence de liens d’évitement
+  puts e.message
+end
+```
 
-## How to test this gem
+### Intégration dans les tests Rails
 
-There are two main ways to test this gem:
+La validation s’exécute automatiquement pendant les tests. Si une page n’a pas de liens d’évitement et n’est pas en liste blanche, vous verrez :
 
-1) Run the gem's test suite locally (fast, no Rails app needed)
-- Install dependencies:
+```
+DsfrAccessibleSkipLinks::SkipLinksImplementedChecker::SkipLinksNotDefinedError: 
+No skip links defined for this page (posts#show). Use content_for(:skip_links) 
+to define skip links or define them in a view-specific helper.
+```
+
+Pour corriger cela, soit :
+1. Ajoutez la route à votre configuration de liste blanche
+2. Définissez des liens d’évitement personnalisés dans votre vue :
+
+```erb
+<% content_for :skip_links do %>
+  <%= skip_link('Aller au contenu', 'main-content') %>
+  <%= skip_link('Aller aux commentaires', 'comments') %>
+<% end %>
+```
+
+## Fonctionnalités d’accessibilité
+
+Cette gem implémente des liens d’évitement conformément aux [WCAG 2.2](https://www.w3.org/WAI/WCAG22/quickref/) et aux spécifications du [DSFR (Système de design de l’État français)](https://www.systeme-de-design.gouv.fr/).
+
+### Conformité aux standards
+- **WCAG 2.2 niveau AA** : conforme aux standards internationaux d’accessibilité
+- **Recommandations DSFR** : suit les exigences d’accessibilité du système de design de l’État
+- **RGAA 4.1** : compatible avec le Référentiel Général d’Amélioration de l’Accessibilité
+
+### Caractéristiques techniques
+- **HTML sémantique** : structure adéquate avec l’élément `<nav>` et `role="navigation"`
+- **Compatibilité lecteurs d’écran** : `aria-label="Accès rapide"` descriptif pour les aides techniques
+- **Navigation au clavier** : accessibilité complète avec gestion correcte du focus
+- **Aller au contenu** : navigation directe vers les zones principales (#content, #header, #footer)
+- **Design visuel** : compatible avec les classes CSS officielles du DSFR pour un style cohérent
+
+### Assurance qualité
+- **Validation automatisée** : un vérificateur intégré évite d’oublier les liens d’évitement
+- **Intégration aux tests** : vérifie la présence des liens pendant les exécutions de test
+- **Validation configurable** : liste blanche des routes ne nécessitant pas de liens d’évitement
+- **Retour développeur** : messages d’erreur clairs pour guider l’implémentation
+
+### Intégration DSFR
+Cette gem implémente le composant officiel [liens d’évitement DSFR](https://www.systeme-de-design.gouv.fr/elements-d-interface/composants/liens-d-evitement) en respectant :
+- Les classes CSS officielles (`.fr-skiplinks`, `.fr-container`, `.fr-skiplinks__list`, `.fr-link`)
+- La structure HTML recommandée et les attributs ARIA
+- Les libellés en français par défaut pour les sites publics
+- La compatibilité responsive
+
+### Bénéfices en accessibilité
+- **Navigation plus rapide** : les utilisateurs de lecteurs d’écran et au clavier peuvent aller directement au contenu
+- **Charge cognitive réduite** : une structure claire améliore l’expérience utilisateur
+- **Conformité réglementaire** : aide à satisfaire les exigences françaises pour le secteur public
+- **Conception universelle** : profite à tous, notamment aux personnes avec déficiences motrices ou visuelles
+
+Pour en savoir plus sur les exigences d’accessibilité web en France :
+- [Documentation officielle DSFR](https://www.systeme-de-design.gouv.fr/)
+- [RGAA](https://www.numerique.gouv.fr/publications/rgaa-accessibilite/)
+- [WCAG 2.2](https://www.w3.org/WAI/WCAG22/quickref/)
+
+## Comment tester cette gem
+
+Il y a deux façons principales de tester cette gem :
+
+1) Exécuter la suite de tests localement (rapide, pas besoin d’une app Rails)
+- Installer les dépendances :
   ```bash
   bundle install
   ```
-- Run RSpec:
+- Lancer RSpec :
   ```bash
   bundle exec rake spec
   ```
-- Run RuboCop:
+- Lancer RuboCop :
   ```bash
   bundle exec rake rubocop
   ```
-- Run both (default task):
+- Lancer les deux (tâche par défaut) :
   ```bash
   bundle exec rake
   ```
 
-2) Try it inside a real Rails app (to test the generator and integration)
-- Create a new Rails app (or use an existing one):
+2) L’essayer dans une vraie application Rails (pour tester le générateur et l’intégration)
+- Créer une nouvelle application Rails (ou utiliser une existante) :
   ```bash
   rails new demo_app --skip-javascript --skip-hotwire --skip-action-mailbox --skip-action-text --skip-active-storage --skip-active-job --skip-system-test
   cd demo_app
   ```
-- Point the app to your local copy of this gem. In demo_app/Gemfile add:
+- Pointer l’app vers votre copie locale de cette gem. Dans demo_app/Gemfile, ajoutez :
   ```ruby
   gem 'dsfr_accessible_skip_links', path: '../path/to/your/dsfr_accessible_skip_links'
   ```
-  Then run:
+  Puis exécutez :
   ```bash
   bundle install
   ```
-- Run the installer (copies the partial and injects a render line into your layout):
+- Lancer l’installateur :
   ```bash
   bin/rails g dsfr_accessible_skip_links:install
   ```
-- Verify changes:
-  - The partial should exist at: app/views/shared/_skip_links.html.erb
-  - Your app layout (app/views/layouts/application.html.erb) should include:
-    ```erb
-    <%= render partial: 'shared/skip_links' %>
-    ```
-  - Ensure your layout has the anchor targets used by default links:
-    ```erb
-    <header id="header"></header>
-    <main id="content"><%= yield %></main>
-    <footer id="footer"></footer>
-    ```
-- Start the server and check the skip links at the top of the page:
+- Vérifier que le partial existe : `app/views/shared/_skip_links.html.erb`
+- Ajouter l’appel au partial dans votre layout et vérifier la présence des éléments HTML requis (voir section Utilisation ci‑dessus)
+- Démarrer le serveur et vérifier les liens d’évitement en haut de la page :
   ```bash
   bin/rails s
   ```
-  Visit http://localhost:3000 and look for the skip links markup
-  ("Aller au contenu", "Menu", "Pied de page").
+  Rendez‑vous sur http://localhost:3000 et repérez le balisage des liens d’évitement
+  (« Aller au contenu », « Menu », « Pied de page »).
+
+**Notes :**
+- Le générateur est idempotent : il n’insérera pas la ligne `render` deux fois si elle existe déjà.
+
+### Mettre en place la validation des liens d’évitement
+
+Après avoir installé la gem, créez un initializer pour configurer les routes en liste blanche :
+
+```bash
+# Créer le fichier d’initialisation
+touch config/initializers/dsfr_accessible_skip_links.rb
+```
+
+Ajoutez votre configuration :
+
+```ruby
+# config/initializers/dsfr_accessible_skip_links.rb
+DsfrAccessibleSkipLinks.configure do |config|
+  config.whitelisted_routes = [
+    # Pages d’atterrissage utilisant les liens d’évitement par défaut
+    'pages#home',
+    'pages#about',
+    'pages#contact',
+    
+    # Pages d’admin avec layout standard
+    'admin/dashboard#index',
+    'admin/users#index',
+    
+    # Endpoints d’API ou pages sans layout standard
+    'api/health#check',
+    'errors#not_found'
+  ]
+end
+```
 
-Notes
-- The generator is idempotent: it won’t insert the render line twice if it already exists.
-- You can customize the skip links in any view using `content_for :skip_links` as described below in Usage.
+Cette configuration garantit que :
+- Les routes listées ne déclencheront pas d’erreurs de validation dans les tests
+- Les pages hors liste blanche doivent définir des liens d’évitement personnalisés
+- Vous maintenez la conformité d’accessibilité dans toute votre application
 
-## Development
+## Développement
 
-After checking out the repo, run `bundle install` to install dependencies. 
+Après avoir cloné le dépôt, exécutez `bundle install` pour installer les dépendances.
 
-Run the test suite:
+Lancer la suite de tests :
 ```bash
 bundle exec rake spec
 ```
 
-Run RuboCop for code quality checks:
+Lancer RuboCop pour les contrôles de qualité de code :
 ```bash
 bundle exec rake rubocop
 ```
 
-Run both tests and RuboCop:
+Lancer à la fois les tests et RuboCop :
 ```bash
 bundle exec rake
 ```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Pour installer cette gem sur votre machine locale, exécutez `bundle exec rake install`.
 
-## Contributing
+## Contribuer
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Isalafont/dsfr_accessible_skip_links.
+Les rapports de bug et les pull requests sont les bienvenus sur GitHub : https://github.com/Isalafont/dsfr_accessible_skip_links.
 
-## License
+## Licence
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+Cette gem est disponible en open source selon les termes de la [licence MIT](https://opensource.org/licenses/MIT).

data/lib/dsfr_accessible_skip_links/configuration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DsfrAccessibleSkipLinks
+  class Configuration
+    attr_accessor :whitelisted_routes, :disable_validation
+
+    def initialize
+      @whitelisted_routes = []
+      @disable_validation = false
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/dsfr_accessible_skip_links/engine.rb

@@ -14,8 +14,17 @@ module DsfrAccessibleSkipLinks
       end
     end
 
-    config.to_prepare do
-      ApplicationController.include(DsfrAccessibleSkipLinks::SkipLinks) if defined?(ApplicationController)
+    # Ensure helpers are available automatically in controllers and views
+    initializer "dsfr_accessible_skip_links.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        include DsfrAccessibleSkipLinks::SkipLinks
+
+        helper DsfrAccessibleSkipLinks::SkipLinks if respond_to?(:helper)
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include DsfrAccessibleSkipLinks::SkipLinks
+      end
     end
   end
 end

data/lib/dsfr_accessible_skip_links/skip_links.rb

@@ -41,9 +41,17 @@ module DsfrAccessibleSkipLinks
     private
 
     def validate_skip_links_in_test!
-      # This would be implemented to validate skip links in test environment
-      # For now, just a placeholder
-      true
+      return true unless defined?(Rails) && Rails.env.test?
+      return true unless respond_to?(:controller)
+      return true if DsfrAccessibleSkipLinks.configuration.disable_validation
+
+      has_custom_skip_links = content_for?(:skip_links)
+
+      SkipLinksImplementedChecker.new(
+        controller_name: controller.controller_name,
+        action_name: controller.action_name,
+        has_skip_links: has_custom_skip_links
+      ).perform!
     end
   end
 end

data/lib/dsfr_accessible_skip_links/skip_links_implemented_checker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DsfrAccessibleSkipLinks
+  class SkipLinksImplementedChecker
+    attr_reader :controller_name, :action_name, :has_skip_links
+
+    def initialize(controller_name:, action_name:, has_skip_links: false)
+      @controller_name = controller_name
+      @action_name = action_name
+      @has_skip_links = has_skip_links
+    end
+
+    def perform!
+      return true if has_skip_links
+      return true if whitelisted?
+
+      current_route = "#{controller_name}##{action_name}"
+      raise SkipLinksNotDefinedError,
+            "No skip links defined for this page (#{current_route}). " \
+            "Use content_for(:skip_links) to define skip links or " \
+            "define them in a view-specific helper."
+    end
+
+    private
+
+    def whitelisted?
+      DsfrAccessibleSkipLinks.configuration.whitelisted_routes.include?("#{controller_name}##{action_name}")
+    end
+
+    class SkipLinksNotDefinedError < StandardError; end
+  end
+end

data/lib/dsfr_accessible_skip_links/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DsfrAccessibleSkipLinks
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/dsfr_accessible_skip_links.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "dsfr_accessible_skip_links/version"
+require_relative "dsfr_accessible_skip_links/configuration"
 require_relative "dsfr_accessible_skip_links/engine" if defined?(Rails)
 require_relative "dsfr_accessible_skip_links/skip_links"
+require_relative "dsfr_accessible_skip_links/skip_links_implemented_checker"
 
 module DsfrAccessibleSkipLinks
   class Error < StandardError; end

data/lib/generators/dsfr_accessible_skip_links/install_generator.rb

@@ -8,46 +8,81 @@ module DsfrAccessibleSkipLinks
       source_root File.expand_path("templates", __dir__)
 
       desc(
-        "Installs DsfrAccessibleSkipLinks by copying the skip links partial " \
-        "and injecting the render call into the application layout."
+        "Installs DsfrAccessibleSkipLinks by copying the skip links partial. " \
+        "No manual controller configuration is needed; helpers are auto-included."
       )
       def copy_partial
-        template "_skip_links.html.erb", "app/views/shared/_skip_links.html.erb"
+        copy_file "_skip_links.html.erb", "app/views/shared/_skip_links.html.erb"
       end
 
-      # rubocop:disable Metrics/MethodLength
+      # For backward compatibility, provide an optional injection step disabled by default.
+      class_option :inject_layout, type: :boolean, default: false,
+                                   desc: "Also inject <%= render 'shared/skip_links' %> into application layout"
+
       def inject_into_layout
+        return unless options[:inject_layout]
+
         layout_path = "app/views/layouts/application.html.erb"
         return unless File.exist?(layout_path)
+        return if layout_contains_render?(layout_path)
 
-        render_snippet = "    <%= render partial: 'shared/skip_links' %>\n"
-
-        content = File.read(layout_path)
-        if content.include?("render partial: 'shared/skip_links'") || content.include?("render 'shared/skip_links'")
-          return
-        end
-
-        if content =~ /<body[^>]*>/
-          insert_into_file layout_path, after: /<body[^>]*>\s*\n?/ do
-            render_snippet
-          end
+        if layout_has_body_tag?(layout_path)
+          insert_render_after_body(layout_path)
         else
-          # If <body> tag is not found, append at the beginning of the file as a fallback
-          prepend_to_file layout_path, render_snippet
+          prepend_render_to_layout(layout_path)
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
+      # rubocop:disable Metrics/MethodLength
       def readme
         say <<~MSG
-          DsfrAccessibleSkipLinks installed.
+          DsfrAccessibleSkipLinks installed successfully!
+
+          📁 Files created:
+             • app/views/shared/_skip_links.html.erb (skip links partial)
+
+          🔧 Next steps:
+             1. Add <%= render 'shared/skip_links' %> to your layout file (typically app/views/layouts/application.html.erb)
+                Place it right after the <body> tag for best accessibility.
+
+             2. Ensure your layout has these elements with IDs:
+                • #header (main navigation)
+                • #content (main content area)#{'  '}
+                • #footer (page footer)
 
-          - A copy of the skip links partial has been placed at app/views/shared/_skip_links.html.erb
-          - Your application layout has been updated to render the skip links.
+          💡 Quick setup option:
+             Run `bin/rails g dsfr_accessible_skip_links:install --inject-layout` to automatically
+             add the render call to your application layout.
 
-          Ensure your layout contains elements with ids: #header, #content, and #footer for the default links.
+          ℹ️  Helpers are automatically available in all controllers and views.
         MSG
       end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def layout_contains_render?(layout_path)
+        content = File.read(layout_path)
+        content.include?("render partial: 'shared/skip_links'") ||
+          content.include?("render 'shared/skip_links'")
+      end
+
+      def layout_has_body_tag?(layout_path)
+        File.read(layout_path) =~ /<body[^>]*>/
+      end
+
+      def insert_render_after_body(layout_path)
+        render_snippet = "    <%= render 'shared/skip_links' %>\n"
+        insert_into_file layout_path, after: /<body[^>]*>\s*\n?/ do
+          render_snippet
+        end
+      end
+
+      # If <body> tag is not found, append at the beginning of the file as a fallback
+      def prepend_render_to_layout(layout_path)
+        render_snippet = "    <%= render 'shared/skip_links' %>\n"
+        prepend_to_file layout_path, render_snippet
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dsfr_accessible_skip_links
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Isabelle Lafont
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-27 00:00:00.000000000 Z
+date: 2025-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,8 +112,10 @@ files:
 - Rakefile
 - app/views/shared/_skip_links.html.erb
 - lib/dsfr_accessible_skip_links.rb
+- lib/dsfr_accessible_skip_links/configuration.rb
 - lib/dsfr_accessible_skip_links/engine.rb
 - lib/dsfr_accessible_skip_links/skip_links.rb
+- lib/dsfr_accessible_skip_links/skip_links_implemented_checker.rb
 - lib/dsfr_accessible_skip_links/version.rb
 - lib/generators/dsfr_accessible_skip_links/install_generator.rb
 - lib/generators/dsfr_accessible_skip_links/templates/_skip_links.html.erb
@@ -127,7 +129,7 @@ metadata:
   changelog_uri: https://github.com/Isalafont/dsfr_accessible_skip_links/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message: |
-  Thank you for installing dsfr_accessible_skip_links (v0.1.2)!
+  Thank you for installing dsfr_accessible_skip_links (v0.2.0)!
 
   To complete setup in your Rails app, run:
     bin/rails g dsfr_accessible_skip_links:install