rubocop 0.76.0 → 0.79.0

data/lib/rubocop/ast/builder.rb

@@ -15,48 +15,49 @@ module RuboCop
     #   root_node = parser.parse(buffer)
     class Builder < Parser::Builders::Default
       NODE_MAP = {
-        and:        AndNode,
-        alias:      AliasNode,
-        args:       ArgsNode,
-        array:      ArrayNode,
-        block:      BlockNode,
-        break:      BreakNode,
-        case:       CaseNode,
-        class:      ClassNode,
-        def:        DefNode,
-        defined?:   DefinedNode,
-        defs:       DefNode,
-        ensure:     EnsureNode,
-        for:        ForNode,
-        float:      FloatNode,
-        hash:       HashNode,
-        if:         IfNode,
-        int:        IntNode,
-        irange:     RangeNode,
-        erange:     RangeNode,
-        kwsplat:    KeywordSplatNode,
-        module:     ModuleNode,
-        or:         OrNode,
-        pair:       PairNode,
-        regexp:     RegexpNode,
-        resbody:    ResbodyNode,
-        retry:      RetryNode,
-        return:     ReturnNode,
-        csend:      SendNode,
-        send:       SendNode,
-        str:        StrNode,
-        dstr:       StrNode,
-        xstr:       StrNode,
-        sclass:     SelfClassNode,
-        super:      SuperNode,
-        zsuper:     SuperNode,
-        sym:        SymbolNode,
-        until:      UntilNode,
-        until_post: UntilNode,
-        when:       WhenNode,
-        while:      WhileNode,
-        while_post: WhileNode,
-        yield:      YieldNode
+        and:          AndNode,
+        alias:        AliasNode,
+        args:         ArgsNode,
+        array:        ArrayNode,
+        block:        BlockNode,
+        break:        BreakNode,
+        case:         CaseNode,
+        class:        ClassNode,
+        def:          DefNode,
+        defined?:     DefinedNode,
+        defs:         DefNode,
+        ensure:       EnsureNode,
+        for:          ForNode,
+        forward_args: ForwardArgsNode,
+        float:        FloatNode,
+        hash:         HashNode,
+        if:           IfNode,
+        int:          IntNode,
+        irange:       RangeNode,
+        erange:       RangeNode,
+        kwsplat:      KeywordSplatNode,
+        module:       ModuleNode,
+        or:           OrNode,
+        pair:         PairNode,
+        regexp:       RegexpNode,
+        resbody:      ResbodyNode,
+        retry:        RetryNode,
+        return:       ReturnNode,
+        csend:        SendNode,
+        send:         SendNode,
+        str:          StrNode,
+        dstr:         StrNode,
+        xstr:         StrNode,
+        sclass:       SelfClassNode,
+        super:        SuperNode,
+        zsuper:       SuperNode,
+        sym:          SymbolNode,
+        until:        UntilNode,
+        until_post:   UntilNode,
+        when:         WhenNode,
+        while:        WhileNode,
+        while_post:   WhileNode,
+        yield:        YieldNode
       }.freeze
 
       # Generates {Node} from the given information.

data/lib/rubocop/ast/node/block_node.rb

@@ -9,6 +9,8 @@ module RuboCop
     # A `block` node is essentially a method send with a block. Parser nests
     # the `send` node inside the `block` node.
     class BlockNode < Node
+      include MethodIdentifierPredicates
+
       VOID_CONTEXT_METHODS = %i[each tap].freeze
 
       # The `send` node associated with this block.

data/lib/rubocop/ast/node/def_node.rb

@@ -16,6 +16,17 @@ module RuboCop
         method?(:initialize) || assignment_method?
       end
 
+      # Checks whether this method definition node forwards its arguments
+      # as per the feature added in Ruby 2.7.
+      #
+      # @note This is written in a way that may support lead arguments
+      #       which are rumored to be added in a later version of Ruby.
+      #
+      # @return [Boolean] whether the `def` node uses argument forwarding
+      def argument_forwarding?
+        arguments.any?(&:forward_args_type?)
+      end
+
       # The name of the defined method as a symbol.
       #
       # @return [Symbol] the name of the defined method

