rubocop 1.6.1 → 1.7.0

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

@@ -27,8 +27,9 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if offense?(node) && opposite_style_detected
+          if offense?(node)
             add_offense(node) do |corrector|
+              opposite_style_detected
               autocorrect(corrector, node)
             end
           else

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

@@ -40,6 +40,9 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
+      # NOTE: Parens are required around a method with arguments when inside an
+      # endless method definition (>= Ruby 3.0).
+      #
       # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad

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

@@ -14,25 +14,35 @@ module RuboCop
 
           def omit_parentheses(node)
             return unless node.parenthesized?
+            return if inside_endless_method_def?(node)
             return if node.implicit_call?
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              if parentheses_at_the_end_of_multiline_call?(node)
-                corrector.replace(args_begin(node), ' \\')
-              else
-                corrector.replace(args_begin(node), ' ')
-              end
-              corrector.remove(node.loc.end)
+              auto_correct(corrector, node)
+            end
+          end
+
+          def auto_correct(corrector, node)
+            if parentheses_at_the_end_of_multiline_call?(node)
+              corrector.replace(args_begin(node), ' \\')
+            else
+              corrector.replace(args_begin(node), ' ')
             end
+            corrector.remove(node.loc.end)
           end
 
           def offense_range(node)
             node.loc.begin.join(node.loc.end)
           end
 
+          def inside_endless_method_def?(node)
+            # parens are required around arguments inside an endless method
+            node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
+          end
+
           def super_call_without_arguments?(node)
             node.super_type? && node.arguments.none?
           end

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       #
+      # This cop does not consider endless methods, since parentheses are
+      # always required for them.
+      #
       # @example EnforcedStyle: require_parentheses (default)
       #   # The `require_parentheses` style requires method definitions
       #   # to always use parentheses
@@ -94,6 +97,8 @@ module RuboCop
                       'parameters.'
 
         def on_def(node)
+          return if node.endless?
+
           args = node.arguments
 
           if require_parentheses?(args)
@@ -142,6 +147,7 @@ module RuboCop
 
           add_offense(location, message: MSG_MISSING) do |corrector|
             correct_definition(node, corrector)
+            unexpected_style_detected 'require_no_parentheses'
           end
         end
 
@@ -149,6 +155,7 @@ module RuboCop
           add_offense(args, message: MSG_PRESENT) do |corrector|
             # offense is registered on args node when parentheses are unwanted
             correct_arguments(args, corrector)
+            unexpected_style_detected 'require_parentheses'
           end
         end
       end

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

@@ -19,6 +19,9 @@ module RuboCop
       #   end
       #
       class MultilineMethodSignature < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Avoid multi-line method signatures.'
 
         def on_def(node)
@@ -26,12 +29,34 @@ module RuboCop
           return if opening_line(node) == closing_line(node)
           return if correction_exceeds_max_line_length?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_defs on_def
 
         private
 
+        def autocorrect(corrector, node)
+          arguments = node.arguments
+          joined_arguments = arguments.map(&:source).join(', ')
+          last_line_source_of_arguments = processed_source[arguments.last_line - 1].strip
+
+          if last_line_source_of_arguments.start_with?(')')
+            joined_arguments = "#{joined_arguments}#{last_line_source_of_arguments}"
+
+            corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
+          end
+
+          corrector.replace(arguments_range(node), joined_arguments)
+        end
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
+          )
+        end
+
         def opening_line(node)
           node.first_line
         end

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

@@ -58,7 +58,9 @@ module RuboCop
         private
 
         def require_then?(when_node)
-          return true if when_node.conditions.count >= 2
+          unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
+            return true
+          end
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line

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

@@ -14,6 +14,8 @@ module RuboCop
       # positives. Luckily, there is no harm in freezing an already
       # frozen object.
       #
+      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+      #
       # @example EnforcedStyle: literals (default)
       #   # bad
       #   CONST = [1, 2, 3]
@@ -94,7 +96,8 @@ module RuboCop
           range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
 
           return unless mutable_literal?(value) ||
-                        range_enclosed_in_parentheses
+                        target_ruby_version <= 2.7 && range_enclosed_in_parentheses
+
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
@@ -119,11 +122,14 @@ module RuboCop
         end
 
         def mutable_literal?(value)
