rubocop-rails 2.0.1 → 2.19.1

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -3,12 +3,15 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of http methods like `get`, `post`,
+      # Identifies usages of http methods like `get`, `post`,
       # `put`, `patch` without the usage of keyword arguments in your tests and
       # change them to use keyword args. This cop only applies to Rails >= 5.
       # If you are running Rails < 5 you should disable the
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
-      # .rubocop.yml file to 4.0, etc.
+      # .rubocop.yml file to 4.2.
+      #
+      # NOTE: It does not detect any cases where `include Rack::Test::Methods` is used
+      # which makes the http methods incompatible behavior.
       #
       # @example
       #   # bad
@@ -16,55 +19,76 @@ module RuboCop
       #
       #   # good
       #   get :new, params: { user_id: 1 }
-      class HttpPositionalArguments < Cop
+      #   get :new, **options
+      class HttpPositionalArguments < Base
+        include RangeHelp
+        extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env
-        ].freeze
-        HTTP_METHODS = %i[get post put patch delete head].freeze
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
+        ROUTING_METHODS = %i[draw routes].freeze
+        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
         minimum_target_rails_version 5.0
 
-        def_node_matcher :http_request?, <<-PATTERN
-          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
+        def_node_matcher :http_request?, <<~PATTERN
+          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
+        PATTERN
+
+        def_node_matcher :kwsplat_hash?, <<~PATTERN
+          (hash (kwsplat _))
+        PATTERN
+
+        def_node_matcher :include_rack_test_methods?, <<~PATTERN
+          (send nil? :include
+            (const
+              (const
+                (const {nil? cbase} :Rack) :Test) :Methods))
         PATTERN
 
         def on_send(node)
+          return if in_routing_block?(node) || use_rack_test_methods?
+
           http_request?(node) do |data|
             return unless needs_conversion?(data)
 
-            add_offense(node, location: :selector,
-                              message: format(MSG, verb: node.method_name))
+            message = format(MSG, verb: node.method_name)
+
+            add_offense(highlight_range(node), message: message) do |corrector|
+              # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
+              #
+              # @return lambda of auto correct procedure
+              # the result should look like:
+              #     get :new, params: { user_id: @user.id }, session: {}
+              # the http_method is the method used to call the controller
+              # the controller node can be a symbol, method, object or string
+              # that represents the path/action on the Rails controller
+              # the data is the http parameters and environment sent in
+              # the Rails 5 http call
+              corrector.replace(node, correction(node))
+            end
           end
         end
 
-        # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
-        #
-        # @return lambda of auto correct procedure
-        # the result should look like:
-        #     get :new, params: { user_id: @user.id }, session: {}
-        # the http_method is the method used to call the controller
-        # the controller node can be a symbol, method, object or string
-        # that represents the path/action on the Rails controller
-        # the data is the http parameters and environment sent in
-        # the Rails 5 http call
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, correction(node))
-          end
+        private
+
+        def in_routing_block?(node)
+          !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
         end
 
-        private
+        def use_rack_test_methods?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            include_rack_test_methods?(node)
+          end
+        end
 
         def needs_conversion?(data)
           return true unless data.hash_type?
+          return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              format_arg?(pair.key) && data.pairs.one?
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
 
@@ -76,12 +100,17 @@ module RuboCop
           node.sym_type? && node.value == :format
         end
 
+        def highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
         def convert_hash_data(data, type)
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces

data/lib/rubocop/cop/rails/http_status.rb

@@ -11,12 +11,14 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
       #   # good
       #   render :foo, status: :ok
       #   render json: { foo: 'bar' }, status: :ok
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -24,43 +26,48 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: :not_found
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       #   # good
       #   render :foo, status: 200
       #   render json: { foo: 'bar' }, status: 404
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
-      class HttpStatus < Cop
+      class HttpStatus < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        def_node_matcher :http_status, <<-PATTERN
+        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
+
+        def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
+            (send nil? :head ${int sym} ...)
           }
         PATTERN
 
-        def_node_matcher :status_code, <<-PATTERN
+        def_node_matcher :status_code, <<~PATTERN
           (hash <(pair (sym :status) ${int sym}) ...>)
         PATTERN
 
         def on_send(node)
