Class: Mongo::URI

# File 'lib/mongo/uri.rb', line 47

attr_reader :servers

# File 'lib/mongo/uri.rb', line 42

attr_reader :uri_options

# File 'lib/mongo/uri.rb', line 307

def credentials
  { user: @user, password: @password }
end

# File 'lib/mongo/uri.rb', line 319

def database
  @database || Database::ADMIN
end

# File 'lib/mongo/uri.rb', line 451

def decode(value)
  ::URI::DEFAULT_PARSER.unescape(value)
end

# File 'lib/mongo/uri.rb', line 455

def encode(value)
  CGI.escape(value).gsub('+', '%20')
end

# File 'lib/mongo/uri.rb', line 398

def options_mapper
  @options_mapper ||= OptionsMapper.new(
    logger: @options[:logger]
  )
end

# File 'lib/mongo/uri.rb', line 366

def parse!(remaining)
  hosts_and_db, options = remaining.split('?', 2)
  if options && options.index('?')
    raise_invalid_error!('Options contain an unescaped question mark (?), or the database name contains a question mark and was not escaped')
  end

  hosts, db = hosts_and_db.split('/', 2)
  raise_invalid_error!("Database name contains an unescaped slash (/): #{db}") if db && db.index('/')

  if hosts.index('@')
    creds, hosts = hosts.split('@', 2)
    raise_invalid_error!('Empty hosts list') if hosts.empty?
    raise_invalid_error!('Unescaped @ in auth info') if hosts.index('@')
  end

  raise_invalid_error!('Missing host; at least one must be provided') unless hosts.length > 0

  @servers = hosts.split(',').map do |host|
    raise_invalid_error!('Empty host given in the host list') if host.empty?
    decode(host).tap do |host|
      validate_address_str!(host)
    end
  end

  @user = parse_user!(creds)
  @password = parse_password!(creds)
  @uri_options = Options::Redacted.new(parse_uri_options!(options))
  @database = parse_database!(db) if db
rescue Error::InvalidAddress => e
  raise_invalid_error!(e.message)
end

# File 'lib/mongo/uri.rb', line 438

def parse_database!(string)
  raise_invalid_error!(UNESCAPED_DATABASE) if UNSAFE.match?(string)
  decode(string) if string.length > 0
end

# File 'lib/mongo/uri.rb', line 429

def parse_password!(string)
  if string && (pwd = string.partition(AUTH_USER_PWD_DELIM)[2]) && (pwd.length > 0)
    raise_invalid_error!(UNESCAPED_USER_PWD) if UNSAFE.match?(pwd)
    pwd_decoded = decode(pwd)
    raise_invalid_error!(UNESCAPED_USER_PWD) if pwd_decoded =~ PERCENT_CHAR && encode(pwd_decoded) != pwd
    pwd_decoded
  end
end

# File 'lib/mongo/uri.rb', line 404

def parse_uri_options!(string)
  uri_options = {}
  return uri_options unless string

  string.split('&').each do |option_str|
    next if option_str.empty?

    key, value = option_str.split('=', 2)
    raise_invalid_error!("Option #{key} has no value") if value.nil?
    key = decode(key)
    value = decode(value)
    options_mapper.add_uri_option(key, value, uri_options)
  end
  uri_options
end

# File 'lib/mongo/uri.rb', line 420

def parse_user!(string)
  if string && user = string.partition(AUTH_USER_PWD_DELIM)[0]
    raise_invalid_error!(UNESCAPED_USER_PWD) if UNSAFE.match?(user)
    user_decoded = decode(user)
    raise_invalid_error!(UNESCAPED_USER_PWD) if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
    user_decoded
  end
end

# File 'lib/mongo/uri.rb', line 443

def raise_invalid_error!(details)
  raise Error::InvalidURI.new(@string, details, FORMAT)
end

# File 'lib/mongo/uri.rb', line 447

def raise_invalid_error_no_fmt!(details)
  raise Error::InvalidURI.new(@string, details)
end

# File 'lib/mongo/uri.rb', line 339

def reconstruct_uri
  servers = @servers.join(',')
  options = options_mapper.ruby_to_string(@uri_options).map do |k, vs|
    unless vs.nil?
      if vs.is_a?(Array)
        vs.map { |v| "#{k}=#{v}" }.join('&')
      else
        "#{k}=#{vs}"
      end
    end
  end.compact.join('&')

  uri = "#{scheme}#{SCHEME_DELIM}"
  uri += @user.to_s if @user
  uri += "#{AUTH_USER_PWD_DELIM}#{@password}" if @password
  uri += '@' if @user || @password
  uri += @query_hostname || servers
  uri += '/' if @database || !options.empty?
  uri += @database.to_s if @database
  uri += "?#{options}" unless options.empty?
  uri
