rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces consistent ordering of the standard Rails RESTful controller actions.
+      #
+      # The cop is configurable and can enforce any ordering of the standard actions.
+      # All other methods are ignored. So, the actions specified in `ExpectedOrder` should be
+      # defined before actions not specified.
+      #
+      # [source,yaml]
+      # ----
+      #  Rails/ActionOrder:
+      #    ExpectedOrder:
+      #      - index
+      #      - show
+      #      - new
+      #      - edit
+      #      - create
+      #      - update
+      #      - destroy
+      # ----
+      #
+      # @example
+      #   # bad
+      #   def index; end
+      #   def destroy; end
+      #   def show; end
+      #
+      #   # good
+      #   def index; end
+      #   def show; end
+      #   def destroy; end
+      class ActionOrder < Base
+        extend AutoCorrector
+        include VisibilityHelp
+        include DefNode
+        include RangeHelp
+
+        MSG = 'Action `%<current>s` should appear before `%<previous>s`.'
+
+        def_node_search :action_declarations, '(def {%1} ...)'
+
+        def on_class(node)
+          action_declarations(node, actions).each_cons(2) do |previous, current|
+            next if node_visibility(current) != :public || non_public?(current)
+            next if find_index(current) >= find_index(previous)
+
+            register_offense(previous, current)
+          end
+        end
+
+        private
+
+        def expected_order
+          cop_config['ExpectedOrder'].map(&:to_sym)
+        end
+
+        def actions
+          @actions ||= Set.new(expected_order)
+        end
+
+        def find_index(node)
+          expected_order.find_index(node.method_name)
+        end
+
+        def register_offense(previous, current)
+          message = format(
+            MSG,
+            expected_order: expected_order.join(', '),
+            previous: previous.method_name,
+            current: current.method_name
+          )
+          add_offense(current, message: message) do |corrector|
+            current = correction_target(current)
+            previous = correction_target(previous)
+
+            swap_range(corrector, current, previous)
+          end
+        end
+
+        def correction_target(def_node)
+          range_with_comments_and_lines(def_node.each_ancestor(:if).first || def_node)
+        end
+
+        def add_range(range1, range2)
+          range1.with(
+            begin_pos: [range1.begin_pos, range2.begin_pos].min,
+            end_pos: [range1.end_pos, range2.end_pos].max
+          )
+        end
+
+        def range_with_comments(node)
+          # rubocop:todo InternalAffairs/LocationExpression
+          # Using `RuboCop::Ext::Comment#source_range` requires RuboCop > 1.46,
+          # which introduces https://github.com/rubocop/rubocop/pull/11630.
+          ranges = [node, *processed_source.ast_with_comments[node]].map { |comment| comment.loc.expression }
+          # rubocop:enable InternalAffairs/LocationExpression
+          ranges.reduce do |result, range|
+            add_range(result, range)
+          end
+        end
+
+        def range_with_comments_and_lines(node)
+          range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+        end
+
+        def swap_range(corrector, range1, range2)
+          corrector.insert_before(range2, range1.source)
+          corrector.remove(range1)
+        end
+      end
+    end
+  end
+end

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

@@ -6,42 +6,41 @@ module RuboCop
       # Checks that ActiveRecord aliases are not used. The direct method names
       # are more clear and easier to read.
       #
+      # @safety
+      #   This cop is unsafe because custom `update_attributes` method call was changed to
+      #   `update` but the method name remained same in the method definition.
+      #
       # @example
       #   #bad
-      #   Book.update_attributes!(author: 'Alice')
+      #   book.update_attributes!(author: 'Alice')
       #
       #   #good
-      #   Book.update!(author: 'Alice')
-      class ActiveRecordAliases < Cop
+      #   book.update!(author: 'Alice')
+      class ActiveRecordAliases < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
-        ALIASES = {
-          update_attributes: :update,
-          update_attributes!: :update!
-        }.freeze
+        ALIASES = { update_attributes: :update, update_attributes!: :update! }.freeze
+
+        RESTRICT_ON_SEND = ALIASES.keys.freeze
 
         def on_send(node)
-          ALIASES.each do |bad, good|
-            next unless node.method?(bad)
-
-            add_offense(node,
-                        message: format(MSG, prefer: good, current: bad),
-                        location: :selector,
-                        severity: :warning)
-            break
-          end
-        end
+          return if node.arguments.empty?
 
