@appthreat/atom-parsetools 1.0.4 → 1.0.5

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendor/uri/lib/uri/rfc3986_parser.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+module Bundler::URI
+  class RFC3986_Parser # :nodoc:
+    # Bundler::URI defined in RFC3986
+    HOST = %r[
+      (?<IP-literal>\[(?:
+          (?<IPv6address>
+            (?:\h{1,4}:){6}
+            (?<ls32>\h{1,4}:\h{1,4}
+            | (?<IPv4address>(?<dec-octet>[1-9]\d|1\d{2}|2[0-4]\d|25[0-5]|\d)
+                \.\g<dec-octet>\.\g<dec-octet>\.\g<dec-octet>)
+            )
+          | ::(?:\h{1,4}:){5}\g<ls32>
+          | \h{1,4}?::(?:\h{1,4}:){4}\g<ls32>
+          | (?:(?:\h{1,4}:)?\h{1,4})?::(?:\h{1,4}:){3}\g<ls32>
+          | (?:(?:\h{1,4}:){,2}\h{1,4})?::(?:\h{1,4}:){2}\g<ls32>
+          | (?:(?:\h{1,4}:){,3}\h{1,4})?::\h{1,4}:\g<ls32>
+          | (?:(?:\h{1,4}:){,4}\h{1,4})?::\g<ls32>
+          | (?:(?:\h{1,4}:){,5}\h{1,4})?::\h{1,4}
+          | (?:(?:\h{1,4}:){,6}\h{1,4})?::
+          )
+        | (?<IPvFuture>v\h++\.[!$&-.0-9:;=A-Z_a-z~]++)
+        )\])
+    | \g<IPv4address>
+    | (?<reg-name>(?:%\h\h|[!$&-.0-9;=A-Z_a-z~])*+)
+    ]x
+
+    USERINFO = /(?:%\h\h|[!$&-.0-9:;=A-Z_a-z~])*+/
+
+    SCHEME = %r[[A-Za-z][+\-.0-9A-Za-z]*+].source
+    SEG = %r[(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/])].source
+    SEG_NC = %r[(?:%\h\h|[!$&-.0-9;=@A-Z_a-z~])].source
+    FRAGMENT = %r[(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/?])*+].source
+
+    RFC3986_URI = %r[\A
+    (?<seg>#{SEG}){0}
+    (?<Bundler::URI>
+      (?<scheme>#{SCHEME}):
+      (?<hier-part>//
+        (?<authority>
+          (?:(?<userinfo>#{USERINFO.source})@)?
+          (?<host>#{HOST.source.delete(" \n")})
+          (?::(?<port>\d*+))?
+        )
+        (?<path-abempty>(?:/\g<seg>*+)?)
+      | (?<path-absolute>/((?!/)\g<seg>++)?)
+      | (?<path-rootless>(?!/)\g<seg>++)
+      | (?<path-empty>)
+      )
+      (?:\?(?<query>[^\#]*+))?
+      (?:\#(?<fragment>#{FRAGMENT}))?
+    )\z]x
+
+    RFC3986_relative_ref = %r[\A
+    (?<seg>#{SEG}){0}
+    (?<relative-ref>
+      (?<relative-part>//
+        (?<authority>
+          (?:(?<userinfo>#{USERINFO.source})@)?
+          (?<host>#{HOST.source.delete(" \n")}(?<!/))?
+          (?::(?<port>\d*+))?
+        )
+        (?<path-abempty>(?:/\g<seg>*+)?)
+      | (?<path-absolute>/\g<seg>*+)
+      | (?<path-noscheme>#{SEG_NC}++(?:/\g<seg>*+)?)
+      | (?<path-empty>)
+      )
+      (?:\?(?<query>[^#]*+))?
+      (?:\#(?<fragment>#{FRAGMENT}))?
+    )\z]x
+    attr_reader :regexp
+
+    def initialize
+      @regexp = default_regexp.each_value(&:freeze).freeze
+    end
+
+    def split(uri) #:nodoc:
+      begin
+        uri = uri.to_str
+      rescue NoMethodError
+        raise InvalidURIError, "bad Bundler::URI (is not Bundler::URI?): #{uri.inspect}"
+      end
+      uri.ascii_only? or
+        raise InvalidURIError, "Bundler::URI must be ascii only #{uri.dump}"
+      if m = RFC3986_URI.match(uri)
+        query = m["query"]
+        scheme = m["scheme"]
+        opaque = m["path-rootless"]
+        if opaque
+          opaque << "?#{query}" if query
+          [ scheme,
+            nil, # userinfo
+            nil, # host
+            nil, # port
+            nil, # registry
+            nil, # path
+            opaque,
+            nil, # query
+            m["fragment"]
+          ]
+        else # normal
+          [ scheme,
+            m["userinfo"],
+            m["host"],
+            m["port"],
+            nil, # registry
+            (m["path-abempty"] ||
+             m["path-absolute"] ||
+             m["path-empty"]),
+            nil, # opaque
+            query,
+            m["fragment"]
+          ]
+        end
+      elsif m = RFC3986_relative_ref.match(uri)
+        [ nil, # scheme
+          m["userinfo"],
+          m["host"],
+          m["port"],
+          nil, # registry,
+          (m["path-abempty"] ||
+           m["path-absolute"] ||
+           m["path-noscheme"] ||
+           m["path-empty"]),
+          nil, # opaque
+          m["query"],
+          m["fragment"]
+        ]
+      else
+        raise InvalidURIError, "bad Bundler::URI (is not Bundler::URI?): #{uri.inspect}"
+      end
+    end
+
+    def parse(uri) # :nodoc:
+      Bundler::URI.for(*self.split(uri), self)
+    end
+
+    def join(*uris) # :nodoc:
+      uris[0] = convert_to_uri(uris[0])
+      uris.inject :merge
+    end
+
+    # Compatibility for RFC2396 parser
+    def extract(str, schemes = nil, &block) # :nodoc:
+      warn "Bundler::URI::RFC3986_PARSER.extract is obsolete. Use Bundler::URI::RFC2396_PARSER.extract explicitly.", uplevel: 1 if $VERBOSE
+      RFC2396_PARSER.extract(str, schemes, &block)
+    end
+
+    # Compatibility for RFC2396 parser
+    def make_regexp(schemes = nil) # :nodoc:
+      warn "Bundler::URI::RFC3986_PARSER.make_regexp is obsolete. Use Bundler::URI::RFC2396_PARSER.make_regexp explicitly.", uplevel: 1 if $VERBOSE
+      RFC2396_PARSER.make_regexp(schemes)
+    end
+
+    # Compatibility for RFC2396 parser
+    def escape(str, unsafe = nil) # :nodoc:
+      warn "Bundler::URI::RFC3986_PARSER.escape is obsolete. Use Bundler::URI::RFC2396_PARSER.escape explicitly.", uplevel: 1 if $VERBOSE
+      unsafe ? RFC2396_PARSER.escape(str, unsafe) : RFC2396_PARSER.escape(str)
+    end
+
+    # Compatibility for RFC2396 parser
+    def unescape(str, escaped = nil) # :nodoc:
+      warn "Bundler::URI::RFC3986_PARSER.unescape is obsolete. Use Bundler::URI::RFC2396_PARSER.unescape explicitly.", uplevel: 1 if $VERBOSE
+      escaped ? RFC2396_PARSER.unescape(str, escaped) : RFC2396_PARSER.unescape(str)
+    end
+
+    @@to_s = Kernel.instance_method(:to_s)
+    if @@to_s.respond_to?(:bind_call)
+      def inspect
+        @@to_s.bind_call(self)
+      end
+    else
+      def inspect
+        @@to_s.bind(self).call
+      end
+    end
+
+    private
+
+    def default_regexp # :nodoc:
+      {
+        SCHEME: %r[\A#{SCHEME}\z]o,
+        USERINFO: %r[\A#{USERINFO}\z]o,
+        HOST: %r[\A#{HOST}\z]o,
+        ABS_PATH: %r[\A/#{SEG}*+\z]o,
+        REL_PATH: %r[\A(?!/)#{SEG}++\z]o,
+        QUERY: %r[\A(?:%\h\h|[!$&-.0-9:;=@A-Z_a-z~/?])*+\z],
+        FRAGMENT: %r[\A#{FRAGMENT}\z]o,
+        OPAQUE: %r[\A(?:[^/].*)?\z],
+        PORT: /\A[\x09\x0a\x0c\x0d ]*+\d*[\x09\x0a\x0c\x0d ]*\z/,
+      }
+    end
+
+    def convert_to_uri(uri)
+      if uri.is_a?(Bundler::URI::Generic)
+        uri
+      elsif uri = String.try_convert(uri)
+        parse(uri)
+      else
+        raise ArgumentError,
+          "bad argument (expected Bundler::URI object or Bundler::URI string)"
+      end
+    end
+
+  end # class Parser
+end # module Bundler::URI

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendor/uri/lib/uri/version.rb

@@ -0,0 +1,6 @@
+module Bundler::URI
+  # :stopdoc:
+  VERSION_CODE = '010003'.freeze
+  VERSION = VERSION_CODE.scan(/../).collect{|n| n.to_i}.join('.').freeze
+  # :startdoc:
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendor/uri/lib/uri/ws.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: false
+# = uri/ws.rb
+#
+# Author:: Matt Muller <mamuller@amazon.com>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Bundler::URI for general documentation
+#
+
+require_relative 'generic'
+
+module Bundler::URI
+
+  #
+  # The syntax of WS URIs is defined in RFC6455 section 3.
+  #
+  # Note that the Ruby Bundler::URI library allows WS URLs containing usernames and
+  # passwords. This is not legal as per the RFC, but used to be
+  # supported in Internet Explorer 5 and 6, before the MS04-004 security
+  # update. See <URL:http://support.microsoft.com/kb/834489>.
+  #
+  class WS < Generic
+    # A Default port of 80 for Bundler::URI::WS.
+    DEFAULT_PORT = 80
+
+    # An Array of the available components for Bundler::URI::WS.
+    COMPONENT = %i[
+      scheme
+      userinfo host port
+      path
+      query
+    ].freeze
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::WS object from components, with syntax checking.
+    #
+    # The components accepted are userinfo, host, port, path, and query.
+    #
+    # The components should be provided either as an Array, or as a Hash
+    # with keys formed by preceding the component names with a colon.
+    #
+    # If an Array is used, the components must be passed in the
+    # order <code>[userinfo, host, port, path, query]</code>.
+    #
+    # Example:
+    #
+    #     uri = Bundler::URI::WS.build(host: 'www.example.com', path: '/foo/bar')
+    #
+    #     uri = Bundler::URI::WS.build([nil, "www.example.com", nil, "/path", "query"])
+    #
+    # Currently, if passed userinfo components this method generates
+    # invalid WS URIs as per RFC 1738.
+    #
+    def self.build(args)
+      tmp = Util.make_components_hash(self, args)
+      super(tmp)
+    end
+
+    #
+    # == Description
+    #
+    # Returns the full path for a WS Bundler::URI, as required by Net::HTTP::Get.
+    #
+    # If the Bundler::URI contains a query, the full path is Bundler::URI#path + '?' + Bundler::URI#query.
+    # Otherwise, the path is simply Bundler::URI#path.
+    #
+    # Example:
+    #
+    #     uri = Bundler::URI::WS.build(path: '/foo/bar', query: 'test=true')
+    #     uri.request_uri #  => "/foo/bar?test=true"
+    #
+    def request_uri
+      return unless @path
+
+      url = @query ? "#@path?#@query" : @path.dup
+      url.start_with?(?/.freeze) ? url : ?/ + url
+    end
+  end
+
+  register_scheme 'WS', WS
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendor/uri/lib/uri/wss.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: false
+# = uri/wss.rb
+#
+# Author:: Matt Muller <mamuller@amazon.com>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Bundler::URI for general documentation
+#
+
+require_relative 'ws'
+
+module Bundler::URI
+
+  # The default port for WSS URIs is 443, and the scheme is 'wss:' rather
+  # than 'ws:'. Other than that, WSS URIs are identical to WS URIs;
+  # see Bundler::URI::WS.
+  class WSS < WS
+    # A Default port of 443 for Bundler::URI::WSS
+    DEFAULT_PORT = 443
+  end
+
+  register_scheme 'WSS', WSS
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendor/uri/lib/uri.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: false
+# Bundler::URI is a module providing classes to handle Uniform Resource Identifiers
+# (RFC2396[https://www.rfc-editor.org/rfc/rfc2396]).
+#
+# == Features
+#
+# * Uniform way of handling URIs.
+# * Flexibility to introduce custom Bundler::URI schemes.
+# * Flexibility to have an alternate Bundler::URI::Parser (or just different patterns
+#   and regexp's).
+#
+# == Basic example
+#
+#   require 'bundler/vendor/uri/lib/uri'
+#
+#   uri = Bundler::URI("http://foo.com/posts?id=30&limit=5#time=1305298413")
+#   #=> #<Bundler::URI::HTTP http://foo.com/posts?id=30&limit=5#time=1305298413>
+#
+#   uri.scheme    #=> "http"
+#   uri.host      #=> "foo.com"
+#   uri.path      #=> "/posts"
+#   uri.query     #=> "id=30&limit=5"
+#   uri.fragment  #=> "time=1305298413"
+#
+#   uri.to_s      #=> "http://foo.com/posts?id=30&limit=5#time=1305298413"
+#
+# == Adding custom URIs
+#
+#   module Bundler::URI
+#     class RSYNC < Generic
+#       DEFAULT_PORT = 873
+#     end
+#     register_scheme 'RSYNC', RSYNC
+#   end
+#   #=> Bundler::URI::RSYNC
+#
+#   Bundler::URI.scheme_list
+#   #=> {"FILE"=>Bundler::URI::File, "FTP"=>Bundler::URI::FTP, "HTTP"=>Bundler::URI::HTTP,
+#   #    "HTTPS"=>Bundler::URI::HTTPS, "LDAP"=>Bundler::URI::LDAP, "LDAPS"=>Bundler::URI::LDAPS,
+#   #    "MAILTO"=>Bundler::URI::MailTo, "RSYNC"=>Bundler::URI::RSYNC}
+#
+#   uri = Bundler::URI("rsync://rsync.foo.com")
+#   #=> #<Bundler::URI::RSYNC rsync://rsync.foo.com>
+#
+# == RFC References
+#
+# A good place to view an RFC spec is http://www.ietf.org/rfc.html.
+#
+# Here is a list of all related RFC's:
+# - RFC822[https://www.rfc-editor.org/rfc/rfc822]
+# - RFC1738[https://www.rfc-editor.org/rfc/rfc1738]
+# - RFC2255[https://www.rfc-editor.org/rfc/rfc2255]
+# - RFC2368[https://www.rfc-editor.org/rfc/rfc2368]
+# - RFC2373[https://www.rfc-editor.org/rfc/rfc2373]
+# - RFC2396[https://www.rfc-editor.org/rfc/rfc2396]
+# - RFC2732[https://www.rfc-editor.org/rfc/rfc2732]
+# - RFC3986[https://www.rfc-editor.org/rfc/rfc3986]
+#
+# == Class tree
+#
+# - Bundler::URI::Generic (in uri/generic.rb)
+#   - Bundler::URI::File - (in uri/file.rb)
+#   - Bundler::URI::FTP - (in uri/ftp.rb)
+#   - Bundler::URI::HTTP - (in uri/http.rb)
+#     - Bundler::URI::HTTPS - (in uri/https.rb)
+#   - Bundler::URI::LDAP - (in uri/ldap.rb)
+#     - Bundler::URI::LDAPS - (in uri/ldaps.rb)
+#   - Bundler::URI::MailTo - (in uri/mailto.rb)
+# - Bundler::URI::Parser - (in uri/common.rb)
+# - Bundler::URI::REGEXP - (in uri/common.rb)
+#   - Bundler::URI::REGEXP::PATTERN - (in uri/common.rb)
+# - Bundler::URI::Util - (in uri/common.rb)
+# - Bundler::URI::Error - (in uri/common.rb)
+#   - Bundler::URI::InvalidURIError - (in uri/common.rb)
+#   - Bundler::URI::InvalidComponentError - (in uri/common.rb)
+#   - Bundler::URI::BadURIError - (in uri/common.rb)
+#
+# == Copyright Info
+#
+# Author:: Akira Yamada <akira@ruby-lang.org>
+# Documentation::
+#   Akira Yamada <akira@ruby-lang.org>
+#   Dmitry V. Sabanin <sdmitry@lrn.ru>
+#   Vincent Batts <vbatts@hashbangbash.com>
+# License::
+#  Copyright (c) 2001 akira yamada <akira@ruby-lang.org>
+#  You can redistribute it and/or modify it under the same term as Ruby.
+#
+
+module Bundler::URI
+end
+
+require_relative 'uri/version'
+require_relative 'uri/common'
+require_relative 'uri/generic'
+require_relative 'uri/file'
+require_relative 'uri/ftp'
+require_relative 'uri/http'
+require_relative 'uri/https'
+require_relative 'uri/ldap'
+require_relative 'uri/ldaps'
+require_relative 'uri/mailto'
+require_relative 'uri/ws'
+require_relative 'uri/wss'

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_fileutils.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Bundler; end
+require_relative "vendor/fileutils/lib/fileutils"

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_net_http.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This defined? guard can be removed once RubyGems 3.4 support is dropped.
+#
+# Bundler specs load this code from `spec/support/vendored_net_http.rb` to avoid
+# activating the Bundler gem too early. Without this guard, we get redefinition
+# warnings once Bundler is actually activated and
+# `lib/bundler/vendored_net_http.rb` is required. This is not an issue in
+# RubyGems versions including `rubygems/vendored_net_http` since `require` takes
+# care of avoiding the double load.
+#
+unless defined?(Gem::Net)
+  begin
+    require "rubygems/vendored_net_http"
+  rescue LoadError
+    begin
+      require "rubygems/net/http"
+    rescue LoadError
+      require "net/http"
+      Gem::Net = Net
+    end
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_persistent.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bundler
+  module Persistent
+    module Net
+      module HTTP
+      end
+    end
+  end
+end
+require_relative "vendor/net-http-persistent/lib/net/http/persistent"

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_pub_grub.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Bundler; end
+require_relative "vendor/pub_grub/lib/pub_grub"

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_securerandom.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Use RubyGems vendored copy when available. Otherwise fallback to Bundler
+# vendored copy. The vendored copy in Bundler can be removed once support for
+# RubyGems 3.5.18 is dropped.
+
+begin
+  require "rubygems/vendored_securerandom"
+rescue LoadError
+  require_relative "vendor/securerandom/lib/securerandom"
+  Gem::SecureRandom = Bundler::SecureRandom
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_thor.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Bundler
+  def self.require_thor_actions
+    require_relative "vendor/thor/lib/thor/actions"
+  end
+end
+require_relative "vendor/thor/lib/thor"

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_timeout.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+begin
+  require "rubygems/vendored_timeout"
+rescue LoadError
+  begin
+    require "rubygems/timeout"
+  rescue LoadError
+    require "timeout"
+    Gem::Timeout = Timeout
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_tsort.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Bundler; end
+require_relative "vendor/tsort/lib/tsort"

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vendored_uri.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Bundler; end
+
+# Use RubyGems vendored copy when available. Otherwise fallback to Bundler
+# vendored copy. The vendored copy in Bundler can be removed once support for
+# RubyGems 3.5 is dropped.
+
+begin
+  require "rubygems/vendor/uri/lib/uri"
+rescue LoadError
+  require_relative "vendor/uri/lib/uri"
+  Gem::URI = Bundler::URI
+
+  module Gem
+    def URI(uri) # rubocop:disable Naming/MethodName
+      Bundler::URI(uri)
+    end
+    module_function :URI
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: false
+
+module Bundler
+  VERSION = "2.6.7".freeze
+
+  def self.bundler_major_version
+    @bundler_major_version ||= VERSION.split(".").first.to_i
+  end
+
+  def self.gem_version
+    @gem_version ||= Gem::Version.create(VERSION)
+  end
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/vlad.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "shared_helpers"
+Bundler::SharedHelpers.major_deprecation 2,
+  "The Bundler task for Vlad"
+
+# Vlad task for Bundler.
+#
+# Add "require 'bundler/vlad'" in your Vlad deploy.rb, and
+# include the vlad:bundle:install task in your vlad:deploy task.
+require_relative "deployment"
+
+include Rake::DSL if defined? Rake::DSL
+
+namespace :vlad do
+  Bundler::Deployment.define_task(Rake::RemoteTask, :remote_task, roles: :app)
+end

package/plugins/rubyastgen/bundle/ruby/3.4.0/gems/bundler-2.6.7/lib/bundler/worker.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Bundler
+  class Worker
+    POISON = Object.new
+
+    class WrappedException < StandardError
+      attr_reader :exception
+      def initialize(exn)
+        @exception = exn
+      end
+    end
+
+    # @return [String] the name of the worker
+    attr_reader :name
+
+    # Creates a worker pool of specified size
+    #
+    # @param size [Integer] Size of pool
+    # @param name [String] name the name of the worker
+    # @param func [Proc] job to run in inside the worker pool
+    def initialize(size, name, func)
+      @name = name
+      @request_queue = Thread::Queue.new
+      @response_queue = Thread::Queue.new
+      @func = func
+      @size = size
+      @threads = nil
+      @previous_interrupt_handler = nil
+    end
+
+    # Enqueue a request to be executed in the worker pool
+    #
+    # @param obj [String] mostly it is name of spec that should be downloaded
+    def enq(obj)
+      create_threads unless @threads
+      @request_queue.enq obj
+    end
+
+    # Retrieves results of job function being executed in worker pool
+    def deq
+      result = @response_queue.deq
+      raise result.exception if result.is_a?(WrappedException)
+      result
+    end
+
+    def stop
+      stop_threads
+    end
+
+    private
+
+    def process_queue(i)
+      loop do
+        obj = @request_queue.deq
+        break if obj.equal? POISON
+        @response_queue.enq apply_func(obj, i)
+      end
+    end
+
+    def apply_func(obj, i)
+      @func.call(obj, i)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      WrappedException.new(e)
+    end
+
+    # Stop the worker threads by sending a poison object down the request queue
+    # so as worker threads after retrieving it, shut themselves down
+    def stop_threads
+      return unless @threads
+
+      @threads.each { @request_queue.enq POISON }
+      @threads.each(&:join)
+
+      remove_interrupt_handler
+
+      @threads = nil
+    end
+
+    def abort_threads
+      Bundler.ui.debug("\n#{caller.join("\n")}")
+      @threads.each(&:exit)
+      exit 1
+    end
+
+    def create_threads
+      creation_errors = []
+
+      @threads = Array.new(@size) do |i|
+        Thread.start { process_queue(i) }.tap do |thread|
+          thread.name = "#{name} Worker ##{i}" if thread.respond_to?(:name=)
+        end
+      rescue ThreadError => e
+        creation_errors << e
+        nil
+      end.compact
+
+      add_interrupt_handler unless @threads.empty?
+
+      return if creation_errors.empty?
+
+      message = "Failed to create threads for the #{name} worker: #{creation_errors.map(&:to_s).uniq.join(", ")}"
+      raise ThreadCreationError, message if @threads.empty?
+      Bundler.ui.info message
+    end
+
+    def add_interrupt_handler
+      @previous_interrupt_handler = trap("INT") { abort_threads }
+    end
+
+    def remove_interrupt_handler
+      return unless @previous_interrupt_handler
+
+      trap "INT", @previous_interrupt_handler
+    end
+  end
+end