fn pub static new[B: Bytes](path: ref B) -> Option[Self] {
  match parse(path, start: 0, standalone: true) {
    case Ok((Some(val), _)) -> Option.Some(val)
    case Ok(_) -> Option.Some(Path(''))
    case _ -> Option.None
  }
}

fn pub static new[B: Bytes](path: ref B) -> Option[Path]

Returns a Path created from the given String.

If the supplied path string is invalid, an Option.None is returned.

Normalization

If the path argument is an absolute path containing . or .. segments, the path is normalized such that e.g. /foo/../bar is turned into /bar.

Examples

import std.uri (Path)

Path.new('/hello/world') # => Option.Some(Path('/hello/world'))
Path.new('foo?bar')      # => Option.None

fn pub !=(other: ref Self) -> Bool {
  (self == other).false?
}

fn pub !=(other: ref Self) -> Bool

Returns true if self and the given object are not equal to each other.

fn pub ==(other: ref Path) -> Bool {
  @value == other.value
}

fn pub ==(other: ref Path) -> Bool

Returns true if self and other are equal.

This method doesn't perform any percent decoding or normalization.

fn pub inline absolute? -> Bool {
  @value.starts_with?('/')
}

fn pub inline absolute? -> Bool

Returns true if self is an absolute path.

Examples

import std.uri (Path)

Path.new('/hello').get.absolute? # => true
Path.new('hello').get.absolute? # => false

fn pub components -> PathComponents {
  PathComponents(path: @value, index: 0)
}

fn pub components -> PathComponents

Returns an iterator over the components in self.

Percent decoding

Components containing percent-encoded sequences are decoded into a PathComponent.Owned after splitting the components.

Examples

import std.uri (Uri)

let uri = Uri.parse('https://example.com/foo/bar').or_panic
let iter = uri.path.as_ref.get.components

iter.next.or_panic.to_string # => '/'
iter.next.or_panic.to_string # => 'foo'

fn pub inline empty? -> Bool {
  size == 0
}

fn pub inline empty? -> Bool

Returns true if self is empty.

Examples

import std.uri (Path)

Path.new('').get.empty? # => true
Path.new('foo').get.empty? # => false

fn pub fmt(formatter: mut Formatter) {
  formatter.object('Path').field('value', @value).finish
}

fn pub fmt(formatter: mut Formatter)

Formats self in a human-readable format for debugging purposes.

fn pub inline relative? -> Bool {
  absolute?.false?
}

fn pub inline relative? -> Bool

Returns true if self is a relative path.

Examples

import std.uri (Path)

Path.new('/hello').get.relative? # => false
Path.new('hello').get.relative? # => true

fn pub inline size -> Int {
  @value.size
}

fn pub inline size -> Int

Returns the size of self, before applying percent decoding.

Examples

import std.uri (Path)

Path.empty.size # => 0
Path.new('a%20b').get.size # => 5

fn pub to_string -> String {
  let buf = ByteArray.new

  decode(@value, buf)
  buf.into_string
}

fn pub to_string -> String

Returns a String containing the percent-decoded value of self.

If after decoding the data contains bytes that aren't valid UTF-8, these bytes are replaced with U+FFFD REPLACEMENT CHARACTER.