-        alias on_csend on_send
+          method_name = node.method_name
+          alias_method = ALIASES[method_name]
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              ALIASES[node.method_name].to_s
-            )
+          add_offense(
+            node.loc.selector,
+            message: format(MSG, prefer: alias_method, current: method_name),
+            severity: :warning
+          ) do |corrector|
+            corrector.replace(node.loc.selector, alias_method)
           end
         end
+
+        alias on_csend on_send
       end
     end
   end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that Active Record callbacks are declared
+      # in the order in which they will be executed.
+      #
+      # @example
+      #   # bad
+      #   class Person < ApplicationRecord
+      #     after_commit :after_commit_callback
+      #     before_validation :before_validation_callback
+      #   end
+      #
+      #   # good
+      #   class Person < ApplicationRecord
+      #     before_validation :before_validation_callback
+      #     after_commit :after_commit_callback
+      #   end
+      #
+      class ActiveRecordCallbacksOrder < Base
+        extend AutoCorrector
+
+        MSG = '`%<current>s` is supposed to appear before `%<previous>s`.'
+
+        CALLBACKS_IN_ORDER = %i[
+          after_initialize
+          before_validation
+          after_validation
+          before_save
+          around_save
+          before_create
+          around_create
+          after_create
+          before_update
+          around_update
+          after_update
+          before_destroy
+          around_destroy
+          after_destroy
+          after_save
+          after_commit
+          after_rollback
+          after_find
+          after_touch
+        ].freeze
+
+        CALLBACKS_ORDER_MAP = CALLBACKS_IN_ORDER.each_with_index.to_h.freeze
+
+        def on_class(class_node)
+          previous_index = -1
+          previous_callback = nil
+
+          defined_callbacks(class_node).each do |node|
+            callback = node.method_name
+            index = CALLBACKS_ORDER_MAP[callback]
+
+            if index < previous_index
+              message = format(MSG, current: callback, previous: previous_callback)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
+            previous_index = index
+            previous_callback = callback
+          end
+        end
+
+        private
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(corrector, node)
+          previous = node.left_siblings.reverse_each.find do |sibling|
+            callback?(sibling)
+          end
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
+        end
+
+        def defined_callbacks(class_node)
+          class_def = class_node.body
+
+          if class_def
+            class_def.each_child_node.select { |c| callback?(c) }
+          else
+            []
+          end
+        end
+
+        def callback?(node)
+          node.send_type? && CALLBACKS_ORDER_MAP.key?(node.method_name)
+        end
+
+        def source_range_with_comment(node)
+          begin_pos = begin_pos_with_comment(node)
+          end_pos = end_position_for(node)
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def end_position_for(node)
+          end_line = buffer.line_for_position(node.source_range.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          annotation_line = node.first_line - 1
+          first_comment = nil
+
+          processed_source.each_comment_in_lines(0..annotation_line).reverse_each do |comment|
+            if comment.location.line == annotation_line && !inline_comment?(comment)
+              first_comment = comment
+              annotation_line -= 1
+            end
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def inline_comment?(comment)
+          # rubocop:todo InternalAffairs/LocationExpression
+          # Using `RuboCop::Ext::Comment#source_range` requires RuboCop > 1.46,
+          # which introduces https://github.com/rubocop/rubocop/pull/11630.
+          !comment_line?(comment.loc.expression.source_line)
+          # rubocop:enable InternalAffairs/LocationExpression
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+      end
+    end
+  end
+end

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

@@ -24,13 +24,10 @@ module RuboCop
       #     end
       #   end
       #
-      class ActiveRecordOverride < Cop
-        MSG =
-          'Use %<prefer>s callbacks instead of overriding the Active Record ' \
-          'method `%<bad>s`.'
+      class ActiveRecordOverride < Base
+        MSG = 'Use %<prefer>s callbacks instead of overriding the Active Record method `%<bad>s`.'
         BAD_METHODS = %i[create destroy save update].freeze
-        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base
-                                   ActiveRecord::Base].freeze
+        ACTIVE_RECORD_CLASSES = %w[ApplicationRecord ActiveModel::Base ActiveRecord::Base].freeze
 
         def on_def(node)
           return unless BAD_METHODS.include?(node.method_name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that ActiveSupport aliases to core ruby methods
+      # Checks that ActiveSupport aliases to core ruby methods
       # are not used.
       #
       # @example
@@ -19,8 +19,11 @@ module RuboCop
       #   [1, 2, 'a'].append('b')
       #   [1, 2, 'a'].prepend('b')
       #
-      class ActiveSupportAliases < Cop
+      class ActiveSupportAliases < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[starts_with? ends_with? append prepend].freeze
 
         ALIASES = {
           starts_with?: {
@@ -39,29 +42,17 @@ module RuboCop
 
         def on_send(node)
           ALIASES.each_key do |aliased_method|
-            register_offense(node, aliased_method) if
-              public_send(aliased_method, node)
-          end
-        end
+            next unless public_send(aliased_method, node)
 
-        def autocorrect(node)
-          return false if append(node)
+            preferred_method = ALIASES[aliased_method][:original]
+            message = format(MSG, prefer: preferred_method, current: aliased_method)
 
-          lambda do |corrector|
-            method_name = node.loc.selector.source
-            replacement = ALIASES[method_name.to_sym][:original]
-            corrector.replace(node.loc.selector, replacement.to_s)
-          end
-        end
-
-        private
+            add_offense(node, message: message) do |corrector|
+              next if append(node)
 
-        def register_offense(node, method_name)
-          add_offense(
-            node,
-            message: format(MSG, prefer: ALIASES[method_name][:original],
-                                 current: method_name)
-          )
+              corrector.replace(node.loc.selector, preferred_method)
+            end
+          end
         end
       end
     end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for Rails framework classes that are patched directly instead of using Active Support load hooks. Direct
+      # patching forcibly loads the framework referenced, using hooks defers loading until it's actually needed.
+      #
+      # @safety
+      #   While using lazy load hooks is recommended, it changes the order in which is code is loaded and may reveal
+      #   load order dependency bugs.
+      #
+      # @example
+      #
+      #   # bad
+      #   ActiveRecord::Base.include(MyClass)
+      #
+      #   # good
+      #   ActiveSupport.on_load(:active_record) { include MyClass }
+      class ActiveSupportOnLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[prepend include extend].freeze
+        LOAD_HOOKS = {
+          'ActionCable' => 'action_cable',
+          'ActionCable::Channel::Base' => 'action_cable_channel',
+          'ActionCable::Connection::Base' => 'action_cable_connection',
+          'ActionCable::Connection::TestCase' => 'action_cable_connection_test_case',
+          'ActionController::API' => 'action_controller',
+          'ActionController::Base' => 'action_controller',
+          'ActionController::TestCase' => 'action_controller_test_case',
+          'ActionDispatch::IntegrationTest' => 'action_dispatch_integration_test',
+          'ActionDispatch::Request' => 'action_dispatch_request',
+          'ActionDispatch::Response' => 'action_dispatch_response',
+          'ActionDispatch::SystemTestCase' => 'action_dispatch_system_test_case',
+          'ActionMailbox::Base' => 'action_mailbox',
+          'ActionMailbox::InboundEmail' => 'action_mailbox_inbound_email',
+          'ActionMailbox::Record' => 'action_mailbox_record',
+          'ActionMailbox::TestCase' => 'action_mailbox_test_case',
+          'ActionMailer::Base' => 'action_mailer',
+          'ActionMailer::TestCase' => 'action_mailer_test_case',
+          'ActionText::Content' => 'action_text_content',
+          'ActionText::Record' => 'action_text_record',
+          'ActionText::RichText' => 'action_text_rich_text',
+          'ActionView::Base' => 'action_view',
+          'ActionView::TestCase' => 'action_view_test_case',
+          'ActiveJob::Base' => 'active_job',
+          'ActiveJob::TestCase' => 'active_job_test_case',
+          'ActiveRecord::Base' => 'active_record',
+          'ActiveStorage::Attachment' => 'active_storage_attachment',
+          'ActiveStorage::Blob' => 'active_storage_blob',
+          'ActiveStorage::Record' => 'active_storage_record',
+          'ActiveStorage::VariantRecord' => 'active_storage_variant_record',
+          'ActiveSupport::TestCase' => 'active_support_test_case'
+        }.freeze
+
+        def on_send(node)
+          receiver, method, arguments = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return unless receiver && (hook = LOAD_HOOKS[receiver.const_name])
+
+          preferred = "ActiveSupport.on_load(:#{hook}) { #{method} #{arguments.source} }"
+          add_offense(node, message: format(MSG, prefer: preferred, current: node.source)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for migrations using `add_column` that have an `index`
+      # key. `add_column` does not accept `index`, but also does not raise an
+      # error for extra keys, so it is possible to mistakenly add the key without
+      # realizing it will not actually add an index.
+      #
+      # @example
+      #   # bad (will not add an index)
+      #   add_column :table, :column, :integer, index: true
+      #
+      #   # good
+      #   add_column :table, :column, :integer
+      #   add_index :table, :column
+      #
+      class AddColumnIndex < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`add_column` does not accept an `index` key, use `add_index` instead.'
+        RESTRICT_ON_SEND = %i[add_column].freeze
+
+        # @!method add_column_with_index(node)
+        def_node_matcher :add_column_with_index, <<~PATTERN
+          (
+            send nil? :add_column $_table $_column
+              <(hash <$(pair {(sym :index) (str "index")} $_) ...>) ...>
+          )
+        PATTERN
+
+        def on_send(node)
+          table, column, pair, value = add_column_with_index(node)
+          return unless pair
+
+          add_offense(pair) do |corrector|
+            corrector.remove(index_range(pair))
+
+            add_index = "add_index #{table.source}, #{column.source}"
+            add_index_opts = ''
+
+            if value.hash_type?
+              hash = value.source_range.adjust(begin_pos: 1, end_pos: -1).source.strip
+              add_index_opts = ", #{hash}"
+            end
+
+            corrector.insert_after(node, "\n#{add_index}#{add_index_opts}")
+          end
+        end
+
+        private
+
+        def index_range(pair_node)
+          range_with_surrounding_comma(range_with_surrounding_space(pair_node.source_range, side: :left), :left)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces that there is only one call to `after_commit`
+      # (and its aliases - `after_create_commit`, `after_update_commit`,
+      # and `after_destroy_commit`) with the same callback name per model.
+      #
+      # @example
+      #   # bad
+      #   # This won't be triggered.
+      #   after_create_commit :log_action
+      #
+      #   # This will override the callback added by
+      #   # after_create_commit.
+      #   after_update_commit :log_action
+      #
+      #   # bad
+      #   # This won't be triggered.
+      #   after_commit :log_action, on: :create
+      #   # This won't be triggered.
+      #   after_update_commit :log_action
+      #   # This will override both previous callbacks.
+      #   after_commit :log_action, on: :destroy
+      #
+      #   # good
+      #   after_save_commit :log_action
+      #
+      #   # good
+      #   after_create_commit :log_create_action
+      #   after_update_commit :log_update_action
+      #
+      class AfterCommitOverride < Base
+        include ClassSendNodeHelper
+
+        MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
+
+        AFTER_COMMIT_CALLBACKS = %i[
+          after_commit
+          after_create_commit
+          after_update_commit
+          after_save_commit
+          after_destroy_commit
+        ].freeze
+
+        def on_class(class_node)
+          seen_callback_names = {}
+
+          each_after_commit_callback(class_node) do |node|
+            callback_name = node.arguments[0].value
+            if seen_callback_names.key?(callback_name)
+              add_offense(node, message: format(MSG, name: callback_name))
+            else
+              seen_callback_names[callback_name] = true
+            end
+          end
+        end
+
+        private
+
+        def each_after_commit_callback(class_node)
+          class_send_nodes(class_node).each do |node|
+            yield node if after_commit_callback?(node) && named_callback?(node)
+          end
+        end
+
+        def after_commit_callback?(node)
+          AFTER_COMMIT_CALLBACKS.include?(node.method_name)
+        end
+
+        def named_callback?(node)
+          name = node.first_argument
+          return false unless name
+
+          name.sym_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that controllers subclass `ApplicationController`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationController`
+      #   sneak into a controller that is not purposed to inherit logic common among other controllers.
+      #
+      # @example
+      #
+      #  # good
+      #  class MyController < ApplicationController
+      #    # ...
+      #  end
+      #
+      #  # bad
+      #  class MyController < ActionController::Base
+      #    # ...
+      #  end
+      class ApplicationController < Base
+        extend AutoCorrector
+
+        MSG = 'Controllers should subclass `ApplicationController`.'
+        SUPERCLASS = 'ApplicationController'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActionController) :Base)'
+
+        # rubocop:disable Layout/ClassStructure
+        include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
+      end
+    end
+  end
+end

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

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that jobs subclass ApplicationJob with Rails 5.0.
+      # Checks that jobs subclass `ApplicationJob` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationJob`
+      #   sneak into a job that is not purposed to inherit logic common among other jobs.
       #
       # @example
       #
@@ -16,14 +20,15 @@ module RuboCop
       #  class Rails4Job < ActiveJob::Base
       #    # ...
       #  end
-      class ApplicationJob < Cop
+      class ApplicationJob < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0
 
         MSG = 'Jobs should subclass `ApplicationJob`.'
         SUPERCLASS = 'ApplicationJob'
-        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActiveJob) :Base)'
 
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass
@@ -31,7 +36,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, self.class::SUPERCLASS)
+            corrector.replace(node, self.class::SUPERCLASS)
           end
         end
       end