bundler-clone 4.0.15

data/lib/bundler/vendor/uri/lib/uri/http.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: false
+# = uri/http.rb
+#
+# Author:: Akira Yamada <akira@ruby-lang.org>
+# 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 HTTP URIs is defined in RFC1738 section 3.3.
+  #
+  # Note that the Ruby Bundler::URI library allows HTTP 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 HTTP < Generic
+    # A Default port of 80 for Bundler::URI::HTTP.
+    DEFAULT_PORT = 80
+
+    # An Array of the available components for Bundler::URI::HTTP.
+    COMPONENT = %i[
+      scheme
+      userinfo host port
+      path
+      query
+      fragment
+    ].freeze
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::HTTP object from components, with syntax checking.
+    #
+    # The components accepted are userinfo, host, port, path, query, and
+    # fragment.
+    #
+    # 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, fragment]</code>.
+    #
+    # Example:
+    #
+    #     uri = Bundler::URI::HTTP.build(host: 'www.example.com', path: '/foo/bar')
+    #
+    #     uri = Bundler::URI::HTTP.build([nil, "www.example.com", nil, "/path",
+    #       "query", 'fragment'])
+    #
+    # Currently, if passed userinfo components this method generates
+    # invalid HTTP URIs as per RFC 1738.
+    #
+    def self.build(args)
+      tmp = Util.make_components_hash(self, args)
+      super(tmp)
+    end
+
+    # Do not allow empty host names, as they are not allowed by RFC 3986.
+    def check_host(v)
+      ret = super
+
+      if ret && v.empty?
+        raise InvalidComponentError,
+          "bad component(expected host component): #{v}"
+      end
+
+      ret
+    end
+
+    #
+    # == Description
+    #
+    # Returns the full path for an HTTP request, 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::HTTP.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
+
+    #
+    # == Description
+    #
+    # Returns the authority for an HTTP uri, as defined in
+    # https://www.rfc-editor.org/rfc/rfc3986#section-3.2.
+    #
+    #
+    # Example:
+    #
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', path: '/foo/bar').authority #=> "www.example.com"
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', port: 8000, path: '/foo/bar').authority #=> "www.example.com:8000"
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', port: 80, path: '/foo/bar').authority #=> "www.example.com"
+    #
+    def authority
+      if port == default_port
+        host
+      else
+        "#{host}:#{port}"
+      end
+    end
+
+    #
+    # == Description
+    #
+    # Returns the origin for an HTTP uri, as defined in
+    # https://www.rfc-editor.org/rfc/rfc6454.
+    #
+    #
+    # Example:
+    #
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', path: '/foo/bar').origin #=> "http://www.example.com"
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', port: 8000, path: '/foo/bar').origin #=> "http://www.example.com:8000"
+    #     Bundler::URI::HTTP.build(host: 'www.example.com', port: 80, path: '/foo/bar').origin #=> "http://www.example.com"
+    #     Bundler::URI::HTTPS.build(host: 'www.example.com', path: '/foo/bar').origin #=> "https://www.example.com"
+    #
+    def origin
+      "#{scheme}://#{authority}"
+    end
+  end
+
+  register_scheme 'HTTP', HTTP
+end

data/lib/bundler/vendor/uri/lib/uri/https.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: false
+# = uri/https.rb
+#
+# Author:: Akira Yamada <akira@ruby-lang.org>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Bundler::URI for general documentation
+#
+
+require_relative 'http'
+
+module Bundler::URI
+
+  # The default port for HTTPS URIs is 443, and the scheme is 'https:' rather
+  # than 'http:'. Other than that, HTTPS URIs are identical to HTTP URIs;
+  # see Bundler::URI::HTTP.
+  class HTTPS < HTTP
+    # A Default port of 443 for Bundler::URI::HTTPS
+    DEFAULT_PORT = 443
+  end
+
+  register_scheme 'HTTPS', HTTPS
+end

