rubocop 0.79.0 → 0.80.0

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

@@ -54,6 +54,7 @@ module RuboCop
 
         def expect_params_after_method_name?(node)
           return false if node.parenthesized?
+          return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument
 
@@ -61,6 +62,13 @@ module RuboCop
             !(allow_for_alignment? &&
               aligned_with_something?(first_arg.source_range))
         end
+
+        def no_space_between_method_name_and_first_argument?(node)
+          end_pos_of_method_name = node.loc.selector.end_pos
+          begin_pos_of_argument = node.first_argument.source_range.begin_pos
+
+          end_pos_of_method_name == begin_pos_of_argument
+        end
       end
     end
   end

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

@@ -83,17 +83,10 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            # It is possible that BracesAroundHashParameters will remove the
-            # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code. If we replace the brace with a
-            # brace plus space (rather than just inserting a space), then any
-            # removal of the same brace will give us a clobbering error. This
-            # in turn will make RuboCop fall back on cop-by-cop
-            # auto-correction. Problem solved.
             case range.source
             when /\s/ then corrector.remove(range)
-            when '{' then corrector.replace(range, '{ ')
-            else corrector.replace(range, ' }')
+            when '{' then corrector.insert_after(range, ' ')
+            else corrector.insert_before(range, ' ')
             end
           end
         end

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug :console} ...)
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (send (send {#kernel? nil?} :binding)
              {:pry :remote_pry :pry_remote :console} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)

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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-# The Lint/RedundantCopEnableDirective cop needs to be disabled so as
-# to be able to provide a (bad) example of an unneeded enable.
+# The Lint/RedundantCopEnableDirective and Lint/RedundantCopDisableDirective
+# cops need to be disabled so as to be able to provide a (bad) example of an
+# unneeded enable.
 
 # rubocop:disable Lint/RedundantCopEnableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -21,15 +23,15 @@ module RuboCop
       #   foo = 1
       # @example
       #   # bad
-      #   # rubocop:disable Layout/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
-      #   # rubocop:enable Layout/LineLength
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
+      #   # rubocop:enable Style/StringLiterals
       #   baz
       #   # rubocop:enable all
       #
       #   # good
-      #   # rubocop:disable Layout/LineLength
-      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:disable Style/StringLiterals
+      #   foo = "1"
       #   # rubocop:enable all
       #   baz
       class RedundantCopEnableDirective < Cop
@@ -112,3 +114,6 @@ module RuboCop
     end
   end
 end
+
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Lint/RedundantCopEnableDirective

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

@@ -6,6 +6,10 @@ module RuboCop
       # This cop checks for setter call to local variable as the final
       # expression of a function definition.
       #
+      # Note: There are edge cases in which the local variable references a
+      # value that is also accessible outside the local scope. This is not
+      # detected by the cop, and it can yield a false positive.
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/migration/department_name.rb

@@ -35,8 +35,13 @@ module RuboCop
 
         def autocorrect(range)
           shall_warn = false
-          qualified_cop_name = Cop.registry.qualified_cop_name(range.source,
+          cop_name = range.source
+          qualified_cop_name = Cop.registry.qualified_cop_name(cop_name,
                                                                nil, shall_warn)
+          unless qualified_cop_name.include?('/')
+            qualified_cop_name = qualified_legacy_cop_name(cop_name)
+          end
+
           ->(corrector) { corrector.replace(range, qualified_cop_name) }
         end
 
@@ -53,6 +58,14 @@ module RuboCop
         def valid_content_token?(content_token)
           !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
         end
+
+        def qualified_legacy_cop_name(cop_name)
+          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+
+          legacy_cop_names.detect do |legacy_cop_name|
+            legacy_cop_name.split('/')[1] == cop_name
+          end
+        end
       end
     end
   end

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

@@ -60,6 +60,10 @@ module RuboCop
       alias conflicting_styles_detected no_acceptable_style!
       alias unrecognized_style_detected no_acceptable_style!
 
+      def style_configured?
+        cop_config.key?(style_parameter_name)
+      end
+
       def style
         @style ||= begin
           s = cop_config[style_parameter_name].to_sym

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

@@ -39,6 +39,12 @@ module RuboCop
         end
       end
 
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
+
       def leading_comment_lines
         processed_source.comments.first(3).map(&:text)
       end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      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_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        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_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        puts node.class
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      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_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(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,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        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_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = node.parent&.block_type? ? 0 : '.to_h'.length
+          new(match, node.children.first, 0, strip_trailing_chars)
+        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/mixin/trailing_comma.rb

@@ -23,7 +23,7 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind)
+          put_comma(items, kind)
         end
       end
 
@@ -145,9 +145,7 @@ module RuboCop
         add_offense(range, location: range, message: msg)
       end
 
-      def put_comma(node, items, kind)
-        return if avoid_autocorrect?(elements(node))
-
+      def put_comma(items, kind)
         last_item = items.last
         return if last_item.block_pass_type?
 
@@ -169,11 +167,6 @@ module RuboCop
         range_between(expr.begin_pos + ix, expr.end_pos)
       end
 
-      # By default, there's no reason to avoid auto-correct.
-      def avoid_autocorrect?(_nodes)
-        false
-      end
-
       def any_heredoc?(items)
         items.any? { |item| heredoc?(item) }
       end

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

@@ -10,7 +10,7 @@ module RuboCop
       # directive. It can be configured to allow for memoized instance variables
       # prefixed with an underscore. Prefixing ivars with an underscore is a
       # convention that is used to implicitly indicate that an ivar should not
-      # be set or referencd outside of the memoization method.
+      # be set or referenced outside of the memoization method.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad

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