rubocop 0.79.0 → 0.83.0

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

@@ -33,8 +33,6 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return false if target_ruby_version <= 2.3
-
           lambda do |corrector|
             corrector.replace(node.loc.name, 'Integer')
           end

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

@@ -38,9 +38,34 @@ module RuboCop
       #   def do_something(unused)
       #   end
       #
+      # @example IgnoreNotImplementedMethods: true (default)
+      #   # good
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
+      # @example IgnoreNotImplementedMethods: false
+      #   # bad
+      #   def do_something(unused)
+      #     raise NotImplementedError
+      #   end
+      #
+      #   def do_something_else(unused)
+      #     fail "TODO"
+      #   end
+      #
       class UnusedMethodArgument < Cop
         include UnusedArgument
 
+        def_node_matcher :not_implemented?, <<~PATTERN
+          {(send nil? :raise (const nil? :NotImplementedError))
+           (send nil? :fail ...)}
+        PATTERN
+
         def autocorrect(node)
           UnusedArgCorrector.correct(processed_source, node)
         end
@@ -51,16 +76,17 @@ module RuboCop
           return unless variable.method_argument?
           return if variable.keyword_argument? &&
                     cop_config['AllowUnusedKeywordArguments']
-
-          if cop_config['IgnoreEmptyMethods']
-            body = variable.scope.node.body
-
-            return if body.nil?
-          end
+          return if ignored_method?(variable.scope.node.body)
 
           super
         end
 
+        def ignored_method?(body)
+          cop_config['IgnoreEmptyMethods'] && body.nil? ||
+            cop_config['IgnoreNotImplementedMethods'] &&
+              not_implemented?(body)
+        end
+
         def message(variable)
           message = +"Unused method argument - `#{variable.name}`."
 

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

@@ -21,7 +21,7 @@ module RuboCop
         def_node_matcher :uri_regexp_with_argument?, <<~PATTERN
           (send
             (const ${nil? cbase} :URI) :regexp
-            (str $_))
+            ${(str _) (array ...)})
         PATTERN
 
         def_node_matcher :uri_regexp_without_argument?, <<~PATTERN
@@ -32,7 +32,7 @@ module RuboCop
         def on_send(node)
           uri_regexp_with_argument?(node) do |double_colon, arg|
             register_offense(
-              node, top_level: double_colon ? '::' : '', arg: "('#{arg}')"
+              node, top_level: double_colon ? '::' : '', arg: "(#{arg.source})"
             )
           end
 
@@ -51,10 +51,10 @@ module RuboCop
             double_colon, arg = captured_values
 
             top_level = double_colon ? '::' : ''
-            argument = arg ? "('#{arg}')" : ''
+            argument = arg ? "(#{arg.source})" : ''
 
             corrector.replace(
-              node.loc.expression,
+              node,
               "#{top_level}URI::DEFAULT_PARSER.make_regexp#{argument}"
             )
           end

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

@@ -125,6 +125,8 @@ module RuboCop
       #     delegate :method_a, to: :method_b
       #   end
       class UselessAccessModifier < Cop
+        include RangeHelp
+
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
@@ -145,6 +147,16 @@ module RuboCop
           check_node(node.children[1]) # singleton class body
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.remove(range)
+          end
+        end
+
         private
 
         def_node_matcher :static_method_definition?, <<~PATTERN

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

@@ -31,7 +31,6 @@ module RuboCop
       #     do_something(some_var)
       #   end
       class UselessAssignment < Cop
-        include NameSimilarity
         MSG = 'Useless assignment to variable - `%<variable>s`.'
 
         def join_force?(force_class)
@@ -94,7 +93,9 @@ module RuboCop
         end
 
         def similar_name_message(variable)
-          similar_name = find_similar_name(variable.name, variable.scope)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name,
+                                                          variable_like_names)
           " Did you mean `#{similar_name}`?" if similar_name
         end
 

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

@@ -40,6 +40,11 @@ module RuboCop
           diagnostic.reason == :useless_else
         end
 
+        def find_offense_node_by(diagnostic)
+          # TODO: When implementing auto-correction, this method should return
+          # an offense node passed as first argument of `add_offense` method.
+        end
+
         def alternative_message(_diagnostic)
           MSG
         end

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

@@ -14,19 +14,24 @@ module RuboCop
           /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
 
         # The token that makes up a disable comment.
-        # The token used after `# rubocop: disable` are `A-z`, `/`, and `,`.
-        # Also `A-z` includes `all`.
-        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z/,]+}.freeze
+        # The allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-z]+/[A-z]+|all}.freeze
 
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment.text !~ DISABLE_COMMENT_FORMAT
 
             offset = Regexp.last_match(1).length
-            Regexp.last_match(4).scan(%r{[\w/]+|\W+}) do |name|
-              break unless valid_content_token?(name.strip)
 
-              check_cop_name(name, comment, offset)
+            Regexp.last_match(4).scan(/[^,]+|[\W]+/) do |name|
+              trimmed_name = name.strip
+
+              break if contain_plain_comment?(trimmed_name)
+
+              unless valid_content_token?(trimmed_name)
+                check_cop_name(trimmed_name, comment, offset)
+              end
 
               offset += name.length
             end
@@ -35,23 +40,44 @@ 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
 
         private
 
-        def check_cop_name(name, comment, offset)
-          return if name !~ /^[A-Z]/ || name =~ %r{/}
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
 
+        def check_cop_name(name, comment, offset)
           start = comment.location.expression.begin_pos + offset
           range = range_between(start, start + name.length)
+
           add_offense(range, location: range)
         end
 
         def valid_content_token?(content_token)
-          !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+          !/\W+/.match(content_token).nil? ||
+            !DISABLING_COPS_CONTENT_TOKEN.match(content_token).nil?
+        end
+
+        def contain_plain_comment?(name)
+          name == '#'
+        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

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/end_keyword_alignment.rb

@@ -20,7 +20,7 @@ module RuboCop
         return if ignored_node?(node)
 
         end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
+        return if accept_end_kw_alignment?(end_loc)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -49,6 +49,11 @@ module RuboCop
         add_offense(node, location: end_loc, message: msg)
       end
 
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          processed_source.lines[end_loc.line - 1] !~ /\A[ \t]*end/
+      end
+
       def style_parameter_name
         'EnforcedStyleAlignWith'
       end

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

@@ -39,8 +39,23 @@ 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)
+        first_non_comment_token = processed_source.tokens.find do |token|
+          !token.comment?
+        end
+
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...first_non_comment_token.line - 1]
+        else
+          processed_source.lines
+        end
       end
     end
   end

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

@@ -0,0 +1,178 @@
+# 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)
+        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 = 0
+
+          unless node.parent&.block_type?
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          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,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end