rubocop 0.76.0 → 0.83.0

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

@@ -4,12 +4,23 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in array literals.
+      # The configuration options are:
+      #
+      # - `consistent_comma`: Requires a comma after the
+      # last item of all non-empty, multiline array literals.
+      # - `comma`: Requires a comma after last item in an array,
+      # but only when each item is on its own line.
+      # - `no_comma`: Does not requires a comma after the
+      # last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma
       #   # bad
       #   a = [1, 2,]
       #
       #   # good
+      #   a = [1, 2]
+      #
+      #   # good
       #   a = [
       #     1, 2,
       #     3,
@@ -17,6 +28,11 @@ module RuboCop
       #
       #   # good
       #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
       #     1,
       #     2,
       #   ]
@@ -26,6 +42,31 @@ module RuboCop
       #   a = [1, 2,]
       #
       #   # good
+      #   a = [1, 2]
+      #
+      #   # bad
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2,
+      #     3
+      #   ]
+      #
+      #   # bad
+      #   a = [
+      #     1, 2, 3,
+      #   ]
+      #
+      #   # good
+      #   a = [
+      #     1, 2, 3
+      #   ]
+      #
+      #   # good
       #   a = [
       #     1,
       #     2,

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether trailing commas in block arguments are
+      # required. Blocks with only one argument and a trailing comma require
+      # that comma to be present. Blocks with more than one argument never
+      # require a trailing comma.
+      #
+      # @example
+      #   # bad
+      #   add { |foo, bar,| foo + bar }
+      #
+      #    # good
+      #   add { |foo, bar| foo + bar }
+      #
+      #   # good
+      #   add { |foo,| foo }
+      #
+      #   # good
+      #   add { foo }
+      #
+      #   # bad
+      #  add do |foo, bar,|
+      #    foo + bar
+      #   end
+      #
+      #  # good
+      #  add do |foo, bar|
+      #    foo + bar
+      #  end
+      #
+      #  # good
+      #   add do |foo,|
+      #    foo
+      #  end
+      #
+      #  # good
+      #  add do
+      #     foo + bar
+      #  end
+      class TrailingCommaInBlockArgs < Cop
+        MSG = 'Useless trailing comma present in block arguments.'
+
+        def on_block(node)
+          # lambda literal (`->`) never has block arguments.
+          return if node.send_node.lambda_literal?
+
+          return unless useless_trailing_comma?(node)
+
+          add_offense(node, location: last_comma(node).pos)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(last_comma(node).pos, '') }
+        end
+
+        private
+
+        def useless_trailing_comma?(node)
+          arg_count(node) > 1 && trailing_comma?(node)
+        end
+
+        def arg_count(node)
+          node.arguments.each_descendant(:arg, :optarg, :kwoptarg).to_a.size
+        end
+
+        def trailing_comma?(node)
+          argument_tokens(node).last.comma?
+        end
+
+        def last_comma(node)
+          argument_tokens(node).last
+        end
+
+        def argument_tokens(node)
+          pipes = tokens(node).select { |token| token.type == :tPIPE }
+          begin_pos, end_pos = pipes.map do |pipe|
+            tokens(node).index(pipe)
+          end
+
+          tokens(node)[begin_pos + 1..end_pos - 1]
+        end
+      end
+    end
+  end
+end

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

@@ -4,12 +4,24 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in hash literals.
+      # The configuration options are:
+      #
+      # - `consistent_comma`: Requires a comma after the
+      # last item of all non-empty, multiline hash literals.
+      # - `comma`: Requires a comma after the last item in a hash,
+      # but only when each item is on its own line.
+      # - `no_comma`: Does not requires a comma after the
+      # last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #
       #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # good
       #   a = {
       #     foo: 1, bar: 2,
       #     qux: 3,
@@ -17,21 +29,53 @@ module RuboCop
       #
       #   # good
       #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
       #     foo: 1,
       #     bar: 2,
       #   }
       #
       # @example EnforcedStyleForMultiline: comma
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #
       #   # good
