rubocop 0.93.1 → 1.6.1

data/lib/rubocop/config_obsoletion/changed_enforced_styles.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for changing a parameter
+    # @api private
+    class ChangedEnforcedStyles < ParameterRule
+      BASE_MESSAGE = 'obsolete `%<parameter>s: %<value>s` (for `%<cop>s`) found in %<path>s'
+
+      def violated?
+        super && config[cop][parameter] == value
+      end
+
+      def message
+        base = format(BASE_MESSAGE,
+                      parameter: parameter, value: value, cop: cop, path: smart_loaded_path)
+
+        if alternative
+          "#{base}\n`#{parameter}: #{value}` has been renamed to " \
+            "`#{parameter}: #{alternative.chomp}`."
+        else
+          "#{base}\n#{reason.chomp}"
+        end
+      end
+
+      private
+
+      def value
+        metadata['value']
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/changed_parameter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for changing a parameter
+    # @api private
+    class ChangedParameter < ParameterRule
+      BASE_MESSAGE = 'obsolete parameter `%<parameter>s` (for `%<cop>s`) found in %<path>s'
+
+      def message
+        base = format(BASE_MESSAGE, parameter: parameter, cop: cop, path: smart_loaded_path)
+
+        if alternative
+          "#{base}\n`#{parameter}` has been renamed to `#{alternative.chomp}`."
+        else
+          "#{base}\n#{reason.chomp}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/cop_rule.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Base class for ConfigObsoletion rules relating to cops
+    # @api private
+    class CopRule < Rule
+      attr_reader :old_name
+
+      def initialize(config, old_name)
+        super(config)
+        @old_name = old_name
+      end
+
+      def cop_rule?
+        true
+      end
+
+      def message
+        rule_message + "\n(obsolete configuration found in " \
+                       "#{smart_loaded_path}, please update it)"
+      end
+
+      # Cop rules currently can only be failures, not warnings
+      def warning?
+        false
+      end
+
+      def violated?
+        config.key?(old_name) || config.key?(Cop::Badge.parse(old_name).cop_name)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/extracted_cop.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for splitting a cop's
+    # functionality into multiple new cops.
+    # @api private
+    class ExtractedCop < CopRule
+      attr_reader :gem, :department
+
+      def initialize(config, old_name, gem)
+        super(config, old_name)
+        @department, * = old_name.rpartition('/')
+        @gem = gem
+      end
+
+      def violated?
+        return false if feature_loaded?
+
+        affected_cops.any?
+      end
+
+      def rule_message
+        msg = '%<name>s been extracted to the `%<gem>s` gem.'
+        format(msg,
+               name: affected_cops.size > 1 ? "`#{department}` cops have" : "`#{old_name}` has",
+               gem: gem)
+      end
+
+      private
+
+      def affected_cops
+        return old_name unless old_name.end_with?('*')
+
+        # Handle whole departments (expressed as `Department/*`)
+        config.keys.grep(Regexp.new("^#{department}"))
+      end
+
+      def feature_loaded?
+        config.loaded_features.include?(gem)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/parameter_rule.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Base class for ConfigObsoletion rules relating to parameters
+    # @api private
+    class ParameterRule < Rule
+      attr_reader :cop, :parameter, :metadata
+
+      def initialize(config, cop, parameter, metadata)
+        super(config)
+        @cop = cop
+        @parameter = parameter
+        @metadata = metadata
+      end
+
+      def parameter_rule?
+        true
+      end
+
+      def violated?
+        config[cop]&.key?(parameter)
+      end
+
+      def warning?
+        severity == 'warning'
+      end
+
+      private
+
+      def alternative
+        metadata['alternative']
+      end
+
+      def reason
+        metadata['reason']
+      end
+
+      def severity
+        metadata['severity']
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/removed_cop.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for removing
+    # a previously defined cop.
+    # @api private
+    class RemovedCop < CopRule
+      attr_reader :old_name, :metadata
+
+      BASE_MESSAGE = 'The `%<old_name>s` cop has been removed'
+
+      def initialize(config, old_name, metadata)
+        super(config, old_name)
+        @metadata = metadata.is_a?(Hash) ? metadata : {}
+      end
+
+      def rule_message
+        base = format(BASE_MESSAGE, old_name: old_name)
+
+        if reason
+          "#{base} since #{reason.chomp}."
+        elsif alternatives
+          "#{base}. Please use #{to_sentence(alternatives, connector: 'and/or')} instead."
+        else
+          "#{base}."
+        end
+      end
+
+      private
+
+      def reason
+        metadata['reason']
+      end
+
+      def alternatives
+        Array(metadata['alternatives']).map { |name| "`#{name}`" }
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/renamed_cop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for renaming
+    # a cop or moving it to a new department.
+    # @api private
+    class RenamedCop < CopRule
+      attr_reader :new_name
+
+      def initialize(config, old_name, new_name)
+        super(config, old_name)
+        @new_name = new_name
+      end
+
+      def rule_message
+        "The `#{old_name}` cop has been #{verb} to `#{new_name}`."
+      end
+
+      private
+
+      def moved?
+        old_badge = Cop::Badge.parse(old_name)
+        new_badge = Cop::Badge.parse(new_name)
+
+        old_badge.department != new_badge.department && old_badge.cop_name == new_badge.cop_name
+      end
+
+      def verb
+        moved? ? 'moved' : 'renamed'
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/rule.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Abstract base class for ConfigObsoletion rules
+    # @api private
+    class Rule
+      def initialize(config)
+        @config = config
+      end
+
+      # Does this rule relate to cops?
+      def cop_rule?
+        false
+      end
+
+      # Does this rule relate to parameters?
+      def parameter_rule?
+        false
+      end
+
+      def violated?
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :config
+
+      def to_sentence(collection, connector: 'and')
+        return collection.first if collection.size == 1
+
+        [collection[0..-2].join(', '), collection[-1]].join(" #{connector} ")
+      end
+
+      def smart_loaded_path
+        PathUtil.smart_path(config.loaded_path)
+      end
+    end
+  end
+end

