rubocop 0.80.0 → 1.42.0

data/lib/rubocop/directive_comment.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class wraps the `Parser::Source::Comment` object that represents a
+  # special `rubocop:disable` and `rubocop:enable` comment and exposes what
+  # cops it contains.
+  class DirectiveComment
+    # @api private
+    REDUNDANT_DIRECTIVE_COP_DEPARTMENT = 'Lint'
+    # @api private
+    REDUNDANT_DIRECTIVE_COP = "#{REDUNDANT_DIRECTIVE_COP_DEPARTMENT}/RedundantCopDisableDirective"
+    # @api private
+    COP_NAME_PATTERN = '([A-Z]\w+/)*(?:[A-Z]\w+)'
+    # @api private
+    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
+    # @api private
+    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
+    # @api private
+    DIRECTIVE_COMMENT_REGEXP = Regexp.new(
+      "# rubocop : ((?:disable|enable|todo))\\b #{COPS_PATTERN}"
+        .gsub(' ', '\s*')
+    )
+
+    def self.before_comment(line)
+      line.split(DIRECTIVE_COMMENT_REGEXP).first
+    end
+
+    attr_reader :comment, :cop_registry, :mode, :cops
+
+    def initialize(comment, cop_registry = Cop::Registry.global)
+      @comment = comment
+      @cop_registry = cop_registry
+      @mode, @cops = match_captures
+    end
+
+    # Checks if this directive relates to single line
+    def single_line?
+      !comment.text.start_with?(DIRECTIVE_COMMENT_REGEXP)
+    end
+
+    # Checks if this directive contains all the given cop names
+    def match?(cop_names)
+      parsed_cop_names.uniq.sort == cop_names.uniq.sort
+    end
+
+    def range
+      match = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      begin_pos = comment.loc.expression.begin_pos
+      Parser::Source::Range.new(
+        comment.loc.expression.source_buffer, begin_pos + match.begin(0), begin_pos + match.end(0)
+      )
+    end
+
+    # Returns match captures to directive comment pattern
+    def match_captures
+      @match_captures ||= comment.text.match(DIRECTIVE_COMMENT_REGEXP)&.captures
+    end
+
+    # Checks if this directive disables cops
+    def disabled?
+      %w[disable todo].include?(mode)
+    end
+
+    # Checks if this directive enables cops
+    def enabled?
+      mode == 'enable'
+    end
+
+    # Checks if this directive enables all cops
+    def enabled_all?
+      !disabled? && all_cops?
+    end
+
+    # Checks if this directive disables all cops
+    def disabled_all?
+      disabled? && all_cops?
+    end
+
+    # Checks if all cops specified in this directive
+    def all_cops?
+      cops == 'all'
+    end
+
+    # Returns array of specified in this directive cop names
+    def cop_names
+      @cop_names ||= all_cops? ? all_cop_names : parsed_cop_names
+    end
+
+    # Returns array of specified in this directive department names
+    # when all department disabled
+    def department_names
+      splitted_cops_string.select { |cop| department?(cop) }
+    end
+
+    # Checks if directive departments include cop
+    def in_directive_department?(cop)
+      department_names.any? { |department| cop.start_with?(department) }
+    end
+
+    # Checks if cop department has already used in directive comment
+    def overridden_by_department?(cop)
+      in_directive_department?(cop) && splitted_cops_string.include?(cop)
+    end
+
+    def directive_count
+      splitted_cops_string.count
+    end
+
+    # Returns line number for directive
+    def line_number
+      comment.loc.expression.line
+    end
+
+    private
+
+    def splitted_cops_string
+      (cops || '').split(/,\s*/)
+    end
+
+    def parsed_cop_names
+      splitted_cops_string.map do |name|
+        department?(name) ? cop_names_for_department(name) : name
+      end.flatten
+    end
+
+    def department?(name)
+      cop_registry.department?(name)
+    end
+
+    def all_cop_names
+      exclude_redundant_directive_cop(cop_registry.names)
+    end
+
+    def cop_names_for_department(department)
+      names = cop_registry.names_for_department(department)
+      has_redundant_directive_cop = department == REDUNDANT_DIRECTIVE_COP_DEPARTMENT
+      has_redundant_directive_cop ? exclude_redundant_directive_cop(names) : names
+    end
+
+    def exclude_redundant_directive_cop(cops)
+      cops - [REDUNDANT_DIRECTIVE_COP]
+    end
+  end
+end

