rubocop 0.46.0 → 0.47.0

data/lib/rubocop/comment_config.rb

@@ -133,9 +133,7 @@ module RuboCop
     end
 
     def all_cop_names
-      @all_cop_names ||= Cop::Cop.all.map(&:cop_name).reject do |cop_name|
-        cop_name == UNNEEDED_DISABLE
-      end
+      @all_cop_names ||= Cop::Cop.registry.names - [UNNEEDED_DISABLE]
     end
 
     def comment_only_line?(line_number)

data/lib/rubocop/config.rb

@@ -27,7 +27,7 @@ module RuboCop
         'The `Rails/DefaultScope` cop no longer exists.',
       'Style/SingleSpaceBeforeFirstArg' =>
         'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
-        '`Style/SpaceBeforeFirstArg. ',
+        '`Style/SpaceBeforeFirstArg.`',
       'Lint/SpaceBeforeFirstArg' =>
         'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
         'duplicate of `Style/SpaceBeforeFirstArg`. Please use ' \
@@ -37,9 +37,60 @@ module RuboCop
         'use `Style/SpaceAroundKeyword` instead.',
       'Style/SpaceBeforeModifierKeyword' =>
         'The `Style/SpaceBeforeModifierKeyword` cop has been removed. Please ' \
-        'use `Style/SpaceAroundKeyword` instead.'
+        'use `Style/SpaceAroundKeyword` instead.',
+      'Style/MethodCallParentheses' =>
+        'The `Style/MethodCallParentheses` cop has been renamed to ' \
+          '`Style/MethodCallWithoutArgsParentheses`.',
+      'Lint/Eval' =>
+        'The `Lint/Eval` cop has been renamed to `Security/Eval`.'
     }.freeze
 
+    OBSOLETE_PARAMETERS = [
+      {
+        cop: 'Style/SpaceAroundOperators',
+        parameter: 'MultiSpaceAllowedForOperators',
+        alternative: 'If your intention was to allow extra spaces ' \
+                     'for alignment, please use AllowForAlignment: ' \
+                     'true instead.'
+      },
+      {
+        cop: 'AllCops',
+        parameter: 'RunRailsCops',
+        alternative: "Use the following configuration instead:\n" \
+                     "Rails:\n  Enabled: true"
+      },
+      {
+        cop: 'Style/CaseIndentation',
+        parameter: 'IndentWhenRelativeTo',
+        alternative: '`IndentWhenRelativeTo` has been renamed to ' \
+                     '`EnforcedStyle`'
+      },
+      {
+        cop: 'Lint/BlockAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Lint/EndAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Lint/DefEndAlignment',
+        parameter: 'AlignWith',
+        alternative: '`AlignWith` has been renamed to ' \
+                     '`EnforcedStyleAlignWith`'
+      },
+      {
+        cop: 'Rails/UniqBeforePluck',
+        parameter: 'EnforcedMode',
+        alternative: '`EnforcedMode` has been renamed to ' \
+                     '`EnforcedStyle`'
+      }
+    ].freeze
+
     attr_reader :loaded_path
 
     def initialize(hash = {}, loaded_path = nil)
@@ -142,13 +193,11 @@ module RuboCop
     end
 
     def cop_enabled?(cop)
-      department = cop.cop_type.to_s.capitalize!
-
-      if (dept_config = self[department])
+      if (dept_config = self[cop.department.to_s])
         return false if dept_config['Enabled'] == false
       end
 
-      for_cop(cop).empty? || for_cop(cop)['Enabled']
+      for_cop(cop).empty? || for_cop(cop).fetch('Enabled', true)
     end
 
     def validate
@@ -161,9 +210,8 @@ module RuboCop
         ConfigLoader.default_configuration.key?(key)
       end
 
-      reject_obsolete_cops
+      reject_obsolete_cops_and_parameters
       warn_about_unrecognized_cops(invalid_cop_names)
-      reject_obsolete_parameters
       check_target_ruby
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
@@ -259,7 +307,7 @@ module RuboCop
         end
 
         # There could be a custom cop with this name. If so, don't warn
