rubocop 0.75.1

data/lib/rubocop/string_interpreter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Take a string with embedded escapes, and convert the escapes as the Ruby
+  # interpreter would when reading a double-quoted string literal.
+  # For example, "\\n" will be converted to "\n".
+  class StringInterpreter
+    STRING_ESCAPES = {
+      '\a' => "\a", '\b' => "\b", '\e' => "\e", '\f' => "\f", '\n' => "\n",
+      '\r' => "\r", '\s' => ' ',  '\t' => "\t", '\v' => "\v", "\\\n" => ''
+    }.freeze
+    STRING_ESCAPE_REGEX = /\\(?:
+                            [abefnrstv\n]     |   # simple escapes (above)
+                            \d{1,3}           |   # octal byte escape
+                            x[0-9a-fA-F]{1,2} |   # hex byte escape
+                            u[0-9a-fA-F]{4}   |   # unicode char escape
+                            u\{[^}]*\}        |   # extended unicode escape
+                            .                     # any other escaped char
+                          )/x.freeze
+    class << self
+      def interpret(string)
+        # We currently don't handle \cx, \C-x, and \M-x
+        string.gsub(STRING_ESCAPE_REGEX) do |escape|
+          STRING_ESCAPES[escape] || interpret_string_escape(escape)
+        end
+      end
+
+      private
+
+      def interpret_string_escape(escape)
+        case escape[1]
+        when 'u' then interpret_unicode(escape)
+        when 'x' then interpret_hex(escape)
+        when /\d/       then interpret_octal(escape)
+        else
+          escape[1] # literal escaped char, like \\
+        end
+      end
+
+      def interpret_unicode(escape)
+        if escape[2] == '{'
+          escape[3..-1].split(/\s+/).map(&:hex).pack('U*')
+        else
+          [escape[2..-1].hex].pack('U')
+        end
+      end
+
+      def interpret_hex(escape)
+        [escape[2..-1].hex].pack('C')
+      end
+
+      def interpret_octal(escape)
+        [escape[1..-1].to_i(8)].pack('C')
+      end
+    end
+  end
+end

data/lib/rubocop/string_util.rb