data/lib/rubocop/error.rb

@@ -12,6 +12,7 @@ module RuboCop
   # A wrapper to display errored location of analyzed file.
   class ErrorWithAnalyzedFileLocation < Error
     def initialize(cause:, node:, cop:)
+      super()
       @cause = cause
       @cop = cop
       @location = node.is_a?(RuboCop::AST::Node) ? node.loc : node

data/lib/rubocop/ext/processed_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to AST::ProcessedSource for our cached comment_config
+    module ProcessedSource
+      attr_accessor :registry, :config
+
+      def comment_config
+        @comment_config ||= CommentConfig.new(self)
+      end
+
+      def disabled_line_ranges
+        comment_config.cop_disabled_line_ranges
+      end
+    end
+  end
+end
+
+RuboCop::ProcessedSource.include RuboCop::Ext::ProcessedSource

data/lib/rubocop/ext/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to Parser::Source::Range
+    module Range
+      # Adds `Range#single_line?` to parallel `Node#single_line?`
+      def single_line?
+        first_line == last_line
+      end
+    end
+  end
+end
+
+Parser::Source::Range.include RuboCop::Ext::Range

data/lib/rubocop/ext/regexp_node.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to AST::RegexpNode for our cached parsed regexp info
+    module RegexpNode
+      ANY = Object.new
+      def ANY.==(_)
+        true
+      end
+      private_constant :ANY
+
+      # @return [Regexp::Expression::Root, nil]
+      # Note: we extend Regexp nodes to provide `loc` and `expression`
+      # see `ext/regexp_parser`.
+      attr_reader :parsed_tree
+
+      if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
+        def assign_properties(*)
+          super
+
+          str = with_interpolations_blanked
+          @parsed_tree = begin
+            Regexp::Parser.parse(str, options: options)
+          rescue StandardError
+            nil
+          end
+          origin = loc.begin.end
+          @parsed_tree&.each_expression(true) { |e| e.origin = origin }
+        end
+      # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
+      # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+      else
+        def assign_properties(*)
+          super
+
+          str = with_interpolations_blanked
+          begin
+            @parsed_tree = Regexp::Parser.parse(str, options: options)
+          rescue StandardError
+            @parsed_tree = nil
+          else
+            origin = loc.begin.end
+            source = @parsed_tree.to_s
+            @parsed_tree.each_expression(true) do |e|
+              e.origin = origin
+              e.source = source
+            end
+          end
+        end
+      end
+
+      def each_capture(named: ANY)
+        return enum_for(__method__, named: named) unless block_given?
+
+        parsed_tree&.traverse do |event, exp, _index|
+          yield(exp) if event == :enter &&
+                        named == exp.respond_to?(:name) &&
+                        exp.respond_to?(:capturing?) &&
+                        exp.capturing?
+        end
+
+        self
+      end
+
+      private
+
+      def with_interpolations_blanked
+        # Ignore the trailing regopt node
+        children[0...-1].map do |child|
+          source = child.source
+
+          # We don't want to consider the contents of interpolations as part of the pattern source,
+          # but need to preserve their width, to allow offsets to correctly line up with the
+          # original source: spaces have no effect, and preserve width.
+          if child.begin_type?
+            ' ' * source.length
+          else
+            source
+          end
+        end.join
+      end
+
+      AST::RegexpNode.include self
+    end
+  end
+end

