rubocop 0.80.1 → 0.85.0

data/lib/rubocop/processed_source.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest/sha1'
-
-module RuboCop
-  # ProcessedSource contains objects which are generated by Parser
-  # and other information such as disabled lines for cops.
-  # It also provides a convenient way to access source lines.
-  class ProcessedSource
-    STRING_SOURCE_NAME = '(string)'
-
-    attr_reader :path, :buffer, :ast, :comments, :tokens, :diagnostics,
-                :parser_error, :raw_source, :ruby_version
-
-    def self.from_file(path, ruby_version)
-      file = File.read(path, mode: 'rb')
-      new(file, ruby_version, path)
-    rescue Errno::ENOENT
-      raise RuboCop::Error, "No such file or directory: #{path}"
-    end
-
-    def initialize(source, ruby_version, path = nil)
-      # Defaults source encoding to UTF-8, regardless of the encoding it has
-      # been read with, which could be non-utf8 depending on the default
-      # external encoding.
-      unless source.encoding == Encoding::UTF_8
-        source.force_encoding(Encoding::UTF_8)
-      end
-
-      @raw_source = source
-      @path = path
-      @diagnostics = []
-      @ruby_version = ruby_version
-      @parser_error = nil
-
-      parse(source, ruby_version)
-    end
-
-    def comment_config
-      @comment_config ||= CommentConfig.new(self)
-    end
-
-    def disabled_line_ranges
-      comment_config.cop_disabled_line_ranges
-    end
-
-    def ast_with_comments
-      return if !ast || !comments
-
-      @ast_with_comments ||= Parser::Source::Comment.associate(ast, comments)
-    end
-
-    # Returns the source lines, line break characters removed, excluding a
-    # possible __END__ and everything that comes after.
-    def lines
-      @lines ||= begin
-        all_lines = @buffer.source_lines
-        last_token_line = tokens.any? ? tokens.last.line : all_lines.size
-        result = []
-        all_lines.each_with_index do |line, ix|
-          break if ix >= last_token_line && line == '__END__'
-
-          result << line
-        end
-        result
-      end
-    end
-
-    def [](*args)
-      lines[*args]
-    end
-
-    def valid_syntax?
-      return false if @parser_error
-
-      @diagnostics.none? { |d| %i[error fatal].include?(d.level) }
-    end
-
-    # Raw source checksum for tracking infinite loops.
-    def checksum
-      Digest::SHA1.hexdigest(@raw_source)
-    end
-
-    def each_comment
-      comments.each { |comment| yield comment }
-    end
-
-    def find_comment
-      comments.find { |comment| yield comment }
-    end
-
-    def each_token
-      tokens.each { |token| yield token }
-    end
-
-    def find_token
-      tokens.find { |token| yield token }
-    end
-
-    def file_path
-      buffer.name
-    end
-
-    def blank?
-      ast.nil?
-    end
-
-    def commented?(source_range)
-      comment_lines.include?(source_range.line)
-    end
-
-    def comments_before_line(line)
-      comments.select { |c| c.location.line <= line }
-    end
-
-    def start_with?(string)
-      return false if self[0].nil?
-
-      self[0].start_with?(string)
-    end
-
-    def preceding_line(token)
-      lines[token.line - 2]
-    end
-
-    def current_line(token)
-      lines[token.line - 1]
-    end
-
-    def following_line(token)
-      lines[token.line]
-    end
-
-    def line_indentation(line_number)
-      lines[line_number - 1]
-        .match(/^(\s*)/)[1]
-        .to_s
-        .length
-    end
-
-    private
-
-    def comment_lines
-      @comment_lines ||= comments.map { |c| c.location.line }
-    end
-
-    def parse(source, ruby_version)
-      buffer_name = @path || STRING_SOURCE_NAME
-      @buffer = Parser::Source::Buffer.new(buffer_name, 1)
-
-      begin
-        @buffer.source = source
-      rescue EncodingError => e
-        @parser_error = e
-        return
-      end
-
-      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
-    end
-
-    def tokenize(parser)
-      begin
-        ast, comments, tokens = parser.tokenize(@buffer)
-
-        ast.respond_to?(:complete!) && ast.complete!
-      rescue Parser::SyntaxError # rubocop:disable Lint/SuppressedException
-        # All errors are in diagnostics. No need to handle exception.
-      end
-
-      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
-
-      [ast, comments, tokens]
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def parser_class(ruby_version)
-      case ruby_version
-      when 2.3
-        require 'parser/ruby23'
-        Parser::Ruby23
-      when 2.4
-        require 'parser/ruby24'
-        Parser::Ruby24
-      when 2.5
-        require 'parser/ruby25'
-        Parser::Ruby25
-      when 2.6
-        require 'parser/ruby26'
-        Parser::Ruby26
-      when 2.7
-        require 'parser/ruby27'
-        Parser::Ruby27
-      else
-        raise ArgumentError,
-              "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def create_parser(ruby_version)
-      builder = RuboCop::AST::Builder.new
-
-      parser_class(ruby_version).new(builder).tap do |parser|
-        # On JRuby there's a risk that we hang in tokenize() if we
-        # don't set the all errors as fatal flag. The problem is caused by a bug
-        # in Racc that is discussed in issue #93 of the whitequark/parser
-        # project on GitHub.
-        parser.diagnostics.all_errors_are_fatal = (RUBY_ENGINE != 'ruby')
-        parser.diagnostics.ignore_warnings = false
-        parser.diagnostics.consumer = lambda do |diagnostic|
-          @diagnostics << diagnostic
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/string_util.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'jaro_winkler'
-
-module RuboCop
-  # This module provides approximate string matching methods.
-  module StringUtil
-    module_function
-
-    def similarity(string_a, string_b)
-      JaroWinkler.distance(string_a.to_s, string_b.to_s)
-    end
-  end
-end