data/lib/rubocop/ast/node/forward_args_node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `forward-args` nodes. This will be used in place
+    # of a plain node when the builder constructs the AST, making its methods
+    # available to all `forward-args` nodes within RuboCop.
+    class ForwardArgsNode < Node
+      include CollectionNode
+
+      # Node wraps itself in an array to be compatible with other
+      # enumerable argument types.
+      def to_a
+        [self]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node.rb

@@ -624,7 +624,7 @@ module RuboCop
       end
 
       def parent_module_name_for_block(ancestor)
-        if ancestor.method_name == :class_eval
+        if ancestor.method?(:class_eval)
           # `class_eval` with no receiver applies to whatever module or class
           # we are currently in
           return unless (receiver = ancestor.receiver)

data/lib/rubocop/ast/traversal.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module AST
     # Provides methods for traversing an AST.
@@ -18,15 +19,21 @@ module RuboCop
                              rational str sym regopt self lvar
                              ivar cvar gvar nth_ref back_ref cbase
                              arg restarg blockarg shadowarg
-                             kwrestarg zsuper lambda redo retry].freeze
+                             kwrestarg zsuper lambda redo retry
+                             forward_args forwarded_args
+                             match_var match_nil_pattern].freeze
       ONE_CHILD_NODE    = %i[splat kwsplat block_pass not break next
                              preexe postexe match_current_line defined?
-                             arg_expr].freeze
+                             arg_expr pin match_rest if_guard unless_guard
+                             match_with_trailing_comma].freeze
       MANY_CHILD_NODES  = %i[dstr dsym xstr regexp array hash pair
                              mlhs masgn or_asgn and_asgn
                              undef alias args super yield or and
                              while_post until_post iflipflop eflipflop
-                             match_with_lvasgn begin kwbegin return].freeze
+                             match_with_lvasgn begin kwbegin return
+                             in_match case_match in_pattern match_alt
+                             match_as array_pattern array_pattern_with_tail
+                             hash_pattern const_pattern].freeze
       SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
                              kwoptarg].freeze
 
