cocRb 0.1.0

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/path_util.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Common methods and behaviors for dealing with paths.
+  module PathUtil
+    module_function
+
+    def relative_path(path, base_dir = Dir.pwd)
+      # Optimization for the common case where path begins with the base
+      # dir. Just cut off the first part.
+      if path.start_with?(base_dir)
+        base_dir_length = base_dir.length
+        result_length = path.length - base_dir_length - 1
+        return path[base_dir_length + 1, result_length]
+      end
+
+      path_name = Pathname.new(File.expand_path(path))
+      begin
+        path_name.relative_path_from(Pathname.new(base_dir)).to_s
+      rescue ArgumentError
+        path
+      end
+    end
+
+    def smart_path(path)
+      # Ideally, we calculate this relative to the project root.
+      base_dir = Dir.pwd
+
+      if path.start_with? base_dir
+        relative_path(path, base_dir)
+      else
+        path
+      end
+    end
+
+    def match_path?(pattern, path)
+      case pattern
+      when String
+        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) ||
+          hidden_file_in_not_hidden_dir?(pattern, path)
+      when Regexp
+        begin
+          pattern.match?(path)
+        rescue ArgumentError => e
+          return false if e.message.start_with?('invalid byte sequence')
+
+          raise e
+        end
+      end
+    end
+
+    # Returns true for an absolute Unix or Windows path.
+    def absolute?(path)
+      %r{\A([A-Z]:)?/}i.match?(path)
+    end
+
+    def hidden_file_in_not_hidden_dir?(pattern, path)
+      hidden_file?(path) &&
+        File.fnmatch?(
+          pattern, path,
+          File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+        ) &&
+        !hidden_dir?(path)
+    end
+
+    def hidden_file?(path)
+      maybe_hidden_file?(path) && File.basename(path).start_with?('.')
+    end
+
+    # Loose check to reduce memory allocations
+    def maybe_hidden_file?(path)
+      separator_index = path.rindex(File::SEPARATOR)
+      return false unless separator_index
+
+      dot_index = path.index('.', separator_index + 1)
+      dot_index == separator_index + 1
+    end
+
+    def hidden_dir?(path)
+      File.dirname(path).split(File::SEPARATOR).any? { |dir| dir.start_with?('.') }
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/platform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This module provides information on the platform that RuboCop is being run
+  # on.
+  module Platform
+    def self.windows?
+      /cygwin|mswin|mingw|bccwin|wince|emx/.match?(RbConfig::CONFIG['host_os'])
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/rake_task.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+
+module RuboCop
+  # Provides a custom rake task.
+  #
+  # require 'rubocop/rake_task'
+  # RuboCop::RakeTask.new
+  #
+  # Use global Rake namespace here to avoid namespace issues with custom
+  # rubocop-rake tasks
+  class RakeTask < ::Rake::TaskLib
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
+
+    def initialize(name = :rubocop, *args, &task_block)
+      super()
+      setup_ivars(name)
+
+      desc 'Run RuboCop' unless ::Rake.application.last_description
+
+      task(name, *args) do |_, task_args|
+        RakeFileUtils.verbose(verbose) do
+          yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+          run_cli(verbose, full_options)
+        end
+      end
+
+      setup_subtasks(name, *args, &task_block)
+    end
+
+    private
+
+    def run_cli(verbose, options)
+      # We lazy-load rubocop so that the task doesn't dramatically impact the
+      # load time of your Rakefile.
+      require 'rubocop'
+
+      cli = CLI.new
+      puts 'Running RuboCop...' if verbose
+      result = cli.run(options)
+      abort('RuboCop failed!') if result.nonzero? && fail_on_error
+    end
+
+    def full_options
+      formatters.map { |f| ['--format', f] }.flatten
+                .concat(requires.map { |r| ['--require', r] }.flatten)
+                .concat(options.flatten)
+                .concat(patterns)
+    end
+
+    def setup_ivars(name)
+      @name = name
+      @verbose = true
+      @fail_on_error = true
+      @patterns = []
+      @requires = []
+      @options = []
+      @formatters = []
+    end
+
+    def setup_subtasks(name, *args, &task_block)
+      namespace(name) do
+        desc 'Auto-correct RuboCop offenses'
+
+        task(:auto_correct, *args) do |_, task_args|
+          RakeFileUtils.verbose(verbose) do
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
+            options = full_options.unshift('--auto-correct-all')
+            # `parallel` will automatically be removed from the options internally.
+            # This is a nice to have to suppress the warning message
+            # about parallel and auto-corrent not being compatible.
+            options.delete('--parallel')
+            run_cli(verbose, options)
+          end
+        end
+      end
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/remote_config.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'time'
+
+module RuboCop
+  # Common methods and behaviors for dealing with remote config files.
+  # @api private
+  class RemoteConfig
+    attr_reader :uri
+
+    CACHE_LIFETIME = 24 * 60 * 60
+
+    def initialize(url, base_dir)
+      @uri = URI.parse(url)
+      @base_dir = base_dir
+    end
+
+    def file
+      return cache_path unless cache_path_expired?
+
+      request do |response|
+        next if response.is_a?(Net::HTTPNotModified)
+        next if response.is_a?(SocketError)
+
+        File.open cache_path, 'w' do |io|
+          io.write response.body
+        end
+      end
+
+      cache_path
+    end
+
+    def inherit_from_remote(file, path)
+      new_uri = @uri.dup
+      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file}")
+      RemoteConfig.new(new_uri.to_s, File.dirname(path))
+    end
+
+    private
+
+    def request(uri = @uri, limit = 10, &block)
+      raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
+
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = uri.instance_of?(URI::HTTPS)
+
+      generate_request(uri) do |request|
+        handle_response(http.request(request), limit, &block)
+      rescue SocketError => e
+        handle_response(e, limit, &block)
+      end
+    end
+
+    def generate_request(uri)
+      request = Net::HTTP::Get.new(uri.request_uri)
+
+      request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822 if cache_path_exists?
+
+      yield request
+    end
+
+    def handle_response(response, limit, &block)
+      case response
+      when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
+        yield response
+      when Net::HTTPRedirection
+        request(URI.parse(response['location']), limit - 1, &block)
+      else
+        begin
+          response.error!
+        rescue StandardError => e
+          message = "#{e.message} while downloading remote config file #{uri}"
+          raise e, message
+        end
+      end
+    end
+
+    def cache_path
+      File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)
+    end
+
+    def cache_path_exists?
+      @cache_path_exists ||= File.exist?(cache_path)
+    end
+
+    def cache_path_expired?
+      return true unless cache_path_exists?
+
+      @cache_path_expired ||= begin
+        file_age = (Time.now - File.stat(cache_path).mtime).to_f
+        (file_age / CACHE_LIFETIME) > 1
+      end
+    end
+
+    def cache_name_from_uri
+      uri = @uri.clone
+      uri.query = nil
+      uri.to_s.gsub!(/[^0-9A-Za-z]/, '-')
+    end
+  end
+end

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/result_cache.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+require 'find'
+require 'etc'
+require 'zlib'
+
+module RuboCop
+  # Provides functionality for caching rubocop runs.
+  # @api private
+  class ResultCache
+    NON_CHANGING = %i[color format formatters out debug fail_level auto_correct
+                      cache fail_fast stdin parallel].freeze
+
+    # Remove old files so that the cache doesn't grow too big. When the
+    # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
+    # files in the cache are removed. The reason for removing so much is that
+    # cleaning should be done relatively seldom, since there is a slight risk
+    # that some other RuboCop process was just about to read the file, when
+    # there's parallel execution and the cache is shared.
+    def self.cleanup(config_store, verbose, cache_root = nil)
+      return if inhibit_cleanup # OPTIMIZE: For faster testing
+
+      cache_root ||= cache_root(config_store)
+      return unless File.exist?(cache_root)
+
+      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      return unless requires_file_removal?(files.length, config_store)
+
+      remove_oldest_files(files, dirs, cache_root, verbose)
+    end
+
+    class << self
+      # @api private
+      attr_accessor :rubocop_required_features
+
+      ResultCache.rubocop_required_features = []
+
+      private
+
+      def requires_file_removal?(file_count, config_store)
+        file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
+      end
+
+      def remove_oldest_files(files, dirs, cache_root, verbose)
+        # Add 1 to half the number of files, so that we remove the file if
+        # there's only 1 left.
+        remove_count = 1 + files.length / 2
+        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
+        sorted = files.sort_by { |path| File.mtime(path) }
+        remove_files(sorted, dirs, remove_count)
+      rescue Errno::ENOENT
+        # This can happen if parallel RuboCop invocations try to remove the
+        # same files. No problem.
+        puts $ERROR_INFO if verbose
+      end
+
+      def remove_files(files, dirs, remove_count)
+        # Batch file deletions, deleting over 130,000+ files will crash
+        # File.delete.
+        files[0, remove_count].each_slice(10_000).each do |files_slice|
+          File.delete(*files_slice)
+        end
+        dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
+      end
+    end
+
+    def self.cache_root(config_store)
+      root = ENV['RUBOCOP_CACHE_ROOT']
+      root ||= config_store.for_pwd.for_all_cops['CacheRootDirectory']
+      root ||= if ENV.key?('XDG_CACHE_HOME')
+                 # Include user ID in the path to make sure the user has write
+                 # access.
+                 File.join(ENV['XDG_CACHE_HOME'], Process.uid.to_s)
+               else
+                 File.join(ENV['HOME'], '.cache')
+               end
+      File.join(root, 'rubocop_cache')
+    end
+
+    def self.allow_symlinks_in_cache_location?(config_store)
+      config_store.for_pwd.for_all_cops['AllowSymlinksInCacheRootDirectory']
+    end
+
+    attr :path
+
+    def initialize(file, team, options, config_store, cache_root = nil)
+      cache_root ||= options[:cache_root]
+      cache_root ||= ResultCache.cache_root(config_store)
+      @allow_symlinks_in_cache_location =
+        ResultCache.allow_symlinks_in_cache_location?(config_store)
+      @path = File.join(cache_root,
+                        rubocop_checksum,
+                        context_checksum(team, options),
+                        file_checksum(file, config_store))
+      @cached_data = CachedData.new(file)
+      @debug = options[:debug]
+    end
+
+    def debug?
+      @debug
+    end
+
+    def valid?
+      File.exist?(@path)
+    end
+
+    def load
+      puts "Loading cache from #{@path}" if debug?
+      @cached_data.from_json(File.read(@path, encoding: Encoding::UTF_8))
+    end
+
+    def save(offenses)
+      dir = File.dirname(@path)
+
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue Errno::EACCES, Errno::EROFS => e
+        warn "Couldn't create cache directory. Continuing without cache.\n  #{e.message}"
+        return
+      end
+
+      preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
+      # RuboCop must be in control of where its cached data is stored. A
+      # symbolic link anywhere in the cache directory tree can be an
+      # indication that a symlink attack is being waged.
+      return if symlink_protection_triggered?(dir)
+
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
+        f.write(@cached_data.to_json(offenses))
+      end
+      # The preliminary path is used so that if there are multiple RuboCop
+      # processes trying to save data for the same inspected file
+      # simultaneously, the only problem we run in to is a competition who gets
+      # to write to the final file. The contents are the same, so no corruption
+      # of data should occur.
+      FileUtils.mv(preliminary_path, @path)
+    end
+
+    private
+
+    def symlink_protection_triggered?(path)
+      !@allow_symlinks_in_cache_location && any_symlink?(path)
+    end
+
+    def any_symlink?(path)
+      while path != File.dirname(path)
+        if File.symlink?(path)
+          warn "Warning: #{path} is a symlink, which is not allowed."
+          return true
+        end
+        path = File.dirname(path)
+      end
+      false
+    end
+
+    def file_checksum(file, config_store)
+      digester = Digest::SHA1.new
+      mode = File.stat(file).mode
+      digester.update("#{file}#{mode}#{config_store.for_file(file).signature}")
+      digester.file(file)
+      digester.hexdigest
+    rescue Errno::ENOENT
+      # Spurious files that come and go should not cause a crash, at least not
+      # here.
+      '_'
+    end
+
+    class << self
+      attr_accessor :source_checksum, :inhibit_cleanup
+    end
+
+    # The checksum of the rubocop program running the inspection.
+    def rubocop_checksum
+      ResultCache.source_checksum ||=
+        begin
+          digest = Digest::SHA1.new
+          rubocop_extra_features
+            .select { |path| File.file?(path) }
+            .sort!
+            .each do |path|
+              content = File.open(path, 'rb', &:read)
+              digest << Zlib.crc32(content).to_s # mtime not reliable
+            end
+          digest << RuboCop::Version::STRING << RuboCop::AST::Version::STRING
+          digest.hexdigest
+        end
+    end
+
+    def rubocop_extra_features
+      lib_root = File.join(File.dirname(__FILE__), '..')
+      exe_root = File.join(lib_root, '..', 'exe')
+
+      # These are all the files we have `require`d plus everything in the
+      # exe directory. A change to any of them could affect the cop output
+      # so we include them in the cache hash.
+      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
+      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+
+      source_files
+    end
+
+    # Return a hash of the options given at invocation, minus the ones that have
+    # no effect on which offenses and disabled line ranges are found, and thus
+    # don't affect caching.
+    def relevant_options_digest(options)
+      options = options.reject { |key, _| NON_CHANGING.include?(key) }
+      options.to_s.gsub(/[^a-z]+/i, '_')
+    end
+
+    # The external dependency checksums are cached per RuboCop team so that
+    # the checksums don't need to be recomputed for each file.
+    def team_checksum(team)
+      @checksum_by_team ||= {}.compare_by_identity
+      @checksum_by_team[team] ||= team.external_dependency_checksum
+    end
+
+    # We combine team and options into a single "context" checksum to avoid
+    # making file names that are too long for some filesystems to handle.
+    # This context is for anything that's not (1) the RuboCop executable
+    # checksum or (2) the inspected file checksum.
+    def context_checksum(team, options)
+      Digest::SHA1.hexdigest([team_checksum(team), relevant_options_digest(options)].join)
+    end
+  end
+end