rubocop-rails 2.4.2 → 2.7.0

data/lib/rubocop/cop/mixin/index_method.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails/IndexBy and Rails/IndexWith
+    module IndexMethod # rubocop:disable Metrics/ModuleLength
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[map { ... }]')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        return if captures.noop_transformation?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      def extract_captures(match)
+        argname, body_expr = *match
+        Captures.new(argname, body_expr)
+      end
+
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = 0
+
+          unless node.parent&.block_type?
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object` case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body.loc.expression,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop 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 < Cop
+        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 = Hash[
+          CALLBACKS_IN_ORDER.map.with_index { |name, index| [name, index] }
+        ].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)
+            end
+            previous_index = index
+            previous_callback = callback
+          end
+        end
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(node)
+          previous = left_siblings_of(node).find do |sibling|
+            callback?(sibling)
+          end
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          lambda do |corrector|
+            corrector.insert_before(previous_range, current_range.source)
+            corrector.remove(current_range)
+          end
+        end
+
+        private
+
+        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 left_siblings_of(node)
+          siblings_of(node)[0, node.sibling_index]
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        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.loc.expression.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.comments_before_line(annotation_line)
+                          .reverse_each do |comment|
+            if comment.location.line == annotation_line
+              first_comment = comment
+              annotation_line -= 1
+            end
+          end
+
+          start_line_position(first_comment || node)
+        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/content_tag.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that `tag` is used instead of `content_tag`
+      # because `content_tag` is legacy syntax.
+      #
+      # NOTE: Allow `content_tag` when the first argument is a variable because
+      #      `content_tag(name)` is simpler rather than `tag.public_send(name)`.
+      #
+      # @example
+      #  # bad
+      #  content_tag(:p, 'Hello world!')
+      #  content_tag(:br)
+      #
+      #  # good
+      #  tag.p('Hello world!')
+      #  tag.br
+      #  content_tag(name, 'Hello world!')
+      class ContentTag < Cop
+        include RangeHelp
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Use `tag` instead of `content_tag`.'
+
+        def on_send(node)
+          return unless node.method?(:content_tag)
+
+          first_argument = node.first_argument
+          return unless first_argument
+
+          return if first_argument.variable? || first_argument.send_type? || first_argument.const_type?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if method_name?(node.first_argument)
+              range = correction_range(node)
+
+              rest_args = node.arguments.drop(1)
+              replacement = "tag.#{node.first_argument.value}(#{rest_args.map(&:source).join(', ')})"
+
+              corrector.replace(range, replacement)
+            else
+              corrector.replace(node.loc.selector, 'tag')
+            end
+          end
+        end
+
+        private
+
+        def method_name?(node)
+          return false unless node.str_type? || node.sym_type?
+
+          /^[a-zA-Z_][a-zA-Z_0-9]*$/.match?(node.value)
+        end
+
+        def correction_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -70,9 +70,7 @@ module RuboCop
           parent = node.parent
 
           if create_table_with_block?(parent)
-            if parent.body.nil? || !time_columns_included?(parent.body)
-              add_offense(parent)
-            end
+            add_offense(parent) if parent.body.nil? || !time_columns_included?(parent.body)
           elsif create_table_with_timestamps_proc?(node)
             # nothing to do
           else

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `default_scope`.
+      #
+      # @example
+      #   # bad
+      #   default_scope -> { where(hidden: false) }
+      #
+      #   # good
+      #   scope :published, -> { where(hidden: false) }
+      #
+      #   # bad
+      #   def self.default_scope
+      #     where(hidden: false)
+      #   end
+      #
+      #   # good
+      #   def self.published
+      #     where(hidden: false)
+      #   end
+      #
+      class DefaultScope < Cop
+        MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
+
+        def_node_matcher :method_call?, <<~PATTERN
+          (send nil? :default_scope ...)
+        PATTERN
+
+        def_node_matcher :class_method_definition?, <<~PATTERN
+          (defs _ :default_scope args ...)
+        PATTERN
+
+        def_node_matcher :eigenclass_method_definition?, <<~PATTERN
+          (sclass (self) $(def :default_scope args ...))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node, location: :selector) if method_call?(node)
+        end
+
+        def on_defs(node)
+          add_offense(node, location: :name) if class_method_definition?(node)
+        end
+
+        def on_sclass(node)
+          eigenclass_method_definition?(node) { |default_scope| add_offense(default_scope, location: :name) }
+        end
+      end
+    end
+  end
+end

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

@@ -71,9 +71,7 @@ module RuboCop
           delegation = ["delegate :#{node.body.method_name}",
                         "to: :#{node.body.receiver.method_name}"]
 
-          if node.method?(prefixed_method_name(node.body))
-            delegation << ['prefix: true']
-          end
+          delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
 
           lambda do |corrector|
             corrector.replace(node.source_range, delegation.join(', '))
@@ -124,7 +122,7 @@ module RuboCop
         end
 
         def private_or_protected_inline(line)
-          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+          processed_source[line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end
     end