-        next if Cop::Cop.all.any? { |c| c.match?([name]) }
+        next if Cop::Cop.registry.contains_cop_matching?([name])
 
         warn Rainbow("Warning: unrecognized cop #{name} found in " \
                      "#{loaded_path}").yellow
@@ -286,42 +334,52 @@ module RuboCop
 
     def validate_enforced_styles(valid_cop_names)
       valid_cop_names.each do |name|
-        next unless (style = self[name]['EnforcedStyle'])
-        valid = ConfigLoader.default_configuration[name]['SupportedStyles']
-        next if valid.include?(style)
-
-        msg = "invalid EnforcedStyle '#{style}' for #{name} found in " \
-              "#{loaded_path}\n" \
-              "Valid choices are: #{valid.join(', ')}"
-        raise ValidationError, msg
+        styles = self[name].select { |key, _| key.start_with?('Enforced') }
+
+        styles.each do |style_name, style|
+          supported_key = RuboCop::Cop::Util.to_supported_styles(style_name)
+          valid = ConfigLoader.default_configuration[name][supported_key]
+          next unless valid
+          next if valid.include?(style)
+
+          msg = "invalid #{style_name} '#{style}' for #{name} found in " \
+            "#{loaded_path}\n" \
+            "Valid choices are: #{valid.join(', ')}"
+          raise ValidationError, msg
+        end
       end
     end
 
-    def reject_obsolete_parameters
-      check_obsolete_parameter('Style/SpaceAroundOperators',
-                               'MultiSpaceAllowedForOperators',
-                               'If your intention was to allow extra spaces ' \
-                               'for alignment, please use AllowForAlignment: ' \
-                               'true instead.')
-      check_obsolete_parameter('AllCops', 'RunRailsCops',
-                               "Use the following configuration instead:\n" \
-                               "Rails:\n  Enabled: true")
+    def reject_obsolete_cops_and_parameters
+      messages = [
+        obsolete_cops,
+        obsolete_parameters
+      ].flatten.compact
+      return if messages.empty?
+
+      raise ValidationError, messages.join("\n")
+    end
+
+    def obsolete_parameters
+      OBSOLETE_PARAMETERS.map do |params|
+        obsolete_parameter_message(params[:cop], params[:parameter],
+                                   params[:alternative])
+      end
     end
 
-    def check_obsolete_parameter(cop, parameter, alternative = nil)
+    def obsolete_parameter_message(cop, parameter, alternative)
       return unless self[cop] && self[cop].key?(parameter)
 
-      raise ValidationError, "obsolete parameter #{parameter} (for #{cop}) " \
-                            "found in #{loaded_path}" \
-                            "#{"\n" if alternative}#{alternative}"
+      "obsolete parameter #{parameter} (for #{cop}) " \
+        "found in #{loaded_path}" \
+        "\n#{alternative}"
     end
 
-    def reject_obsolete_cops
-      OBSOLETE_COPS.each do |cop_name, message|
-        next unless key?(cop_name) || key?(cop_name.split('/').last)
-        message += "\n(obsolete configuration found in #{loaded_path}, please" \
+    def obsolete_cops
+      OBSOLETE_COPS.map do |cop_name, message|
+        next unless key?(cop_name) || key?(Cop::Badge.parse(cop_name).cop_name)
+        message + "\n(obsolete configuration found in #{loaded_path}, please" \
                    ' update it)'
-        raise ValidationError, message
       end
     end
 

data/lib/rubocop/config_loader.rb

@@ -169,7 +169,7 @@ module RuboCop
             YAML.safe_load(yaml_code, [Regexp], [], false, filename)
           end
         else
-          YAML.load(yaml_code, filename)
+          YAML.load(yaml_code, filename) # rubocop:disable Security/YAMLLoad
         end
       end
 

