rubocop 1.4.2 → 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_validator.rb

@@ -42,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
@@ -68,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?
 
@@ -99,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

data/lib/rubocop/cop/base.rb

@@ -288,13 +288,6 @@ module RuboCop
         @current_corrector&.merge!(corrector) if corrector
       end
 
-      def correction_strategy
-        return :unsupported unless correctable?
-        return :uncorrected unless autocorrect?
-
-        :attempt_correction
-      end
-
       ### Reserved for Commissioner:
 
       def current_offense_locations
@@ -341,33 +334,42 @@ module RuboCop
 
       # @return [Symbol, Corrector] offense status
       def correct(range)
-        status = correction_strategy
-
         if block_given?
           corrector = Corrector.new(self)
           yield corrector
-          if !corrector.empty? && !self.class.support_autocorrect?
+          if corrector.empty?
+            corrector = nil
+          elsif !self.class.support_autocorrect?
             raise "The Cop #{name} must `extend AutoCorrector` to be able to autocorrect"
           end
         end
 
-        status = attempt_correction(range, corrector) if status == :attempt_correction
+        [use_corrector(range, corrector), corrector]
+      end
 
-        [status, corrector]
+      # @return [Symbol] offense status
+      def use_corrector(range, corrector)
+        if autocorrect?
+          attempt_correction(range, corrector)
+        elsif corrector
+          :uncorrected
+        else
+          :unsupported
+        end
       end
 
       # @return [Symbol] offense status
       def attempt_correction(range, corrector)
-        if corrector && !corrector.empty?
+        if corrector
           status = :corrected
         elsif disable_uncorrectable?
           corrector = disable_uncorrectable(range)
           status = :corrected_with_todo
         else
-          return :uncorrected
+          return :unsupported
         end
 
-        apply_correction(corrector) if corrector
+        apply_correction(corrector)
         status
       end
 

data/lib/rubocop/cop/cop.rb

@@ -27,7 +27,7 @@ module RuboCop
       def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
         @v0_argument = node_or_range
         range = find_location(node_or_range, location)
-        if block.nil? && !autocorrect?
+        if block.nil? && !support_autocorrect?
           super(range, message: message, severity: severity)
         else
           super(range, message: message, severity: severity) do |corrector|
@@ -136,7 +136,7 @@ module RuboCop
       end
 
       def correction_lambda
-        return unless correction_strategy == :attempt_correction && support_autocorrect?
+        return unless support_autocorrect?
 
         dedup_on_node(@v0_argument) do
           autocorrect(@v0_argument)