rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Bundler
+      # Gems should be alphabetically sorted within groups.
+      #
+      # @example
+      #   # bad
+      #   gem 'rubocop'
+      #   gem 'rspec'
+      #
+      #   # good
+      #   gem 'rspec'
+      #   gem 'rubocop'
+      #
+      #   # good
+      #   gem 'rubocop'
+      #
+      #   gem 'rspec'
+      #
+      #   # good only if TreatCommentsAsGroupSeparators is true
+      #   # For code quality
+      #   gem 'rubocop'
+      #   # For tests
+      #   gem 'rspec'
+      class OrderedGems < Cop
+        include ConfigurableEnforcedStyle
+        include OrderedGemNode
+
+        MSG = 'Gems should be sorted in an alphabetical order within their '\
+              'section of the Gemfile. '\
+              'Gem `%<previous>s` should appear before `%<current>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 case_insensitive_out_of_order?(
+              gem_name(current),
+              gem_name(previous)
+            )
+            register_offense(previous, current)
+          end
+        end
+
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
+        private
+
+        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 str ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/commissioner.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,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
 
@@ -27,26 +28,26 @@ 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)
-        class_eval <<-EOS, __FILE__, __LINE__
+        next unless method_defined?(callback)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           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
 
             #{!no_child_callbacks.include?(callback) && 'super'}
           end
-        EOS
+        RUBY
       end
 
       def investigate(processed_source)
@@ -68,6 +69,14 @@ 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
+        @cops.reject! do |cop|
+          cop.class.respond_to?(:support_target_rails_version?) &&
+            !cop.class.support_target_rails_version?(cop.target_rails_version)
+        end
       end
 
       def reset_callbacks
@@ -93,11 +102,19 @@ module RuboCop
         end
       end
 
-      def with_cop_error_handling(cop)
+      # 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.
+      def with_cop_error_handling(cop, node = nil)
         yield
-      rescue => e
+      rescue StandardError => e
         raise e if @options[:raise_error]
-        @errors[cop] << e
+        if node
+          line = node.first_line
+          column = node.loc.column
+        end
+        error = CopError.new(e, line, column)
+        @errors[cop] << error
       end
     end
   end

data/lib/rubocop/cop/cop.rb

