rubocop 0.75.1 → 0.80.0

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])
@@ -429,12 +432,13 @@ module RuboCop
         [0..Float::INFINITY, 'true']
       end
 
+      # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/MethodLength
       def compile_any_order(capture_all = nil)
         rest = capture_rest = nil
         patterns = []
         with_temp_variables do |child, matched|
-          tokens_until('>', 'any child').each do
+          tokens_until('>', 'any child') do
             fail_due_to 'ellipsis must be at the end of <>' if rest
             token = tokens.shift
             case token
@@ -448,6 +452,7 @@ module RuboCop
         end
       end
       # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
 
       def insure_same_captures(enum, what)
         return to_enum __method__, enum, what unless block_given?
@@ -464,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 }
 
@@ -494,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'
@@ -501,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
 
@@ -558,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")
@@ -794,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

@@ -255,21 +255,27 @@ module RuboCop
       @options = options
     end
 
+    def validate_cop_options
+      %i[only except].each do |opt|
+        OptionsValidator.validate_cop_list(@options[opt])
+      end
+    end
+
     # rubocop:disable Metrics/AbcSize
     def validate_compatibility # rubocop:disable Metrics/MethodLength
-      if only_includes_unneeded_disable?
-        raise OptionArgumentError, 'Lint/UnneededCopDisableDirective can not ' \
+      if only_includes_redundant_disable?
+        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
@@ -323,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|
@@ -332,10 +338,10 @@ module RuboCop
       end
     end
 
-    def only_includes_unneeded_disable?
+    def only_includes_redundant_disable?
       @options.key?(:only) &&
-        (@options[:only] & %w[Lint/UnneededCopDisableDirective
-                              UnneededCopDisableDirective]).any?
+        (@options[:only] & %w[Lint/RedundantCopDisableDirective
+                              RedundantCopDisableDirective]).any?
     end
 
     def display_only_fail_level_offenses_with_autocorrect?
@@ -367,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 = {
@@ -449,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
 

data/lib/rubocop/rake_task.rb

@@ -70,6 +70,7 @@ module RuboCop
           RakeFileUtils.verbose(verbose) do
             yield(*[self, task_args].slice(0, task_block.arity)) if block_given?
             options = full_options.unshift('--auto-correct')
+            options.delete('--parallel')
             run_cli(verbose, options)
           end
         end

data/lib/rubocop/result_cache.rb

@@ -77,12 +77,13 @@ module RuboCop
       config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
     end
 
-    def initialize(file, options, config_store, cache_root = nil)
+    def initialize(file, team, options, config_store, cache_root = nil)
       cache_root ||= ResultCache.cache_root(config_store)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root, rubocop_checksum,
-                        relevant_options_digest(options),
+      @path = File.join(cache_root,
+                        rubocop_checksum,
+                        context_checksum(team, options),
                         file_checksum(file, config_store))
       @cached_data = CachedData.new(file)
     end
@@ -100,7 +101,7 @@ module RuboCop
 
       begin
         FileUtils.mkdir_p(dir)
-      rescue Errno::EACCES => e
+      rescue Errno::EACCES, Errno::EROFS => e
         warn "Couldn't create cache directory. Continuing without cache."\
              "\n  #{e.message}"
         return
@@ -182,10 +183,25 @@ module RuboCop
     # don't affect caching.
     def relevant_options_digest(options)
       options = options.reject { |key, _| NON_CHANGING.include?(key) }
-      options = options.to_s.gsub(/[^a-z]+/i, '_')
-      # We must avoid making file names too long for some filesystems to handle
-      # If they are short, we can leave them human-readable
-      options.length <= 32 ? options : Digest::SHA1.hexdigest(options)
+      options.to_s.gsub(/[^a-z]+/i, '_')
+    end
+
+    # The external dependency checksums are cached per RuboCop team so that
+    # the checksums don't need to be recomputed for each file.
+    def team_checksum(team)
+      @checksum_by_team ||= {}
+      @checksum_by_team[team.object_id] ||= team.external_dependency_checksum
+    end
+
+    # We combine team and options into a single "context" checksum to avoid
+    # making file names that are too long for some filesystems to handle.
+    # This context is for anything that's not (1) the RuboCop executable
+    # checksum or (2) the inspected file checksum.
+    def context_checksum(team, options)
+      Digest::SHA1.hexdigest([
+        team_checksum(team),
+        relevant_options_digest(options)
+      ].join)
     end
   end
 end