rubocop 0.78.0 → 0.82.0

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

@@ -29,7 +29,7 @@ module RuboCop
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError # rubocop:disable Lint/SuppressedException
+        rescue IndexError
           # range is not on a valid line; perhaps the source file is empty
         end
       end

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/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

@@ -56,7 +56,7 @@ module RuboCop
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError # rubocop:disable Lint/SuppressedException
+        rescue IndexError
           # range is not on a valid line; perhaps the source file is empty
         end
       end

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)
@@ -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

@@ -154,6 +154,7 @@ module RuboCop
       end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
@@ -162,6 +163,8 @@ module RuboCop
       option(opts, '-E', '--extra-details')
       option(opts, '-S', '--display-style-guide')
       option(opts, '-a', '--auto-correct')
+      option(opts, '--disable-pending-cops')
+      option(opts, '--enable-pending-cops')
       option(opts, '--ignore-disable-comments')
 
       option(opts, '--safe')
@@ -172,6 +175,7 @@ module RuboCop
       option(opts, '-V', '--verbose-version')
       option(opts, '-P', '--parallel')
     end
+    # rubocop:enable Metrics/MethodLength
 
     def add_aliases(opts)
       option(opts, '-l', '--lint') do
@@ -362,7 +366,7 @@ module RuboCop
     end
 
     def validate_exclude_limit_option
-      return if @options[:exclude_limit] =~ /^\d+$/
+      return if /^\d+$/.match?(@options[:exclude_limit])
 
       # Emulate OptionParser's behavior to make failures consistent regardless
       # of option order.
@@ -438,7 +442,9 @@ module RuboCop
       debug:                            'Display debug info.',
       display_cop_names:                ['Display cop names in offense messages.',
                                          'Default is true.'],
+      disable_pending_cops:             'Run without pending cops.',
       display_style_guide:              'Display style guide URLs in offense messages.',
+      enable_pending_cops:              'Run with pending cops.',
       extra_details:                    'Display extra details in offense messages.',
       lint:                             'Run only lint cops.',
       safe:                             'Run only safe cops.',

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/SuppressedException
+      rescue Parser::SyntaxError
         # All errors are in diagnostics. No need to handle exception.
       end
 
@@ -175,9 +175,6 @@ module RuboCop
     # rubocop:disable Metrics/MethodLength
     def parser_class(ruby_version)
       case ruby_version
-      when 2.3
-        require 'parser/ruby23'
-        Parser::Ruby23
       when 2.4
         require 'parser/ruby24'
         Parser::Ruby24

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,7 +6,7 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { 2.3 }
+  let(:ruby_version) { 2.4 }
   let(:rails_version) { false }
 
   def inspect_source_file(source)

data/lib/rubocop/rspec/expect_offense.rb

@@ -153,7 +153,7 @@ module RuboCop
           annotations = []
 
           annotated_source.each_line do |source_line|
-            if source_line =~ ANNOTATION_PATTERN
+            if ANNOTATION_PATTERN.match?(source_line)
               annotations << [source.size, source_line]
             else
               source << source_line

data/lib/rubocop/rspec/shared_contexts.rb

@@ -52,6 +52,7 @@ RSpec.shared_context 'config', :config do
       cop_name = described_class.cop_name
       hash[cop_name] = RuboCop::ConfigLoader
                        .default_configuration[cop_name]
+                       .merge('Enabled' => true) # in case it is 'pending'
                        .merge(cop_config)
     end
 
@@ -73,10 +74,6 @@ RSpec.shared_context 'mock console output' do
   end
 end
 
-RSpec.shared_context 'ruby 2.3', :ruby23 do
-  let(:ruby_version) { 2.3 }
-end
-
 RSpec.shared_context 'ruby 2.4', :ruby24 do
   let(:ruby_version) { 2.4 }
 end
@@ -88,3 +85,7 @@ end
 RSpec.shared_context 'ruby 2.6', :ruby26 do
   let(:ruby_version) { 2.6 }
 end
+
+RSpec.shared_context 'ruby 2.7', :ruby27 do
+  let(:ruby_version) { 2.7 }
+end

