study_line 0.2.7 → 0.2.8

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/server/server_command.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-#
-# This code is based on https://github.com/fohte/rubocop-daemon.
-#
-# Copyright (c) 2018 Hayato Kawai
-#
-# The MIT License (MIT)
-#
-# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
-#
-module RuboCop
-  module Server
-    # @api private
-    module ServerCommand
-      autoload :Base, 'rubocop/server/server_command/base'
-      autoload :Exec, 'rubocop/server/server_command/exec'
-      autoload :Stop, 'rubocop/server/server_command/stop'
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/server/socket_reader.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-#
-# This code is based on https://github.com/fohte/rubocop-daemon.
-#
-# Copyright (c) 2018 Hayato Kawai
-#
-# The MIT License (MIT)
-#
-# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
-#
-module RuboCop
-  module Server
-    # This class sends the request read from the socket to server.
-    # @api private
-    class SocketReader
-      Request = Struct.new(:header, :body)
-      Header = Struct.new(:token, :cwd, :command, :args)
-
-      def initialize(socket)
-        @socket = socket
-      end
-
-      def read!
-        request = parse_request(@socket.read)
-
-        stderr = StringIO.new
-        Helper.redirect(
-          stdin: StringIO.new(request.body),
-          stdout: @socket,
-          stderr: stderr
-        ) do
-          create_command_instance(request).run
-        end
-      ensure
-        Cache.stderr_path.write(stderr.string)
-        @socket.close
-      end
-
-      private
-
-      def parse_request(content)
-        raw_header, *body = content.lines
-
-        Request.new(parse_header(raw_header), body.join)
-      end
-
-      def parse_header(header)
-        token, cwd, command, *args = header.shellsplit
-        Header.new(token, cwd, command, args)
-      end
-
-      def create_command_instance(request)
-        klass = find_command_class(request.header.command)
-
-        klass.new(request.header.args, token: request.header.token, cwd: request.header.cwd)
-      end
-
-      def find_command_class(command)
-        case command
-        when 'stop' then ServerCommand::Stop
-        when 'exec' then ServerCommand::Exec
-        else
-          raise UnknownServerCommandError, "#{command.inspect} is not a valid command"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/server.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'platform'
-
-#
-# This code is based on https://github.com/fohte/rubocop-daemon.
-#
-# Copyright (c) 2018 Hayato Kawai
-#
-# The MIT License (MIT)
-#
-# https://github.com/fohte/rubocop-daemon/blob/master/LICENSE.txt
-#
-module RuboCop
-  # The bootstrap module for server.
-  # @api private
-  module Server
-    TIMEOUT = 20
-
-    autoload :CLI, 'rubocop/server/cli'
-    autoload :Cache, 'rubocop/server/cache'
-    autoload :ClientCommand, 'rubocop/server/client_command'
-    autoload :Helper, 'rubocop/server/helper'
-    autoload :Core, 'rubocop/server/core'
-    autoload :ServerCommand, 'rubocop/server/server_command'
-    autoload :SocketReader, 'rubocop/server/socket_reader'
-
-    class << self
-      def support_server?
-        RUBY_ENGINE == 'ruby' && !RuboCop::Platform.windows?
-      end
-
-      def running?
-        return false unless support_server? # Never running.
-
-        Cache.pid_running?
-      end
-
-      def wait_for_running_status!(expected)
-        start_time = Time.now
-        while Server.running? != expected
-          sleep 0.1
-          next unless Time.now - start_time > TIMEOUT
-
-          warn "running? was not #{expected} after #{TIMEOUT} seconds!"
-          exit 1
-        end
-      end
-    end
-  end
-end
-
-require_relative 'server/errors'

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/string_interpreter.rb