end

# File 'lib/mongo/uri.rb', line 362

def scheme
  MONGODB_SCHEME
end

# File 'lib/mongo/uri.rb', line 265

def srv_records
  nil
end

# File 'lib/mongo/uri.rb', line 329

def to_s
  reconstruct_uri
end

# File 'lib/mongo/uri.rb', line 459

def validate_uri_options!
  # The URI options spec requires that we raise an error if there are conflicting values of
  # 'tls' and 'ssl'. In order to fulfill this, we parse the values of each instance into an
  # array; assuming all values in the array are the same, we replace the array with that value.
  unless uri_options[:ssl].nil? || uri_options[:ssl].empty?
    unless uri_options[:ssl].uniq.length == 1
      raise_invalid_error_no_fmt!("all instances of 'tls' and 'ssl' must have the same value")
    end

    uri_options[:ssl] = uri_options[:ssl].first
  end

  # Check for conflicting TLS insecure options.
  unless uri_options[:ssl_verify].nil?
    unless uri_options[:ssl_verify_certificate].nil?
      raise_invalid_error_no_fmt!("'tlsInsecure' and 'tlsAllowInvalidCertificates' cannot both be specified")
    end

    unless uri_options[:ssl_verify_hostname].nil?
      raise_invalid_error_no_fmt!("tlsInsecure' and 'tlsAllowInvalidHostnames' cannot both be specified")
    end

    unless uri_options[:ssl_verify_ocsp_endpoint].nil?
      raise_invalid_error_no_fmt!("tlsInsecure' and 'tlsDisableOCSPEndpointCheck' cannot both be specified")
    end
  end

  if !uri_options[:ssl_verify_certificate].nil? && !uri_options[:ssl_verify_ocsp_endpoint].nil?
    raise_invalid_error_no_fmt!("tlsAllowInvalidCertificates' and 'tlsDisableOCSPEndpointCheck' cannot both be specified")
  end

  # Since we know that the only URI option that sets :ssl_cert is
  # "tlsCertificateKeyFile", any value set for :ssl_cert must also be set
  # for :ssl_key.
  uri_options[:ssl_key] = uri_options[:ssl_cert] if uri_options[:ssl_cert]

  if uri_options[:write_concern] && !uri_options[:write_concern].empty?
    begin
      WriteConcern.get(uri_options[:write_concern])
    rescue Error::InvalidWriteConcern => e
      raise_invalid_error_no_fmt!("#{e.class}: #{e}")
    end
  end

  if uri_options[:direct_connection]
    if uri_options[:connect] && uri_options[:connect].to_s != 'direct'
      raise_invalid_error_no_fmt!("directConnection=true cannot be used with connect=#{uri_options[:connect]}")
    end
    raise_invalid_error_no_fmt!('directConnection=true cannot be used with multiple seeds') if servers.length > 1
  elsif uri_options[:direct_connection] == false && uri_options[:connect].to_s == 'direct'
    raise_invalid_error_no_fmt!('directConnection=false cannot be used with connect=direct')
  end

  if uri_options[:load_balanced]
    raise_invalid_error_no_fmt!('loadBalanced=true cannot be used with multiple seeds') if servers.length > 1

    if uri_options[:direct_connection]
      raise_invalid_error_no_fmt!('directConnection=true cannot be used with loadBalanced=true')
    end

    if uri_options[:connect] && uri_options[:connect].to_sym == :direct
      raise_invalid_error_no_fmt!('connect=direct cannot be used with loadBalanced=true')
    end

    if uri_options[:replica_set]
      raise_invalid_error_no_fmt!('loadBalanced=true cannot be used with replicaSet option')
    end
  end

  unless is_a?(URI::SRVProtocol)
    raise_invalid_error_no_fmt!('srvMaxHosts cannot be used on non-SRV URI') if uri_options[:srv_max_hosts]

    raise_invalid_error_no_fmt!('srvServiceName cannot be used on non-SRV URI') if uri_options[:srv_service_name]
  end

  return unless uri_options[:srv_max_hosts] && uri_options[:srv_max_hosts] > 0

  raise_invalid_error_no_fmt!('srvMaxHosts > 0 cannot be used with replicaSet option') if uri_options[:replica_set]

  return unless options[:load_balanced]

  raise_invalid_error_no_fmt!('srvMaxHosts > 0 cannot be used with loadBalanced=true')
end