-          value&.mutable_literal?
+          return false if value.nil?
+          return false if frozen_regexp_or_range_literals?(value)
+
+          value.mutable_literal?
         end
 
         def immutable_literal?(node)
-          node.nil? || node.immutable_literal?
+          node.nil? || frozen_regexp_or_range_literals?(node) || node.immutable_literal?
         end
 
         def frozen_string_literal?(node)
@@ -131,6 +137,10 @@ module RuboCop
             frozen_string_literals_enabled?
         end
 
+        def frozen_regexp_or_range_literals?(node)
+          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+        end
+
         def requires_parentheses?(node)
           node.range_type? ||
             (node.send_type? && node.loc.dot.nil?)

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

@@ -95,6 +95,7 @@ module RuboCop
               replacement = correction_exploded_to_compact(node)
 
               corrector.replace(node, replacement)
+              opposite_style_detected
             end
           else
             correct_style_detected
@@ -115,6 +116,7 @@ module RuboCop
             replacement = correction_compact_to_exploded(node)
 
             corrector.replace(node, replacement)
+            opposite_style_detected
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # 1. This cop matches for method names only and hence cannot tell apart
       #    methods with same name in different classes.
       # 2. This cop is limited to methods with single parameter.
-      # 3. This cop is unsafe if certain special global variables (e.g. `$;`) are set.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
       #    That depends on the nature of the target methods, of course.
       #
       # Method names and their redundant arguments can be configured like this:
@@ -20,6 +20,8 @@ module RuboCop
       # Methods:
       #   join: ''
       #   split: ' '
+      #   chomp: "\n"
+      #   chomp!: "\n"
       #   foo: 2
       #
       # @example
@@ -28,6 +30,8 @@ module RuboCop
       #   [1, 2, 3].join("")
       #   string.split(" ")
       #   "first\nsecond".split(" ")
+      #   string.chomp("\n")
+      #   string.chomp!("\n")
       #   A.foo(2)
       #
       #   # good
@@ -35,6 +39,8 @@ module RuboCop
       #   [1, 2, 3].join
       #   string.split
       #   "first second".split
+      #   string.chomp
+      #   string.chomp!
       #   A.foo
       class RedundantArgument < Base
         include RangeHelp

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop check for uses of Object#freeze on immutable objects.
+      # This cop check for uses of `Object#freeze` on immutable objects.
+      #
+      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
       #
       # @example
       #   # bad
@@ -37,8 +39,10 @@ module RuboCop
 
           return true if node.immutable_literal?
 
-          FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?
+          return true if FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
+                         frozen_string_literals_enabled?
+
+          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
         end
 
         def strip_parenthesis(node)
