rubocop 0.60.0 → 0.61.0

data/lib/rubocop.rb

@@ -76,6 +76,7 @@ require_relative 'rubocop/cop/corrector'
 require_relative 'rubocop/cop/force'
 require_relative 'rubocop/cop/severity'
 require_relative 'rubocop/cop/generator'
+require_relative 'rubocop/cop/generator/configuration_injector'
 require_relative 'rubocop/cop/generator/require_file_injector'
 
 require_relative 'rubocop/cop/variable_force'
@@ -150,7 +151,10 @@ require_relative 'rubocop/cop/mixin/unused_argument'
 
 require_relative 'rubocop/cop/correctors/alignment_corrector'
 require_relative 'rubocop/cop/correctors/condition_corrector'
+require_relative 'rubocop/cop/correctors/each_to_for_corrector'
 require_relative 'rubocop/cop/correctors/empty_line_corrector'
+require_relative 'rubocop/cop/correctors/for_to_each_corrector'
+require_relative 'rubocop/cop/correctors/lambda_literal_to_method_corrector'
 require_relative 'rubocop/cop/correctors/line_break_corrector'
 require_relative 'rubocop/cop/correctors/multiline_literal_brace_corrector'
 require_relative 'rubocop/cop/correctors/ordered_gem_corrector'
@@ -368,6 +372,7 @@ require_relative 'rubocop/cop/performance/fixed_size'
 require_relative 'rubocop/cop/performance/flat_map'
 require_relative 'rubocop/cop/performance/inefficient_hash_search'
 require_relative 'rubocop/cop/performance/lstrip_rstrip'
+require_relative 'rubocop/cop/performance/open_struct'
 require_relative 'rubocop/cop/performance/range_include'
 require_relative 'rubocop/cop/performance/redundant_block_call'
 require_relative 'rubocop/cop/performance/redundant_match'

data/lib/rubocop/ast/node.rb

@@ -54,7 +54,7 @@ module RuboCop
       OPERATOR_KEYWORDS = %i[and or].freeze
       SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].freeze
 
-      # @see http://rubydoc.info/gems/ast/AST/Node:initialize
+      # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
       def initialize(type, children = [], properties = {})
         @mutable_attributes = {}
 

data/lib/rubocop/ast/sexp.rb

@@ -5,7 +5,7 @@ module RuboCop
     # This module provides a shorthand method to create a {Node} like
     # `Parser::AST::Sexp`.
     #
-    # @see http://rubydoc.info/gems/ast/AST/Sexp
+    # @see https://www.rubydoc.info/gems/ast/AST/Sexp
     module Sexp
       # Creates a {Node} with type `type` and children `children`.
       def s(type, *children)

data/lib/rubocop/cli.rb

@@ -10,9 +10,10 @@ module RuboCop
     SKIPPED_PHASE_1 = 'Phase 1 of 2: run Metrics/LineLength cop (skipped ' \
                       'because the default Metrics/LineLength:Max is ' \
                       'overridden)'.freeze
-    STATUS_SUCCESS  = 0
-    STATUS_OFFENSES = 1
-    STATUS_ERROR    = 2
+    STATUS_SUCCESS     = 0
+    STATUS_OFFENSES    = 1
+    STATUS_ERROR       = 2
+    STATUS_INTERRUPTED = 128 + Signal.list['INT']
 
     class Finished < RuntimeError; end
 
@@ -58,15 +59,6 @@ module RuboCop
     end
     # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-    def trap_interrupt(runner)
-      Signal.trap('INT') do
-        exit!(1) if runner.aborting?
-        runner.abort
-        warn
-        warn 'Exiting... Interrupt again to exit immediately.'
-      end
-    end
-
     private
 
     def execute_runners(paths)
@@ -118,6 +110,7 @@ module RuboCop
 
     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
@@ -135,6 +128,7 @@ module RuboCop
       ConfigLoader.debug = @options[:debug]
       ConfigLoader.auto_gen_config = @options[:auto_gen_config]
       ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
+      ConfigLoader.options_config = @options[:config]
 
       @config_store.options_config = @options[:config] if @options[:config]
       @config_store.force_default_config! if @options[:force_default_config]