+      #   a = { foo: 1, bar: 2 }
+      #
+      #   # bad
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2,
+      #     qux: 3
+      #   }
+      #
+      #   # bad
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3,
+      #   }
+      #
+      #   # good
+      #   a = {
+      #     foo: 1, bar: 2, qux: 3
+      #   }
+      #
+      #   # good
       #   a = {
       #     foo: 1,
       #     bar: 2,
       #   }
       #
       # @example EnforcedStyleForMultiline: no_comma (default)
+      #
       #   # bad
       #   a = { foo: 1, bar: 2, }
       #

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

@@ -20,8 +20,14 @@ module RuboCop
       #   a, *b, _ = foo()
       #   # => The correction `a, *b, = foo()` is a syntax error
       #
-      #   # good if AllowNamedUnderscoreVariables is true
+      # @example AllowNamedUnderscoreVariables: true (default)
+      #   # good
       #   a, b, _something = foo()
+      #
+      # @example AllowNamedUnderscoreVariables: false
+      #   # bad
+      #   a, b, _something = foo()
+      #
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
         include RangeHelp

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

@@ -60,7 +60,7 @@ module RuboCop
             when :module
               return true
             else
-              return true if pnode.method_name == :instance_eval
+              return true if pnode.method?(:instance_eval)
             end
           end
           false
@@ -95,9 +95,9 @@ module RuboCop
           cop_config['IgnoreClassMethods']
         end
 
-        def whitelist
-          whitelist = cop_config['Whitelist']
-          Array(whitelist).map(&:to_sym) + [:initialize]
+        def allowed_methods
+          allowed_methods = cop_config['AllowedMethods']
+          Array(allowed_methods).map(&:to_sym) + [:initialize]
         end
 
         def dsl_writer?(method_name)
@@ -124,7 +124,7 @@ module RuboCop
         PATTERN
 
         def allowed_method?(node)
-          whitelist.include?(node.method_name) ||
+          allowed_methods.include?(node.method_name) ||
             exact_name_match? && !names_match?(node)
         end
 
@@ -161,7 +161,7 @@ module RuboCop
           return unless names_match?(node) && !node.predicate_method? && kind
 
           lambda do |corrector|
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               accessor(kind, node.method_name))
           end
         end

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

@@ -18,10 +18,6 @@ module RuboCop
       #   'foo'.unpack1('h*')
       #
       class UnpackFirst < Cop
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
-
         MSG = 'Use `%<receiver>s.unpack1(%<format>s)` instead of '\
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
 

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

@@ -29,7 +29,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
+            corrector.replace(node, "{#{node.source}}")
           end
         end
 

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # Checks for while and until statements that would fit on one line
       # if written as a modifier while/until. The maximum line length is
-      # configured in the `Metrics/LineLength` cop.
+      # configured in the `Layout/LineLength` cop.
       #
       # @example
       #   # bad
@@ -43,7 +43,7 @@ module RuboCop
                     "#{node.condition.source}"
 
           lambda do |corrector|
-            corrector.replace(node.source_range, oneline)
+            corrector.replace(node, oneline)
           end
         end
 

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

@@ -93,7 +93,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+            corrector.replace(node, "[#{words.join(', ')}]")
           end
         end
       end

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

@@ -67,9 +67,16 @@ module RuboCop
 
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
 
+        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+
+        def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
+          (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
+        PATTERN
+
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node)
+          return if equality_only? && non_equality_operator?(node) ||
+                    file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node)
         end
@@ -135,6 +142,14 @@ module RuboCop
         def noncommutative_operator?(node)
           NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
+
+        def source_file_path_constant?(node)
+          node.source == '__FILE__'
+        end
+
+        def program_name?(name)
+          PROGRAM_NAMES.include?(name)
+        end
       end
     end
   end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement(node))
+            corrector.replace(node, replacement(node))
           end
         end
 

data/lib/rubocop/cop/team.rb

@@ -86,6 +86,11 @@ module RuboCop
         raise e.cause
       end
 
+      def external_dependency_checksum
+        keys = cops.map(&:external_dependency_checksum).compact
+        Digest::SHA1.hexdigest(keys.join)
+      end
+
       private
 
       def offenses(processed_source)

data/lib/rubocop/cop/util.rb

@@ -17,6 +17,10 @@ module RuboCop
         line_source =~ /^\s*#/
       end
 