@@ -0,0 +1,14 @@
+# 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/target_finder.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  # This class finds target files to inspect by scanning the directory tree
+  # and picking ruby files.
+  class TargetFinder
+    def initialize(config_store, options = {})
+      @config_store = config_store
+      @options = options
+    end
+
+    def force_exclusion?
+      @options[:force_exclusion]
+    end
+
+    def debug?
+      @options[:debug]
+    end
+
+    def fail_fast?
+      @options[:fail_fast]
+    end
+
+    # Generate a list of target files by expanding globbing patterns
+    # (if any). If args is empty, recursively find all Ruby source
+    # files under the current directory
+    # @return [Array] array of file paths
+    def find(args)
+      return target_files_in_dir if args.empty?
+
+      files = []
+
+      args.uniq.each do |arg|
+        files += if File.directory?(arg)
+                   target_files_in_dir(arg.chomp(File::SEPARATOR))
+                 else
+                   process_explicit_path(arg)
+                 end
+      end
+
+      files.map { |f| File.expand_path(f) }.uniq
+    end
+
+    # Finds all Ruby source files under the current or other supplied
+    # directory. A Ruby source file is defined as a file with the `.rb`
+    # extension or a file with no extension that has a ruby shebang line
+    # as its first line.
+    # It is possible to specify includes and excludes using the config file,
+    # so you can include other Ruby files like Rakefiles and gemspecs.
+    # @param base_dir Root directory under which to search for
+    #   ruby source files
+    # @return [Array] Array of filenames
+    def target_files_in_dir(base_dir = Dir.pwd)
+      # Support Windows: Backslashes from command-line -> forward slashes
+      if File::ALT_SEPARATOR
+        base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR)
+      end
+      all_files = find_files(base_dir, File::FNM_DOTMATCH)
+      hidden_files = Set.new(all_files - find_files(base_dir, 0))
+      base_dir_config = @config_store.for(base_dir)
+
+      target_files = all_files.select do |file|
+        to_inspect?(file, hidden_files, base_dir_config)
+      end
+
+      if fail_fast?
+        # Most recently modified file first.
+        target_files.sort_by! { |path| -Integer(File.mtime(path)) }
+      else
+        target_files.sort!
+      end
+    end
+
+    def to_inspect?(file, hidden_files, base_dir_config)
+      return false if base_dir_config.file_to_exclude?(file)
+      return true if !hidden_files.include?(file) && ruby_file?(file)
+
+      base_dir_config.file_to_include?(file)
+    end
+
+    # Search for files recursively starting at the given base directory using
+    # the given flags that determine how the match is made. Excluded files will
+    # be removed later by the caller, but as an optimization find_files removes
+    # the top level directories that are excluded in configuration in the
+    # normal way (dir/**/*).
+    def find_files(base_dir, flags)
+      wanted_toplevel_dirs = toplevel_dirs(base_dir, flags) -
+                             excluded_dirs(base_dir)
+      wanted_toplevel_dirs.map! { |dir| dir << '/**/*' }
+
+      pattern = if wanted_toplevel_dirs.empty?
+                  # We need this special case to avoid creating the pattern
+                  # /**/* which searches the entire file system.
+                  ["#{base_dir}/**/*"]
+                else
+                  # Search the non-excluded top directories, but also add files
+                  # on the top level, which would otherwise not be found.
+                  wanted_toplevel_dirs.unshift("#{base_dir}/*")
+                end
+      Dir.glob(pattern, flags).select { |path| FileTest.file?(path) }
+    end
+
+    def toplevel_dirs(base_dir, flags)
+      Dir.glob(File.join(base_dir, '*'), flags).select do |dir|
+        File.directory?(dir) && !dir.end_with?('/.', '/..')
+      end
+    end
+
+    def excluded_dirs(base_dir)
+      all_cops_config = @config_store.for(base_dir).for_all_cops
+      dir_tree_excludes = all_cops_config['Exclude'].select do |pattern|
+        pattern.is_a?(String) && pattern.end_with?('/**/*')
+      end
+      dir_tree_excludes.map { |pattern| pattern.sub(%r{/\*\*/\*$}, '') }
+    end
+
+    def ruby_extension?(file)
+      ruby_extensions.include?(File.extname(file))
+    end
+
+    def ruby_extensions
+      ext_patterns = all_cops_include.select do |pattern|
+        pattern.start_with?('**/*.')
+      end
+      ext_patterns.map { |pattern| pattern.sub('**/*', '') }
+    end
+
+    def ruby_filename?(file)
+      ruby_filenames.include?(File.basename(file))
+    end
+
+    def ruby_filenames
+      file_patterns = all_cops_include.reject do |pattern|
+        pattern.start_with?('**/*.')
+      end
+      file_patterns.map { |pattern| pattern.sub('**/', '') }
+    end
+
+    def all_cops_include
+      @config_store.for('.').for_all_cops['Include'].map(&:to_s)
+    end
+
+    def ruby_executable?(file)
+      return false unless File.extname(file).empty? && File.exist?(file)
+
+      first_line = File.open(file, &:readline)
+      !(first_line =~ /#!.*(#{ruby_interpreters(file).join('|')})/).nil?
+    rescue EOFError, ArgumentError => e
+      warn("Unprocessable file #{file}: #{e.class}, #{e.message}") if debug?
+
+      false
+    end
+
+    def ruby_interpreters(file)
+      @config_store.for(file).for_all_cops['RubyInterpreters']
+    end
+
+    def stdin?
+      @options.key?(:stdin)
+    end
+
+    def ruby_file?(file)
+      stdin? || ruby_extension?(file) || ruby_filename?(file) ||
+        ruby_executable?(file)
+    end
+
+    def configured_include?(file)
+      @config_store.for('.').file_to_include?(file)
+    end
+
+    def included_file?(file)
+      ruby_file?(file) || configured_include?(file)
+    end
+
+    def process_explicit_path(path)
+      files = path.include?('*') ? Dir[path] : [path]
+
+      files.select! { |file| included_file?(file) }
+
+      return files unless force_exclusion?
+
+      files.reject do |file|
+        config = @config_store.for(file)
+        config.file_to_exclude?(file)
+      end
+    end
+  end
+end

data/lib/rubocop/token.rb

@@ -0,0 +1,114 @@
+# 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

data/lib/rubocop/version.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module holds the RuboCop version information.
+  module Version
+    STRING = '0.75.1'
+
+    MSG = '%<version>s (using Parser %<parser_version>s, running on ' \
+          '%<ruby_engine>s %<ruby_version>s %<ruby_platform>s)'
+
+    def self.version(debug = false)
+      if debug
+        format(MSG, version: STRING, parser_version: Parser::VERSION,
+                    ruby_engine: RUBY_ENGINE, ruby_version: RUBY_VERSION,
+                    ruby_platform: RUBY_PLATFORM)
+      else
+        STRING
+      end
+    end
+  end
+end

data/lib/rubocop/warning.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # A Warning exception is different from an Offense with severity 'warning'
+  # When a Warning is raised, this means that RuboCop was unable to perform a
+  # requested operation (such as inspecting or correcting a source file) due to
+  # user error
+  # For example, a configuration value in .rubocop.yml might be malformed
+  class Warning < StandardError
+  end
+end

data/lib/rubocop/yaml_duplication_checker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Find duplicated keys from YAML.
+  module YAMLDuplicationChecker
+    def self.check(yaml_string, filename, &on_duplicated)
+      # Ruby 2.6+
+      tree = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0')
+               # Specify filename to display helpful message when it raises
+               # an error.
+               YAML.parse(yaml_string, filename: filename)
+             else
+               YAML.parse(yaml_string, filename)
+             end
+      return unless tree
+
+      traverse(tree, &on_duplicated)
+    end
+
+    def self.traverse(tree, &on_duplicated)
+      case tree
+      when Psych::Nodes::Mapping
+        tree.children.each_slice(2).with_object([]) do |(key, value), keys|
+          exist = keys.find { |key2| key2.value == key.value }
+          on_duplicated.call(exist, key) if exist
+          keys << key
+          traverse(value, &on_duplicated)
+        end
+      else
+        children = tree.children
+        return unless children
+
+        children.each { |c| traverse(c, &on_duplicated) }
+      end
+    end
+
+    private_class_method :traverse
+  end
+end