-          http_status(node) do |hash_node|
-            status = status_code(hash_node)
+          http_status(node) do |hash_node_or_status_code|
+            status = if hash_node_or_status_code.hash_type?
+                       status_code(hash_node_or_status_code)
+                     else
+                       hash_node_or_status_code
+                     end
             return unless status
 
             checker = checker_class.new(status)
             return unless checker.offensive?
 
-            add_offense(checker.node, message: checker.message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = checker_class.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
+            add_offense(checker.node, message: checker.message) do |corrector|
+              corrector.replace(checker.node, checker.preferred_style)
+            end
           end
         end
 
@@ -77,12 +84,11 @@ module RuboCop
 
         # :nodoc:
         class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end
@@ -110,20 +116,18 @@ module RuboCop
           end
 
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
           end
         end
 
         # :nodoc:
         class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end

data/lib/rubocop/cop/rails/i18n_lazy_lookup.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for places where I18n "lazy" lookup can be used.
+      #
+      # @example
+      #   # en.yml
+      #   # en:
+      #   #   books:
+      #   #     create:
+      #   #       success: Book created!
+      #
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      class I18nLazyLookup < Base
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Use "lazy" lookup for the text used in controllers.'
+
+        RESTRICT_ON_SEND = %i[translate t].freeze
+
+        def_node_matcher :translate_call?, <<~PATTERN
+          (send nil? {:translate :t} ${sym_type? str_type?} ...)
+        PATTERN
+
+        def on_send(node)
+          translate_call?(node) do |key_node|
+            key = key_node.value
+            return if key.to_s.start_with?('.')
+
+            controller, action = controller_and_action(node)
+            return unless controller && action
+
+            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
+        end
+
+        private
+
+        def controller_and_action(node)
+          action_node = node.each_ancestor(:def).first
+          return unless action_node && node_visibility(action_node) == :public
+
+          controller_node = node.each_ancestor(:class).first
+          return unless controller_node && controller_node.identifier.source.end_with?('Controller')
+
+          [controller_node, action_node]
+        end
+
+        def get_scoped_key(key_node, controller, action)
+          path = controller_path(controller).tr('/', '.')
+          action_name = action.method_name
+          key = key_node.value.to_s.split('.').last
+
+          "#{path}.#{action_name}.#{key}"
+        end
+
+        def controller_path(controller)
+          module_name = controller.parent_module_name
+          controller_name = controller.identifier.source
+
+          path = if module_name == 'Object'
+                   controller_name
+                 else
+                   "#{module_name}::#{controller_name}"
+                 end
+
+          path.delete_suffix('Controller').underscore
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/i18n_locale_assignment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for the use of `I18n.locale=` method.
+      #
+      # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
+      # unexpected behavior at a later time.
+      # Using `I18n.with_locale` ensures the code passed in the block is the only place `I18n.locale` is affected.
+      # It eliminates the possibility of a `locale` sticking around longer than intended.
+      #
+      # @example
+      #   # bad
+      #   I18n.locale = :fr
+      #
+      #   # good
+      #   I18n.with_locale(:fr) do
+      #   end
+      #
+      class I18nLocaleAssignment < Base
+        MSG = 'Use `I18n.with_locale` with block instead of `I18n.locale=`.'
+        RESTRICT_ON_SEND = %i[locale=].freeze
+
+        def_node_matcher :i18n_locale_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :I18n) :locale= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless i18n_locale_assignment?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/i18n_locale_texts.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces use of I18n and locale files instead of locale specific strings.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     validates :email, presence: { message: "must be present" }
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   activerecord:
+      #   #     errors:
+      #   #       models:
+      #   #         user:
+      #   #           blank: "must be present"
+      #
+      #   class User < ApplicationRecord
+      #     validates :email, presence: true
+      #   end
+      #
+      #   # bad
+      #   class PostsController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to root_path, notice: "Post created!"
+      #     end
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   posts:
+      #   #     create:
+      #   #       success: "Post created!"
+      #
+      #   class PostsController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to root_path, notice: t(".success")
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class UserMailer < ApplicationMailer
+      #     def welcome(user)
+      #       mail(to: user.email, subject: "Welcome to My Awesome Site")
+      #     end
+      #   end
+      #
+      #   # good
+      #   # config/locales/en.yml
+      #   # en:
+      #   #   user_mailer:
+      #   #     welcome:
+      #   #       subject: "Welcome to My Awesome Site"
+      #
+      #   class UserMailer < ApplicationMailer
+      #     def welcome(user)
+      #       mail(to: user.email)
+      #     end
+      #   end
+      #
+      class I18nLocaleTexts < Base
+        MSG = 'Move locale texts to the locale files in the `config/locales` directory.'
+
+        RESTRICT_ON_SEND = %i[validates redirect_to redirect_back []= mail].freeze
+
+        def_node_search :validation_message, <<~PATTERN
+          (pair (sym :message) $str)
+        PATTERN
+
+        def_node_search :redirect_to_flash, <<~PATTERN
+          (pair (sym {:notice :alert}) $str)
+        PATTERN
+
+        def_node_matcher :flash_assignment?, <<~PATTERN
+          (send (send nil? :flash) :[]= _ $str)
+        PATTERN
+
+        def_node_search :mail_subject, <<~PATTERN
+          (pair (sym :subject) $str)
+        PATTERN
+
+        def on_send(node)
+          case node.method_name
+          when :validates
+            validation_message(node) do |text_node|
+              add_offense(text_node)
+            end
+            return
+          when :redirect_to, :redirect_back
+            text_node = redirect_to_flash(node).to_a.last
+          when :[]=
+            text_node = flash_assignment?(node)
+          when :mail
+            text_node = mail_subject(node).to_a.last
+          end
+
+          add_offense(text_node) if text_node
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/ignored_columns_assignment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for assignments of `ignored_columns` that may override previous
+      # assignments.
+      #
+      # Overwriting previous assignments is usually a mistake, since it will
+      # un-ignore the first set of columns. Since duplicate column names is not
+      # a problem, it is better to simply append to the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one]
+      #   end
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one]
+      #     self.ignored_columns += [:two]
+      #   end
+      #
+      class IgnoredColumnsAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use `+=` instead of `=`.'
+        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
+
+        def on_send(node)
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '+=')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that `if` and `only` (or `except`) are not used together
+      # Checks that `if` and `only` (or `except`) are not used together
       # as options of `skip_*` action filter.
       #
       # The `if` option will be ignored when `if` and `only` are used together.