@@ -153,7 +147,6 @@ module RuboCop
     def execute_runner(paths)
       runner = Runner.new(@options, @config_store)
 
-      trap_interrupt(runner)
       all_passed = runner.run(paths)
       display_warning_summary(runner.warnings)
       display_error_summary(runner.errors)
@@ -161,7 +154,9 @@ module RuboCop
 
       all_pass_or_excluded = all_passed || @options[:auto_gen_config]
 
-      if all_pass_or_excluded && !runner.aborting? && runner.errors.empty?
+      if runner.aborting?
+        STATUS_INTERRUPTED
+      elsif all_pass_or_excluded && runner.errors.empty?
         STATUS_SUCCESS
       else
         STATUS_OFFENSES

data/lib/rubocop/config.rb

@@ -14,7 +14,7 @@ module RuboCop
     include PathUtil
     include FileFinder
 
-    COMMON_PARAMS = %w[Exclude Include Severity
+    COMMON_PARAMS = %w[Exclude Include Severity inherit_mode
                        AutoCorrect StyleGuide Details].freeze
     # 2.2 is the oldest officially supported Ruby version.
     DEFAULT_RUBY_VERSION = 2.2
@@ -440,11 +440,11 @@ module RuboCop
     end
 
     def target_ruby_version
-      @target_ruby_version ||=
+      @target_ruby_version ||= begin
         if for_all_cops['TargetRubyVersion']
           @target_ruby_version_source = :rubocop_yml
 
-          for_all_cops['TargetRubyVersion']
+          for_all_cops['TargetRubyVersion'].to_f
         elsif target_ruby_version_from_version_file
           @target_ruby_version_source = :ruby_version_file
 
@@ -456,6 +456,7 @@ module RuboCop
         else
           DEFAULT_RUBY_VERSION
         end
+      end
     end
 
     def target_rails_version

data/lib/rubocop/config_loader.rb

@@ -22,7 +22,8 @@ module RuboCop
     class << self
       include FileFinder
 
-      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion
+      attr_accessor :debug, :auto_gen_config, :ignore_parent_exclusion,
+                    :options_config
       attr_writer :default_configuration
 
       alias debug? debug
@@ -30,7 +31,7 @@ module RuboCop
       alias ignore_parent_exclusion? ignore_parent_exclusion
 
       def clear_options
-        @debug = @auto_gen_config = nil
+        @debug = @auto_gen_config = @options_config = nil
         FileFinder.root_level = nil
       end
 
@@ -43,7 +44,6 @@ module RuboCop
         resolver.resolve_requires(path, hash)
 
         add_missing_namespaces(path, hash)
-        target_ruby_version_to_f!(hash)
 
         resolver.resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
         resolver.resolve_inheritance(path, hash, file, debug?)
@@ -117,36 +117,38 @@ module RuboCop
         resolver.merge_with_default(config, config_file)
       end
 
-      def target_ruby_version_to_f!(hash)
-        version = 'TargetRubyVersion'
-        return unless hash['AllCops'] && hash['AllCops'][version]
-
-        hash['AllCops'][version] = hash['AllCops'][version].to_f
-      end
-
       def add_inheritance_from_auto_generated_file
         file_string = " #{AUTO_GENERATED_FILE}"
 
-        if File.exist?(DOTFILE)
-          files = Array(load_yaml_configuration(DOTFILE)['inherit_from'])
+        config_file = options_config || DOTFILE
+
+        if File.exist?(config_file)
+          files = Array(load_yaml_configuration(config_file)['inherit_from'])
+
           return if files.include?(AUTO_GENERATED_FILE)
 
           files.unshift(AUTO_GENERATED_FILE)
           file_string = "\n  - " + files.join("\n  - ") if files.size > 1
-          rubocop_yml_contents = IO.read(DOTFILE, encoding: Encoding::UTF_8)
-                                   .sub(/^inherit_from: *[.\w]+/, '')
-                                   .sub(/^inherit_from: *(\n *- *[.\w]+)+/, '')
+          rubocop_yml_contents = existing_configuration(config_file)
         end
-        write_dotfile(file_string, rubocop_yml_contents)
+
+        write_config_file(config_file, file_string, rubocop_yml_contents)
+
         puts "Added inheritance from `#{AUTO_GENERATED_FILE}` in `#{DOTFILE}`."
       end
 
       private
 
-      def write_dotfile(file_string, rubocop_yml_contents)
-        File.open(DOTFILE, 'w') do |f|
+      def existing_configuration(config_file)
+        IO.read(config_file, encoding: Encoding::UTF_8)
+          .sub(%r{^inherit_from: *[.\/\w]+}, '')
+          .sub(%r{^inherit_from: *(\n *- *[.\/\w]+)+}, '')
+      end
+
+      def write_config_file(file_name, file_string, rubocop_yml_contents)
+        File.open(file_name, 'w') do |f|
           f.write "inherit_from:#{file_string}\n"
-          f.write "\n#{rubocop_yml_contents}" if rubocop_yml_contents
+          f.write "\n#{rubocop_yml_contents}" if rubocop_yml_contents =~ /\S/
         end
       end
 
@@ -181,11 +183,12 @@ module RuboCop
         if defined?(SafeYAML) && SafeYAML.respond_to?(:load)
           SafeYAML.load(yaml_code, filename,
                         whitelisted_tags: %w[!ruby/regexp])
-        elsif RUBY_VERSION >= '2.6'
+        # Ruby 2.6+
+        elsif Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0.pre1')
           YAML.safe_load(
             yaml_code,
-            whitelist_classes: [Regexp, Symbol],
-            whitelist_symbols: [],
+            permitted_classes: [Regexp, Symbol],
+            permitted_symbols: [],
             aliases: false,
             filename: filename
           )

data/lib/rubocop/config_loader_resolver.rb

@@ -76,11 +76,11 @@ module RuboCop
                  config_file)
     end
 
