rubocop 0.78.0 → 0.82.0

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

@@ -5,11 +5,12 @@ module RuboCop
     module Style
       # Access modifiers should be declared to apply to a group of methods
       # or inline before each method, depending on configuration.
+      # EnforcedStyle config covers only method definitions.
+      # Applications of visibility methods to symbols can be controlled
+      # using AllowModifiersOnSymbols config.
       #
       # @example EnforcedStyle: group (default)
-      #
       #   # bad
-      #
       #   class Foo
       #
       #     private def bar; end
@@ -18,7 +19,6 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private
@@ -27,10 +27,9 @@ module RuboCop
       #     def baz; end
       #
       #   end
-      # @example EnforcedStyle: inline
       #
+      # @example EnforcedStyle: inline
       #   # bad
-      #
       #   class Foo
       #
       #     private
@@ -41,13 +40,28 @@ module RuboCop
       #   end
       #
       #   # good
-      #
       #   class Foo
       #
       #     private def bar; end
       #     private def baz; end
       #
       #   end
+      #
+      # @example AllowModifiersOnSymbols: true
+      #   # good
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
+      #
+      # @example AllowModifiersOnSymbols: false
+      #   # bad
+      #   class Foo
+      #
+      #     private :bar, :baz
+      #
+      #   end
       class AccessModifierDeclarations < Cop
         include ConfigurableEnforcedStyle
 
@@ -61,9 +75,15 @@ module RuboCop
           'inlined in method definitions.'
         ].join(' ')
 
+        def_node_matcher :access_modifier_with_symbol?, <<~PATTERN
+          (send nil? {:private :protected :public} (sym _))
+        PATTERN
+
         def on_send(node)
           return unless node.access_modifier?
           return if node.parent.pair_type?
+          return if cop_config['AllowModifiersOnSymbols'] &&
+                    access_modifier_with_symbol?(node)
 
           if offense?(node)
             add_offense(node, location: :selector) do

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

@@ -115,7 +115,7 @@ module RuboCop
           lambda do |corrector|
             new, old = *send_node.arguments
             replacement = "alias #{identifier(new)} #{identifier(old)}"
-            corrector.replace(send_node.source_range, replacement)
+            corrector.replace(send_node, replacement)
           end
         end
 
@@ -125,15 +125,15 @@ module RuboCop
               'alias_method ' \
               ":#{identifier(node.new_identifier)}, " \
               ":#{identifier(node.old_identifier)}"
-            corrector.replace(node.source_range, replacement)
+            corrector.replace(node, replacement)
           end
         end
 
         def correct_alias_with_symbol_args(node)
           lambda do |corrector|
