rubygems-update 3.1.0.pre3 → 3.1.0

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

@@ -0,0 +1,88 @@
+# 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.
+# Revision:: $Id$
+#
+# 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
+
+    #
+    # == 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
+  end
+
+  @@schemes['HTTP'] = HTTP
+
+end

data/bundler/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.
+# Revision:: $Id$
+#
+# 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
+  @@schemes['HTTPS'] = HTTPS
+end

data/bundler/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.
+# Revision:: $Id$
+#
+# 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
+      @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
+
+  @@schemes['LDAP'] = LDAP
+end

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

@@ -0,0 +1,21 @@
+# 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
+  @@schemes['LDAPS'] = LDAPS
+end

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

@@ -0,0 +1,294 @@
+# frozen_string_literal: false
+# = uri/mailto.rb
+#
+# Author:: Akira Yamada <akira@ruby-lang.org>
+# License:: You can redistribute it and/or modify it under the same term as Ruby.
+# Revision:: $Id$
+#
+# See Bundler::URI for general documentation
+#
+
+require_relative 'generic'
+
+module Bundler::URI
+
+  #
+  # RFC6068, the mailto URL scheme.
+  #
+  class MailTo < Generic
+    include REGEXP
+
+    # A Default port of nil for Bundler::URI::MailTo.
+    DEFAULT_PORT = nil
+
+    # An Array of the available components for Bundler::URI::MailTo.
+    COMPONENT = [ :scheme, :to, :headers ].freeze
+
+    # :stopdoc:
+    #  "hname" and "hvalue" are encodings of an RFC 822 header name and
+    #  value, respectively. As with "to", all URL reserved characters must
+    #  be encoded.
+    #
+    #  "#mailbox" is as specified in RFC 822 [RFC822]. This means that it
+    #  consists of zero or more comma-separated mail addresses, possibly
+    #  including "phrase" and "comment" components. Note that all URL
+    #  reserved characters in "to" must be encoded: in particular,
+    #  parentheses, commas, and the percent sign ("%"), which commonly occur
+    #  in the "mailbox" syntax.
+    #
+    #  Within mailto URLs, the characters "?", "=", "&" are reserved.
+
+    # ; RFC 6068
+    # hfields      = "?" hfield *( "&" hfield )
+    # hfield       = hfname "=" hfvalue
+    # hfname       = *qchar
+    # hfvalue      = *qchar
+    # qchar        = unreserved / pct-encoded / some-delims
+    # some-delims  = "!" / "$" / "'" / "(" / ")" / "*"
+    #              / "+" / "," / ";" / ":" / "@"
+    #
+    # ; RFC3986
+    # unreserved   = ALPHA / DIGIT / "-" / "." / "_" / "~"
+    # pct-encoded  = "%" HEXDIG HEXDIG
+    HEADER_REGEXP  = /\A(?<hfield>(?:%\h\h|[!$'-.0-;@-Z_a-z~])*=(?:%\h\h|[!$'-.0-;@-Z_a-z~])*)(?:&\g<hfield>)*\z/
+    # practical regexp for email address
+    # https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
+    EMAIL_REGEXP = /\A[a-zA-Z0-9.!\#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\z/
+    # :startdoc:
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::MailTo object from components, with syntax checking.
+    #
+    # Components can be provided as an Array or Hash. If an Array is used,
+    # the components must be supplied as <code>[to, headers]</code>.
+    #
+    # If a Hash is used, the keys are the component names preceded by colons.
+    #
+    # The headers can be supplied as a pre-encoded string, such as
+    # <code>"subject=subscribe&cc=address"</code>, or as an Array of Arrays
+    # like <code>[['subject', 'subscribe'], ['cc', 'address']]</code>.
+    #
+    # Examples:
+    #
+    #    require 'bundler/vendor/uri/lib/uri'
+    #
+    #    m1 = Bundler::URI::MailTo.build(['joe@example.com', 'subject=Ruby'])
+    #    m1.to_s  # => "mailto:joe@example.com?subject=Ruby"
+    #
+    #    m2 = Bundler::URI::MailTo.build(['john@example.com', [['Subject', 'Ruby'], ['Cc', 'jack@example.com']]])
+    #    m2.to_s  # => "mailto:john@example.com?Subject=Ruby&Cc=jack@example.com"
+    #
+    #    m3 = Bundler::URI::MailTo.build({:to => 'listman@example.com', :headers => [['subject', 'subscribe']]})
+    #    m3.to_s  # => "mailto:listman@example.com?subject=subscribe"
+    #
+    def self.build(args)
+      tmp = Util.make_components_hash(self, args)
+
+      case tmp[:to]
+      when Array
+        tmp[:opaque] = tmp[:to].join(',')
+      when String
+        tmp[:opaque] = tmp[:to].dup
+      else
+        tmp[:opaque] = ''
+      end
+
+      if tmp[:headers]
+        query =
+          case tmp[:headers]
+          when Array
+            tmp[:headers].collect { |x|
+              if x.kind_of?(Array)
+                x[0] + '=' + x[1..-1].join
+              else
+                x.to_s
+              end
+            }.join('&')
+          when Hash
+            tmp[:headers].collect { |h,v|
+              h + '=' + v
+            }.join('&')
+          else
+            tmp[:headers].to_s
+          end
+        unless query.empty?
+          tmp[:opaque] << '?' << query
+        end
+      end
+
+      super(tmp)
+    end
+
+    #
+    # == Description
+    #
+    # Creates a new Bundler::URI::MailTo object from generic URL components with
+    # no syntax checking.
+    #
+    # This method is usually called from Bundler::URI::parse, which checks
+    # the validity of each component.
+    #
+    def initialize(*arg)
+      super(*arg)
+
+      @to = nil
+      @headers = []
+
+      # The RFC3986 parser does not normally populate opaque
+      @opaque = "?#{@query}" if @query && !@opaque
+
+      unless @opaque
+        raise InvalidComponentError,
+          "missing opaque part for mailto URL"
+      end
+      to, header = @opaque.split('?', 2)
+      # allow semicolon as a addr-spec separator
+      # http://support.microsoft.com/kb/820868
+      unless /\A(?:[^@,;]+@[^@,;]+(?:\z|[,;]))*\z/ =~ to
+        raise InvalidComponentError,
+          "unrecognised opaque part for mailtoURL: #{@opaque}"
+      end
+
+      if arg[10] # arg_check
+        self.to = to
+        self.headers = header
+      else
+        set_to(to)
+        set_headers(header)
+      end
+    end
+
+    # The primary e-mail address of the URL, as a String.
+    attr_reader :to
+
+    # E-mail headers set by the URL, as an Array of Arrays.
+    attr_reader :headers
+
+    # Checks the to +v+ component.
+    def check_to(v)
+      return true unless v
+      return true if v.size == 0
+
+      v.split(/[,;]/).each do |addr|
+        # check url safety as path-rootless
+        if /\A(?:%\h\h|[!$&-.0-;=@-Z_a-z~])*\z/ !~ addr
+          raise InvalidComponentError,
+            "an address in 'to' is invalid as Bundler::URI #{addr.dump}"
+        end
+
+        # check addr-spec
+        # don't s/\+/ /g
+        addr.gsub!(/%\h\h/, Bundler::URI::TBLDECWWWCOMP_)
+        if EMAIL_REGEXP !~ addr
+          raise InvalidComponentError,
+            "an address in 'to' is invalid as uri-escaped addr-spec #{addr.dump}"
+        end
+      end
+
+      true
+    end
+    private :check_to
+
+    # Private setter for to +v+.
+    def set_to(v)
+      @to = v
+    end
+    protected :set_to
+
+    # Setter for to +v+.
+    def to=(v)
+      check_to(v)
+      set_to(v)
+      v
+    end
+
+    # Checks the headers +v+ component against either
+    # * HEADER_REGEXP
+    def check_headers(v)
+      return true unless v
+      return true if v.size == 0
+      if HEADER_REGEXP !~ v
+        raise InvalidComponentError,
+          "bad component(expected opaque component): #{v}"
+      end
+
+      true
+    end
+    private :check_headers
+
+    # Private setter for headers +v+.
+    def set_headers(v)
+      @headers = []
+      if v
+        v.split('&').each do |x|
+          @headers << x.split(/=/, 2)
+        end
+      end
+    end
+    protected :set_headers
+
+    # Setter for headers +v+.
+    def headers=(v)
+      check_headers(v)
+      set_headers(v)
+      v
+    end
+
+    # Constructs String from Bundler::URI.
+    def to_s
+      @scheme + ':' +
+        if @to
+          @to
+        else
+          ''
+        end +
+        if @headers.size > 0
+          '?' + @headers.collect{|x| x.join('=')}.join('&')
+        else
+          ''
+        end +
+        if @fragment
+          '#' + @fragment
+        else
+          ''
+        end
+    end
+
+    # Returns the RFC822 e-mail text equivalent of the URL, as a String.
+    #
+    # Example:
+    #
+    #   require 'bundler/vendor/uri/lib/uri'
+    #
+    #   uri = Bundler::URI.parse("mailto:ruby-list@ruby-lang.org?Subject=subscribe&cc=myaddr")
+    #   uri.to_mailtext
+    #   # => "To: ruby-list@ruby-lang.org\nSubject: subscribe\nCc: myaddr\n\n\n"
+    #
+    def to_mailtext
+      to = Bundler::URI.decode_www_form_component(@to)
+      head = ''
+      body = ''
+      @headers.each do |x|
+        case x[0]
+        when 'body'
+          body = Bundler::URI.decode_www_form_component(x[1])
+        when 'to'
+          to << ', ' + Bundler::URI.decode_www_form_component(x[1])
+        else
+          head << Bundler::URI.decode_www_form_component(x[0]).capitalize + ': ' +
+            Bundler::URI.decode_www_form_component(x[1])  + "\n"
+        end
+      end
+
+      "To: #{to}
+#{head}
+#{body}
+"
+    end
+    alias to_rfc822text to_mailtext
+  end
+
+  @@schemes['MAILTO'] = MailTo
+end