rubocop 0.52.1 → 0.93.1

data/lib/rubocop/processed_source.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest/md5'
-
-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)'.freeze
-
-    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::MD5.hexdigest(@raw_source)
-    end
-
-    private
-
-    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 => error
-        @parser_error = error
-        return
-      end
-
-      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
-    end
-
-    def tokenize(parser)
-      begin
-        ast, comments, tokens = parser.tokenize(@buffer)
-        ast.complete! if ast
-      rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
-        # 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.1
-        require 'parser/ruby21'
-        Parser::Ruby21
-      when 2.2
-        require 'parser/ruby22'
-        Parser::Ruby22
-      when 2.3
-        require 'parser/ruby23'
-        Parser::Ruby23
-      when 2.4
-        require 'parser/ruby24'
-        Parser::Ruby24
-      when 2.5
-        require 'parser/ruby25'
-        Parser::Ruby25
-      else
-        raise ArgumentError, "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/rspec/shared_examples.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-# `cop` and `source` must be declared with #let.
-
-shared_examples_for 'accepts' do
-  it 'accepts' do
-    inspect_source(source)
-    expect(cop.offenses).to be_empty
-  end
-end
-
-shared_examples_for 'mimics MRI 2.1' do |grep_mri_warning|
-  if RUBY_ENGINE == 'ruby' && RUBY_VERSION.start_with?('2.1')
-    it "mimics MRI #{RUBY_VERSION} built-in syntax checking" do
-      inspect_source(source)
-      offenses_by_mri = MRISyntaxChecker.offenses_for_source(
-        source, cop.name, grep_mri_warning
-      )
-
-      # Compare objects before comparing counts for clear failure output.
-      cop.offenses.each_with_index do |offense_by_cop, index|
-        offense_by_mri = offenses_by_mri[index]
-        # Exclude column attribute since MRI does not
-        # output column number.
-        %i[severity line cop_name].each do |a|
-          expect(offense_by_cop.send(a)).to eq(offense_by_mri.send(a))
-        end
-      end
-
-      expect(cop.offenses.count).to eq(offenses_by_mri.count)
-    end
-  end
-end
-
-shared_examples_for 'misaligned' do |prefix, alignment_base, arg, end_kw, name|
-  name ||= alignment_base
-  source = ["#{prefix}#{alignment_base} #{arg}",
-            end_kw]
-
-  it "registers an offense for mismatched #{name} ... end" do
-    inspect_source(source)
-    expect(cop.offenses.size).to eq(1)
-    base_regexp = Regexp.escape(alignment_base)
-    regexp = /`end` at 2, \d+ is not aligned with `#{base_regexp}` at 1,/
-    expect(cop.messages.first).to match(regexp)
-    expect(cop.highlights.first).to eq('end')
-
-    other_styles = (cop.supported_styles - [cop.style]).map(&:to_s)
-    # In some cases, the code under test will happen to match an alternative
-    # style. In other cases, it won't match any style at all
-    expect(cop.config_to_allow_offenses).to(
-      eq('Enabled' => false).or(
-        satisfy { |h| other_styles.include?(h['EnforcedStyleAlignWith']) }
-      )
-    )
-  end
-
-  it "auto-corrects mismatched #{name} ... end" do
-    aligned_source = ["#{prefix}#{alignment_base} #{arg}",
-                      "#{' ' * prefix.length}#{end_kw.strip}"].join("\n")
-    corrected = autocorrect_source(source)
-    expect(corrected).to eq(aligned_source)
-  end
-end
-
-shared_examples_for 'aligned' do |alignment_base, arg, end_kw, name|
-  name ||= alignment_base
-  name = name.gsub(/\n/, ' <newline>')
-  it "accepts matching #{name} ... end" do
-    inspect_source(["#{alignment_base} #{arg}",
-                    end_kw])
-    expect(cop.offenses).to be_empty
-  end
-end
-
-shared_examples_for 'debugger' do |name, src|
-  it "reports an offense for a #{name} call" do
-    inspect_source(src)
-    src = [src] if src.is_a? String
-    expect(cop.offenses.size).to eq(src.size)
-    expect(cop.messages)
-      .to eq(src.map { |s| "Remove debugger entry point `#{s}`." })
-    expect(cop.highlights).to eq(src)
-  end
-end
-
-shared_examples_for 'non-debugger' do |name, src|
-  it "does not report an offense for #{name}" do
-    inspect_source(src)
-    expect(cop.offenses).to be_empty
-  end
-end