data/lib/rubocop/cop/badge.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Identifier of all cops containing a department and cop name.
+    #
+    # All cops are identified by their badge. For example, the badge
+    # for `RuboCop::Cop::Style::Tab` is `Style/Tab`. Badges can be
+    # parsed as either `Department/CopName` or just `CopName` to allow
+    # for badge references in source files that omit the department
+    # for RuboCop to infer.
+    class Badge
+      # Error raised when a badge parse fails.
+      class InvalidBadge < Error
+        MSG = 'Invalid badge %<badge>p. ' \
+              'Expected `Department/CopName` or `CopName`.'.freeze
+
+        def initialize(token)
+          super(format(MSG, badge: token))
+        end
+      end
+
+      attr_reader :department, :cop_name
+
+      def self.for(class_name)
+        new(*class_name.split('::').last(2))
+      end
+
+      def self.parse(identifier)
+        parts = identifier.split('/', 2)
+
+        raise InvalidBadge, identifier if parts.size > 2
+
+        if parts.one?
+          new(nil, *parts)
+        else
+          new(*parts)
+        end
+      end
+
+      def initialize(department, cop_name)
+        @department = department.to_sym if department
+        @cop_name   = cop_name
+      end
+
+      def ==(other)
+        hash == other.hash
+      end
+      alias eql? ==
+
+      def hash
+        [department, cop_name].hash
+      end
+
+      def match?(other)
+        cop_name == other.cop_name &&
+          (!qualified? || department == other.department)
+      end
+
+      def to_s
+        qualified? ? "#{department}/#{cop_name}" : cop_name
+      end
+
+      def qualified?
+        !department.nil?
+      end
+
+      def with_department(department)
+        self.class.new(department, cop_name)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -34,7 +34,7 @@ module RuboCop
 
           duplicated_gem_nodes.each do |nodes|
             nodes[1..-1].each do |node|