-            corrector.replace(node.new_identifier.source_range,
+            corrector.replace(node.new_identifier,
                               node.new_identifier.source[1..-1])
-            corrector.replace(node.old_identifier.source_range,
+            corrector.replace(node.old_identifier,
                               node.old_identifier.source[1..-1])
           end
         end

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

@@ -97,12 +97,12 @@ module RuboCop
           return unless correctable_send?(node)
 
           corrector.replace(whitespace_before_arg(node), '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '(')
-          corrector.insert_after(node.last_argument.source_range, ')')
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         # ! is a special case:
@@ -124,8 +124,7 @@ module RuboCop
         def correct_other(node, corrector)
           return if node.source_range.begin.is?('(')
 
-          corrector.insert_before(node.source_range, '(')
-          corrector.insert_after(node.source_range, ')')
+          corrector.wrap(node, '(', ')')
         end
 
         def correctable_send?(node)
@@ -137,7 +136,7 @@ module RuboCop
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
-          end_paren += 1 unless node.source =~ /\?\S/
+          end_paren += 1 unless /\?\S/.match?(node.source)
           range_between(begin_paren, end_paren)
         end
       end

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

@@ -30,7 +30,7 @@ module RuboCop
           array, join_arg = join_candidate?(node).map(&:source)
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+            corrector.replace(node, "#{array}.join(#{join_arg})")
           end
         end
       end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -106,12 +107,41 @@ module RuboCop
       #     word.flip.flop
       #   }
       #
+      # @example BracesRequiredMethods: ['sig']
+      #
+      #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
+      #   # in this example, will require `{...}` braces. This option takes
+      #   # precedence over all other configurations except IgnoredMethods.
+      #
+      #   # bad
+      #   sig do
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   end
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   sig {
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   }
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
       class BlockDelimiters < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
 
         ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
 
+        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
+          "'%<method_name>s' method."
+
         def on_send(node)
           return unless node.arguments?
           return if node.parenthesized?
@@ -175,7 +205,15 @@ module RuboCop
           end
         end
 
+        def braces_required_message(node)
+          format(BRACES_REQUIRED_MESSAGE, method_name: node.method_name.to_s)
+        end
+
         def message(node)
+          if braces_required_method?(node.method_name)
+            return braces_required_message(node)
+          end
+
           case style
           when :line_count_based    then line_count_based_message(node)
           when :semantic            then semantic_message(node)
@@ -238,7 +276,9 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         def proper_block_style?(node)
-          return true if ignored_method?(node.method_name)
+          if special_method?(node.method_name)
+            return special_method_proper_block_style?(node)
+          end
 
           case style
           when :line_count_based    then line_count_based_block_style?(node)
@@ -248,6 +288,24 @@ module RuboCop
           end
         end
 
+        def special_method?(method_name)
+          ignored_method?(method_name) || braces_required_method?(method_name)
+        end
+
+        def special_method_proper_block_style?(node)
+          method_name = node.method_name
+          return true if ignored_method?(method_name)
+          return node.braces? if braces_required_method?(method_name)
+        end
+
+        def braces_required_method?(method_name)
+          braces_required_methods.include?(method_name.to_s)
+        end
+
+        def braces_required_methods
+          cop_config.fetch('BracesRequiredMethods', [])
+        end
+
         def line_count_based_block_style?(node)
           node.multiline? ^ node.braces?
         end
@@ -329,3 +387,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -16,14 +16,37 @@ module RuboCop
       #   (1..100).include?(7)
       #   some_string =~ /something/
       #
+      # @example AllowOnConstant
+      #   # Style/CaseEquality:
+      #   #   AllowOnConstant: true
+      #
+      #   # bad
+      #   (1..100) === 7
+      #   /something/ === some_string
+      #
+      #   # good
+      #   Array === something
+      #   (1..100).include?(7)
+      #   some_string =~ /something/
+      #
       class CaseEquality < Cop
         MSG = 'Avoid the use of the case equality operator `===`.'
 
-        def_node_matcher :case_equality?, '(send _ :=== _)'
+        def_node_matcher :case_equality?, '(send #const? :=== _)'
 
         def on_send(node)
           case_equality?(node) { add_offense(node, location: :selector) }
         end
+
+        private
+
+        def const?(node)
+          if cop_config.fetch('AllowOnConstant', false)
+            !node.const_type?
+          else
+            true
+          end
+        end
       end
     end
   end

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

@@ -33,9 +33,9 @@ module RuboCop
             # special character like \n
             # or ' which needs to use "" or be escaped.
             if string.length == 2 || string == "'"
-              corrector.replace(node.source_range, %("#{string}"))
+              corrector.replace(node, %("#{string}"))
             elsif string.length == 1 # normal character
-              corrector.replace(node.source_range, "'#{string}'")
+              corrector.replace(node, "'#{string}'")
             end
           end
         end

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

@@ -27,6 +27,7 @@ module RuboCop
       #   items.inject
       #   items.detect
       #   items.find_all
+      #   items.member?
       #
       #   # good
       #   items.map
@@ -34,6 +35,7 @@ module RuboCop
       #   items.reduce
       #   items.find
       #   items.select
+      #   items.include?
       #
       class CollectionMethods < Cop
         include MethodPreference

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

@@ -458,7 +458,7 @@ module RuboCop
         def correct_if_branches(corrector, cop, node)
           if_branch, elsif_branches, else_branch = extract_tail_branches(node)
 
-          corrector.insert_before(node.source_range, lhs(if_branch))
+          corrector.insert_before(node, lhs(if_branch))
           replace_branch_assignment(corrector, if_branch)
           correct_branches(corrector, elsif_branches)
           replace_branch_assignment(corrector, else_branch)
@@ -475,13 +475,13 @@ module RuboCop
                           source
                         end
 
-          corrector.replace(branch.source_range, replacement)
+          corrector.replace(branch, replacement)
         end
 
         def correct_branches(corrector, branches)
           branches.each do |branch|
             *_, assignment = *branch
-            corrector.replace(branch.source_range, assignment.source)
+            corrector.replace(branch, assignment.source)
           end
         end
       end
@@ -494,7 +494,7 @@ module RuboCop
 
           def correct(node)
             lambda do |corrector|
-              corrector.replace(node.source_range, correction(node))
+              corrector.replace(node, correction(node))
             end
           end
 
@@ -547,7 +547,7 @@ module RuboCop
           end
 
           def move_branch_inside_condition(corrector, branch, assignment)
-            corrector.insert_before(branch.loc.expression, assignment.source)
+            corrector.insert_before(branch, assignment.source)
           end
         end
       end
@@ -589,7 +589,7 @@ module RuboCop
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
+            corrector.insert_before(branch_assignment,
                                     assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
@@ -611,7 +611,7 @@ module RuboCop
             when_branches, else_branch = extract_tail_branches(node)
 
             lambda do |corrector|
-              corrector.insert_before(node.source_range, lhs(else_branch))
+              corrector.insert_before(node, lhs(else_branch))
               correct_branches(corrector, when_branches)
               replace_branch_assignment(corrector, else_branch)
 
@@ -652,7 +652,7 @@ module RuboCop
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
+            corrector.insert_before(branch_assignment,
                                     assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)

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

@@ -55,7 +55,7 @@ module RuboCop
           raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
 
           regex = Regexp.new(notice)
-          return if autocorrect_notice =~ regex
+          return if autocorrect_notice&.match?(regex)
 
           raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
                          "match Notice /#{notice}/"

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, '__dir__')
+            corrector.replace(node, '__dir__')
           end
         end
 

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects comments to enable/disable RuboCop.
+      # This is useful if want to make sure that every RuboCop error gets fixed
+      # and not quickly disabled with a comment.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # good
+      #   def fixed_method_name_and_no_rubocop_comments
+      #   end
+      #
+      class DisableCopsWithinSourceCodeDirective < Cop
+        # rubocop:enable Lint/RedundantCopDisableDirective
+        MSG = 'Comment to disable/enable RuboCop.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless rubocop_directive_comment?(comment)
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          lambda do |corrector|
+            corrector.replace(comment, '')
+          end
+        end
+
+        private
+
+        def rubocop_directive_comment?(comment)
+          comment.text =~ CommentConfig::COMMENT_DIRECTIVE_REGEXP
+        end
+      end
+    end
+  end
+end