@@ -181,3 +188,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/rubocop/cli/command/auto_genenerate_config.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Generate a configuration file acting as a TODO list.
+      class AutoGenerateConfig < Base
+        self.command_name = :auto_gen_config
+
+        PHASE_1 = 'Phase 1 of 2: run Layout/LineLength cop'
+        PHASE_2 = 'Phase 2 of 2: run all cops'
+
+        PHASE_1_OVERRIDDEN =
+          '(skipped because the default Layout/LineLength:Max is overridden)'
+        PHASE_1_DISABLED =
+          '(skipped because Layout/LineLength is disabled)'
+
+        def run
+          add_formatter
+          reset_config_and_auto_gen_file
+          line_length_contents = maybe_run_line_length_cop
+          run_all_cops(line_length_contents)
+        end
+
+        private
+
+        def maybe_run_line_length_cop
+          if !line_length_enabled?(@config_store.for(Dir.pwd))
+            skip_line_length_cop(PHASE_1_DISABLED)
+          elsif !same_max_line_length?(
+            @config_store.for(Dir.pwd), ConfigLoader.default_configuration
+          )
+            skip_line_length_cop(PHASE_1_OVERRIDDEN)
+          else
+            run_line_length_cop
+          end
+        end
+
+        def skip_line_length_cop(reason)
+          puts Rainbow("#{PHASE_1} #{reason}").yellow
+          ''
+        end
+
+        def line_length_enabled?(config)
+          line_length_cop(config)['Enabled']
+        end
+
+        def same_max_line_length?(config1, config2)
+          max_line_length(config1) == max_line_length(config2)
+        end
+
+        def max_line_length(config)
+          line_length_cop(config)['Max']
+        end
+
+        def line_length_cop(config)
+          config.for_cop('Layout/LineLength')
+        end
+
+        # Do an initial run with only Layout/LineLength so that cops that
+        # depend on Layout/LineLength:Max get the correct value for that
+        # parameter.
+        def run_line_length_cop
+          puts Rainbow(PHASE_1).yellow
+          @options[:only] = ['Layout/LineLength']
+          execute_runner
+          @options.delete(:only)
+          @config_store = ConfigStore.new
+          # Save the todo configuration of the LineLength cop.
+          IO.read(ConfigLoader::AUTO_GENERATED_FILE)
+            .lines
+            .drop_while { |line| line.start_with?('#') }
+            .join
+        end
+
+        def run_all_cops(line_length_contents)
+          puts Rainbow(PHASE_2).yellow
+          result = execute_runner
+          # This run was made with the current maximum length allowed, so append
+          # the saved setting for LineLength.
+          File.open(ConfigLoader::AUTO_GENERATED_FILE, 'a') do |f|
+            f.write(line_length_contents)
+          end
+          result
+        end
+
+        def reset_config_and_auto_gen_file
+          @config_store = ConfigStore.new
+          @config_store.options_config = @options[:config] if @options[:config]
+          File.open(ConfigLoader::AUTO_GENERATED_FILE, 'w') {}
+          ConfigLoader.add_inheritance_from_auto_generated_file
+        end
+
+        def add_formatter
+          @options[:formatters] << [Formatter::DisabledConfigFormatter,
+                                    ConfigLoader::AUTO_GENERATED_FILE]
+        end
+
+        def execute_runner
+          Environment.new(@options, @config_store, @paths).run(:execute_runner)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # A subcommand in the CLI.
+      class Base
+        attr_reader :env
+
+        @subclasses = []
+
+        class << self
+          attr_accessor :command_name
+
+          def inherited(subclass)
+            @subclasses << subclass
+          end
+
+          def by_command_name(name)
+            @subclasses.detect { |s| s.command_name == name }
+          end
+        end
+
+        def initialize(env)
+          @env = env
+          @options = env.options
+          @config_store = env.config_store
+          @paths = env.paths
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/execute_runner.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Run all the selected cops and report the result.
+      class ExecuteRunner < Base
+        include Formatter::TextUtil
+
+        self.command_name = :execute_runner
+
+        def run
+          execute_runner(@paths)
+        end
+
+        private
+
+        def execute_runner(paths)
+          runner = Runner.new(@options, @config_store)
+
+          all_passed = runner.run(paths)
+          display_warning_summary(runner.warnings)
+          display_error_summary(runner.errors)
+          maybe_print_corrected_source
+
+          all_pass_or_excluded = all_passed || @options[:auto_gen_config]
+
+          if runner.aborting?
+            STATUS_INTERRUPTED
+          elsif all_pass_or_excluded && runner.errors.empty?
+            STATUS_SUCCESS
+          else
+            STATUS_OFFENSES
+          end
+        end
+
+        def display_warning_summary(warnings)
+          return if warnings.empty?
+
+          warn Rainbow("\n#{pluralize(warnings.size, 'warning')}:").yellow
+
+          warnings.each { |warning| warn warning }
+        end
+
+        def display_error_summary(errors)
+          return if errors.empty?
+
+          warn Rainbow("\n#{pluralize(errors.size, 'error')} occurred:").red
+
+          errors.each { |error| warn error }
+
+          warn <<~WARNING
+            Errors are usually caused by RuboCop bugs.
+            Please, report your problems to RuboCop's issue tracker.
+            #{Gem.loaded_specs['rubocop'].metadata['bug_tracker_uri']}
+
+            Mention the following information in the issue report:
+            #{RuboCop::Version.version(true)}
+          WARNING
+        end
+
+        def maybe_print_corrected_source
+          # If we are asked to autocorrect source code read from stdin, the only
+          # reasonable place to write it is to stdout
+          # Unfortunately, we also write other information to stdout
+          # So a delimiter is needed for tools to easily identify where the
+          # autocorrected source begins
+          return unless @options[:stdin] && @options[:auto_correct]
+
+          puts '=' * 20
+          print @options[:stdin]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/init_dotfile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Generate a .rubocop.yml file in the current directory.
+      class InitDotfile < Base
+        DOTFILE = ConfigLoader::DOTFILE
+
+        self.command_name = :init
+
+        def run
+          path = File.expand_path(DOTFILE)
+
+          if File.exist?(DOTFILE)
+            warn Rainbow("#{DOTFILE} already exists at #{path}").red
+
+            STATUS_ERROR
+          else
+            description = <<~DESC
+              # The behavior of RuboCop can be controlled via the .rubocop.yml
+              # configuration file. It makes it possible to enable/disable
+              # certain cops (checks) and to alter their behavior if they accept
+              # any parameters. The file can be placed either in your home
+              # directory or in some project directory.
+              #
+              # RuboCop will start looking for the configuration file in the directory
+              # where the inspected file is and continue its way up to the root directory.
+              #
+              # See https://github.com/rubocop-hq/rubocop/blob/master/manual/configuration.md
+            DESC
+
+            File.open(DOTFILE, 'w') do |f|
+              f.write(description)
+            end
+
+            puts "Writing new #{DOTFILE} to #{path}"
+
+            STATUS_SUCCESS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/show_cops.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Shows the given cops, or all cops by default, and their configurations
+      # for the current directory.
+      class ShowCops < Base
+        self.command_name = :show_cops
+
+        def initialize(env)
+          super
+
+          # Load the configs so the require()s are done for custom cops
+          @config = @config_store.for(Dir.pwd)
+        end
+
+        def run
+          print_available_cops
+        end
+
+        private
+
+        def print_available_cops
+          registry = Cop::Cop.registry
+          show_all = @options[:show_cops].empty?
+
+          if show_all
+            puts "# Available cops (#{registry.length}) " \
+                 "+ config for #{Dir.pwd}: "
+          end
+
+          registry.departments.sort!.each do |department|
+            print_cops_of_department(registry, department, show_all)
+          end
+        end
+
+        def print_cops_of_department(registry, department, show_all)
+          selected_cops = if show_all
+                            cops_of_department(registry, department)
+                          else
+                            selected_cops_of_department(registry, department)
+                          end
+
+          if show_all
+            puts "# Department '#{department}' (#{selected_cops.length}):"
+          end
+
+          print_cop_details(selected_cops)
+        end
+
+        def print_cop_details(cops)
+          cops.each do |cop|
+            if cop.new(@config).support_autocorrect?
+              puts '# Supports --auto-correct'
+            end
+            puts "#{cop.cop_name}:"
+            puts config_lines(cop)
+            puts
+          end
+        end
+
+        def selected_cops_of_department(cops, department)
+          cops_of_department(cops, department).select do |cop|
+            @options[:show_cops].include?(cop.cop_name)
+          end
+        end
+
+        def cops_of_department(cops, department)
+          cops.with_department(department).sort!
+        end
+
+        def config_lines(cop)
+          cnf = @config.for_cop(cop)
+          cnf.to_yaml.lines.to_a.drop(1).map { |line| '  ' + line }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Display version.
+      class Version < Base
+        self.command_name = :version
+
+        def run
+          puts RuboCop::Version.version(false) if @options[:version]
+          puts RuboCop::Version.version(true) if @options[:verbose_version]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Home of subcommands in the CLI.
+    module Command
+      class << self
+        # Find the command with a given name and run it in an environment.
+        def run(env, name)
+          class_for(name).new(env).run
+        end
+
+        private
+
+        def class_for(name)
+          Base.by_command_name(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/environment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Execution environment for a CLI command.
+    class Environment
+      attr_reader :options, :config_store, :paths
+
+      def initialize(options, config_store, paths)
+        @options = options
+        @config_store = config_store
+        @paths = paths
+      end
+
+      # Run a command in this environment.
+      def run(name)
+        Command.run(self, name)
+      end
+    end
+  end
+end