data/lib/rubocop/token.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # A basic wrapper around Parser's tokens.
-  class Token
-    attr_reader :pos, :type, :text
-
-    def self.from_parser_token(parser_token)
-      type, details = parser_token
-      text, range = details
-      new(range, type, text)
-    end
-
-    def initialize(pos, type, text)
-      @pos = pos
-      @type = type
-      # Parser token "text" may be an Integer
-      @text = text.to_s
-    end
-
-    def line
-      @pos.line
-    end
-
-    def column
-      @pos.column
-    end
-
-    def begin_pos
-      @pos.begin_pos
-    end
-
-    def end_pos
-      @pos.end_pos
-    end
-
-    def to_s
-      "[[#{line}, #{column}], #{type}, #{text.inspect}]"
-    end
-
-    # Checks if there is whitespace after token
-    def space_after?
-      pos.source_buffer.source.match(/\G\s/, end_pos)
-    end
-
-    # Checks if there is whitespace before token
-    def space_before?
-      position = begin_pos.zero? ? begin_pos : begin_pos - 1
-      pos.source_buffer.source.match(/\G\s/, position)
-    end
-
-    ## Type Predicates
-
-    def comment?
-      type == :tCOMMENT
-    end
-
-    def semicolon?
-      type == :tSEMI
-    end
-
-    def left_array_bracket?
-      type == :tLBRACK
-    end
-
-    def left_ref_bracket?
-      type == :tLBRACK2
-    end
-
-    def left_bracket?
-      %i[tLBRACK tLBRACK2].include?(type)
-    end
-
-    def right_bracket?
-      type == :tRBRACK
-    end
-
-    def left_brace?
-      type == :tLBRACE
-    end
-
-    def left_curly_brace?
-      type == :tLCURLY
-    end
-
-    def right_curly_brace?
-      type == :tRCURLY
-    end
-
-    def left_parens?
-      %i[tLPAREN tLPAREN2].include?(type)
-    end
-
-    def right_parens?
-      type == :tRPAREN
-    end
-
-    def comma?
-      type == :tCOMMA
-    end
-
-    def rescue_modifier?
-      type == :kRESCUE_MOD
-    end
-
-    def end?
-      type == :kEND
-    end
-
-    def equal_sign?
-      %i[tEQL tOP_ASGN].include?(type)
-    end
-  end
-end