-              offense(
+              register_offense(
                 node,
                 node.method_args.first.to_a.first,
                 nodes.first.loc.line
@@ -54,7 +54,7 @@ module RuboCop
             .values
         end
 
-        def offense(node, gem_name, line_of_first_occurence)
+        def register_offense(node, gem_name, line_of_first_occurence)
           line_range = node.loc.column...node.loc.last_column
 
           add_offense(

data/lib/rubocop/cop/bundler/ordered_gems.rb

@@ -17,18 +17,26 @@ module RuboCop
       #
       #   gem 'rspec'
       class OrderedGems < Cop
-        MSG = 'Gem `%s` should appear before `%s` in their gem group.'.freeze
+        MSG = 'Gems should be sorted in an alphabetical order within their '\
+              'section of the Gemfile. '\
+              'Gem `%s` should appear before `%s`.'.freeze
         def investigate(processed_source)
           return if processed_source.ast.nil?
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
-            next unless current.children[2].children.first.to_s <
-                        previous.children[2].children.first.to_s
+            next unless case_insensitive_out_of_order?(
+              current.children[2].children.first.to_s,
+              previous.children[2].children.first.to_s
+            )
             register_offense(previous, current)
           end
         end
 
+        def case_insensitive_out_of_order?(string_a, string_b)
+          1 > string_a.casecmp(string_b)
+        end
+
         def consecutive_lines(previous, current)
           previous.source_range.last_line == current.source_range.first_line - 1
         end
@@ -45,6 +53,38 @@ module RuboCop
           )
         end
 
+        def autocorrect(node)
+          previous = previous_declaration(node)
+
+          current_range = declaration_with_comment(node)
+          previous_range = declaration_with_comment(previous)
+
+          lambda do |corrector|
+            swap_range(corrector, current_range, previous_range)
+          end
+        end
+
+        def declaration_with_comment(node)
+          buffer = processed_source.buffer
+          begin_pos = node.loc.expression.begin_pos
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_pos = buffer.line_range(end_line).end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def swap_range(corrector, range1, range2)
+          src1 = range1.source
+          src2 = range2.source
+          corrector.replace(range1, src2)
+          corrector.replace(range2, src1)
+        end
+
+        def previous_declaration(node)
+          declarations = gem_declarations(processed_source.ast)
+          node_index = declarations.find_index(node)
+          declarations.to_a[node_index - 1]
+        end
+
         def_node_search :gem_declarations, <<-PATTERN
           (:send, nil, :gem, ...)
         PATTERN

data/lib/rubocop/cop/commissioner.rb

@@ -5,7 +5,9 @@ module RuboCop
     # Commissioner class is responsible for processing the AST and delegating
     # work to the specified cops.
     class Commissioner
-      include RuboCop::Node::Traversal
+      include RuboCop::AST::Traversal
+
+      CopError = Struct.new(:error, :line, :column)
 
       attr_reader :errors
 
@@ -26,19 +28,19 @@ module RuboCop
       # to continue iterating over the children of a node.
       # However, if we know that a certain node type (like `int`) never has
       # child nodes, there is no reason to pay the cost of calling `super`.
-      no_child_callbacks = Node::Traversal::NO_CHILD_NODES.map do |type|
+      no_child_callbacks = NO_CHILD_NODES.map do |type|
         :"on_#{type}"
       end
 
       callback_methods.each do |callback|
-        next unless RuboCop::Node::Traversal.method_defined?(callback)
+        next unless method_defined?(callback)
         class_eval <<-EOS, __FILE__, __LINE__
           def #{callback}(node)
             @callbacks[:"#{callback}"] ||= @cops.select do |cop|
               cop.respond_to?(:"#{callback}")
             end
             @callbacks[:#{callback}].each do |cop|
-              with_cop_error_handling(cop) do
+              with_cop_error_handling(cop, node) do
                 cop.send(:#{callback}, node)
               end
             end
@@ -67,6 +69,10 @@ module RuboCop
 
       def remove_irrelevant_cops(filename)
         @cops.reject! { |cop| cop.excluded_file?(filename) }
+        @cops.reject! do |cop|
+          cop.class.respond_to?(:support_target_ruby_version?) &&
+            !cop.class.support_target_ruby_version?(cop.target_ruby_version)
+        end
       end
 
       def reset_callbacks
@@ -92,11 +98,16 @@ module RuboCop
         end
       end
 
-      def with_cop_error_handling(cop)
+      def with_cop_error_handling(cop, node = nil)
         yield
       rescue => e
         raise e if @options[:raise_error]
-        @errors[cop] << e
+        if node
+          line = node.loc.line
+          column = node.loc.column
+        end
+        error = CopError.new(e, line, column)
+        @errors[cop] << error
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -3,58 +3,6 @@ require 'uri'
 
 module RuboCop
   module Cop
-    class AmbiguousCopName < RuboCop::Error; end
-
-    # Store for all cops with helper functions
-    class CopStore < ::Array
-      # @return [Array<String>] list of types for current cops.
-      def types
-        @types ||= map(&:cop_type).uniq!
-      end
-
-      # @return [Array<Cop>] Cops for that specific type.
-      def with_type(type)
-        CopStore.new(select { |c| c.cop_type == type })
-      end
-
-      # @return [Array<Cop>] Cops not for a specific type.
-      def without_type(type)
-        CopStore.new(reject { |c| c.cop_type == type })
-      end
-
-      def qualified_cop_name(name, origin)
-        return name if cop_names.include?(name)
-
-        basename = File.basename(name)
-        found_ns = types.map(&:capitalize).select do |ns|
-          cop_names.include?("#{ns}/#{basename}")
-        end
-
-        case found_ns.size
-        when 0 then name # No namespace found. Deal with it later in caller.
-        when 1 then cop_name_with_namespace(name, origin, basename, found_ns[0])
-        else raise AmbiguousCopName,
-                   "Ambiguous cop name `#{name}` used in #{origin} needs " \
-                   'namespace qualifier. Did you mean ' \
-                   "#{found_ns.map { |ns| "#{ns}/#{basename}" }.join(' or ')}"
-        end
-      end
-
-      def cop_name_with_namespace(name, origin, basename, found_ns)
-        if name != basename && found_ns != File.dirname(name).to_sym
-          warn "#{origin}: #{name} has the wrong namespace - should be " \
-               "#{found_ns}"
-        end
-        "#{found_ns}/#{basename}"
-      end
-
-      private
-
-      def cop_names
-        @cop_names ||= Set.new(map(&:cop_name))
-      end
-    end
-
     # A scaffold for concrete cops.
     #
     # The Cop class is meant to be extended.
@@ -75,9 +23,9 @@ module RuboCop
     #     end
     #   end
     class Cop
-      extend RuboCop::Sexp
+      extend RuboCop::AST::Sexp
       extend NodePattern::Macros
-      include RuboCop::Sexp
+      include RuboCop::AST::Sexp
       include Util
       include IgnoredNode
       include AutocorrectLogic
@@ -85,34 +33,42 @@ module RuboCop
       attr_reader :config, :offenses, :corrections
       attr_accessor :processed_source # TODO: Bad design.
 
-      @all = CopStore.new
+      @registry = Registry.new
+
+      class << self
+        attr_reader :registry
+      end
 
       def self.all
-        @all.without_type(:test)
+        registry.without_department(:Test).cops
       end
 
       def self.qualified_cop_name(name, origin)
-        @all.qualified_cop_name(name, origin)
+        registry.qualified_cop_name(name, origin)
       end
 
       def self.non_rails
-        all.without_type(:rails)
+        registry.without_department(:Rails)
       end
 
       def self.inherited(subclass)
-        @all << subclass
+        registry.enlist(subclass)
+      end
+
+      def self.badge
+        @badge ||= Badge.for(name)
       end
 
       def self.cop_name
-        @cop_name ||= name.split('::').last(2).join('/')
+        badge.to_s
       end
 
-      def self.cop_type
-        @cop_type ||= name.split('::')[-2].downcase.to_sym
+      def self.department
+        badge.department
       end
 
       def self.lint?
-        cop_type == :lint
+        department == :Lint
       end
 
       # Returns true if the cop name or the cop namespace matches any of the
@@ -121,7 +77,7 @@ module RuboCop
         return false unless given_names
 
         given_names.include?(cop_name) ||
-          given_names.include?(cop_type.to_s.capitalize)
+          given_names.include?(department.to_s)
       end
 
       def initialize(config = nil, options = nil)
@@ -141,25 +97,6 @@ module RuboCop
         @cop_config ||= @config.for_cop(self)
       end
 
-      def debug?
-        @options[:debug]
-      end
-
-      def display_cop_names?
-        debug? || @options[:display_cop_names] ||
-          @config.for_all_cops['DisplayCopNames']
-      end
-
-      def display_style_guide?
-        (style_guide_url || reference_url) &&
-          (@options[:display_style_guide] ||
-            config.for_all_cops['DisplayStyleGuide'])
-      end
-
-      def extra_details?
-        @options[:extra_details] || config.for_all_cops['ExtraDetails']
-      end
-
       def message(_node = nil)
         self.class::MSG
       end
@@ -172,7 +109,7 @@ module RuboCop
         severity = custom_severity || severity || default_severity
 
         message ||= message(node)
-        message = annotate_message(message)
+        message = annotate(message)
 
         status = enabled_line?(location.line) ? correct(node) : :disabled
 
@@ -232,36 +169,12 @@ module RuboCop
         !relevant_file?(file)
       end
 
-      def style_guide_url
-        url = cop_config['StyleGuide']
-        return nil if url.nil? || url.empty?
-
-        base_url = config.for_all_cops['StyleGuideBaseURL']
-        return url if base_url.nil? || base_url.empty?
-
-        URI.join(base_url, url).to_s
-      end
-
-      def reference_url
-        url = cop_config['Reference']
-        url.nil? || url.empty? ? nil : url
-      end
-
-      def details
-        details = cop_config && cop_config['Details']
-        details.nil? || details.empty? ? nil : details
-      end
-
       private
 
-      def annotate_message(message)
-        message = "#{name}: #{message}" if display_cop_names?
-        message += " #{details}" if extra_details?
-        if display_style_guide?
-          links = [style_guide_url, reference_url].compact.join(', ')
-          message = "#{message} (#{links})"
-        end
-        message
+      def annotate(message)
+        RuboCop::Cop::MessageAnnotator.new(
+          config, cop_config, @options
+        ).annotate(message, name)
       end
 
       def file_name_matches_any?(file, parameter, default_result)