rubocop 0.76.0 → 0.80.1

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

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/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/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,16 +24,14 @@ module RuboCop
           message: message(offense)
         )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
+        rescue IndexError # rubocop:disable Lint/SuppressedException
           # 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

@@ -17,6 +17,7 @@ module RuboCop
         '[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,63 @@
+# 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)
+        offenses.group_by(&:cop_name).each do |cop_name, grouped_offenses|
+          REXML::Element.new('testcase', @testsuite).tap do |testcase|
+            testcase.attributes['classname'] = file.gsub(
+              /\.rb\Z/, ''
+            ).gsub("#{Dir.pwd}/", '').tr('/', '.')
+            testcase.attributes['name'] = cop_name
+
+            add_failure_to(testcase, grouped_offenses, cop_name)
+          end
+        end
+      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/tap_formatter.rb

@@ -51,16 +51,14 @@ module RuboCop
           message: message(offense)
         )
 
-        # rubocop:disable Lint/HandleExceptions
         begin
           return unless valid_line?(offense)
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError
+        rescue IndexError # rubocop:disable Lint/SuppressedException
           # 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/node_pattern.rb

@@ -78,6 +78,8 @@ module RuboCop
   #                         # matching process starts
   #     '^^send'            # each ^ ascends one level in the AST
   #                         # so this matches against the grandparent node
+  #     '`send'             # descends any number of level in the AST
+  #                         # so this matches against any descendant node
   #     '#method'           # we call this a 'funcall'; it calls a method in the
   #                         # context where a pattern-matching method is defined
   #                         # if that returns a truthy value, the match succeeds
@@ -112,7 +114,7 @@ module RuboCop
       SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}.freeze
       IDENTIFIER   = /[a-zA-Z_][a-zA-Z0-9_-]*/.freeze
       META         = Regexp.union(
-        %w"( ) { } [ ] $< < > $... $ ! ^ ... + * ?"
+        %w"( ) { } [ ] $< < > $... $ ! ^ ` ... + * ?"
       ).freeze
       NUMBER       = /-?\d+(?:\.\d+)?/.freeze
       STRING       = /".+?"/.freeze
@@ -188,7 +190,7 @@ module RuboCop
 
         @temps    = 0  # avoid name clashes between temp variables
         @captures = 0  # number of captures seen
-        @unify    = {} # named wildcard -> temp variable number
+        @unify    = {} # named wildcard -> temp variable
         @params   = 0  # highest % (param) number seen
         run(node_var)
       end
@@ -223,6 +225,7 @@ module RuboCop
         when '!'       then compile_negation
         when '$'       then compile_capture
         when '^'       then compile_ascend
+        when '`'       then compile_descend
         when WILDCARD  then compile_wildcard(token[1..-1])
         when FUNCALL   then compile_funcall(token)
         when LITERAL   then compile_literal(token)
@@ -380,7 +383,7 @@ module RuboCop
         def compile_seq_head
           return unless seq_head?
 
-          fail_due_to 'sequences can not start with <' \
+          fail_due_to 'sequences cannot start with <' \
             if @terms[0].respond_to? :call
 
           with_seq_head_context(@terms[0])
@@ -466,12 +469,67 @@ module RuboCop
         end
       end
 
+      def access_unify(name)
+        var = @unify[name]
+
+        if var == :forbidden_unification
+          fail_due_to "Wildcard #{name} was first seen in a subset of a" \
+                      " union and can't be used outside that union"
+        end
+        var
+      end
+
+      def forbid_unification(*names)
+        names.each do |name|
+          @unify[name] = :forbidden_unification
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def unify_in_union(enum)
+        # We need to reset @unify before each branch is processed.
+        # Moreover we need to keep track of newly encountered wildcards.
+        # Var `new_unify_intersection` will hold those that are encountered
+        # in all branches; these are not a problem.
+        # Var `partial_unify` will hold those encountered in only a subset
+        # of the branches; these can't be used outside of the union.
+
+        return to_enum __method__, enum unless block_given?
+
+        new_unify_intersection = nil
+        partial_unify = []
+        unify_before = @unify.dup
+
+        result = enum.each do |e|
+          @unify = unify_before.dup if new_unify_intersection
+          yield e
+          new_unify = @unify.keys - unify_before.keys
+          if new_unify_intersection.nil?
+            # First iteration
+            new_unify_intersection = new_unify
+          else
+            union = new_unify_intersection | new_unify
+            new_unify_intersection &= new_unify
+            partial_unify |= union - new_unify_intersection
+          end
+        end
+
+        # At this point, all members of `new_unify_intersection` can be used
+        # for unification outside of the union, but partial_unify may not
+
+        forbid_unification(*partial_unify)
+
+        result
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
       def compile_union
         # we need to ensure that each branch of the {} contains the same
         # number of captures (since only one branch of the {} can actually
         # match, the same variables are used to hold the captures for each
         # branch)
         enum = tokens_until('}', 'union')
+        enum = unify_in_union(enum)
         terms = insure_same_captures(enum, 'branch of {}')
                 .map { compile_expr }
 
