rubocop 0.69.0 → 0.70.0

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

@@ -117,9 +117,9 @@ module RuboCop
 
           add_offense(right_paren,
                       location: right_paren,
-                      message: message(correct_column,
-                                       left_paren,
-                                       right_paren))
+                      message:  message(correct_column,
+                                        left_paren,
+                                        right_paren))
         end
 
         def check_for_no_elements(node)
@@ -137,9 +137,9 @@ module RuboCop
           @column_delta = correct_column - right_paren.column
           add_offense(right_paren,
                       location: right_paren,
-                      message: message(correct_column,
-                                       left_paren,
-                                       right_paren))
+                      message:  message(correct_column,
+                                        left_paren,
+                                        right_paren))
         end
 
         def expected_column(left_paren, elements)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Layout
       # Access modifiers should be surrounded by blank lines.
       #
-      # @example
+      # @example EnforcedStyle: around (default)
       #
       #   # bad
       #   class Foo
@@ -22,13 +22,35 @@ module RuboCop
       #
       #     def baz; end
       #   end
+      #
+      # @example EnforcedStyle: only_before
+      #
+      #   # bad
+      #   class Foo
+      #     def bar; end
+      #     private
+      #     def baz; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar; end
+      #
+      #     private
+      #     def baz; end
+      #   end
+      #
       class EmptyLinesAroundAccessModifier < Cop
+        include ConfigurableEnforcedStyle
         include RangeHelp
 
         MSG_AFTER = 'Keep a blank line after `%<modifier>s`.'
         MSG_BEFORE_AND_AFTER = 'Keep a blank line before and after ' \
                                '`%<modifier>s`.'
 
+        MSG_BEFORE_FOR_ONLY_BEFORE = 'Keep a blank line before `%<modifier>s`.'
+        MSG_AFTER_FOR_ONLY_BEFORE = 'Remove a blank line after `%<modifier>s`.'
+
         def initialize(config = nil, options = nil)
           super
 
@@ -63,7 +85,12 @@ module RuboCop
         def on_send(node)
           return unless node.bare_access_modifier?
 
-          return if empty_lines_around?(node)
+          case style
+          when :around
+            return if empty_lines_around?(node)
+          when :only_before
+            return if allowed_only_before_style?(node)
+          end
 
           add_offense(node)
         end
@@ -76,14 +103,35 @@ module RuboCop
               corrector.insert_before(line, "\n")
             end
 
+            correct_next_line_if_denied_style(corrector, node, line)
+          end
+        end
+
+        private
+
+        def allowed_only_before_style?(node)
+          if node.special_modifier?
+            return false if next_line_empty?(node.last_line)
+          end
+
+          previous_line_empty?(node.first_line)
+        end
+
+        def correct_next_line_if_denied_style(corrector, node, line)
+          case style
+          when :around
             unless next_line_empty?(node.last_line)
               corrector.insert_after(line, "\n")
             end
+          when :only_before
+            if next_line_empty?(node.last_line)
+              range = next_empty_line_range(node)
+
+              corrector.remove(range)
+            end
           end
         end
 
-        private
-
         def previous_line_ignoring_comments(processed_source, send_line)
           processed_source[0..send_line - 2].reverse.find do |line|
             !comment_line?(line)
@@ -128,7 +176,20 @@ module RuboCop
           line == @class_or_module_def_last_line - 1
         end
 
+        def next_empty_line_range(node)
+          source_range(processed_source.buffer, node.last_line + 1, 0)
+        end
+
         def message(node)
+          case style
+          when :around
+            message_for_around_style(node)
+          when :only_before
+            message_for_only_before_style(node)
+          end
+        end
+
+        def message_for_around_style(node)
           send_line = node.first_line
 
           if block_start?(send_line) ||
@@ -138,6 +199,16 @@ module RuboCop
             format(MSG_BEFORE_AND_AFTER, modifier: node.loc.selector.source)
           end
         end
