rubocop 0.78.0

data/lib/rubocop/cop/commissioner.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      include RuboCop::AST::Traversal
+
+      attr_reader :errors
+
+      def initialize(cops, forces = [], options = {})
+        @cops = cops
+        @forces = forces
+        @options = options
+        @callbacks = {}
+
+        reset_errors
+      end
+
+      # Create methods like :on_send, :on_super, etc. They will be called
+      # during AST traversal and try to call corresponding methods on cops.
+      # A call to `super` is used
+      # 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`.
+      Parser::Meta::NODE_TYPES.each do |node_type|
+        method_name = :"on_#{node_type}"
+        next unless method_defined?(method_name)
+
+        define_method(method_name) do |node|
+          trigger_responding_cops(method_name, node)
+          super(node) unless NO_CHILD_NODES.include?(node_type)
+        end
+      end
+
+      def investigate(processed_source)
+        reset_errors
+        remove_irrelevant_cops(processed_source.file_path)
+        reset_callbacks
+        prepare(processed_source)
+        invoke_custom_processing(@cops, processed_source)
+        invoke_custom_processing(@forces, processed_source)
+        walk(processed_source.ast) unless processed_source.blank?
+        invoke_custom_post_walk_processing(@cops, processed_source)
+        @cops.flat_map(&:offenses)
+      end
+
+      private
+
+      def trigger_responding_cops(callback, node)
+        @callbacks[callback] ||= @cops.select do |cop|
+          cop.respond_to?(callback)
+        end
+        @callbacks[callback].each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.send(callback, node)
+          end
+        end
+      end
+
+      def reset_errors
+        @errors = []
+      end
+
+      def remove_irrelevant_cops(filename)
+        @cops.reject! do |cop|
+          cop.excluded_file?(filename) ||
+            !support_target_ruby_version?(cop) ||
+            !support_target_rails_version?(cop)
+        end
+      end
+
+      def support_target_ruby_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_ruby_version?)
+
+        cop.class.support_target_ruby_version?(cop.target_ruby_version)
+      end
+
+      def support_target_rails_version?(cop)
+        return true unless cop.class.respond_to?(:support_target_rails_version?)
+
+        cop.class.support_target_rails_version?(cop.target_rails_version)
+      end
+
+      def reset_callbacks
+        @callbacks.clear
+      end
+
+      # TODO: Bad design.
+      def prepare(processed_source)
+        @cops.each { |cop| cop.processed_source = processed_source }
+      end
+
+      # There are cops/forces that require their own custom processing.
+      # If they define the #investigate method, all input parameters passed
+      # to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      #
+      # These custom processors are invoked before the AST traversal,
+      # so they can build initial state that is later used by callbacks
+      # during the AST traversal.
+      def invoke_custom_processing(cops_or_forces, processed_source)
+        cops_or_forces.each do |cop|
+          next unless cop.respond_to?(:investigate)
+
+          with_cop_error_handling(cop) do
+            cop.investigate(processed_source)
+          end
+        end
+      end
+
+      # There are cops that require their own custom processing **after**
+      # the AST traversal. By performing the walk before invoking these
+      # custom processors, we allow these cops to build their own
+      # state during the primary AST traversal instead of performing their
+      # own AST traversals. Minimizing the number of walks is more efficient.
+      #
+      # If they define the #investigate_post_walk method, all input parameters
+      # passed to the commissioner will be passed to the cop too in order to do
+      # its own processing.
+      def invoke_custom_post_walk_processing(cops, processed_source)
+        cops.each do |cop|
+          next unless cop.respond_to?(:investigate_post_walk)
+
+          with_cop_error_handling(cop) do
+            cop.investigate_post_walk(processed_source)
+          end
+        end
+      end
+
+      # 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 StandardError => e
+        raise e if @options[:raise_error]
+
+        err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        @errors << err
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module RuboCop
+  module Cop
+    # A scaffold for concrete cops.
+    #
+    # The Cop class is meant to be extended.
+    #
+    # Cops track offenses and can autocorrect them on the fly.
+    #
+    # A commissioner object is responsible for traversing the AST and invoking
+    # the specific callbacks on each cop.
+    # If a cop needs to do its own processing of the AST or depends on
+    # something else, it should define the `#investigate` method and do
+    # the processing there.
+    #
+    # @example
+    #
+    #   class CustomCop < Cop
+    #     def investigate(processed_source)
+    #       # Do custom processing
+    #     end
+    #   end
+    class Cop
+      extend RuboCop::AST::Sexp
+      extend NodePattern::Macros
+      include RuboCop::AST::Sexp
+      include Util
+      include IgnoredNode
+      include AutocorrectLogic
+
+      Correction = Struct.new(:lambda, :node, :cop) do
+        def call(corrector)
+          lambda.call(corrector)
+        rescue StandardError => e
+          raise ErrorWithAnalyzedFileLocation.new(
+            cause: e, node: node, cop: cop
+          )
+        end
+      end
+
+      attr_reader :config, :offenses, :corrections
+      attr_accessor :processed_source # TODO: Bad design.
+
+      @registry = Registry.new
+
+      class << self
+        attr_reader :registry
+      end
+
+      def self.all
+        registry.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        registry.qualified_cop_name(name, origin)
+      end
+
+      def self.inherited(subclass)
+        registry.enlist(subclass)
+      end
+
+      def self.badge
+        @badge ||= Badge.for(name)
+      end
+
+      def self.cop_name
+        badge.to_s
+      end
+
+      def self.department
+        badge.department
+      end
+
+      def self.lint?
+        department == :Lint
+      end
+
+      # Returns true if the cop name or the cop namespace matches any of the
+      # given names.
+      def self.match?(given_names)
+        return false unless given_names
+
+        given_names.include?(cop_name) ||
+          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)
+        @config = config || Config.new
+        @options = options || { debug: false }
+
+        @offenses = []
+        @corrections = []
+        @corrected_nodes = {}
+        @corrected_nodes.compare_by_identity
+        @processed_source = nil
+      end
+
+      def join_force?(_force_class)
+        false
+      end
+
+      def cop_config
+        # 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, location: :expression, message: nil, severity: nil)
+        loc = find_location(node, location)
+
+        return if duplicate_location?(loc)
+
+        severity = find_severity(node, severity)
+        message = find_message(node, message)
+
+        status = enabled_line?(loc.line) ? correct(node) : :disabled
+
+        @offenses << Offense.new(severity, loc, message, name, status)
+        yield if block_given? && status != :disabled
+      end
+
+      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)
+        reason = reason_to_not_correct(node)
+        return reason if reason
+
+        @corrected_nodes[node] = true
+        if support_autocorrect?
+          correction = autocorrect(node)
+          return :uncorrected unless correction
+
+          @corrections << Correction.new(correction, node, self)
+          :corrected
+        elsif disable_uncorrectable?
+          disable_uncorrectable(node)
+          :corrected_with_todo
+        end
+      end
+
+      def reason_to_not_correct(node)
+        return :unsupported unless correctable?
+        return :uncorrected unless autocorrect?
+        return :already_corrected if @corrected_nodes.key?(node)
+
+        nil
+      end
+
+      def disable_uncorrectable(node)
+        return unless node
+
+        @disabled_lines ||= {}
+        line = node.location.line
+        return if @disabled_lines.key?(line)
+
+        @disabled_lines[line] = true
+        @corrections << Correction.new(disable_offense(node), node, self)
+      end
+
+      def config_to_allow_offenses
+        Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses[cop_name] ||= {}
+      end
+
+      def config_to_allow_offenses=(hash)
+        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
+          hash
+      end
+
+      def target_ruby_version
+        @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
+
+      def cop_name
+        @cop_name ||= self.class.cop_name
+      end
+
+      alias name cop_name
+
+      def relevant_file?(file)
+        file_name_matches_any?(file, 'Include', true) &&
+          !file_name_matches_any?(file, 'Exclude', false)
+      end
+
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
+      # This method should be overridden when a cop's behavior depends
+      # on state that lives outside of these locations:
+      #
+      #   (1) the file under inspection
+      #   (2) the cop's source code
+      #   (3) the config (eg a .rubocop.yml file)
+      #
+      # For example, some cops may want to look at other parts of
+      # the codebase being inspected to find violations. A cop may
+      # use the presence or absence of file `foo.rb` to determine
+      # whether a certain violation exists in `bar.rb`.
+      #
+      # Overriding this method allows the cop to indicate to RuboCop's
+      # ResultCache system when those external dependencies change,
+      # ie when the ResultCache should be invalidated.
+      def external_dependency_checksum
+        nil
+      end
+
+      private
+
+      def find_message(node, message)
+        annotate(message || message(node))
+      end
+
+      def annotate(message)
+        RuboCop::Cop::MessageAnnotator.new(
+          config, cop_name, cop_config, @options
+        ).annotate(message)
+      end
+
+      def file_name_matches_any?(file, parameter, default_result)
+        patterns = cop_config[parameter]
+        return default_result unless patterns
+
+        path = nil
+        patterns.any? do |pattern|
+          # Try to match the absolute path, as Exclude properties are absolute.
+          next true if match_path?(pattern, file)
+
+          # Try with relative path.
+          path ||= config.path_relative_to_config(file)
+          match_path?(pattern, path)
+        end
+      end
+
+      def enabled_line?(line_number)
+        return true if @options[:ignore_disable_comments] || !@processed_source
+
+        @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
+      end
+
+      def find_severity(_node, severity)
+        custom_severity || severity || default_severity
+      end
+
+      def default_severity
+        self.class.lint? ? :warning : :convention
+      end
+
+      def custom_severity
+        severity = cop_config['Severity']
+        return unless severity
+
+        if Severity::NAMES.include?(severity.to_sym)
+          severity.to_sym
+        else
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/corrector.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class takes a source buffer and rewrite its source
+    # based on the different correction rules supplied.
+    #
+    # Important!
+    # The nodes modified by the corrections should be part of the
+    # AST of the source_buffer.
+    class Corrector
+      #
+      # @param source_buffer [Parser::Source::Buffer]
+      # @param corrections [Array(#call)]
+      #   Array of Objects that respond to #call. They will receive the
+      #   corrector itself and should use its method to modify the source.
+      #
+      # @example
+      #
+      #   class AndOrCorrector
+      #     def initialize(node)
+      #       @node = node
+      #     end
+      #
+      #     def call(corrector)
+      #       replacement = (@node.type == :and ? '&&' : '||')
+      #       corrector.replace(@node.loc.operator, replacement)
+      #     end
+      #   end
+      #
+      #   corrections = [AndOrCorrector.new(node)]
+      #   corrector = Corrector.new(source_buffer, corrections)
+      def initialize(source_buffer, corrections = [])
+        @source_buffer = source_buffer
+        raise 'source_buffer should be a Parser::Source::Buffer' unless \
+          source_buffer.is_a? Parser::Source::Buffer
+
+        @corrections = corrections
+        @source_rewriter = Parser::Source::TreeRewriter.new(
+          source_buffer,
+          different_replacements: :raise,
+          swallowed_insertions: :raise,
+          crossing_deletions: :accept
+        )
+
+        @diagnostics = []
+        # Don't print warnings to stderr if corrections conflict with each other
+        @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
+          @diagnostics << diagnostic
+        end
+      end
+
+      attr_reader :corrections, :diagnostics
+
+      # Does the actual rewrite and returns string corresponding to
+      # the rewritten source.
+      #
+      # @return [String]
+      def rewrite
+        @corrections.each do |correction|
+          begin
+            @source_rewriter.transaction do
+              correction.call(self)
+            end
+          rescue ErrorWithAnalyzedFileLocation => e
+            raise e unless e.cause.is_a?(::Parser::ClobberingError)
+          end
+        end
+
+        @source_rewriter.process
+      end
+
+      # Removes the source range.
+      #
+      # @param [Parser::Source::Range] range
+      def remove(range)
+        validate_range range
+        @source_rewriter.remove(range)
+      end
+
+      # Inserts new code before the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_before(range, content)
+        validate_range range
+        # TODO: Fix Cops using bad ranges instead
+        if range.end_pos > @source_buffer.source.size
+          range = range.with(end_pos: @source_buffer.source.size)
+        end
+
+        @source_rewriter.insert_before(range, content)
+      end
+
+      # Inserts new code after the given source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def insert_after(range, content)
+        validate_range range
+        @source_rewriter.insert_after(range, content)
+      end
+
+      # Replaces the code of the source range `range` with `content`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [String] content
+      def replace(range, content)
+        validate_range range
+        @source_rewriter.replace(range, content)
+      end
+
+      # Removes `size` characters prior to the source range.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_preceding(range, size)
+        validate_range range
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos - size,
+                                              range.begin_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the beginning of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the end of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_leading(range, size)
+        validate_range range
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.begin_pos,
+                                              range.begin_pos + size)
+        @source_rewriter.remove(to_remove)
+      end
+
+      # Removes `size` characters from the end of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the beginning of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_trailing(range, size)
+        validate_range range
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.end_pos - size,
+                                              range.end_pos)
+        @source_rewriter.remove(to_remove)
+      end
+
+      private
+
+      # :nodoc:
+      def validate_range(range)
+        buffer = range.source_buffer
+        return if buffer == @source_buffer
+
+        unless buffer.is_a?(Parser::Source::Buffer)
+          # actually this should be enforced by parser gem
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
+        end
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect}" \
+              " is not current #{@source_buffer.object_id} " \
+              "name:#{@source_buffer.name.inspect} under investigation"
+      end
+    end
+  end
+end