rubocop 0.50.0 → 0.51.0

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

@@ -26,6 +26,7 @@ module RuboCop
       #   gem 'rspec'
       class OrderedGems < Cop
         include ConfigurableEnforcedStyle
+        include OrderedGemNode
 
         MSG = 'Gems should be sorted in an alphabetical order within their '\
               'section of the Gemfile. '\
@@ -46,66 +47,14 @@ module RuboCop
 
         private
 
-        def case_insensitive_out_of_order?(string_a, string_b)
-          string_a.downcase < string_b.downcase
-        end
-
-        def consecutive_lines(previous, current)
-          first_line = get_source_range(current).first_line
-          previous.source_range.last_line == first_line - 1
-        end
-
-        def register_offense(previous, current)
-          add_offense(current, :expression,
-                      format(MSG, gem_name(current), gem_name(previous)))
-        end
-
-        def gem_name(declaration_node)
-          declaration_node.first_argument.str_content
-        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 = get_source_range(node).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 get_source_range(node)
-          unless cop_config['TreatCommentsAsGroupSeparators']
-            first_comment = processed_source.ast_with_comments[node].first
-            return first_comment.loc.expression unless first_comment.nil?
-          end
-          node.source_range
-        end
-
         def_node_search :gem_declarations, <<-PATTERN