+
+        def message_for_only_before_style(node)
+          modifier = node.loc.selector.source
+
+          if next_line_empty?(node.last_line)
+            format(MSG_AFTER_FOR_ONLY_BEFORE, modifier: modifier)
+          else
+            format(MSG_BEFORE_FOR_ONLY_BEFORE, modifier: modifier)
+          end
+        end
       end
     end
   end

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

@@ -52,8 +52,6 @@ module RuboCop
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
               'spaces for%<name>s indentation.'
 
-        SPECIAL_MODIFIERS = %w[private protected].freeze
-
         def_node_matcher :access_modifier?, <<-PATTERN
           [(send ...) access_modifier?]
         PATTERN
@@ -188,7 +186,7 @@ module RuboCop
         def each_member(members)
           previous_modifier = nil
           members.first.children.each do |member|
-            if member.send_type? && special_modifier?(member)
+            if member.send_type? && member.special_modifier?
               previous_modifier = member
             elsif previous_modifier
               yield member, previous_modifier.source_range
@@ -197,10 +195,6 @@ module RuboCop
           end
         end
 
-        def special_modifier?(node)
-          node.bare_access_modifier? && SPECIAL_MODIFIERS.include?(node.source)
-        end
-
         def indentation_consistency_style
           config.for_cop('Layout/IndentationConsistency')['EnforcedStyle']
         end

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

@@ -24,11 +24,11 @@ module RuboCop
         include ParserDiagnostic
 
         AMBIGUITIES = {
-          '+' => { actual: 'positive number', possible: 'addition' },
-          '-' => { actual: 'negative number', possible: 'subtraction' },
-          '*' => { actual: 'splat',           possible: 'multiplication' },
-          '&' => { actual: 'block',           possible: 'binary AND' },
-          '**' => { actual: 'keyword splat', possible: 'exponent' }
+          '+'  => { actual: 'positive number', possible: 'addition' },
+          '-'  => { actual: 'negative number', possible: 'subtraction' },
+          '*'  => { actual: 'splat',           possible: 'multiplication' },
+          '&'  => { actual: 'block',           possible: 'binary AND' },
+          '**' => { actual: 'keyword splat',   possible: 'exponent' }
         }.each do |key, hash|
           hash[:operator] = key
         end

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

@@ -5,50 +5,89 @@ module RuboCop
     module Lint
       # This cop checks for *rescue* blocks with no body.
       #
-      # @example
+      # @example AllowComments: false (default)
       #
       #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
       #
+      #   # bad
       #   def some_method
       #     do_something
       #   rescue
       #     # do nothing
       #   end
       #
-      # @example
-      #
       #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
       #
+      #   # bad
       #   begin
       #     do_something
       #   rescue
       #     # do nothing
       #   end
       #
-      # @example
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
       #
       #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example AllowComments: true
       #
+      #   # bad
       #   def some_method
       #     do_something
       #   rescue
-      #     handle_exception
       #   end
       #
-      # @example
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
       #
       #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing but comment
+      #   end
       #
+      #   # good
       #   begin
       #     do_something
       #   rescue
-      #     handle_exception
+      #     # do nothing but comment
       #   end
       class HandleExceptions < Cop
         MSG = 'Do not suppress exceptions.'
 
         def on_resbody(node)
-          add_offense(node) unless node.body
+          return if node.body
+          return if cop_config['AllowComments'] && comment_lines?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
         end
       end
     end

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

@@ -53,6 +53,13 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression,
+                              correct_method(node, node.receiver))
+          end
+        end
+
         private
 
         def date_time_object?(node)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Lint
       # This cop checks for useless `else` in `begin..end` without `rescue`.
       #
+      # Note: This syntax is no longer valid on Ruby 2.6 or higher and
+      # this cop is going to be removed at some point the future.
+      #
       # @example
       #
       #   # bad

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

@@ -9,7 +9,7 @@ module RuboCop
 
       FORMATS = {
         snake_case: /^@{0,2}[\da-z_]+[!?=]?$/,
-        camelCase: /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
+        camelCase:  /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
       }.freeze
     end
   end

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