data/lib/rubocop/ext/regexp_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions for `regexp_parser` gem
+    module RegexpParser
+      # Source map for RegexpParser nodes
+      class Map < ::Parser::Source::Map
+        attr_reader :body, :quantifier, :begin, :end
+
+        def initialize(expression, body:, quantifier: nil, begin_l: nil, end_l: nil)
+          @begin = begin_l
+          @end = end_l
+          @body = body
+          @quantifier = quantifier
+          super(expression)
+        end
+      end
+
+      module Expression
+        # Add `expression` and `loc` to all `regexp_parser` nodes
+        module Base
+          attr_accessor :origin
+
+          if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
+            # Shortcut to `loc.expression`
+            def expression
+              @expression ||= origin.adjust(begin_pos: ts, end_pos: ts + full_length)
+            end
+          # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
+          # It's for compatibility with regexp_arser 1.8 and will never be maintained.
+          else
+            attr_accessor :source
+
+            def start_index
+              # ts is a byte index; convert it to a character index
+              @start_index ||= source.byteslice(0, ts).length
+            end
+
+            # Shortcut to `loc.expression`
+            def expression
+              end_pos = start_index + full_length
+              @expression ||= origin.adjust(begin_pos: start_index, end_pos: end_pos)
+            end
+          end
+
+          # @returns a location map like `parser` does, with:
+          #   - expression: complete expression
+          #   - quantifier: for `+`, `{1,2}`, etc.
+          #   - begin/end: for `[` and `]` (only CharacterSet for now)
+          #
+          # E.g.
+          #     [a-z]{2,}
+          #     ^^^^^^^^^ expression
+          #          ^^^^ quantifier
+          #     ^^^^^     body
+          #     ^         begin
+          #         ^     end
+          #
+          # Please open issue if you need other locations
+          def loc
+            @loc ||= Map.new(expression, **build_location)
+          end
+
+          private
+
+          def build_location
+            return { body: expression } unless (q = quantifier)
+
+            body = expression.adjust(end_pos: -q.text.length)
+            q_loc = expression.with(begin_pos: body.end_pos)
+            { body: body, quantifier: q_loc }
+          end
+        end
+
+        # Provide `CharacterSet` with `begin` and `end` locations.
+        module CharacterSet
+          def build_location
+            h = super
+            body = h[:body]
+            h.merge!(
+              begin_l: body.with(end_pos: body.begin_pos + 1),
+              end_l: body.with(begin_pos: body.end_pos - 1)
+            )
+          end
+        end
+      end
+      ::Regexp::Expression::Base.include Expression::Base
+      ::Regexp::Expression::CharacterSet.include Expression::CharacterSet
+    end
+  end
+end

data/lib/rubocop/feature_loader.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles loading files (a.k.a. features in Ruby) specified
+  # by `--require` command line option and `require` directive in the config.
+  #
+  # Normally, the given string is directly passed to `require`. If a string
+  # beginning with `.` is given, it is assumed to be relative to the given
+  # directory.
+  #
+  # If a string containing `-` is given, it will be used as is, but if we
+  # cannot find the file to load, we will replace `-` with `/` and try it
+  # again as when Bundler loads gems.
+  #
+  # @api private
+  class FeatureLoader
+    class << self
+      # @param [String] config_directory_path
+      # @param [String] feature
+      def load(config_directory_path:, feature:)
+        new(config_directory_path: config_directory_path, feature: feature).load
+      end
+    end
+
+    # @param [String] config_directory_path
+    # @param [String] feature
+    def initialize(config_directory_path:, feature:)
+      @config_directory_path = config_directory_path
+      @feature = feature
+    end
+
+    def load
+      # Don't use `::Kernel.require(target)` to prevent the following error:
+      # https://github.com/rubocop/rubocop/issues/10893
+      require(target)
+    rescue ::LoadError => e
+      raise if e.path != target
+
+      begin
+        # Don't use `::Kernel.require(target)` to prevent the following error:
+        # https://github.com/rubocop/rubocop/issues/10893
+        require(namespaced_target)
+      rescue ::LoadError => error_for_namespaced_target
+        # NOTE: This wrap is necessary due to JRuby 9.3.4.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/7316
+        raise LoadError, e if error_for_namespaced_target.path == namespaced_target
+
+        raise error_for_namespaced_target
+      end
+    end
+
+    private
+
+    # @return [String]
+    def namespaced_feature
+      @feature.tr('-', '/')
+    end
+
+    # @return [String]
+    def namespaced_target
+      if relative?
+        relative(namespaced_feature)
+      else
+        namespaced_feature
+      end
+    end
+
+    # @param [String]
+    # @return [String]
+    def relative(feature)
+      ::File.join(@config_directory_path, feature)
+    end
+
+    # @return [Boolean]
+    def relative?
+      @feature.start_with?('.')
+    end
+
+    # @param [LoadError] error
+    # @return [Boolean]
+    def seems_cannot_load_such_file_error?(error)
+      error.path == target
+    end
+
+    # @return [String]
+    def target
+      if relative?
+        relative(@feature)
+      else
+        @feature
+      end
+    end
+  end
+end

data/lib/rubocop/file_finder.rb

@@ -4,38 +4,37 @@ require 'pathname'
 
 module RuboCop
   # Common methods for finding files.