data/lib/bundler/vendor/uri/lib/uri/ldap.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: false
+# = uri/ldap.rb
+#
+# Author::
+#  Takaaki Tateishi <ttate@jaist.ac.jp>
+#  Akira Yamada <akira@ruby-lang.org>
+# License::
+#   Bundler::URI::LDAP is copyrighted free software by Takaaki Tateishi and Akira Yamada.
+#   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
+
+  #
+  # LDAP Bundler::URI SCHEMA (described in RFC2255).
+  #--
+  # ldap://<host>/<dn>[?<attrs>[?<scope>[?<filter>[?<extensions>]]]]
+  #++
+  class LDAP < Generic
+
+    # A Default port of 389 for Bundler::URI::LDAP.
+    DEFAULT_PORT = 389
+
+    # An Array of the available components for Bundler::URI::LDAP.
+    COMPONENT = [
+      :scheme,
+      :host, :port,
+      :dn,
+      :attributes,
+      :scope,
+      :filter,
+      :extensions,
+    ].freeze
+
+    # Scopes available for the starting point.
+    #
+    # * SCOPE_BASE - the Base DN
+    # * SCOPE_ONE  - one level under the Base DN, not including the base DN and
+    #   not including any entries under this
+    # * SCOPE_SUB  - subtrees, all entries at all levels
+    #
+    SCOPE = [
+      SCOPE_ONE = 'one',
+      SCOPE_SUB = 'sub',
+      SCOPE_BASE = 'base',
+    ].freeze
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::LDAP object from components, with syntax checking.
+    #
+    # The components accepted are host, port, dn, attributes,
+    # scope, filter, and extensions.
+    #
+    # 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>[host, port, dn, attributes, scope, filter, extensions]</code>.
+    #
+    # Example:
+    #
+    #     uri = Bundler::URI::LDAP.build({:host => 'ldap.example.com',
+    #       :dn => '/dc=example'})
+    #
+    #     uri = Bundler::URI::LDAP.build(["ldap.example.com", nil,
+    #       "/dc=example;dc=com", "query", nil, nil, nil])
+    #
+    def self.build(args)
+      tmp = Util::make_components_hash(self, args)
+
+      if tmp[:dn]
+        tmp[:path] = tmp[:dn]
+      end
+
+      query = []
+      [:extensions, :filter, :scope, :attributes].collect do |x|
+        next if !tmp[x] && query.size == 0
+        query.unshift(tmp[x])
+      end
+
+      tmp[:query] = query.join('?')
+
+      return super(tmp)
+    end
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::LDAP object from generic Bundler::URI components as per
+    # RFC 2396. No LDAP-specific syntax checking is performed.
+    #
+    # Arguments are +scheme+, +userinfo+, +host+, +port+, +registry+, +path+,
+    # +opaque+, +query+, and +fragment+, in that order.
+    #
+    # Example:
+    #
+    #     uri = Bundler::URI::LDAP.new("ldap", nil, "ldap.example.com", nil, nil,
+    #       "/dc=example;dc=com", nil, "query", nil)
+    #
+    # See also Bundler::URI::Generic.new.
+    #
+    def initialize(*arg)
+      super(*arg)
+
+      if @fragment
+        raise InvalidURIError, 'bad LDAP URL'
+      end
+
+      parse_dn
+      parse_query
+    end
+
+    # Private method to cleanup +dn+ from using the +path+ component attribute.
+    def parse_dn
+      raise InvalidURIError, 'bad LDAP URL' unless @path
+      @dn = @path[1..-1]
+    end
+    private :parse_dn
+
+    # Private method to cleanup +attributes+, +scope+, +filter+, and +extensions+
+    # from using the +query+ component attribute.
+    def parse_query
+      @attributes = nil
+      @scope      = nil
+      @filter     = nil
+      @extensions = nil
+
+      if @query
+        attrs, scope, filter, extensions = @query.split('?')
+
+        @attributes = attrs if attrs && attrs.size > 0
+        @scope      = scope if scope && scope.size > 0
+        @filter     = filter if filter && filter.size > 0
+        @extensions = extensions if extensions && extensions.size > 0
+      end
+    end
+    private :parse_query
+
+    # Private method to assemble +query+ from +attributes+, +scope+, +filter+, and +extensions+.
+    def build_path_query
+      @path = '/' + @dn
+
+      query = []
+      [@extensions, @filter, @scope, @attributes].each do |x|
+        next if !x && query.size == 0
+        query.unshift(x)
+      end
+      @query = query.join('?')
+    end
+    private :build_path_query
+
+    # Returns dn.
+    def dn
+      @dn
+    end
+
+    # Private setter for dn +val+.
+    def set_dn(val)
+      @dn = val
+      build_path_query
+      @dn
+    end
+    protected :set_dn
+
+    # Setter for dn +val+.
+    def dn=(val)
+      set_dn(val)
+      val
+    end
+
+    # Returns attributes.
+    def attributes
+      @attributes
+    end
+
+    # Private setter for attributes +val+.
+    def set_attributes(val)
+      @attributes = val
+      build_path_query
+      @attributes
+    end
+    protected :set_attributes
+
+    # Setter for attributes +val+.
+    def attributes=(val)
+      set_attributes(val)
+      val
+    end
+
+    # Returns scope.
+    def scope
+      @scope
+    end
+
+    # Private setter for scope +val+.
+    def set_scope(val)
+      @scope = val
+      build_path_query
+      @scope
+    end
+    protected :set_scope
+
+    # Setter for scope +val+.
+    def scope=(val)
+      set_scope(val)
+      val
+    end
+
+    # Returns filter.
+    def filter
+      @filter
+    end
+
+    # Private setter for filter +val+.
+    def set_filter(val)
+      @filter = val
+      build_path_query
+      @filter
+    end
+    protected :set_filter
+
+    # Setter for filter +val+.
+    def filter=(val)
+      set_filter(val)
+      val
+    end
+
+    # Returns extensions.
+    def extensions
+      @extensions
+    end
+
+    # Private setter for extensions +val+.
+    def set_extensions(val)
+      @extensions = val
+      build_path_query
+      @extensions
+    end
+    protected :set_extensions
+
+    # Setter for extensions +val+.
+    def extensions=(val)
+      set_extensions(val)
+      val
+    end
+
+    # Checks if Bundler::URI has a path.
+    # For Bundler::URI::LDAP this will return +false+.
+    def hierarchical?
+      false
+    end
+  end
+
+  register_scheme 'LDAP', LDAP
+end

data/lib/bundler/vendor/uri/lib/uri/ldaps.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: false
+# = uri/ldap.rb
+#
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+#
+# See Bundler::URI for general documentation
+#
+
+require_relative 'ldap'
+
+module Bundler::URI
+
+  # The default port for LDAPS URIs is 636, and the scheme is 'ldaps:' rather
+  # than 'ldap:'. Other than that, LDAPS URIs are identical to LDAP URIs;
+  # see Bundler::URI::LDAP.
+  class LDAPS < LDAP
+    # A Default port of 636 for Bundler::URI::LDAPS
+    DEFAULT_PORT = 636
+  end
+
+  register_scheme 'LDAPS', LDAPS
+end