@@ -8,8 +8,8 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case: /(?:[a-z_]|_\d+)$/,
-        normalcase: /(?:_\D*|[A-Za-z]\d*)$/,
+        snake_case:  /(?:[a-z_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
         non_integer: /[A-Za-z_]$/
       }.freeze
     end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain methods when
+    # parsing using regex patterns.
+    module IgnoredMethodPatterns
+      private
+
+      def ignored_method_pattern?(name)
+        ignored_method_patterns.any? { |pattern| Regexp.new(pattern) =~ name }
+      end
+
+      def ignored_method_patterns
+        cop_config.fetch('IgnoredMethodPatterns', [])
+      end
+    end
+  end
+end

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

@@ -21,20 +21,20 @@ module RuboCop
         MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
 
         CORRECTIONS = {
-          refute: 'assert_not',
-          refute_empty: 'assert_not_empty',
-          refute_equal: 'assert_not_equal',
-          refute_in_delta: 'assert_not_in_delta',
-          refute_in_epsilon: 'assert_not_in_epsilon',
-          refute_includes: 'assert_not_includes',
+          refute:             'assert_not',
+          refute_empty:       'assert_not_empty',
+          refute_equal:       'assert_not_equal',
+          refute_in_delta:    'assert_not_in_delta',
+          refute_in_epsilon:  'assert_not_in_epsilon',
+          refute_includes:    'assert_not_includes',
           refute_instance_of: 'assert_not_instance_of',
-          refute_kind_of: 'assert_not_kind_of',
-          refute_nil: 'assert_not_nil',
-          refute_operator: 'assert_not_operator',
-          refute_predicate: 'assert_not_predicate',
-          refute_respond_to: 'assert_not_respond_to',
-          refute_same: 'assert_not_same',
-          refute_match: 'assert_no_match'
+          refute_kind_of:     'assert_not_kind_of',
+          refute_nil:         'assert_not_nil',
+          refute_operator:    'assert_not_operator',
+          refute_predicate:   'assert_not_predicate',
+          refute_respond_to:  'assert_not_respond_to',
+          refute_same:        'assert_not_same',
+          refute_match:       'assert_no_match'
         }.freeze
 
         OFFENSIVE_METHODS = CORRECTIONS.keys.freeze

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -8,10 +8,19 @@ module RuboCop
       # method calls containing parameters.
       #
       # In the default style (require_parentheses), macro methods are ignored.
-      # Additional methods can be added to the `IgnoredMethods` list. This
-      # option is valid only in the default style. Macros can be included by
+      # Additional methods can be added to the `IgnoredMethods`
+      # or `IgnoredMethodPatterns` list. These options are
+      # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
-      # the `IncludedMacros` list. If a method is listed in both
+      # the `IncludedMacros` list.
+      #
+      # Precedence of options is all follows:
+      #
+      # 1. `IgnoredMethods`
+      # 2. `IgnoredMethodPatterns`
+      # 3. `IncludedMacros`
+      #
+      # eg. If a method is listed in both
       # `IncludedMacros` and `IgnoredMethods`, then the latter takes
       # precedence (that is, the method is ignored).
       #
@@ -52,6 +61,9 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
+      #   # okay with `^assert` listed in `IgnoredMethodPatterns`
+      #   assert_equal 'test', x
+      #
       #   # IgnoreMacros: true (default)
       #
       #   # good
@@ -136,6 +148,7 @@ module RuboCop
       class MethodCallWithArgsParentheses < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
+        include IgnoredMethodPatterns
 
         TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
 
@@ -173,6 +186,7 @@ module RuboCop
 
         def add_offense_for_require_parentheses(node)
           return if ignored_method?(node.method_name)
+          return if ignored_method_pattern?(node.method_name)
           return if eligible_for_parentheses_omission?(node)
           return unless node.arguments? && !node.parenthesized?