postfinancecheckout-ruby-sdk 3.3.0 → 4.4.0

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/lib/public_suffix/rule.rb

@@ -1,350 +0,0 @@
-# frozen_string_literal: true
-
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-module PublicSuffix
-
-  # A Rule is a special object which holds a single definition
-  # of the Public Suffix List.
-  #
-  # There are 3 types of rules, each one represented by a specific
-  # subclass within the +PublicSuffix::Rule+ namespace.
-  #
-  # To create a new Rule, use the {PublicSuffix::Rule#factory} method.
-  #
-  #   PublicSuffix::Rule.factory("ar")
-  #   # => #<PublicSuffix::Rule::Normal>
-  #
-  module Rule
-
-    # @api internal
-    Entry = Struct.new(:type, :length, :private) # rubocop:disable Lint/StructNewOverride
-
-    # = Abstract rule class
-    #
-    # This represent the base class for a Rule definition
-    # in the {Public Suffix List}[https://publicsuffix.org].
-    #
-    # This is intended to be an Abstract class
-    # and you shouldn't create a direct instance. The only purpose
-    # of this class is to expose a common interface
-    # for all the available subclasses.
-    #
-    # * {PublicSuffix::Rule::Normal}
-    # * {PublicSuffix::Rule::Exception}
-    # * {PublicSuffix::Rule::Wildcard}
-    #
-    # ## Properties
-    #
-    # A rule is composed by 4 properties:
-    #
-    # value   - A normalized version of the rule name.
-    #           The normalization process depends on rule tpe.
-    #
-    # Here's an example
-    #
-    #   PublicSuffix::Rule.factory("*.google.com")
-    #   #<PublicSuffix::Rule::Wildcard:0x1015c14b0
-    #       @value="google.com"
-    #   >
-    #
-    # ## Rule Creation
-    #
-    # The best way to create a new rule is passing the rule name
-    # to the <tt>PublicSuffix::Rule.factory</tt> method.
-    #
-    #   PublicSuffix::Rule.factory("com")
-    #   # => PublicSuffix::Rule::Normal
-    #
-    #   PublicSuffix::Rule.factory("*.com")
-    #   # => PublicSuffix::Rule::Wildcard
-    #
-    # This method will detect the rule type and create an instance
-    # from the proper rule class.
-    #
-    # ## Rule Usage
-    #
-    # A rule describes the composition of a domain name and explains how to tokenize
-    # the name into tld, sld and trd.
-    #
-    # To use a rule, you first need to be sure the name you want to tokenize
-    # can be handled by the current rule.
-    # You can use the <tt>#match?</tt> method.
-    #
-    #   rule = PublicSuffix::Rule.factory("com")
-    #
-    #   rule.match?("google.com")
-    #   # => true
-    #
-    #   rule.match?("google.com")
-    #   # => false
-    #
-    # Rule order is significant. A name can match more than one rule.
-    # See the {Public Suffix Documentation}[http://publicsuffix.org/format/]
-    # to learn more about rule priority.
-    #
-    # When you have the right rule, you can use it to tokenize the domain name.
-    #
-    #   rule = PublicSuffix::Rule.factory("com")
-    #
-    #   rule.decompose("google.com")
-    #   # => ["google", "com"]
-    #
-    #   rule.decompose("www.google.com")
-    #   # => ["www.google", "com"]
-    #
-    # @abstract
-    #
-    class Base
-
-      # @return [String] the rule definition
-      attr_reader :value
-
-      # @return [String] the length of the rule
-      attr_reader :length
-
-      # @return [Boolean] true if the rule is a private domain
-      attr_reader :private
-
-
-      # Initializes a new rule from the content.
-      #
-      # @param  content [String] the content of the rule
-      # @param  private [Boolean]
-      def self.build(content, private: false)
-        new(value: content, private: private)
-      end
-
-      # Initializes a new rule.
-      #
-      # @param  value [String]
-      # @param  private [Boolean]
-      def initialize(value:, length: nil, private: false)
-        @value    = value.to_s
-        @length   = length || (@value.count(DOT) + 1)
-        @private  = private
-      end
-
-      # Checks whether this rule is equal to <tt>other</tt>.
-      #
-      # @param  other [PublicSuffix::Rule::*] The rule to compare
-      # @return [Boolean] true if this rule and other are instances of the same class
-      #         and has the same value, false otherwise.
-      def ==(other)
-        equal?(other) || (self.class == other.class && value == other.value)
-      end
-      alias eql? ==
-
-      # Checks if this rule matches +name+.
-      #
-      # A domain name is said to match a rule if and only if
-      # all of the following conditions are met:
-      #
-      # - When the domain and rule are split into corresponding labels,
-      #   that the domain contains as many or more labels than the rule.
-      # - Beginning with the right-most labels of both the domain and the rule,
-      #   and continuing for all labels in the rule, one finds that for every pair,
-      #   either they are identical, or that the label from the rule is "*".
-      #
-      # @see https://publicsuffix.org/list/
-      #
-      # @example
-      #   PublicSuffix::Rule.factory("com").match?("example.com")
-      #   # => true
-      #   PublicSuffix::Rule.factory("com").match?("example.net")
-      #   # => false
-      #
-      # @param  name [String] the domain name to check
-      # @return [Boolean]
-      def match?(name)
-        # NOTE: it works because of the assumption there are no
-        # rules like foo.*.com. If the assumption is incorrect,
-        # we need to properly walk the input and skip parts according
-        # to wildcard component.
-        diff = name.chomp(value)
-        diff.empty? || diff.end_with?(DOT)
-      end
-
-      # @abstract
-      def parts
-        raise NotImplementedError
-      end
-
-      # @abstract
-      # @param  domain [#to_s] The domain name to decompose
-      # @return [Array<String, nil>]
-      def decompose(*)
-        raise NotImplementedError
-      end
-
-    end
-
-    # Normal represents a standard rule (e.g. com).
-    class Normal < Base
-
-      # Gets the original rule definition.
-      #
-      # @return [String] The rule definition.
-      def rule
-        value
-      end
-
-      # Decomposes the domain name according to rule properties.
-      #
-      # @param  domain [#to_s] The domain name to decompose
-      # @return [Array<String>] The array with [trd + sld, tld].
-      def decompose(domain)
-        suffix = parts.join('\.')
-        matches = domain.to_s.match(/^(.*)\.(#{suffix})$/)
-        matches ? matches[1..2] : [nil, nil]
-      end
-
-      # dot-split rule value and returns all rule parts
-      # in the order they appear in the value.
-      #
-      # @return [Array<String>]
-      def parts
-        @value.split(DOT)
-      end
-
-    end
-
-    # Wildcard represents a wildcard rule (e.g. *.co.uk).
-    class Wildcard < Base
-
-      # Initializes a new rule from the content.
-      #
-      # @param  content [String] the content of the rule
-      # @param  private [Boolean]
-      def self.build(content, private: false)
-        new(value: content.to_s[2..], private: private)
-      end
-
-      # Initializes a new rule.
-      #
-      # @param  value [String]
-      # @param  length [Integer]
-      # @param  private [Boolean]
-      def initialize(value:, length: nil, private: false)
-        super(value: value, length: length, private: private)
-        length or @length += 1 # * counts as 1
-      end
-
-      # Gets the original rule definition.
-      #
-      # @return [String] The rule definition.
-      def rule
-        value == "" ? STAR : STAR + DOT + value
-      end
-
-      # Decomposes the domain name according to rule properties.
-      #
-      # @param  domain [#to_s] The domain name to decompose
-      # @return [Array<String>] The array with [trd + sld, tld].
-      def decompose(domain)
-        suffix = ([".*?"] + parts).join('\.')
-        matches = domain.to_s.match(/^(.*)\.(#{suffix})$/)
-        matches ? matches[1..2] : [nil, nil]
-      end
-
-      # dot-split rule value and returns all rule parts
-      # in the order they appear in the value.
-      #
-      # @return [Array<String>]
-      def parts
-        @value.split(DOT)
-      end
-
-    end
-
-    # Exception represents an exception rule (e.g. !parliament.uk).
-    class Exception < Base
-
-      # Initializes a new rule from the content.
-      #
-      # @param  content [#to_s] the content of the rule
-      # @param  private [Boolean]
-      def self.build(content, private: false)
-        new(value: content.to_s[1..], private: private)
-      end
-
-      # Gets the original rule definition.
-      #
-      # @return [String] The rule definition.
-      def rule
-        BANG + value
-      end
-
-      # Decomposes the domain name according to rule properties.
-      #
-      # @param  domain [#to_s] The domain name to decompose
-      # @return [Array<String>] The array with [trd + sld, tld].
-      def decompose(domain)
-        suffix = parts.join('\.')
-        matches = domain.to_s.match(/^(.*)\.(#{suffix})$/)
-        matches ? matches[1..2] : [nil, nil]
-      end
-
-      # dot-split rule value and returns all rule parts
-      # in the order they appear in the value.
-      # The leftmost label is not considered a label.
-      #
-      # See http://publicsuffix.org/format/:
-      # If the prevailing rule is a exception rule,
-      # modify it by removing the leftmost label.
-      #
-      # @return [Array<String>]
-      def parts
-        @value.split(DOT)[1..]
-      end
-
-    end
-
-
-    # Takes the +name+ of the rule, detects the specific rule class
-    # and creates a new instance of that class.
-    # The +name+ becomes the rule +value+.
-    #
-    # @example Creates a Normal rule
-    #   PublicSuffix::Rule.factory("ar")
-    #   # => #<PublicSuffix::Rule::Normal>
-    #
-    # @example Creates a Wildcard rule
-    #   PublicSuffix::Rule.factory("*.ar")
-    #   # => #<PublicSuffix::Rule::Wildcard>
-    #
-    # @example Creates an Exception rule
-    #   PublicSuffix::Rule.factory("!congresodelalengua3.ar")
-    #   # => #<PublicSuffix::Rule::Exception>
-    #
-    # @param  content [#to_s] the content of the rule
-    # @return [PublicSuffix::Rule::*] A rule instance.
-    def self.factory(content, private: false)
-      case content.to_s[0, 1]
-      when STAR
-        Wildcard
-      when BANG
-        Exception
-      else
-        Normal
-      end.build(content, private: private)
-    end
-
-    # The default rule to use if no rule match.
-    #
-    # The default rule is "*". From https://publicsuffix.org/list/:
-    #
-    # > If no rules match, the prevailing rule is "*".
-    #
-    # @return [PublicSuffix::Rule::Wildcard] The default rule.
-    def self.default
-      factory(STAR)
-    end
-
-  end
-
-end

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/lib/public_suffix/version.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-#
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-module PublicSuffix
-
-  # @return [String] The current library version.
-  VERSION = "5.0.1"
-
-end

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/lib/public_suffix.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-# = Public Suffix
-#
-# Domain name parser based on the Public Suffix List.
-#
-# Copyright (c) 2009-2022 Simone Carletti <weppos@weppos.net>
-
-require_relative "public_suffix/domain"
-require_relative "public_suffix/version"
-require_relative "public_suffix/errors"
-require_relative "public_suffix/rule"
-require_relative "public_suffix/list"
-
-# PublicSuffix is a Ruby domain name parser based on the Public Suffix List.
-#
-# The [Public Suffix List](https://publicsuffix.org) is a cross-vendor initiative
-# to provide an accurate list of domain name suffixes.
-#
-# The Public Suffix List is an initiative of the Mozilla Project,
-# but is maintained as a community resource. It is available for use in any software,
-# but was originally created to meet the needs of browser manufacturers.
-module PublicSuffix
-
-  DOT   = "."
-  BANG  = "!"
-  STAR  = "*"
-
-  # Parses +name+ and returns the {PublicSuffix::Domain} instance.
-  #
-  # @example Parse a valid domain
-  #   PublicSuffix.parse("google.com")
-  #   # => #<PublicSuffix::Domain:0x007fec2e51e588 @sld="google", @tld="com", @trd=nil>
-  #
-  # @example Parse a valid subdomain
-  #   PublicSuffix.parse("www.google.com")
-  #   # => #<PublicSuffix::Domain:0x007fec276d4cf8 @sld="google", @tld="com", @trd="www">
-  #
-  # @example Parse a fully qualified domain
-  #   PublicSuffix.parse("google.com.")
-  #   # => #<PublicSuffix::Domain:0x007fec257caf38 @sld="google", @tld="com", @trd=nil>
-  #
-  # @example Parse a fully qualified domain (subdomain)
-  #   PublicSuffix.parse("www.google.com.")
-  #   # => #<PublicSuffix::Domain:0x007fec27b6bca8 @sld="google", @tld="com", @trd="www">
-  #
-  # @example Parse an invalid (unlisted) domain
-  #   PublicSuffix.parse("x.yz")
-  #   # => #<PublicSuffix::Domain:0x007fec2f49bec0 @sld="x", @tld="yz", @trd=nil>
-  #
-  # @example Parse an invalid (unlisted) domain with strict checking (without applying the default * rule)
-  #   PublicSuffix.parse("x.yz", default_rule: nil)
-  #   # => PublicSuffix::DomainInvalid: `x.yz` is not a valid domain
-  #
-  # @example Parse an URL (not supported, only domains)
-  #   PublicSuffix.parse("http://www.google.com")
-  #   # => PublicSuffix::DomainInvalid: http://www.google.com is not expected to contain a scheme
-  #
-  #
-  # @param  name [#to_s] The domain name or fully qualified domain name to parse.
-  # @param  list [PublicSuffix::List] The rule list to search, defaults to the default {PublicSuffix::List}
-  # @param  ignore_private [Boolean]
-  # @return [PublicSuffix::Domain]
-  #
-  # @raise [PublicSuffix::DomainInvalid] If domain is not a valid domain.
-  # @raise [PublicSuffix::DomainNotAllowed] If a rule for +domain+ is found, but the rule doesn't allow +domain+.
-  def self.parse(name, list: List.default, default_rule: list.default_rule, ignore_private: false)
-    what = normalize(name)
-    raise what if what.is_a?(DomainInvalid)
-
-    rule = list.find(what, default: default_rule, ignore_private: ignore_private)
-
-    # rubocop:disable Style/IfUnlessModifier
-    if rule.nil?
-      raise DomainInvalid, "`#{what}` is not a valid domain"
-    end
-    if rule.decompose(what).last.nil?
-      raise DomainNotAllowed, "`#{what}` is not allowed according to Registry policy"
-    end
-
-    # rubocop:enable Style/IfUnlessModifier
-
-    decompose(what, rule)
-  end
-
-  # Checks whether +domain+ is assigned and allowed, without actually parsing it.
-  #
-  # This method doesn't care whether domain is a domain or subdomain.
-  # The validation is performed using the default {PublicSuffix::List}.
-  #
-  # @example Validate a valid domain
-  #   PublicSuffix.valid?("example.com")
-  #   # => true
-  #
-  # @example Validate a valid subdomain
-  #   PublicSuffix.valid?("www.example.com")
-  #   # => true
-  #
-  # @example Validate a not-listed domain
-  #   PublicSuffix.valid?("example.tldnotlisted")
-  #   # => true
-  #
-  # @example Validate a not-listed domain with strict checking (without applying the default * rule)
-  #   PublicSuffix.valid?("example.tldnotlisted")
-  #   # => true
-  #   PublicSuffix.valid?("example.tldnotlisted", default_rule: nil)
-  #   # => false
-  #
-  # @example Validate a fully qualified domain
-  #   PublicSuffix.valid?("google.com.")
-  #   # => true
-  #   PublicSuffix.valid?("www.google.com.")
-  #   # => true
-  #
-  # @example Check an URL (which is not a valid domain)
-  #   PublicSuffix.valid?("http://www.example.com")
-  #   # => false
-  #
-  #
-  # @param  name [#to_s] The domain name or fully qualified domain name to validate.
-  # @param  ignore_private [Boolean]
-  # @return [Boolean]
-  def self.valid?(name, list: List.default, default_rule: list.default_rule, ignore_private: false)
-    what = normalize(name)
-    return false if what.is_a?(DomainInvalid)
-
-    rule = list.find(what, default: default_rule, ignore_private: ignore_private)
-
-    !rule.nil? && !rule.decompose(what).last.nil?
-  end
-
-  # Attempt to parse the name and returns the domain, if valid.
-  #
-  # This method doesn't raise. Instead, it returns nil if the domain is not valid for whatever reason.
-  #
-  # @param  name [#to_s] The domain name or fully qualified domain name to parse.
-  # @param  list [PublicSuffix::List] The rule list to search, defaults to the default {PublicSuffix::List}
-  # @param  ignore_private [Boolean]
-  # @return [String]
-  def self.domain(name, **options)
-    parse(name, **options).domain
-  rescue PublicSuffix::Error
-    nil
-  end
-
-
-  # private
-
-  def self.decompose(name, rule)
-    left, right = rule.decompose(name)
-
-    parts = left.split(DOT)
-    # If we have 0 parts left, there is just a tld and no domain or subdomain
-    # If we have 1 part  left, there is just a tld, domain and not subdomain
-    # If we have 2 parts left, the last part is the domain, the other parts (combined) are the subdomain
-    tld = right
-    sld = parts.empty? ? nil : parts.pop
-    trd = parts.empty? ? nil : parts.join(DOT)
-
-    Domain.new(tld, sld, trd)
-  end
-
-  # Pretend we know how to deal with user input.
-  def self.normalize(name)
-    name = name.to_s.dup
-    name.strip!
-    name.chomp!(DOT)
-    name.downcase!
-
-    return DomainInvalid.new("Name is blank") if name.empty?
-    return DomainInvalid.new("Name starts with a dot") if name.start_with?(DOT)
-    return DomainInvalid.new(format("%s is not expected to contain a scheme", name)) if name.include?("://")
-
-    name
-  end
-
-end

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/public_suffix.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-$LOAD_PATH.push File.expand_path("../lib", __FILE__)
-require "public_suffix/version"
-
-Gem::Specification.new do |s|
-  s.name        = "public_suffix"
-  s.version     = PublicSuffix::VERSION
-  s.authors     = ["Simone Carletti"]
-  s.email       = ["weppos@weppos.net"]
-  s.homepage    = "https://simonecarletti.com/code/publicsuffix-ruby"
-  s.summary     = "Domain name parser based on the Public Suffix List."
-  s.description = "PublicSuffix can parse and decompose a domain name into top level domain, domain and subdomains."
-  s.licenses    = ["MIT"]
-
-  s.metadata = {
-    "bug_tracker_uri" => "https://github.com/weppos/publicsuffix-ruby/issues",
-    "changelog_uri" => "https://github.com/weppos/publicsuffix-ruby/blob/master/CHANGELOG.md",
-    "documentation_uri" => "https://rubydoc.info/gems/#{s.name}/#{s.version}",
-    "homepage_uri" => s.homepage,
-    "source_code_uri" => "https://github.com/weppos/publicsuffix-ruby/tree/v#{s.version}",
-  }
-
-  s.required_ruby_version = ">= 2.6"
-
-  s.require_paths    = ["lib"]
-  s.files            = `git ls-files`.split("\n")
-  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.extra_rdoc_files = %w( LICENSE.txt )
-end

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/test/.empty

@@ -1,2 +0,0 @@
-# This is an empty file I use to force a non-empty commit when I only need to store notes
-..

data/vendor/bundle/ruby/2.7.0/gems/public_suffix-5.0.1/test/acceptance_test.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class AcceptanceTest < Minitest::Test
-
-  VALID_CASES = [
-    ["example.com",             "example.com", [nil, "example", "com"]],
-    ["foo.example.com",         "example.com",        ["foo", "example", "com"]],
-
-    ["verybritish.co.uk",       "verybritish.co.uk",  [nil, "verybritish", "co.uk"]],
-    ["foo.verybritish.co.uk",   "verybritish.co.uk",  ["foo", "verybritish", "co.uk"]],
-
-    ["parliament.uk",           "parliament.uk",      [nil, "parliament", "uk"]],
-    ["foo.parliament.uk",       "parliament.uk",      ["foo", "parliament", "uk"]],
-  ].freeze
-
-  def test_valid
-    VALID_CASES.each do |input, domain, results|
-      parsed = PublicSuffix.parse(input)
-      trd, sld, tld = results
-      assert_equal tld, parsed.tld, "Invalid tld for `#{name}`"
-      assert_equal sld, parsed.sld, "Invalid sld for `#{name}`"
-      if trd.nil?
-        assert_nil parsed.trd, "Invalid trd for `#{name}`"
-      else
-        assert_equal trd, parsed.trd, "Invalid trd for `#{name}`"
-      end
-
-      assert_equal domain, PublicSuffix.domain(input)
-      assert PublicSuffix.valid?(input)
-    end
-  end
-
-
-  INVALID_CASES = [
-    ["nic.bd", PublicSuffix::DomainNotAllowed],
-    [nil,                       PublicSuffix::DomainInvalid],
-    ["",                        PublicSuffix::DomainInvalid],
-    ["  ",                      PublicSuffix::DomainInvalid],
-  ].freeze
-
-  def test_invalid
-    INVALID_CASES.each do |(name, error)|
-      assert_raises(error) { PublicSuffix.parse(name) }
-      assert !PublicSuffix.valid?(name)
-    end
-  end
-
-
-  REJECTED_CASES = [
-    ["www. .com", true],
-    ["foo.co..uk",          true],
-    ["goo,gle.com",         true],
-    ["-google.com",         true],
-    ["google-.com",         true],
-
-    # This case was covered in GH-15.
-    # I decided to cover this case because it's not easily reproducible with URI.parse
-    # and can lead to several false positives.
-    ["http://google.com",   false],
-  ].freeze
-
-  def test_rejected
-    REJECTED_CASES.each do |name, expected|
-      assert_equal expected, PublicSuffix.valid?(name),
-                   format("Expected %s to be %s", name.inspect, expected.inspect)
-      assert !valid_domain?(name),
-             "#{name} expected to be invalid"
-    end
-  end
-
-
-  CASE_CASES = [
-    ["Www.google.com", %w[www google com]],
-    ["www.Google.com", %w[www google com]],
-    ["www.google.Com", %w[www google com]],
-  ].freeze
-
-  def test_ignore_case
-    CASE_CASES.each do |name, results|
-      domain = PublicSuffix.parse(name)
-      trd, sld, tld = results
-      assert_equal tld, domain.tld, "Invalid tld for `#{name}'"
-      assert_equal sld, domain.sld, "Invalid sld for `#{name}'"
-      assert_equal trd, domain.trd, "Invalid trd for `#{name}'"
-      assert PublicSuffix.valid?(name)
-    end
-  end
-
-
-  INCLUDE_PRIVATE_CASES = [
-    ["blogspot.com", true, "blogspot.com"],
-    ["blogspot.com", false, nil],
-    ["subdomain.blogspot.com", true, "blogspot.com"],
-    ["subdomain.blogspot.com", false, "subdomain.blogspot.com"],
-  ].freeze
-
-  # rubocop:disable Style/CombinableLoops
-  def test_ignore_private
-    # test domain and parse
-    INCLUDE_PRIVATE_CASES.each do |given, ignore_private, expected|
-      if expected.nil?
-        assert_nil PublicSuffix.domain(given, ignore_private: ignore_private)
-      else
-        assert_equal expected, PublicSuffix.domain(given, ignore_private: ignore_private)
-      end
-    end
-    # test valid?
-    INCLUDE_PRIVATE_CASES.each do |given, ignore_private, expected|
-      assert_equal !expected.nil?, PublicSuffix.valid?(given, ignore_private: ignore_private)
-    end
-  end
-  # rubocop:enable Style/CombinableLoops
-
-
-  def valid_uri?(name)
-    uri = URI.parse(name)
-    !uri.host.nil?
-  rescue StandardError
-    false
-  end
-
-  def valid_domain?(name)
-    uri = URI.parse(name)
-    !uri.host.nil? && uri.scheme.nil?
-  rescue StandardError
-    false
-  end
-
-end