@@ -35,21 +35,16 @@ module RuboCop
       #     skip_before_action :login_required,
       #       if: -> { trusted_origin? && action_name != "admin" }
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
-      class IgnoredSkipActionFilterOption < Cop
+      class IgnoredSkipActionFilterOption < Base
         MSG = <<~MSG.chomp.freeze
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
 
-        FILTERS = %w[
-          :skip_after_action
-          :skip_around_action
-          :skip_before_action
-          :skip_action_callback
-        ].freeze
+        RESTRICT_ON_SEND = %i[skip_after_action skip_around_action skip_before_action skip_action_callback].freeze
+
+        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
 
-        def_node_matcher :filter_options, <<-PATTERN
+        def_node_matcher :filter_options, <<~PATTERN
           (send
             nil?
             {#{FILTERS.join(' ')}}
@@ -65,11 +60,9 @@ module RuboCop
           options = options_hash(options)
 
           if if_and_only?(options)
-            add_offense(options[:if],
-                        message: format(MSG, prefer: :only, ignore: :if))
+            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if))
           elsif if_and_except?(options)
-            add_offense(options[:except],
-                        message: format(MSG, prefer: :if, ignore: :except))
+            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except))
           end
         end
 
@@ -78,7 +71,7 @@ module RuboCop
         def options_hash(options)
           options.pairs
                  .select { |pair| pair.key.sym_type? }
-                 .map { |pair| [pair.key.value, pair] }.to_h
+                 .to_h { |pair| [pair.key.value, pair] }
         end
 
         def if_and_only?(options)

data/lib/rubocop/cop/rails/index_by.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the values are the original elements.
+      # Rails provides the `index_by` method for this purpose.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
+      #   [1, 2, 3].to_h { |el| [foo(el), el] }
+      #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
+      #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
+      #
+      #   # good
+      #   [1, 2, 3].index_by { |el| foo(el) }
+      class IndexBy < Base
+        include IndexMethod
+        extend AutoCorrector
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            (call _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            (call (lvar _memo) :[]= $!`_memo (lvar _el)))
+        PATTERN
+
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            (call _ :to_h)
+            (args (arg $_el))
+            (array $_ (lvar _el)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          (call
+            (block
+              (call _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el)))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const {nil? cbase} :Hash)
+            :[]
+            (block
+              (call _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el))))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_by'
+        end
+      end
+    end
+  end
+end