+      def comment_lines?(node)
+        processed_source[line_range(node)].any? { |line| comment_line?(line) }
+      end
+
       def line_range(node)
         node.first_line..node.last_line
       end
@@ -26,6 +30,26 @@ module RuboCop
           node.loc.end.is?(')')
       end
 
+      def add_parentheses(node, corrector)
+        if node.arguments.empty?
+          corrector.insert_after(node, '()')
+        else
+          corrector.replace(args_begin(node), '(')
+          corrector.insert_after(args_end(node), ')')
+        end
+      end
+
+      def args_begin(node)
+        loc = node.loc
+        selector =
+          node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+        selector.end.resize(1)
+      end
+
+      def args_end(node)
+        node.loc.expression.end
+      end
+
       def on_node(syms, sexp, excludes = [], &block)
         return to_enum(:on_node, syms, sexp, excludes) unless block_given?
 

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -10,6 +10,7 @@ module RuboCop
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
 
         attr_reader :node, :variable, :referenced, :references
+
         alias referenced? referenced
 
         def initialize(node, variable)

data/lib/rubocop/cop/variable_force/scope.rb

@@ -16,6 +16,7 @@ module RuboCop
         }.freeze
 
         attr_reader :node, :variables, :naked_top_level
+
         alias naked_top_level? naked_top_level
 
         def initialize(node)

data/lib/rubocop/cop/variable_force/variable.rb

@@ -11,6 +11,7 @@ module RuboCop
 
         attr_reader :name, :declaration_node, :scope,
                     :assignments, :references, :captured_by_block
+
         alias captured_by_block? captured_by_block
 
         def initialize(name, declaration_node, scope)

data/lib/rubocop/cop/variable_force.rb

@@ -190,7 +190,10 @@ module RuboCop
       end
 
       def regexp_captured_names(node)
-        regexp_string = node.children[0].children[0] || ''
+        regexp_string = node.children.select(&:str_type?).map do |child|
+          child.children.first
+        end.join || ''
+
         regexp = Regexp.new(regexp_string)
 
         regexp.named_captures.keys

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/LineLength
+# rubocop:disable Layout/LineLength
 
 module RuboCop
   module Formatter
@@ -41,7 +41,7 @@ module RuboCop
     # * `#finished`
     #
     class BaseFormatter
-      # rubocop:enable Metrics/LineLength
+      # rubocop:enable Layout/LineLength
 
       # @api public
       #

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -24,7 +24,6 @@ module RuboCop
           message: message(offense)
         )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
@@ -33,7 +32,6 @@ module RuboCop
         rescue IndexError
           # range is not on a valid line; perhaps the source file is empty
         end
-        # rubocop:enable Lint/HandleExceptions
       end
 
       def valid_line?(offense)

data/lib/rubocop/formatter/formatter_set.rb