data/lib/rubocop/string_util.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-    # This class computes Jaro distance, which is a measure of similarity
-    # between two strings.
-    class Jaro
-      attr_reader :shorter, :longer
-
-      def self.distance(*args)
-        new(*args).distance
-      end
-
-      def initialize(a, b)
-        if a.size < b.size
-          @shorter = a
-          @longer = b
-        else
-          @shorter = b
-          @longer = a
-        end
-      end
-
-      def distance
-        @distance ||= compute_distance
-      end
-
-      private
-
-      def compute_distance
-        common_chars_a, common_chars_b = find_common_characters
-        matched_count = common_chars_a.size
-
-        return 0.0 if matched_count.zero?
-
-        transposition_count =
-          count_transpositions(common_chars_a, common_chars_b)
-
-        compute_non_zero_distance(matched_count.to_f, transposition_count)
-      end
-
-      # rubocop:disable Metrics/AbcSize
-      def find_common_characters
-        common_chars_of_shorter = Array.new(shorter.size)
-        common_chars_of_longer = Array.new(longer.size)
-
-        shorter.each_char.with_index do |shorter_char, shorter_index|
-          matching_index_range(shorter_index).each do |longer_index|
-            longer_char = longer.chars[longer_index]
-
-            next unless shorter_char == longer_char
-
-            common_chars_of_shorter[shorter_index] = shorter_char
-            common_chars_of_longer[longer_index] = longer_char
-
-            # Mark the matching character as already used
-            longer.chars[longer_index] = nil
-
-            break
-          end
-        end
-
-        [common_chars_of_shorter, common_chars_of_longer].map(&:compact)
-      end
-      # rubocop:enable Metrics/AbcSize
-
-      def count_transpositions(common_chars_a, common_chars_b)
-        common_chars_a.size.times.count do |index|
-          common_chars_a[index] != common_chars_b[index]
-        end
-      end
-
-      def compute_non_zero_distance(matched_count, transposition_count)
-        sum = (matched_count / shorter.size.to_f) +
-              (matched_count / longer.size.to_f) +
-              ((matched_count - transposition_count / 2) / matched_count)
-
-        sum / 3.0
-      end
-
-      def matching_index_range(origin)
-        min = origin - matching_window
-        min = 0 if min < 0
-
-        max = origin + matching_window
-
-        min..max
-      end
-
-      def matching_window
-        @matching_window ||= (longer.size / 2).to_i - 1
-      end
-    end
-
-    # This class computes Jaro-Winkler distance, which adds prefix-matching
-    # bonus to Jaro distance.
-    class JaroWinkler < Jaro
-      # Add the prefix bonus only when the Jaro distance is above this value.
-      # In other words, if the Jaro distance is less than this value,
-      # JaroWinkler.distance returns the raw Jaro distance.
-      DEFAULT_BOOST_THRESHOLD = 0.7
-
-      # How much the prefix bonus is weighted.
-      # This should not exceed 0.25.
-      DEFAULT_SCALING_FACTOR = 0.1
-
-      # Cutoff the common prefix length to this value if it's longer than this.
-      MAX_COMMON_PREFIX_LENGTH = 4
-
-      attr_reader :boost_threshold, :scaling_factor
-
-      def initialize(a, b, boost_threshold = nil, scaling_factor = nil)
-        super(a, b)
-        @boost_threshold = boost_threshold || DEFAULT_BOOST_THRESHOLD
-        @scaling_factor = scaling_factor || DEFAULT_SCALING_FACTOR
-      end
-
-      private
-
-      def compute_distance
-        jaro_distance = super
-
-        if jaro_distance >= boost_threshold
-          bonus = limited_common_prefix_length.to_f * scaling_factor.to_f *
-                  (1.0 - jaro_distance)
-          jaro_distance + bonus
-        else
-          jaro_distance
-        end
-      end
-
-      def limited_common_prefix_length
-        length = common_prefix_length
-
-        if length > MAX_COMMON_PREFIX_LENGTH
-          MAX_COMMON_PREFIX_LENGTH
-        else
-          length
-        end
-      end
-
-      def common_prefix_length
-        shorter.size.times do |index|
-          return index unless shorter[index] == longer[index]
-        end
-
-        shorter.size
-      end
-    end
-  end
-end

data/lib/rubocop/token.rb

@@ -1,103 +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 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 equal_sign?
-      %i[tEQL tOP_ASGN].include?(type)
-    end
-
-    def to_s
-      "[[#{@pos.line}, #{@pos.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?
-      pos.source_buffer.source.match(/\G\s/, begin_pos - 1)
-    end
-  end
-end