data/lib/rubocop/runner.rb

@@ -314,7 +314,7 @@ module RuboCop
 
         cop_classes.reject! { |c| c.match?(@options[:except]) }
 
-        Cop::Registry.new(cop_classes)
+        Cop::Registry.new(cop_classes, @options)
       end
     end
 

data/lib/rubocop/target_ruby.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The kind of Ruby that code inspected by RuboCop is written in.
+  class TargetRuby
+    KNOWN_RUBIES = [2.4, 2.5, 2.6, 2.7].freeze
+    DEFAULT_VERSION = KNOWN_RUBIES.first
+
+    OBSOLETE_RUBIES = {
+      1.9 => '0.50', 2.0 => '0.50', 2.1 => '0.58', 2.2 => '0.69', 2.3 => '0.82'
+    }.freeze
+    private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
+
+    # A place where information about a target ruby version is found.
+    class Source
+      attr_reader :version, :name
+
+      def initialize(config)
+        @config = config
+        @version = find_version
+      end
+
+      def to_s
+        name
+      end
+    end
+
+    # The target ruby version may be configured in RuboCop's config.
+    class RuboCopConfig < Source
+      def name
+        "`TargetRubyVersion` parameter (in #{@config.smart_loaded_path})"
+      end
+
+      private
+
+      def find_version
+        @config.for_all_cops['TargetRubyVersion']&.to_f
+      end
+    end
+
+    # The target ruby version may be found in a .ruby-version file.
+    class RubyVersionFile < Source
+      FILENAME = '.ruby-version'
+
+      def name
+        "`#{FILENAME}`"
+      end
+
+      private
+
+      def find_version
+        file = ruby_version_file
+        return unless file && File.file?(file)
+
+        File.read(file).match(/\A(ruby-)?(?<version>\d+\.\d+)/) do |md|
+          md[:version].to_f
+        end
+      end
+
+      def ruby_version_file
+        @ruby_version_file ||=
+          @config.find_file_upwards(FILENAME,
+                                    @config.base_dir_for_path_parameters)
+      end
+    end
+
+    # The lock file of Bundler may identify the target ruby version.
+    class BundlerLockFile < Source
+      def name
+        "`#{bundler_lock_file_path}`"
+      end
+
+      private
+
+      def find_version
+        lock_file_path = bundler_lock_file_path
+        return nil unless lock_file_path
+
+        in_ruby_section = false
+        File.foreach(lock_file_path) do |line|
+          # If ruby is in Gemfile.lock or gems.lock, there should be two lines
+          # towards the bottom of the file that look like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ
+          # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
+          # extra logic to make sure we only start looking once we've seen the
+          # "RUBY VERSION" line.
+          in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
+          next unless in_ruby_section
+
+          # We currently only allow this feature to work with MRI ruby. If
+          # jruby (or something else) is used by the project, it's lock file
+          # will have a line that looks like:
+          #     RUBY VERSION
+          #       ruby W.X.YpZ (jruby x.x.x.x)
+          # The regex won't match in this situation.
+          result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
+          return result.captures.first.to_f if result
+        end
+      end
+
+      def bundler_lock_file_path
+        @config.bundler_lock_file_path
+      end
+    end
+
+    # If all else fails, a default version will be picked.
+    class Default < Source
+      def name
+        'default'
+      end
+
+      private
+
+      def find_version
+        DEFAULT_VERSION
+      end
+    end
+
+    def self.supported_versions
+      KNOWN_RUBIES
+    end
+
+    SOURCES = [RuboCopConfig, RubyVersionFile, BundlerLockFile, Default].freeze
+    private_constant :SOURCES
+
+    def initialize(config)
+      @config = config
+    end
+
+    def source
+      @source ||= SOURCES.each.lazy.map { |c| c.new(@config) }.detect(&:version)
+    end
+
+    def version
+      source.version
+    end
+
+    def supported?
+      KNOWN_RUBIES.include?(version)
+    end
+
+    def rubocop_version_with_support
+      if supported?
+        RuboCop::Version.version
+      else
+        OBSOLETE_RUBIES[version]
+      end
+    end
+  end
+end