data/lib/rubocop/config_obsoletion/split_cop.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class ConfigObsoletion
+    # Encapsulation of a ConfigObsoletion rule for splitting a cop's
+    # functionality into multiple new cops.
+    # @api private
+    class SplitCop < CopRule
+      attr_reader :metadata
+
+      def initialize(config, old_name, metadata)
+        super(config, old_name)
+        @metadata = metadata
+      end
+
+      def rule_message
+        "The `#{old_name}` cop has been split into #{to_sentence(alternatives)}."
+      end
+
+      private
+
+      def alternatives
+        Array(metadata['alternatives']).map { |name| "`#{name}`" }
+      end
+    end
+  end
+end

data/lib/rubocop/config_regeneration.rb

@@ -16,7 +16,7 @@ module RuboCop
       match = generation_command.match(COMMAND_REGEX)
       return DEFAULT_OPTIONS unless match
 
-      options = match[1].split(' ')
+      options = match[1].split
       Options.new.parse(options).first
     end
 

data/lib/rubocop/config_validator.rb

@@ -18,6 +18,11 @@ module RuboCop
     # @api private
     NEW_COPS_VALUES = %w[pending disable enable].freeze
 
+    # @api private
+    CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
+    CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
+
     def_delegators :@config, :smart_loaded_path, :for_all_cops
 
     def initialize(config)
@@ -37,7 +42,7 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      @config_obsoletion.reject_obsolete_cops_and_parameters
+      check_obsoletions
 
       alert_about_unrecognized_cops(invalid_cop_names)
       check_target_ruby
@@ -63,6 +68,13 @@ module RuboCop
 
     attr_reader :target_ruby
 
+    def check_obsoletions
+      @config_obsoletion.reject_obsolete!
+      return unless @config_obsoletion.warnings.any?
+
+      warn Rainbow("Warning: #{@config_obsoletion.warnings.join("\n")}").yellow
+    end
+
     def check_target_ruby
       return if target_ruby.supported?
 
@@ -94,10 +106,17 @@ module RuboCop
         # to do so than to pass the value around to various methods.
         next if name == 'inherit_mode'
 
-        unknown_cops << "unrecognized cop #{name} found in " \
-          "#{smart_loaded_path}"
+        suggestions = NameSimilarity.find_similar_names(name, Cop::Registry.global.map(&:cop_name))
+        suggestion = "Did you mean `#{suggestions.join('`, `')}`?" if suggestions.any?
+
+        message = <<~MESSAGE.rstrip
+          unrecognized cop #{name} found in #{smart_loaded_path}
+          #{suggestion}
+        MESSAGE
+
+        unknown_cops << message
       end
-      raise ValidationError, unknown_cops.join(', ') if unknown_cops.any?
+      raise ValidationError, unknown_cops.join("\n") if unknown_cops.any?
     end
 
     def validate_syntax_cop
@@ -202,13 +221,9 @@ module RuboCop
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
-        next unless %w[Enabled
-                       Safe
-                       SafeAutoCorrect
-                       AutoCorrect].include?(key) && value.is_a?(String)
+        next unless CONFIG_CHECK_KEYS.include?(key) && value.is_a?(String)
 
-        next if key == 'Enabled' &&
-                %w[pending override_department].include?(value)
+        next if key == 'Enabled' && CONFIG_CHECK_DEPARTMENTS.include?(value)
 
         raise ValidationError, msg_not_boolean(parent, key, value)
       end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -39,16 +39,31 @@ module RuboCop
       private
 
       def disable_offense(range)
-        eol_comment = " # rubocop:todo #{cop_name}"
-        needed_line_length = (range.source_line + eol_comment).length
-        if needed_line_length <= max_line_length
-          disable_offense_at_end_of_line(range_of_first_line(range),
-                                         eol_comment)
+        heredoc_range = surrounding_heredoc(range)
+        if heredoc_range
+          disable_offense_before_and_after(range_by_lines(heredoc_range))
         else
-          disable_offense_before_and_after(range_by_lines(range))
+          eol_comment = " # rubocop:todo #{cop_name}"
+          needed_line_length = (range.source_line + eol_comment).length
+          if needed_line_length <= max_line_length
+            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
+          else
+            disable_offense_before_and_after(range_by_lines(range))
+          end
         end
       end
 
+      def surrounding_heredoc(offense_range)
+        # The empty offense range is an edge case that can be reached from the Lint/Syntax cop.
+        return nil if offense_range.empty?
+
+        heredoc_nodes = processed_source.ast.each_descendant.select do |node|
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+                     .find { |range| range.contains?(offense_range) }
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length