@@ -1,52 +1,9 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
+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)
-        @cop_names ||= Set.new(map(&:cop_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 `#{basename}` used in" \
-                   "#{origin} needs namespace qualifier."
-        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
-    end
-
     # A scaffold for concrete cops.
     #
     # The Cop class is meant to be extended.
@@ -67,9 +24,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
@@ -77,34 +34,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
@@ -113,7 +78,17 @@ 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
+
+      # List of cops that should not try to autocorrect at the same
+      # time as this cop
+      #
+      # @return [Array<RuboCop::Cop::Cop>]
+      #
+      # @api public
+      def self.autocorrect_incompatible_with
+        []
       end
 
       def initialize(config = nil, options = nil)
@@ -122,6 +97,7 @@ module RuboCop
 
         @offenses = []
         @corrections = []
+        @processed_source = nil
       end
 
       def join_force?(_force_class)
@@ -129,48 +105,42 @@ module RuboCop
       end
 
       def cop_config
-        @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']
+        # 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
 
-      def add_offense(node, loc, message = nil, severity = nil)
-        location = loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def add_offense(node, location: :expression, message: nil, severity: nil)
+        loc = find_location(node, location)
 
-        # Don't include the same location twice for one cop.
-        return if @offenses.any? { |o| o.location == location }
+        return if duplicate_location?(loc)
 
         severity = custom_severity || severity || default_severity
 
         message ||= message(node)
-        message = annotate_message(message)
+        message = annotate(message)
 
-        status = enabled_line?(location.line) ? correct(node) : :disabled
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
 
-        @offenses << Offense.new(severity, location, message, name, status)
+        @offenses << Offense.new(severity, loc, message, name, status)
         yield if block_given? && status != :disabled
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def find_location(node, loc)
+        # Location can be provided as a symbol, e.g.: `:keyword`
+        loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+      end
+
+      def duplicate_location?(location)
+        @offenses.any? { |o| o.location == location }
+      end
 
       def correct(node)
         return :unsupported unless support_autocorrect?
@@ -196,6 +166,10 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      def target_rails_version
+        @config.target_rails_version
+      end
+
       def parse(source, path = nil)
         ProcessedSource.new(source, target_ruby_version, path)
       end
@@ -215,31 +189,12 @@ module RuboCop
         !relevant_file?(file)
       end
 
-      def style_guide_url
-        url = cop_config['StyleGuide']
-        url.nil? || url.empty? ? nil : url
-      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)

data/lib/rubocop/cop/corrector.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does auto-correction of nodes that should just be moved to
+    # the left or to the right, amount being determined by the instance
+    # variable column_delta.
+    class AlignmentCorrector
+      extend Util
+      extend Alignment
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(processed_source, node, column_delta)
+          return unless node
+          @processed_source = processed_source
+          expr = node.respond_to?(:loc) ? node.loc.expression : node
+          return if block_comment_within?(expr)
+
+          lambda do |corrector|
+            each_line(expr) do |line_begin_pos|
+              autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                               heredoc_ranges(node))
+            end
+          end
+        end
+
+        def align_end(processed_source, node, align_to)
+          @processed_source = processed_source
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          column = alignment_column(align_to)
+          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+        end
+
+        private
+
+        def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             heredoc_ranges)
+          range = calculate_range(expr, line_begin_pos, column_delta)
+          # We must not change indentation of heredoc strings.
+          return if heredoc_ranges.any? { |h| within?(range, h) }
+
+          if column_delta > 0
+            unless range.source == "\n"
+              corrector.insert_before(range, ' ' * column_delta)
+            end
+          elsif range.source =~ /\A[ \t]+\z/
+            remove(range, corrector)
+          end
+        end
+
+        def heredoc_ranges(node)
+          return [] unless node.is_a?(Parser::AST::Node)
+
+          node.each_node(:dstr)
+              .select { |n| n.loc.respond_to?(:heredoc_body) }
+              .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+        end
+
+        def block_comment_within?(expr)
+          processed_source.comments.select(&:document?).any? do |c|
+            within?(c.loc.expression, expr)
+          end
+        end
+
+        def calculate_range(expr, line_begin_pos, column_delta)
+          starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
+          pos_to_remove = if column_delta > 0 || starts_with_space
+                            line_begin_pos
+                          else
+                            line_begin_pos - column_delta.abs
+                          end
+
+          range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+        end
+
+        def remove(range, corrector)
+          original_stderr = $stderr
+          $stderr = StringIO.new # Avoid error messages on console
+          corrector.remove(range)
+        rescue RuntimeError
+          range = range_between(range.begin_pos + 1, range.end_pos + 1)
+          retry if range.source =~ /^ +$/
+        ensure
+          $stderr = original_stderr
+        end
+
+        def each_line(expr)
+          line_begin_pos = expr.begin_pos
+          expr.source.each_line do |line|
+            yield line_begin_pos
+            line_begin_pos += line.length
+          end
+        end
+
+        def begins_its_line?(range)
+          (range.source_line =~ /\S/) == range.column
+        end
+
+        def whitespace_range(node)
+          begin_pos = node.loc.end.begin_pos
+
+          range_between(begin_pos - node.loc.end.column, begin_pos)
+        end
+
+        def alignment_column(align_to)
+          if !align_to
+            0
+          elsif align_to.respond_to?(:loc)
+            align_to.source_range.column
+          else
+            align_to.column
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does condition auto-correction
+    class ConditionCorrector
+      class << self
+        def correct_negative_condition(node)
+          condition = negated_condition(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            corrector.replace(condition.source_range,
+                              condition.children.first.source)
+          end
+        end
+
+        private
+
+        def negated_condition(node)
+          condition = node.condition
+          condition = condition.children.first while condition.begin_type?
+          condition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does empty line auto-correction
+    class EmptyLineCorrector
+      class << self
+        def correct(node)
+          offense_style, range = node
+          lambda do |corrector|
+            case offense_style
+            when :no_empty_lines then
+              corrector.remove(range)
+            when :empty_lines then
+              corrector.insert_before(range, "\n")
+            end
+          end
+        end
+
+        def insert_before(node)
+          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Autocorrection logic for the closing brace of a literal either
+    # on the same line as the last contained elements, or a new line.
+    class MultilineLiteralBraceCorrector
+      extend MultilineLiteralBraceLayout
+      extend Util
+
+      class << self
+        attr_reader :processed_source
+
+        # rubocop:disable Metrics/MethodLength
+        def correct(processed_source, node)
+          @processed_source = processed_source
+          if closing_brace_on_same_line?(node)
+            lambda do |corrector|
+              corrector.insert_before(node.loc.end, "\n".freeze)
+            end
+          else
+            # When a comment immediately before the closing brace gets in the
+            # way of an easy correction, the offense is reported but not auto-
+            # corrected. The user must handle the delicate decision of where to
+            # put the comment.
+            return if new_line_needed_before_closing_brace?(node)
+
+            lambda do |corrector|
+              corrector.remove(range_with_surrounding_space(range: node.loc.end,
+                                                            side: :left))
+
+              corrector.insert_after(
+                last_element_range_with_trailing_comma(node),
+                node.loc.end.source
+              )
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def last_element_range_with_trailing_comma(node)
+          trailing_comma_range = last_element_trailing_comma_range(node)
+          if trailing_comma_range
+            children(node).last.source_range.join(trailing_comma_range)
+          else
+            children(node).last.source_range
+          end
+        end
+
+        def last_element_trailing_comma_range(node)
+          range = range_with_surrounding_space(
+            range: children(node).last.source_range,
+            side: :right
+          ).end.resize(1)
+          range.source == ',' ? range : nil
+        end
+      end
+    end
+  end
+end