+  # @api private
   module FileFinder
     def self.root_level=(level)
       @root_level = level
     end
 
-    def self.root_level?(path)
-      @root_level == path.to_s
+    def self.root_level?(path, stop_dir)
+      (@root_level || stop_dir) == path.to_s
     end
 
-    def find_file_upwards(filename, start_dir)
-      traverse_files_upwards(filename, start_dir) do |file|
+    def find_file_upwards(filename, start_dir, stop_dir = nil)
+      traverse_files_upwards(filename, start_dir, stop_dir) do |file|
         # minimize iteration for performance
         return file if file
       end
     end
 
-    def find_files_upwards(filename, start_dir)
-      files = []
-      traverse_files_upwards(filename, start_dir) do |file|
-        files << file
-      end
-      files
+    def find_last_file_upwards(filename, start_dir, stop_dir = nil)
+      last_file = nil
+      traverse_files_upwards(filename, start_dir, stop_dir) { |file| last_file = file }
+      last_file
     end
 
     private
 
-    def traverse_files_upwards(filename, start_dir)
+    def traverse_files_upwards(filename, start_dir, stop_dir)
       Pathname.new(start_dir).expand_path.ascend do |dir|
-        break if FileFinder.root_level?(dir)
-
         file = dir + filename
         yield(file.to_s) if file.exist?
+
+        break if FileFinder.root_level?(dir, stop_dir)
       end
     end
   end

data/lib/rubocop/file_patterns.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # A wrapper around patterns array to perform optimized search.
+  #
+  # For projects with a large set of rubocop todo files, most items in `Exclude`/`Include`
+  # are exact file names. It is wasteful to linearly check the list of patterns over and over
+  # to check if the file is relevant to the cop.
+  #
+  # This class partitions an array of patterns into a set of exact match strings and the rest
+  # of the patterns. This way we can firstly do a cheap check in the set and then proceed via
+  # the costly patterns check, if needed.
+  # @api private
+  class FilePatterns
+    @cache = {}.compare_by_identity
+
+    def self.from(patterns)
+      @cache[patterns] ||= new(patterns)
+    end
+
+    def initialize(patterns)
+      @strings = Set.new
+      @patterns = []
+      partition_patterns(patterns)
+    end
+
+    def match?(path)
+      @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
+    end
+
+    private
+
+    def partition_patterns(patterns)
+      patterns.each do |pattern|
+        if pattern.is_a?(String) && !pattern.match?(/[*{\[?]/)
+          @strings << pattern
+        else
+          @patterns << pattern
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/auto_gen_config_formatter.rb

@@ -9,7 +9,8 @@ module RuboCop
 
         report_summary(inspected_files.size,
                        @total_offense_count,
-                       @total_correction_count)
+                       @total_correction_count,
+                       @total_correctable_count)
       end
     end
   end

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Layout/LineLength
-
 module RuboCop
   module Formatter
     # Abstract base class for formatter, implements all public API methods.
@@ -41,8 +39,6 @@ module RuboCop
     # * `#finished`
     #
     class BaseFormatter
-      # rubocop:enable Layout/LineLength
-
       # @api public
       #
       # @!attribute [r] output

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -29,7 +29,7 @@ module RuboCop
 
           report_line(offense.location)
           report_highlighted_area(offense.highlighted_area)
-        rescue IndexError # rubocop:disable Lint/SuppressedException
+        rescue IndexError
           # range is not on a valid line; perhaps the source file is empty
         end
       end
@@ -41,7 +41,7 @@ module RuboCop
       def report_line(location)
         source_line = location.source_line
 
-        if location.first_line == location.last_line
+        if location.single_line?
           output.puts(source_line)
         else
           output.puts("#{source_line} #{yellow(ELLIPSES)}")
@@ -49,8 +49,10 @@ module RuboCop
       end
 
       def report_highlighted_area(highlighted_area)
-        output.puts("#{' ' * highlighted_area.begin_pos}" \
-                    "#{'^' * highlighted_area.size}")
+        space_area  = highlighted_area.source_buffer.slice(0...highlighted_area.begin_pos)
+        source_area = highlighted_area.source
+        output.puts("#{' ' * Unicode::DisplayWidth.of(space_area)}" \
+                    "#{'^' * Unicode::DisplayWidth.of(source_area)}")
       end
     end
   end