-          (:send nil :gem ...)
+          (:send nil? :gem ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/commissioner.rb

@@ -105,11 +105,9 @@ module RuboCop
       # Allow blind rescues here, since we're absorbing and packaging or
       # re-raising exceptions that can be raised from within the individual
       # cops' `#investigate` methods.
-      #
-      # rubocop:disable Lint/RescueWithoutErrorClass
       def with_cop_error_handling(cop, node = nil)
         yield
-      rescue => e
+      rescue StandardError => e
         raise e if @options[:raise_error]
         if node
           line = node.loc.line
@@ -118,7 +116,6 @@ module RuboCop
         error = CopError.new(e, line, column)
         @errors[cop] << error
       end
-      # rubocop:enable Lint/RescueWithoutErrorClass
     end
   end
 end

data/lib/rubocop/cop/cop.rb

@@ -105,30 +105,23 @@ module RuboCop
       end
 
       def cop_config
-        @cop_config ||= @config.for_cop(self)
+        # Use department configuration as basis, but let individual cop
+        # configuration override.
+        @cop_config ||= @config.for_cop(self.class.department.to_s)
+                               .merge(@config.for_cop(self))
       end
 
       def message(_node = nil)
         self.class::MSG
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def add_offense(node, loc = :expression, message = nil, severity = nil)
-        location = find_location(node, loc)
-
-        return if duplicate_location?(location)
-
-        severity = custom_severity || severity || default_severity
-
-        message ||= message(node)
-        message = annotate(message)
-
-        status = enabled_line?(location.line) ? correct(node) : :disabled
-
-        @offenses << Offense.new(severity, location, message, name, status)
-        yield if block_given? && status != :disabled
+      def add_offense(node, *args, **kwargs, &block)
+        if args.any?
+          add_offense_deprecated(node, *args, &block)
+        else
+          add_offense_common(node, **kwargs, &block)
+        end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def find_location(node, loc)
         # Location can be provided as a symbol, e.g.: `:keyword`
@@ -229,6 +222,46 @@ module RuboCop
           warn(Rainbow(message).red)
         end
       end
+
+      def add_offense_deprecated(node, loc = :expression, message = nil,
+                                 severity = nil, &block)
+
+        caller = caller_locations(2..2).first
+        path = "#{caller.path}:#{caller.lineno}"
+        warn_message = <<-RUBY.strip_indent
+          #{path}
+          Warning: The usage of positional location, message, and severity
+          parameters to Cop#add_offense is deprecated.
+          Please use keyword arguments instead.
+
+          The positional arguments version of Cop#add_offense will be removed in
+          RuboCop 0.52
+        RUBY
+
+        warn(Rainbow(warn_message).red)
+
+        add_offense_common(node, location: loc, message: message,
+                                 severity: severity, &block)
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense_common(node, location: :expression, message: nil,
+                             severity: nil)
+        loc = find_location(node, location)
+
+        return if duplicate_location?(loc)
+
+        severity = custom_severity || severity || default_severity
+
+        message ||= message(node)
+        message = annotate(message)
+
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
+
+        @offenses << Offense.new(severity, loc, message, name, status)
+        yield if block_given? && status != :disabled
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gemspec
+      # Dependencies in the gemspec should be alphabetically sorted.
+      #
+      # @example
+      #   # bad
+      #   spec.add_dependency 'rubocop'
+      #   spec.add_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_dependency 'rspec'
+      #   spec.add_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_dependency 'rubocop'
+      #
+      #   spec.add_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_development_dependency 'rubocop'
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rspec'
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_development_dependency 'rubocop'
+      #
+      #   spec.add_development_dependency 'rspec'
+      #
+      #   # bad
+      #   spec.add_runtime_dependency 'rubocop'
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rspec'
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   # good
+      #   spec.add_runtime_dependency 'rubocop'
+      #
+      #   spec.add_runtime_dependency 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   spec.add_dependency 'rubocop'
+      #   # For tests
+      #   spec.add_dependency 'rspec'
+      class OrderedDependencies < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        MSG = 'Dependencies should be sorted in an alphabetical order within '\
+              'their section of the gemspec. '\
+              'Dependency `%s` should appear before `%s`.'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.ast.nil?
+          dependency_declarations(processed_source.ast)
+            .each_cons(2) do |previous, current|
+            next unless consecutive_lines(previous, current)
+            next unless case_insensitive_out_of_order?(
+              gem_name(current),
+              gem_name(previous)
+            )
+            unless get_dependency_name(previous) == get_dependency_name(current)
+              next
+            end
+
+            register_offense(previous, current)
+          end
+        end
+
+        private
+
+        def previous_declaration(node)
+          declarations = dependency_declarations(processed_source.ast)
+          node_index = declarations.find_index(node)
+          declarations.to_a[node_index - 1]
+        end
+
+        def get_dependency_name(node)
+          node.method_name
+        end
+
+        def_node_search :dependency_declarations, <<-PATTERN
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator.rb

@@ -101,6 +101,8 @@ module RuboCop
           Files created:
             - #{source_path}
             - #{spec_path}
+          File modified:
+            - `require_relative '#{require_path}'` added into lib/rubocop.rb
 
           Do 3 steps:
             1. Add an entry to the "New features" section in CHANGELOG.md,
@@ -115,7 +117,10 @@ module RuboCop
       attr_reader :badge
 
       def write_unless_file_exists(path, contents)
-        raise "#{path} already exists!" if File.exist?(path)
+        if File.exist?(path)
+          warn "rake new_cop: #{path} already exists!"
+          exit!
+        end
 
         dir = File.dirname(path)
         FileUtils.mkdir_p(dir) unless File.exist?(dir)
@@ -170,7 +175,7 @@ module RuboCop
       # It looks for other directives that require files in the same (cop)
       # namespace and injects the provided one in alpha
       class RequireFileInjector
-        REQUIRE_PATH = /require ['"](.+)['"]/
+        REQUIRE_PATH = /require_relative ['"](.+)['"]/
 
         def initialize(require_path)
           @require_path    = require_path
@@ -228,7 +233,7 @@ module RuboCop
         end
 
         def injectable_require_directive
-          "require '#{require_path}'\n"
+          "require_relative '#{require_path}'\n"
         end
       end
     end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'rubocop/cop/internal_affairs/node_type_predicate'
-require 'rubocop/cop/internal_affairs/offense_location_keyword'
-require 'rubocop/cop/internal_affairs/redundant_message_argument'
-require 'rubocop/cop/internal_affairs/redundant_location_argument'
-require 'rubocop/cop/internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/node_type_predicate'
+require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/redundant_message_argument'
+require_relative 'internal_affairs/redundant_location_argument'
+require_relative 'internal_affairs/useless_message_assertion'
+require_relative 'internal_affairs/deprecated_positional_arguments'

data/lib/rubocop/cop/internal_affairs/deprecated_positional_arguments.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces use of keyword arguments for `#add_offense`.
+      #
+      # @example
+      #
+      #   # bad
+      #   add_offense(node, :selector, 'message')
+      #   add_offense(node, :selector, message: 'message')
+      #
+      #   # good
+      #   add_offense(node, location: :selector, message: 'message')
+      #
+      class DeprecatedPositionalArguments < Cop
+        MSG = 'Use of positional arguments on `#add_offense` is ' \
+          'deprecated.'.freeze
+
+        ARGUMENTS = %i[location message severity].freeze
+
+        def on_send(node)
+          return unless node.method_name == :add_offense
+
+          positional_arguments(node) do |arguments|
+            location = range_between(
+              arguments.first.loc.expression.begin_pos,
+              arguments.last.loc.expression.end_pos
+            )
+
+            add_offense(node, location: location)
+          end
+        end
+
+        def autocorrect(node)
+          positional_arguments(node) do |arguments|
+            # Can't autocorrect splat.
+            next if arguments.any?(&:splat_type?)
+
+            lambda do |corrector|
+              arguments.zip(ARGUMENTS).each do |(arg, keyword)|
+                corrector.replace(arg.source_range, "#{keyword}: #{arg.source}")
+              end
+            end
+          end
+        end
+
+        private
+
+        def positional_arguments(node)
+          arguments = extract_arguments(node)
+
+          positional_args =
+            case arguments
+            when :empty?.to_proc then []
+            # Keyword arguments only
+            when ->(args) { args.one? && args.first.hash_type? } then []
+            # Mixed style
+            when ->(args) { args.last.hash_type? } then arguments.drop_last(1)
+            # Positional arguments only
+            else arguments
+            end
+
+          yield positional_args if positional_args.any?
+        end
+
+        def extract_arguments(node)
+          node.arguments.butfirst.take_while do |arg|
+            # Filter out block argument
+            next false if arg.block_pass_type?
+            # Filter out kwsplat
+            next false if arg.hash_type? && arg.each_child_node(:kwsplat).any?
+            # Keep all others
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -24,7 +24,7 @@ module RuboCop
           node_type_check(node) do |_receiver, node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
-            add_offense(node, :expression, format(MSG, node_type))
+            add_offense(node, message: format(MSG, node_type))
           end
         end
 

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -9,31 +9,41 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   add_offense(node, node.loc.selector)
+      #   add_offense(node, location: node.loc.selector)
       #
       #   # good
-      #   add_offense(node, :selector)
+      #   add_offense(node, location: :selector)
       class OffenseLocationKeyword < Cop
         MSG = 'Use `:%s` as the location argument to `#add_offense`.'.freeze
 
         def on_send(node)
-          offense_location(node) do |location_argument, keyword|
-            add_offense(node, location_argument.loc.expression,
-                        format(MSG, keyword))
+          node_type_check(node) do |node_arg, kwargs|
+            find_offending_argument(node_arg, kwargs) do |location, keyword|
+              add_offense(location, message: format(MSG, keyword))
+            end
           end
         end
 
         private
 
-        def_node_matcher :offense_location, <<-PATTERN
-          (send nil :add_offense _offender
-            $(send (send _offender :loc) $_) ...)
+        def_node_matcher :node_type_check, <<-PATTERN
+          (send nil? :add_offense $_node $hash)
+        PATTERN
+
+        def_node_matcher :offending_location_argument, <<-PATTERN
+          (pair (sym :location) $(send (send $_node :loc) $_keyword))
         PATTERN
 
         def autocorrect(node)
-          lambda do |corrector|
-            offense_location(node) do |location_argument, keyword|
-              corrector.replace(location_argument.loc.expression, ":#{keyword}")
+          (*, keyword) = offending_location_argument(node.parent)
+
+          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+        end
+
+        def find_offending_argument(searched_node, kwargs)
+          kwargs.pairs.each do |pair|
+            offending_location_argument(pair) do |location, node, keyword|
+              yield(location, keyword) if searched_node == node
             end
           end
         end