@@ -496,6 +554,19 @@ module RuboCop
         with_context("#{CUR_NODE} && #{compile_expr}", "#{CUR_NODE}.parent")
       end
 
+      def compile_descend
+        with_temp_variables do |descendant|
+          pattern = with_context(compile_expr, descendant,
+                                 use_temp_node: false)
+          [
+            "RuboCop::NodePattern.descend(#{CUR_ELEMENT}).",
+            "any? do |#{descendant}|",
+            "  #{pattern}",
+            'end'
+          ].join("\n")
+        end
+      end
+
       def compile_wildcard(name)
         if name.empty?
           'true'
@@ -503,12 +574,12 @@ module RuboCop
           # we have already seen a wildcard with this name before
           # so the value it matched the first time will already be stored
           # in a temp. check if this value matches the one stored in the temp
-          "#{CUR_ELEMENT} == temp#{@unify[name]}"
+          "#{CUR_ELEMENT} == #{access_unify(name)}"
         else
-          n = @unify[name] = next_temp_value
-          # double assign to temp#{n} to avoid "assigned but unused variable"
-          "(temp#{n} = #{CUR_ELEMENT}; " \
-          "temp#{n} = temp#{n}; true)"
+          n = @unify[name] = "unify_#{name.gsub('-', '__')}"
+          # double assign to avoid "assigned but unused variable"
+          "(#{n} = #{CUR_ELEMENT}; " \
+          "#{n} = #{n}; true)"
         end
       end
 
@@ -560,9 +631,8 @@ module RuboCop
       def compile_arg(token)
         case token
         when WILDCARD  then
-          name   = token[1..-1]
-          number = @unify[name] || fail_due_to('invalid in arglist: ' + token)
-          "temp#{number}"
+          name = token[1..-1]
+          access_unify(name) || fail_due_to('invalid in arglist: ' + token)
         when LITERAL   then token
         when PARAM     then get_param(token[1..-1])
         when CLOSING   then fail_due_to("#{token} in invalid position")
@@ -796,6 +866,22 @@ module RuboCop
     def to_s
       "#<#{self.class} #{pattern}>"
     end
+
+    # Yields its argument and any descendants, depth-first.
+    #
+    def self.descend(element, &block)
+      return to_enum(__method__, element) unless block_given?
+
+      yield element
+
+      if element.is_a?(::RuboCop::AST::Node)
+        element.children.each do |child|
+          descend(child, &block)
+        end
+      end
+
+      nil
+    end
   end
 end
 # rubocop:enable Metrics/ClassLength, Metrics/CyclomaticComplexity

data/lib/rubocop/options.rb

@@ -264,18 +264,18 @@ module RuboCop
     # rubocop:disable Metrics/AbcSize
     def validate_compatibility # rubocop:disable Metrics/MethodLength
       if only_includes_redundant_disable?
-        raise OptionArgumentError, 'Lint/RedundantCopDisableDirective can ' \
-                                   'not be used with --only.'
+        raise OptionArgumentError, 'Lint/RedundantCopDisableDirective cannot ' \
+                                   'be used with --only.'
       end
       if except_syntax?
-        raise OptionArgumentError, 'Syntax checking can not be turned off.'
+        raise OptionArgumentError, 'Syntax checking cannot be turned off.'
       end
       unless boolean_or_empty_cache?
         raise OptionArgumentError, '-C/--cache argument must be true or false'
       end
 
       if display_only_fail_level_offenses_with_autocorrect?
-        raise OptionArgumentError, '--autocorrect can not be used with ' \
+        raise OptionArgumentError, '--autocorrect cannot be used with ' \
           '--display-only-fail-level-offenses'
       end
       validate_auto_gen_config
@@ -329,8 +329,8 @@ module RuboCop
         auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
                          'while --auto-gen-config needs a non-cached run, ' \
                          'so they cannot be combined.',
-        fail_fast: '-P/--parallel can not be combined with -F/--fail-fast.',
-        auto_correct: '-P/--parallel can not be combined with --auto-correct.'
+        fail_fast: '-P/--parallel cannot be combined with -F/--fail-fast.',
+        auto_correct: '-P/--parallel cannot be combined with --auto-correct.'
       }
 
       combos.each do |key, msg|
@@ -373,7 +373,7 @@ module RuboCop
   # This module contains help texts for command line options.
   module OptionsHelp
     MAX_EXCL = RuboCop::Options::DEFAULT_MAXIMUM_EXCLUSION_ITEMS.to_s
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     FORMATTER_OPTION_LIST = RuboCop::Formatter::FormatterSet::BUILTIN_FORMATTERS_FOR_KEYS.keys
 
     TEXT = {
@@ -455,6 +455,6 @@ module RuboCop
                                          'reports. This is useful for editor integration.'],
       init:                             'Generate a .rubocop.yml file in the current directory.'
     }.freeze
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 end

data/lib/rubocop/processed_source.rb

@@ -163,7 +163,7 @@ module RuboCop
         ast, comments, tokens = parser.tokenize(@buffer)
 
         ast.respond_to?(:complete!) && ast.complete!
-      rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
+      rescue Parser::SyntaxError # rubocop:disable Lint/SuppressedException
         # All errors are in diagnostics. No need to handle exception.
       end