@@ -1,60 +0,0 @@
-# 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
-
-    private_constant :STRING_ESCAPES, :STRING_ESCAPE_REGEX
-
-    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..].split(/\s+/).map(&:hex).pack('U*')
-        else
-          [escape[2..].hex].pack('U')
-        end
-      end
-
-      def interpret_hex(escape)
-        [escape[2..].hex].pack('C')
-      end
-
-      def interpret_octal(escape)
-        [escape[1..].to_i(8)].pack('C')
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/target_finder.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # This class finds target files to inspect by scanning the directory tree
-  # and picking ruby files.
-  # @api private
-  class TargetFinder
-    HIDDEN_PATH_SUBSTRING = "#{File::SEPARATOR}."
-
-    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, mode)
-      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, mode)
-                 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
-      base_dir = base_dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
-      all_files = find_files(base_dir, File::FNM_DOTMATCH)
-      # use file.include? for performance optimization
-      hidden_files = all_files.select { |file| file.include?(HIDDEN_PATH_SUBSTRING) }.sort
-      base_dir_config = @config_store.for(base_dir)
-
-      target_files = all_files.select { |file| to_inspect?(file, hidden_files, base_dir_config) }
-
-      target_files.sort_by!(&order)
-    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.bsearch do |hidden_file|
-        file <=> hidden_file
-      end && 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)
-      # get all wanted directories first to improve speed of finding all files
-      exclude_pattern = combined_exclude_glob_patterns(base_dir)
-      dir_flags = flags | File::FNM_PATHNAME | File::FNM_EXTGLOB
-      patterns = wanted_dir_patterns(base_dir, exclude_pattern, dir_flags)
-      patterns.map! { |dir| File.join(dir, '*') }
-      # We need this special case to avoid creating the pattern
-      # /**/* which searches the entire file system.
-      patterns = [File.join(base_dir, '**/*')] if patterns.empty?
-
-      Dir.glob(patterns, flags).select { |path| FileTest.file?(path) }
-    end
-
-    def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      # Escape glob characters in base_dir to avoid unwanted behavior.
-      base_dir = base_dir.gsub(/[\\\{\}\[\]\*\?]/) do |reserved_glob_character|
-        "\\#{reserved_glob_character}"
-      end
-
-      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
-                .reject do |dir|
-                  next true if dir.end_with?('/./', '/../')
-                  next true if File.fnmatch?(exclude_pattern, dir, flags)
-
-                  symlink_excluded_or_infinite_loop?(base_dir, dir, exclude_pattern, flags)
-                end
-      dirs.flat_map { |dir| wanted_dir_patterns(dir, exclude_pattern, flags) }.unshift(base_dir)
-    end
-
-    def symlink_excluded_or_infinite_loop?(base_dir, current_dir, exclude_pattern, flags)
-      dir_realpath = File.realpath(current_dir)
-      File.symlink?(current_dir.chomp('/')) && (
-        File.fnmatch?(exclude_pattern, "#{dir_realpath}/", flags) ||
-        File.realpath(base_dir).start_with?(dir_realpath)
-      )
-    end
-
-    def combined_exclude_glob_patterns(base_dir)
-      exclude = @config_store.for(base_dir).for_all_cops['Exclude'] || []
-      patterns = exclude.select { |pattern| pattern.is_a?(String) && pattern.end_with?('/**/*') }
-                        .map { |pattern| pattern.sub("#{base_dir}/", '') }
-      "#{base_dir}/{#{patterns.join(',')}}"
-    end
-
-    def ruby_extension?(file)
-      ruby_extensions.include?(File.extname(file))
-    end
-
-    def ruby_extensions
-      @ruby_extensions ||= begin
-        ext_patterns = all_cops_include.select { |pattern| pattern.start_with?('**/*.') }
-        ext_patterns.map { |pattern| pattern.sub('**/*', '') }
-      end
-    end
-
-    def ruby_filename?(file)
-      ruby_filenames.include?(File.basename(file))
-    end
-
-    def ruby_filenames
-      @ruby_filenames ||= begin
-        file_patterns = all_cops_include.reject { |pattern| pattern.start_with?('**/*.') }
-        file_patterns.map { |pattern| pattern.sub('**/', '') }
-      end
-    end
-
-    def all_cops_include
-      @all_cops_include ||= @config_store.for_pwd.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)
-      /#!.*(#{ruby_interpreters(file).join('|')})/.match?(first_line)
-    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_pwd.file_to_include?(file)
-    end
-
-    def included_file?(file)
-      ruby_file?(file) || configured_include?(file)
-    end
-
-    def process_explicit_path(path, mode)
-      files = path.include?('*') ? Dir[path] : [path]
-
-      if mode == :only_recognized_file_types || force_exclusion?
-        files.select! { |file| included_file?(file) }
-      end
-
-      return files unless force_exclusion?
-
-      files.reject do |file|
-        config = @config_store.for(file)
-        config.file_to_exclude?(file)
-      end
-    end
-
-    private
-
-    def order
-      if fail_fast?
-        # Most recently modified file first.
-        ->(path) { -Integer(File.mtime(path)) }
-      else
-        :itself
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/target_ruby.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # The kind of Ruby that code inspected by RuboCop is written in.
-  # @api private
-  class TargetRuby
-    KNOWN_RUBIES = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2, 3.3].freeze
-    DEFAULT_VERSION = 2.7
-
-    OBSOLETE_RUBIES = {
-      1.9 => '0.41',
-      2.0 => '0.50',
-      2.1 => '0.57',
-      2.2 => '0.68',
-      2.3 => '0.81',
-      2.4 => '1.12',
-      2.5 => '1.28',
-      2.6 => '1.50'
-    }.freeze
-    private_constant :KNOWN_RUBIES, :OBSOLETE_RUBIES
-
-    # A place where information about a target ruby version is found.
-    # @api private
-    class Source
-      attr_reader :version, :name
-
-      def initialize(config)
-        @config = config
-        @version = find_version
-      end
-
-      def to_s
-        name
-      end
-    end
-
-    # The target ruby version may be configured in RuboCop's config.
-    # @api private
-    class RuboCopConfig < Source
-      def name
-        "`TargetRubyVersion` parameter (in #{@config.smart_loaded_path})"
-      end
-
-      private
-
-      def find_version
-        @config.for_all_cops['TargetRubyVersion']&.to_f
-      end
-    end
-
-    # The target ruby version may be found in a .ruby-version file.
-    # @api private
-    class RubyVersionFile < Source
-      RUBY_VERSION_FILENAME = '.ruby-version'
-      RUBY_VERSION_PATTERN = /\A(?:ruby-)?(?<version>\d+\.\d+)/.freeze
-
-      def name
-        "`#{RUBY_VERSION_FILENAME}`"
-      end
-
-      private
-
-      def filename
-        RUBY_VERSION_FILENAME
-      end
-
-      def pattern
-        RUBY_VERSION_PATTERN
-      end
-
-      def find_version
-        file = version_file
-        return unless file && File.file?(file)
-
-        File.read(file).match(pattern) { |md| md[:version].to_f }
-      end
-
-      def version_file
-        @version_file ||= @config.find_file_upwards(filename, @config.base_dir_for_path_parameters)
-      end
-    end
-
-    # The target ruby version may be found in a .tool-versions file, in a line
-    # starting with `ruby`.
-    # @api private
-    class ToolVersionsFile < RubyVersionFile
-      TOOL_VERSIONS_FILENAME = '.tool-versions'
-      TOOL_VERSIONS_PATTERN = /^(?:ruby )(?<version>\d+\.\d+)/.freeze
-
-      def name
-        "`#{TOOL_VERSIONS_FILENAME}`"
-      end
-
-      private
-
-      def filename
-        TOOL_VERSIONS_FILENAME
-      end
-
-      def pattern
-        TOOL_VERSIONS_PATTERN
-      end
-    end
-
-    # The lock file of Bundler may identify the target ruby version.
-    # @api private
-    class BundlerLockFile < Source
-      def name
-        "`#{bundler_lock_file_path}`"
-      end
-
-      private
-
-      def find_version
-        lock_file_path = bundler_lock_file_path
-        return nil unless lock_file_path
-
-        in_ruby_section = false
-        File.foreach(lock_file_path) do |line|
-          # If ruby is in Gemfile.lock or gems.lock, there should be two lines
-          # towards the bottom of the file that look like:
-          #     RUBY VERSION
-          #       ruby W.X.YpZ
-          # We ultimately want to match the "ruby W.X.Y.pZ" line, but there's
-          # extra logic to make sure we only start looking once we've seen the
-          # "RUBY VERSION" line.
-          in_ruby_section ||= line.match(/^\s*RUBY\s*VERSION\s*$/)
-          next unless in_ruby_section
-
-          # We currently only allow this feature to work with MRI ruby. If
-          # jruby (or something else) is used by the project, it's lock file
-          # will have a line that looks like:
-          #     RUBY VERSION
-          #       ruby W.X.YpZ (jruby x.x.x.x)
-          # The regex won't match in this situation.
-          result = line.match(/^\s*ruby\s+(\d+\.\d+)[p.\d]*\s*$/)
-          return result.captures.first.to_f if result
-        end
-      end
-
-      def bundler_lock_file_path
-        @config.bundler_lock_file_path
-      end
-    end
-
-    # The target ruby version may be found in a .gemspec file.
-    # @api private
-    class GemspecFile < Source
-      extend NodePattern::Macros
-
-      GEMSPEC_EXTENSION = '.gemspec'
-
-      # @!method required_ruby_version(node)
-      def_node_search :required_ruby_version, <<~PATTERN
-        (send _ :required_ruby_version= $_)
-      PATTERN
-
-      # @!method gem_requirement_versions(node)
-      def_node_matcher :gem_requirement_versions, <<~PATTERN
-        (send (const(const _ :Gem):Requirement) :new
-          {$str+ | (send $str :freeze)+ | (array $str+) | (array (send $str :freeze)+)}
-        )
-      PATTERN
-
-      def name
-        "`required_ruby_version` parameter (in #{gemspec_filename})"
-      end
-
-      private
-
-      def find_version
-        file = gemspec_filepath
-        return unless file && File.file?(file)
-
-        right_hand_side = version_from_gemspec_file(file)
-        return if right_hand_side.nil?
-
-        find_default_minimal_known_ruby(right_hand_side)
-      end
-
-      def gemspec_filename
-        @gemspec_filename ||= begin
-          basename = Pathname.new(@config.base_dir_for_path_parameters).basename.to_s
-          "#{basename}#{GEMSPEC_EXTENSION}"
-        end
-      end
-
-      def gemspec_filepath
-        @gemspec_filepath ||=
-          @config.find_file_upwards(gemspec_filename, @config.base_dir_for_path_parameters)
-      end
-
-      def version_from_gemspec_file(file)
-        processed_source = ProcessedSource.from_file(file, DEFAULT_VERSION)
-        required_ruby_version(processed_source.ast).first
-      end
-
-      def version_from_right_hand_side(right_hand_side)
-        gem_requirement_versions = gem_requirement_versions(right_hand_side)
-
-        if right_hand_side.array_type?
-          version_from_array(right_hand_side)
-        elsif gem_requirement_versions
-          gem_requirement_versions.map(&:value)
-        else
-          right_hand_side.value
-        end
-      end
-
-      def version_from_array(array)
-        array.children.map(&:value)
-      end
-
-      def find_default_minimal_known_ruby(right_hand_side)
-        version = version_from_right_hand_side(right_hand_side)
-        requirement = Gem::Requirement.new(version)
-
-        KNOWN_RUBIES.detect do |v|
-          v >= DEFAULT_VERSION && requirement.satisfied_by?(Gem::Version.new("#{v}.99"))
-        end
-      end
-    end
-
-    # If all else fails, a default version will be picked.
-    # @api private
-    class Default < Source
-      def name
-        'default'
-      end
-
-      private
-
-      def find_version
-        DEFAULT_VERSION
-      end
-    end
-
-    def self.supported_versions
-      KNOWN_RUBIES
-    end
-
-    SOURCES = [
-      RuboCopConfig,
-      RubyVersionFile,
-      ToolVersionsFile,
-      BundlerLockFile,
-      GemspecFile,
-      Default
-    ].freeze
-
-    private_constant :SOURCES
-    def initialize(config)
-      @config = config
-    end
-
-    def source
-      @source ||= SOURCES.each.lazy.map { |c| c.new(@config) }.detect(&:version)
-    end
-
-    def version
-      source.version
-    end
-
-    def supported?
-      KNOWN_RUBIES.include?(version)
-    end
-
-    def rubocop_version_with_support
-      if supported?
-        RuboCop::Version.version
-      else
-        OBSOLETE_RUBIES[version]
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/util.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  # This module contains a collection of useful utility methods.
-  module Util
-    def self.silence_warnings
-      # Replaces Kernel::silence_warnings since it hides any warnings,
-      # including the RuboCop ones
-      old_verbose = $VERBOSE
-      $VERBOSE = nil
-      yield
-    ensure
-      $VERBOSE = old_verbose
-    end
-  end
-end