rubocop 0.66.0 → 0.67.0

data/lib/rubocop/cop/layout/multiline_hash_key_line_breaks.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each key in a multi-line hash
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   {
+      #     a: 1, b: 2,
+      #     c: 3
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2,
+      #     c: 3
+      #   }
+      class MultilineHashKeyLineBreaks < Cop
+        include MultilineElementLineBreaks
+
+        MSG = 'Each key in a multi-line hash must start on a ' \
+          'separate line.'.freeze
+
+        def on_hash(node)
+          # This cop only deals with hashes wrapped by a set of curly
+          # braces like {foo: 1}. That is, not a kwargs hashes.
+          # Style/MultilineMethodArgumentLineBreaks handles those.
+          return unless starts_with_curly_brace?(node)
+
+          check_line_breaks(node, node.children) if node.loc.begin
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+
+        private
+
+        def starts_with_curly_brace?(node)
+          node.loc.begin
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop ensures that each argument in a multi-line method call
+      # starts on a separate line.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo(a, b,
+      #     c
+      #   )
+      #
+      #   # good
+      #   foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      class MultilineMethodArgumentLineBreaks < Cop
+        include(MultilineElementLineBreaks)
+
+        MSG = 'Each argument in a multi-line method call must start ' \
+          'on a separate line.'.freeze
+
+        def on_send(node)
+          args = node.arguments
+
+          # If there is a trailing hash arg without explicit braces, like this:
+          #
+          #    method(1, 'key1' => value1, 'key2' => value2)
+          #
+          # ...then each key/value pair is treated as a method 'argument'
+          # when determining where line breaks should appear.
+          if (last_arg = args.last)
+            if last_arg.hash_type? && !last_arg.braces?
+              args = args.concat(args.pop.children)
+            end
+          end
+
+          check_line_breaks(node, args)
+        end
+
+        def autocorrect(node)
+          EmptyLineCorrector.insert_before(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/to_json.rb

@@ -14,7 +14,7 @@ module RuboCop
       #   end
       #
       #   # good
-      #   def to_json(_opts)
+      #   def to_json(*_args)
       #   end
       #
       class ToJSON < Cop
@@ -29,7 +29,10 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.insert_after(node.loc.name, '(_opts)')
+            # The following used `*_args` because `to_json(*args)` has
+            # an offense of `Lint/UnusedMethodArgument` cop if `*args`
+            # is not used.
+            corrector.insert_after(node.loc.name, '(*_args)')
           end
         end
       end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# TEAM: backend_infra
+# WATCHERS: maxh
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before each
+    # element in a multi-line collection.
+    module MultilineElementLineBreaks
+      private
+
+      def check_line_breaks(_node, children)
+        return if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          if last_seen_line >= child.first_line
+            add_offense(child)
+          else
+            last_seen_line = child.last_line
+          end
+        end
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+    end
+  end
+end

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

@@ -13,7 +13,12 @@ module RuboCop
 
       def check(node, args)
         args.each do |arg|
-          name = arg.children.first.to_s
+          # Argument names might be "_" or prefixed with "_" to indicate they
+          # are unused. Trim away this prefix and only analyse the basename.
+          full_name = arg.children.first.to_s
+          next if full_name == '_'
+
+          name = full_name.gsub(/\A([_]+)/, '')
           next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
           next if allowed_names.include?(name)
 

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that rescued exceptions variables are named as
+      # expected.
+      #
+      # The `PreferredName` config option takes a `String`. It represents
+      # the required name of the variable. Its default is `e`.
+      #
+      # @example PreferredName: e (default)
+      #   # bad
+      #   begin
+      #     # do something
+      #   rescue MyException => exc
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => e
+      #     # do something
+      #   end
+      #
+      # @example PreferredName: exception
+      #   # bad
+      #   begin
+      #     # do something
+      #   rescue MyException => e
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => ex
+      #     # do something
+      #   end
+      #
+      class RescuedExceptionsVariableName < Cop
+        MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'.freeze
+
+        def on_resbody(node)
+          exception_type, @exception_name = *node
+          return unless exception_type || @exception_name
+
+          @exception_name ||= exception_type.children.first
+          return if @exception_name.const_type? ||
+                    variable_name == preferred_name
+
+          add_offense(node, location: location)
+        end
+
+        private
+
+        def preferred_name
+          @preferred_name ||= cop_config.fetch('PreferredName', 'e')
+        end
+
+        def variable_name
+          @variable_name ||= location.source
+        end
+
+        def location
+          @location ||= @exception_name.loc.expression
+        end
+
+        def message(_node = nil)
+          format(MSG, preferred: preferred_name, bad: variable_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for overriding built-in Active Record methods instead of using
+      # callbacks.
+      #
+      # @example
+      #   # bad
+      #   class Book < ApplicationRecord
+      #     def save
+      #       self.title = title.upcase!
+      #       super
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Book < ApplicationRecord
+      #     before_save :upcase_title
+      #
+      #     def upcase_title
+      #       self.title = title.upcase!
+      #     end
+      #   end
+      #
+      class ActiveRecordOverride < Cop
+        MSG =
+          'Use %<prefer>s callbacks instead of overriding the Active Record ' \
+          'method `%<bad>s`.'.freeze
+        BAD_METHODS = %i[create destroy save update].freeze
+
+        def on_def(node)
+          method_name = node.method_name
+          return unless BAD_METHODS.include?(node.method_name)
+
+          parent_parts = node.parent.node_parts
+          parent_class = parent_parts.take_while do |part|
+            !part.nil? && part.const_type?
+          end.last
+          return unless %w[ApplicationRecord ActiveModel::Base]
+                        .include?(parent_class.const_name)
+
+          return unless node.descendants.any?(&:zsuper_type?)
+
+          add_offense(node, message: message(method_name))
+        end
+
+        private
+
+        def callback_names(method_name)
+          names = %w[before_ around_ after_].map do |prefix|
+            "`#{prefix}#{method_name}`"
+          end
+
+          names[-1] = "or #{names.last}"
+
+          names.join(', ')
+        end
+
+        def message(method_name)
+          format(MSG, prefer: callback_names(method_name), bad: method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for code that can be written with simpler conditionals
       # using `Object#blank?` defined by Active Support.
       #
+      # Interaction with `Style/UnlessElse`:
+      # The configuration of `NotPresent` will not produce an offense in the
+      # context of `unless else` if `Style/UnlessElse` is inabled. This is
+      # to prevent interference between the auto-correction of the two cops.
+      #
       # @example NilOrEmpty: true (default)
       #   # Converts usages of `nil? || empty?` to `blank?`
       #
@@ -111,6 +116,7 @@ module RuboCop
         def on_if(node)
           return unless cop_config['UnlessPresent']
           return unless node.unless?
+          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
 
           unless_present?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)

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

@@ -6,10 +6,13 @@ module RuboCop
       # This cop checks that methods specified in the filter's `only` or
       # `except` options are defined within the same class or module.
       #
-      # You can technically specify methods of superclass or methods added
-      # by mixins on the filter, but these confuse developers. If you
-      # specify methods that are defined in other classes or modules, you
-      # should define the filter in that class or module.
+      # You can technically specify methods of superclass or methods added by
+      # mixins on the filter, but these can confuse developers. If you specify
+      # methods that are defined in other classes or modules, you should
+      # define the filter in that class or module.
+      #
+      # If you rely on behaviour defined in the superclass actions, you must
+      # remember to invoke `super` in the subclass actions.
       #
       # @example
       #   # bad
@@ -56,6 +59,29 @@ module RuboCop
       #       # something
       #     end
       #   end
+      #
+      # @example
+      #   class ContentController < ApplicationController
+      #     def update
+      #       @content.update(content_attributes)
+      #     end
+      #   end
+      #
+      #   class ArticlesController < ContentController
+      #     before_action :load_article, only: [:update]
+      #
+      #     # the cop requires this method, but it relies on behaviour defined
+      #     # in the superclass, so needs to invoke `super`
+      #     def update
+      #       super
+      #     end
+      #
+      #     private
+      #
+      #     def load_article
+      #       @content = Article.find(params[:article_id])
+      #     end
+      #   end
       class LexicallyScopedActionFilter < Cop
         MSG = '%<action>s not explicitly defined on the %<type>s.'.freeze
 

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

@@ -22,7 +22,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :includes_noopener?, <<-PATTERN
-          (pair {(sym :rel) (str "rel")} (str #contains_noopener?))
+          (pair {(sym :rel) (str "rel")} ({str sym} #contains_noopener?))
         PATTERN
 
         def_node_matcher :rel_node?, <<-PATTERN
@@ -72,17 +72,18 @@ module RuboCop
         end
 
         def add_rel(send_node, offence_node, corrector)
-          quote_style = offence_node.children.last.source[0]
-          new_rel_exp = ", rel: #{quote_style}noopener#{quote_style}"
+          opening_quote = offence_node.children.last.source[0]
+          closing_quote = opening_quote == ':' ? '' : opening_quote
+          new_rel_exp = ", rel: #{opening_quote}noopener#{closing_quote}"
           range = send_node.arguments.last.source_range
 
           corrector.insert_after(range, new_rel_exp)
         end
 
-        def contains_noopener?(str)
-          return false unless str
+        def contains_noopener?(value)
+          return false unless value
 
-          str.split(' ').include?('noopener')
+          value.to_s.split(' ').include?('noopener')
         end
       end
     end

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

@@ -6,7 +6,10 @@ module RuboCop
       # This cop checks for code that can be written with simpler conditionals
       # using `Object#present?` defined by Active Support.
       #
-      # simpler conditionals.
+      # Interaction with `Style/UnlessElse`:
+      # The configuration of `NotBlank` will not produce an offense in the
+      # context of `unless else` if `Style/UnlessElse` is inabled. This is
+      # to prevent interference between the auto-correction of the two cops.
       #
       # @example NotNilAndNotEmpty: true (default)
       #   # Converts usages of `!nil? && !empty?` to `present?`
@@ -104,6 +107,7 @@ module RuboCop
         def on_if(node)
           return unless cop_config['UnlessBlank']
           return unless node.unless?
+          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks Rails model validations for a redundant `allow_nil` when
+      # `allow_blank` is present.
+      #
+      # @example
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: true
+      #
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: true
+      #
+      #   # bad
+      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: false
+      #
+      #   # good
+      #   validates :x, length: { is: 5 }, allow_blank: true
+      #
+      #   # good
+      #   validates :x, length: { is: 5 }, allow_blank: false
+      #
+      #   # good
+      #   # Here, `nil` is valid but `''` is not
+      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
+      #
+      class RedundantAllowNil < Cop
+        include RangeHelp
+
+        MSG_SAME =
+          '`allow_nil` is redundant when `allow_blank` has the same value.'
+          .freeze
+        MSG_ALLOW_NIL_FALSE =
+          '`allow_nil: false` is redundant when `allow_blank` is true.'.freeze
+
+        def on_send(node)
+          return unless node.method_name == :validates
+
+          allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
+          allow_nil_val = allow_nil.children.last
+          allow_blank_val = allow_blank.children.last
+
+          if allow_nil_val.type == allow_blank_val.type
+            add_offense(allow_nil, message: MSG_SAME)
+          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
+            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
+          end
+        end
+
+        def autocorrect(node)
+          prv_sib = previous_sibling(node)
+          nxt_sib = next_sibling(node)
+
+          lambda do |corrector|
+            if nxt_sib
+              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
+            elsif prv_sib
+              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
+            else
+              corrector.remove(node.loc.expression)
+            end
+          end
+        end
+
+        private
+
+        def find_allow_nil_and_allow_blank(node)
+          allow_nil = nil
+          allow_blank = nil
+
+          node.each_descendant do |descendant|
+            next unless descendant.pair_type?
+
+            key = descendant.children.first.value
+
+            allow_nil = descendant if key == :allow_nil
+            allow_blank = descendant if key == :allow_blank
+
+            break if allow_nil && allow_blank
+          end
+
+          [allow_nil, allow_blank]
+        end
+
+        def previous_sibling(node)
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def next_sibling(node)
+          node.parent.children[node.sibling_index + 1]
+        end
+
+        def node_beg(node)
+          node.loc.expression.begin_pos
+        end
+
+        def node_end(node)
+          node.loc.expression.end_pos
+        end
+      end
+    end
+  end
+end