@@ -52,7 +56,7 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
-            (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))
+            (begin (send !{(str _) array} {:+ :- :* :** :/ :%} {float int}))
             (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
             (send (const {nil? cbase} :ENV) :[] _)
             (send _ {:count :length :size} ...)

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

@@ -6,6 +6,8 @@ module RuboCop
       # This cop checks for single-line method definitions that contain a body.
       # It will accept single-line methods with no body.
       #
+      # Endless methods added in Ruby 3.0 are also accepted by this cop.
+      #
       # @example
       #   # bad
       #   def some_method; body end
@@ -15,6 +17,7 @@ module RuboCop
       #   # good
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
+      #   def some_method() = body
       #
       # @example AllowIfMethodIsEmpty: true (default)
       #   # good
@@ -32,6 +35,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.single_line?
+          return if node.endless?
           return if allow_empty? && !node.body
 
           add_offense(node) do |corrector|

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

@@ -22,11 +22,12 @@ module RuboCop
         SUPER_TYPES = %i[super zsuper].freeze
 
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+        def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
         def_node_matcher :symbol_proc?, <<~PATTERN
-          ({block numblock}
-            ${(send ...) (super ...) zsuper}
-            ${(args (arg _)) %Integer}
-            (send (lvar _var) $_))
+          {
+            (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
+            (numblock $#symbol_proc_receiver? $1 (send (lvar :_1) $_))
+          }
         PATTERN
 
         def self.autocorrect_incompatible_with

data/lib/rubocop/cop/util.rb

@@ -33,7 +33,9 @@ module RuboCop
       end
 
       def add_parentheses(node, corrector)
-        if node.arguments.empty?
+        if !node.respond_to?(:arguments)
+          corrector.wrap(node, '(', ')')
+        elsif node.arguments.empty?
           corrector.insert_after(node, '()')
         else
           corrector.replace(args_begin(node), '(')

data/lib/rubocop/options.rb

@@ -66,7 +66,7 @@ module RuboCop
         add_configuration_options(opts)
         add_formatting_options(opts)
 
-        option(opts, '-r', '--require FILE') { |f| require f }
+        option(opts, '-r', '--require FILE') { |f| require_feature(f) }
 
         add_severity_option(opts)
         add_flags_with_optional_args(opts)
@@ -92,14 +92,7 @@ module RuboCop
           raise OptionArgumentError, message
         end
 
-        @options[:"#{option}"] =
-          if list.empty?
-            ['']
-          else
-            list.split(',').map do |c|
-              Cop::Registry.qualified_cop_name(c, "--#{option} option")
-            end
-          end
+        @options[:"#{option}"] = list.empty? ? [''] : list.split(',')
       end
     end
 
@@ -239,6 +232,13 @@ module RuboCop
       long_opt[2..-1].sub('[no-]', '').sub(/ .*/, '')
                      .tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
+
+    def require_feature(file)
+      # If any features were added on the CLI from `--require`,
+      # add them to the config.
+      ConfigLoader.add_loaded_features(file)
+      require file
+    end
   end
 
   # Validates option arguments and the options' compatibility with each other.

data/lib/rubocop/rspec/cop_helper.rb

@@ -9,10 +9,6 @@ module CopHelper
   let(:ruby_version) { 2.4 }
   let(:rails_version) { false }
 
-  def inspect_source_file(source)
-    Tempfile.open('tmp') { |f| inspect_source(source, f) }
-  end
-
   def inspect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}

data/lib/rubocop/rspec/expect_offense.rb

@@ -111,28 +111,9 @@ module RuboCop
         source
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def expect_offense(source, file = nil, severity: nil, **replacements)
-        source = format_offense(source, **replacements)
-        RuboCop::Formatter::DisabledConfigFormatter
-          .config_to_allow_offenses = {}
-        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
-        cop.instance_variable_get(:@options)[:auto_correct] = true
-
-        expected_annotations = AnnotatedSource.parse(source)
-
-        if expected_annotations.plain_source == source
-          raise 'Use `expect_no_offenses` to assert that no offenses are found'
-        end
-
-        @processed_source = parse_source(expected_annotations.plain_source,
-                                         file)
-
-        unless @processed_source.valid_syntax?
-          raise 'Error parsing example code: ' \
-            "#{@processed_source.diagnostics.map(&:render).join("\n")}"
-        end
-
+        expected_annotations = parse_annotations(source, **replacements)
+        @processed_source = parse_processed_source(expected_annotations.plain_source, file)
         @offenses = _investigate(cop, @processed_source)
         actual_annotations =
           expected_annotations.with_offense_annotations(@offenses)
@@ -143,7 +124,14 @@ module RuboCop
         @offenses
       end
 
-      def expect_correction(correction, loop: true)
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def expect_correction(correction, loop: true, source: nil)
+        if source
+          expected_annotations = parse_annotations(source, raise_error: false)
+          @processed_source = parse_processed_source(expected_annotations.plain_source)
+          _investigate(cop, @processed_source)
+        end
+
         raise '`expect_correction` must follow `expect_offense`' unless @processed_source
 
         iteration = 0
@@ -192,6 +180,30 @@ module RuboCop
         expect(actual_annotations.to_s).to eq(source)
       end
 
+      def parse_annotations(source, raise_error: true, **replacements)
+        set_formatter_options
+
+        source = format_offense(source, **replacements)
+        annotations = AnnotatedSource.parse(source)
+        return annotations unless raise_error && annotations.plain_source == source
+
+        raise 'Use `expect_no_offenses` to assert that no offenses are found'
+      end
+
+      def parse_processed_source(source, file = nil)
+        processed_source = parse_source(source, file)
+        return processed_source if processed_source.valid_syntax?
+
+        raise 'Error parsing example code: ' \
+          "#{processed_source.diagnostics.map(&:render).join("\n")}"
+      end
+
+      def set_formatter_options
+        RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:auto_correct] = true
+      end
+
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
         ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze