From 5d9b254b3215ba6915afdb73d30568e968e7b931 Mon Sep 17 00:00:00 2001
From: Sunny Ripert <sunny@sunfox.org>
Date: Sat, 22 Jul 2023 10:26:15 +0200
Subject: [PATCH] Add explicit option to `Rails/I18nLazyLookup`

---
 .../new_explicit_style_to_i18n_lazy_lookup.md |   1 +
 config/default.yml                            |   4 +
 lib/rubocop/cop/rails/i18n_lazy_lookup.rb     |  76 +++++-
 .../cop/rails/i18n_lazy_lookup_spec.rb        | 242 ++++++++++++------
 4 files changed, 227 insertions(+), 96 deletions(-)
 create mode 100644 changelog/new_explicit_style_to_i18n_lazy_lookup.md

diff --git a/changelog/new_explicit_style_to_i18n_lazy_lookup.md b/changelog/new_explicit_style_to_i18n_lazy_lookup.md
new file mode 100644
index 0000000000..660eff6e5e
--- /dev/null
+++ b/changelog/new_explicit_style_to_i18n_lazy_lookup.md
@@ -0,0 +1 @@
+* [#1052](https://github.com/rubocop/rubocop-rails/pull/1052): Add explicit style to `Rails/I18nLazyLookup`. ([@sunny][])
diff --git a/config/default.yml b/config/default.yml
index 0fef0c30d5..704ba72ca2 100644
--- a/config/default.yml
+++ b/config/default.yml
@@ -547,6 +547,10 @@ Rails/I18nLazyLookup:
   Reference: 'https://guides.rubyonrails.org/i18n.html#lazy-lookup'
   Enabled: pending
   VersionAdded: '2.14'
+  EnforcedStyle: lazy
+  SupportedStyles:
+    - lazy
+    - explicit
   Include:
     - 'app/controllers/**/*.rb'
 
diff --git a/lib/rubocop/cop/rails/i18n_lazy_lookup.rb b/lib/rubocop/cop/rails/i18n_lazy_lookup.rb
index 9053397255..87833036d4 100644
--- a/lib/rubocop/cop/rails/i18n_lazy_lookup.rb
+++ b/lib/rubocop/cop/rails/i18n_lazy_lookup.rb
@@ -5,7 +5,13 @@ module Cop
     module Rails
       # Checks for places where I18n "lazy" lookup can be used.
       #
-      # @example
+      # This cop has two different enforcement modes. When the EnforcedStyle
+      # is `lazy` (the default), explicit lookups are added as offenses.
+      #
+      # When the EnforcedStyle is `explicit` then lazy lookups are added as
+      # offenses.
+      #
+      # @example EnforcedStyle: lazy (default)
       #   # en.yml
       #   # en:
       #   #   books:
@@ -28,11 +34,29 @@ module Rails
       #     end
       #   end
       #
+      # @example EnforcedStyle: explicit
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
       class I18nLazyLookup < Base
+        include ConfigurableEnforcedStyle
         include VisibilityHelp
         extend AutoCorrector
 
-        MSG = 'Use "lazy" lookup for the text used in controllers.'
+        MSG = 'Use %<style>s lookup for the text used in controllers.'
 
         RESTRICT_ON_SEND = %i[translate t].freeze
 
@@ -42,23 +66,45 @@ class I18nLazyLookup < Base
 
         def on_send(node)
           translate_call?(node) do |key_node|
-            key = key_node.value
-            return if key.to_s.start_with?('.')
+            case style
+            when :lazy
+              handle_lazy_style(node, key_node)
+            when :explicit
+              handle_explicit_style(node, key_node)
+            end
+          end
+        end
+
+        private
 
-            controller, action = controller_and_action(node)
-            return unless controller && action
+        def handle_lazy_style(node, key_node)
+          key = key_node.value
+          return if key.to_s.start_with?('.')
 
-            scoped_key = get_scoped_key(key_node, controller, action)
-            return unless key == scoped_key
+          controller, action = controller_and_action(node)
+          return unless controller && action
 
-            add_offense(key_node) do |corrector|
-              unscoped_key = key_node.value.to_s.split('.').last
-              corrector.replace(key_node, "'.#{unscoped_key}'")
-            end
+          scoped_key = get_scoped_key(key_node, controller, action)
+          return unless key == scoped_key
+
+          add_offense(key_node) do |corrector|
+            unscoped_key = key_node.value.to_s.split('.').last
+            corrector.replace(key_node, "'.#{unscoped_key}'")
           end
         end
 
-        private
+        def handle_explicit_style(node, key_node)
+          key = key_node.value
+          return unless key.to_s.start_with?('.')
+
+          controller, action = controller_and_action(node)
+          return unless controller && action
+
+          scoped_key = get_scoped_key(key_node, controller, action)
+          add_offense(key_node) do |corrector|
+            corrector.replace(key_node, "'#{scoped_key}'")
+          end
+        end
 
         def controller_and_action(node)
           action_node = node.each_ancestor(:def).first
@@ -90,6 +136,10 @@ def controller_path(controller)
 
           path.delete_suffix('Controller').underscore
         end
+
+        def message(_range)
+          format(MSG, style: style)
+        end
       end
     end
   end
diff --git a/spec/rubocop/cop/rails/i18n_lazy_lookup_spec.rb b/spec/rubocop/cop/rails/i18n_lazy_lookup_spec.rb
index 30f0a4b597..fcf12decef 100644
--- a/spec/rubocop/cop/rails/i18n_lazy_lookup_spec.rb
+++ b/spec/rubocop/cop/rails/i18n_lazy_lookup_spec.rb
@@ -1,114 +1,190 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::Rails::I18nLazyLookup, :config do
-  it 'registers an offense and corrects when using translation helpers with the key scoped to controller and action' do
-    expect_offense(<<~RUBY)
-      class FooController
-        def action
-          t 'foo.action.key'
-            ^^^^^^^^^^^^^^^^ Use "lazy" lookup for the text used in controllers.
-          translate 'foo.action.key'
-                    ^^^^^^^^^^^^^^^^ Use "lazy" lookup for the text used in controllers.
-        end
-      end
-    RUBY
-
-    expect_correction(<<~RUBY)
-      class FooController
-        def action
-          t '.key'
-          translate '.key'
-        end
-      end
-    RUBY
-  end
+  context 'when EnforcedStyle is lazy' do
+    let(:cop_config) { { 'EnforcedStyle' => 'lazy' } }
 
-  it 'does not register an offense when translation methods scoped to `I18n`' do
-    expect_no_offenses(<<~RUBY)
-      class FooController
-        def action
-          I18n.t 'foo.action.key'
-          I18n.translate 'foo.action.key'
+    it 'registers an offense when using translation helpers with the key scoped to controller and action' do
+      expect_offense(<<~RUBY)
+        class FooController
+          def action
+            t 'foo.action.key'
+              ^^^^^^^^^^^^^^^^ Use lazy lookup for the text used in controllers.
+            translate 'foo.action.key'
+                      ^^^^^^^^^^^^^^^^ Use lazy lookup for the text used in controllers.
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
 
-  it 'does not register an offense when not inside controller' do
-    expect_no_offenses(<<~RUBY)
-      class FooService
-        def do_something
-          t 'foo_service.do_something.key'
+      expect_correction(<<~RUBY)
+        class FooController
+          def action
+            t '.key'
+            translate '.key'
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  it 'does not register an offense when not inside controller action' do
-    expect_no_offenses(<<~RUBY)
-      class FooController
-        private
+    it 'does not register an offense when translation methods scoped to `I18n`' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          def action
+            I18n.t 'foo.action.key'
+            I18n.translate 'foo.action.key'
+          end
+        end
+      RUBY
+    end
 
-        def action
-          t 'foo.action.key'
+    it 'does not register an offense when not inside controller' do
+      expect_no_offenses(<<~RUBY)
+        class FooService
+          def do_something
+            t 'foo_service.do_something.key'
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
+
+    it 'does not register an offense when not inside controller action' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          private
 
-  it 'does not register an offense when translating key not scoped to controller and action' do
-    expect_no_offenses(<<~RUBY)
-      class FooController
-        def action
-          t 'one.two.key'
+          def action
+            t 'foo.action.key'
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  it 'does not register an offense when using "lazy" translation' do
-    expect_no_offenses(<<~RUBY)
-      class FooController
-        def action
-          t '.key'
+    it 'does not register an offense when translating key not scoped to controller and action' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          def action
+            t 'one.two.key'
+          end
         end
-      end
-    RUBY
-  end
+      RUBY
+    end
 
-  it 'does not register an offense when translation key is not a string nor a symbol' do
-    expect_no_offenses(<<~RUBY)
-      class FooController
-        def action
-          t ['foo.action.key']
-          t key
+    it 'does not register an offense when using "lazy" translation' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          def action
+            t '.key'
+          end
         end
-      end
-    RUBY
+      RUBY
+    end
+
+    it 'does not register an offense when translation key is not a string nor a symbol' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          def action
+            t ['foo.action.key']
+            t key
+          end
+        end
+      RUBY
+    end
+
+    it 'handles scoped controllers' do
+      expect_offense(<<~RUBY)
+        module Bar
+          class FooController
+            def action
+              t 'bar.foo.action.key'
+                ^^^^^^^^^^^^^^^^^^^^ Use lazy lookup for the text used in controllers.
+              t 'foo.action.key'
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        module Bar
+          class FooController
+            def action
+              t '.key'
+              t 'foo.action.key'
+            end
+          end
+        end
+      RUBY
+    end
   end
 
-  it 'handles scoped controllers' do
-    expect_offense(<<~RUBY)
-      module Bar
+  context 'when EnforcedStyle is explicit' do
+    let(:cop_config) { { 'EnforcedStyle' => 'explicit' } }
+
+    it 'registers an offense and corrects when using "lazy" translation' do
+      expect_offense(<<~RUBY)
+        class FooController
+          def action
+            t '.key'
+              ^^^^^^ Use explicit lookup for the text used in controllers.
+            translate '.key'
+                      ^^^^^^ Use explicit lookup for the text used in controllers.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
         class FooController
           def action
-            t 'bar.foo.action.key'
-              ^^^^^^^^^^^^^^^^^^^^ Use "lazy" lookup for the text used in controllers.
             t 'foo.action.key'
+            translate 'foo.action.key'
           end
         end
-      end
-    RUBY
+      RUBY
+    end
 
-    expect_correction(<<~RUBY)
-      module Bar
+    it 'does not register an offense when using explicit translation keys' do
+      expect_no_offenses(<<~RUBY)
         class FooController
           def action
-            t '.key'
             t 'foo.action.key'
           end
         end
-      end
-    RUBY
+      RUBY
+    end
+
+    it 'does not register an offense when translation key is not a string nor a symbol' do
+      expect_no_offenses(<<~RUBY)
+        class FooController
+          def action
+            t ['.key']
+            t key
+          end
+        end
+      RUBY
+    end
+
+    it 'handles scoped controllers' do
+      expect_offense(<<~RUBY)
+        module Bar
+          class FooController
+            def action
+              t '.key'
+                ^^^^^^ Use explicit lookup for the text used in controllers.
+              t 'foo.action.key'
+            end
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        module Bar
+          class FooController
+            def action
+              t 'bar.foo.action.key'
+              t 'foo.action.key'
+            end
+          end
+        end
+      RUBY
+    end
   end
 end