-    # Returns a new hash where the parameters of the given config hash have
-    # been replaced by parameters returned by the given block.
     # Return a recursive merge of two hashes. That is, a normal hash merge,
     # with the addition that any value that is a hash, and occurs in both
     # arguments, will also be merged. And so on.
+    #
+    # rubocop:disable Metrics/AbcSize
     def merge(base_hash, derived_hash, **opts)
       result = base_hash.merge(derived_hash)
       keys_appearing_in_both = base_hash.keys & derived_hash.keys
@@ -95,6 +95,7 @@ module RuboCop
       end
       result
     end
+    # rubocop:enable Metrics/AbcSize
 
     private
 

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `#each` enumeration to `for` iteration.
+    class EachToForCorrector
+      extend NodePattern::Macros
+
+      CORRECTION_WITH_ARGUMENTS =
+        'for %<variables>s in %<collection>s do'.freeze
+      CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'.freeze
+
+      def initialize(block_node)
+        @block_node = block_node
+        @collection_node = block_node.send_node.receiver
+        @argument_node = block_node.arguments
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :block_node, :collection_node, :argument_node
+
+      def correction
+        if block_node.arguments?
+          format(CORRECTION_WITH_ARGUMENTS,
+                 collection: collection_node.source,
+                 variables: argument_node.children.first.source)
+        else
+          format(CORRECTION_WITHOUT_ARGUMENTS,
+                 enumerable: collection_node.source)
+        end
+      end
+
+      def offending_range
+        if block_node.arguments?
+          replacement_range(argument_node.loc.expression.end_pos)
+        else
+          replacement_range(block_node.loc.begin.end_pos)
+        end
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(block_node.loc.expression.source_buffer,
+                                  block_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `for` iteration to `#each` enumeration.
+    class ForToEachCorrector
+      extend NodePattern::Macros
+
+      CORRECTION = '%<collection>s.each do |%<argument>s|'.freeze
+
+      def initialize(for_node)
+        @for_node        = for_node
+        @variable_node   = for_node.variable
+        @collection_node = for_node.collection
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :for_node, :variable_node, :collection_node
+
+      def correction
+        format(CORRECTION, collection: collection_source,
+                           argument: variable_node.source)
+      end
+
+      def collection_source
+        if requires_parentheses?
+          "(#{collection_node.source})"
+        else
+          collection_node.source
+        end
+      end
+
+      def requires_parentheses?
+        collection_node.irange_type? || collection_node.erange_type?
+      end
+
+      def end_position
+        if for_node.do?
+          keyword_begin.end_pos
+        else
+          collection_end.end_pos
+        end
+      end
+
+      def keyword_begin
+        for_node.loc.begin
+      end
+
+      def collection_end
+        if collection_node.begin_type?
+          collection_node.loc.end
+        else
+          collection_node.loc.expression
+        end
+      end
+
+      def offending_range
+        replacement_range(end_position)
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(for_node.loc.expression.source_buffer,
+                                  for_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects lambda literal to method notation.
+    class LambdaLiteralToMethodCorrector
+      def initialize(block_node)
+        @block_node = block_node
+        @method     = block_node.send_node
+        @arguments  = block_node.arguments
+      end
+
+      def call(corrector)
+        # Check for unparenthesized args' preceding and trailing whitespaces.
+        remove_unparenthesized_whitespace(corrector)
+
+        # Avoid correcting to `lambdado` by inserting whitespace
+        # if none exists before or after the lambda arguments.
+        insert_separating_space(corrector)
+
+        replace_selector(corrector)
+        remove_arguments(corrector)
+
+        replace_delimiters(corrector)
+
+        insert_arguments(corrector)
+      end
+
+      private
+
+      attr_reader :block_node, :method, :arguments
+
+      def remove_unparenthesized_whitespace(corrector)
+        return unless !arguments.empty? && !arguments.parenthesized_call?
+
+        remove_leading_whitespace(corrector)
+        remove_trailing_whitespace(corrector)
+      end
+
+      def insert_separating_space(corrector)
+        return unless needs_separating_space?
+
+        corrector.insert_before(block_begin, ' ')
+      end
+
+      def replace_selector(corrector)
+        corrector.replace(method.source_range, 'lambda')
+      end
+
+      def remove_arguments(corrector)
+        return if arguments.empty_and_without_delimiters?
+
+        corrector.remove(arguments.source_range)
+      end
+
+      def insert_arguments(corrector)
+        return if arguments.empty?
+
+        arg_str = " |#{lambda_arg_string}|"
+        corrector.insert_after(block_node.loc.begin, arg_str)
+      end
+
+      def remove_leading_whitespace(corrector)
+        corrector.remove_preceding(
+          arguments.source_range,
+          arguments.source_range.begin_pos -
+            block_node.send_node.source_range.end_pos
+        )
+      end
+
+      def remove_trailing_whitespace(corrector)
+        corrector.remove_preceding(
+          block_begin,
+          block_begin.begin_pos - arguments.source_range.end_pos - 1
+        )
+      end
+
+      def replace_delimiters(corrector)
+        return if block_node.braces? || !arg_to_unparenthesized_call?
+
+        corrector.insert_after(block_begin, ' ') unless separating_space?
+
+        corrector.replace(block_begin, '{')
+        corrector.replace(block_end, '}')
+      end
+
+      def lambda_arg_string
+        arguments.children.map(&:source).join(', ')
+      end
+
+      def needs_separating_space?
+        block_begin.begin_pos == arguments_end_pos &&
+          selector_end.end_pos == arguments_begin_pos ||
+          block_begin.begin_pos == selector_end.end_pos
+      end
+
+      def arguments_end_pos
+        arguments.loc.end && arguments.loc.end.end_pos
+      end
+
+      def arguments_begin_pos
+        arguments.loc.begin && arguments.loc.begin.begin_pos
+      end
+
+      def block_end
+        block_node.loc.end
+      end
+
+      def block_begin
+        block_node.loc.begin
+      end
+
+      def selector_end
+        method.loc.selector.end
+      end
+
+      def arg_to_unparenthesized_call?
+        current_node = block_node
+
+        parent = current_node.parent
+
+        if parent && parent.pair_type?
+          current_node = parent.parent
+          parent = current_node.parent
+        end
+
+        return false unless parent && parent.send_type?
+        return false if parent.parenthesized_call?
+
+        current_node.sibling_index > 1
+      end
+
+      def separating_space?
+        block_begin.source_buffer.source[block_begin.begin_pos + 2].match(/\s/)
+      end
+    end
+  end
+end