@@ -11,12 +11,12 @@ module RuboCop
       BUILTIN_FORMATTERS_FOR_KEYS = {
         '[a]utogenconf' => AutoGenConfigFormatter,
         '[c]lang'       => ClangStyleFormatter,
-        '[d]isabled'    => DisabledLinesFormatter,
         '[e]macs'       => EmacsStyleFormatter,
         '[fi]les'       => FileListFormatter,
         '[fu]ubar'      => FuubarStyleFormatter,
         '[h]tml'        => HTMLFormatter,
         '[j]son'        => JSONFormatter,
+        '[ju]nit'       => JUnitFormatter,
         '[o]ffenses'    => OffenseCountFormatter,
         '[pa]cman'      => PacmanFormatter,
         '[p]rogress'    => ProgressFormatter,

data/lib/rubocop/formatter/json_formatter.rb

@@ -53,11 +53,12 @@ module RuboCop
 
       def hash_for_offense(offense)
         {
-          severity:  offense.severity.name,
-          message:   offense.message,
-          cop_name:  offense.cop_name,
-          corrected: offense.corrected?,
-          location:  hash_for_location(offense)
+          severity:    offense.severity.name,
+          message:     offense.message,
+          cop_name:    offense.cop_name,
+          corrected:   offense.corrected?,
+          correctable: offense.correctable?,
+          location:    hash_for_location(offense)
         }
       end
 

data/lib/rubocop/formatter/junit_formatter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+#
+# This code is based on https://github.com/mikian/rubocop-junit-formatter.
+#
+# Copyright (c) 2015 Mikko Kokkonen
+#
+# MIT License
+#
+# https://github.com/mikian/rubocop-junit-formatter/blob/master/LICENSE.txt
+#
+module RuboCop
+  module Formatter
+    # This formatter formats the report data in JUnit format.
+    class JUnitFormatter < BaseFormatter
+      def initialize(output, options = {})
+        super
+
+        @document = REXML::Document.new.tap do |document|
+          document << REXML::XMLDecl.new
+        end
+        testsuites = REXML::Element.new('testsuites', @document)
+        testsuite = REXML::Element.new('testsuite', testsuites)
+        @testsuite = testsuite.tap do |element|
+          element.add_attributes('name' => 'rubocop')
+        end
+      end
+
+      def file_finished(file, offenses)
+        # TODO: Returns all cops with the same behavior as
+        # the original rubocop-junit-formatter.
+        # https://github.com/mikian/rubocop-junit-formatter/blob/v0.1.4/lib/rubocop/formatter/junit_formatter.rb#L9
+        #
+        # In the future, it would be preferable to return only enabled cops.
+        Cop::Cop.all.each do |cop|
+          REXML::Element.new('testcase', @testsuite).tap do |testcase|
+            testcase.attributes['classname'] = classname_attribute_value(file)
+            testcase.attributes['name'] = cop.cop_name
+
+            target_offenses = offenses.select do |offense|
+              offense.cop_name == cop.cop_name
+            end
+
+            add_failure_to(testcase, target_offenses, cop.cop_name)
+          end
+        end
+      end
+
+      def classname_attribute_value(file)
+        file.gsub(/\.rb\Z/, '').gsub("#{Dir.pwd}/", '').tr('/', '.')
+      end
+
+      def finished(_inspected_files)
+        @document.write(output, 2)
+      end
+
+      private
+
+      def add_failure_to(testcase, offenses, cop_name)
+        # One failure per offense. Zero failures is a passing test case,
+        # for most surefire/nUnit parsers.
+        offenses.each do |offense|
+          REXML::Element.new('failure', testcase).tap do |failure|
+            failure.attributes['type'] = cop_name
+            failure.attributes['message'] = offense.message
+            failure.add_text(offense.location.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -69,7 +69,7 @@ module RuboCop
         regex = /#{Regexp.quote(PACMAN)}|#{Regexp.quote(PACDOT)}/
         @progress_line = @progress_line.sub(regex, character)
         output.printf("%<line>s\r", line: @progress_line)
-        return unless @progress_line[-1] =~ /ᗣ|\./
+        return unless /ᗣ|\./.match?(@progress_line[-1])
 
         @repetitions += 1
         output.puts

data/lib/rubocop/formatter/tap_formatter.rb

@@ -51,7 +51,6 @@ module RuboCop
           message: message(offense)
         )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
@@ -60,7 +59,6 @@ module RuboCop
         rescue IndexError
           # range is not on a valid line; perhaps the source file is empty
         end
-        # rubocop:enable Lint/HandleExceptions
       end
 
       def annotate_message(msg)

data/lib/rubocop/name_similarity.rb

@@ -3,19 +3,22 @@
 module RuboCop
   # Common functionality for finding names that are similar to a given name.
   module NameSimilarity
-    MINIMUM_SIMILARITY_TO_SUGGEST = 0.9
+    module_function
 
-    def find_similar_name(target_name, scope)
-      names = collect_variable_like_names(scope)
+    def find_similar_name(target_name, names)
+      similar_names = find_similar_names(target_name, names)
+
+      similar_names.first
+    end
+
+    def find_similar_names(target_name, names)
+      names = names.dup
       names.delete(target_name)
 
-      scores = names.each_with_object({}) do |name, hash|
-        score = StringUtil.similarity(target_name, name)
-        hash[name] = score if score >= MINIMUM_SIMILARITY_TO_SUGGEST
-      end
+      spell_checker = DidYouMean::SpellChecker.new(dictionary: names)
+      similar_names = spell_checker.correct(target_name)
 
-      most_similar_name, _max_score = scores.max_by { |_, score| score }
-      most_similar_name
+      similar_names
     end
   end
 end