Dust.Protocol.Path (dustlayer v0.1.1)

Copy Markdown View Source

Segment-first paths for the Dust Elixir SDK.

A path is an ordered, non-empty list of non-empty string segments:

["posts", "hello.world", "image/file"]

Public SDK functions accept either a segment list or a canonical rendered slash string (see from_input/1). Internally the SDK uses segment lists; strings are rendered at boundaries (cache keys, wire protocol, log lines).

This module mirrors DustProtocol.Path from the canonical wire- protocol package; the SDK keeps its own copy so it can be Hex- publishable without taking a dep on the protocol package.

Rendering

Canonical rendered paths join segments with / and escape per RFC 6901 (JSON Pointer) inside each segment:

`~` -> `~0`
`/` -> `~1`

No other character has any special meaning. In particular, . is literal — "example.com" is one segment, not two.

Migration note

This module replaces the legacy dot-as-separator API that shipped in earlier capability versions. Dust.Protocol.Path.LegacyDot is available as a transitional helper for code that still consumes dotted-string paths from old data; it is deleted at the end of the migration.

Summary

Types

error()
rendered()
segment()
segments()

Functions

ancestor?(ancestor, descendant)
child(parent, segment)
concat(parent, tail)
from_input(s)

Accept either a rendered slash string or a segment list, return validated segments. SDK entry points use this so callers can write Dust.put(store, "a/b/c", val) or Dust.put(store, ["a","b","c"], val) interchangeably.

from_segments(segments)
from_segments!(segments)
normalize_rendered(s)
parse_rendered(s)
related?(a, b)
render(segments)
render!(segments)
render_descendant_prefix(segments)
render_descendant_prefix!(segments)

Types

error()

@type error() ::
  :empty_path | :empty_segment | :invalid_escape | :not_a_string | :not_a_list

rendered()

@type rendered() :: String.t()

segment()

@type segment() :: String.t()

segments()

@type segments() :: [segment(), ...]

Functions

ancestor?(ancestor, descendant)

@spec ancestor?(segments(), segments()) :: boolean()

child(parent, segment)

@spec child(term(), term()) :: {:ok, segments()} | {:error, error()}

concat(parent, tail)

@spec concat(term(), term()) :: {:ok, segments()} | {:error, error()}

from_input(s)

@spec from_input(term()) :: {:ok, segments()} | {:error, error()}

Accept either a rendered slash string or a segment list, return validated segments. SDK entry points use this so callers can write Dust.put(store, "a/b/c", val) or Dust.put(store, ["a","b","c"], val) interchangeably.

from_segments(segments)

@spec from_segments(term()) :: {:ok, segments()} | {:error, error()}

from_segments!(segments)

@spec from_segments!(term()) :: segments()

normalize_rendered(s)

@spec normalize_rendered(term()) :: {:ok, rendered()} | {:error, error()}

parse_rendered(s)

@spec parse_rendered(term()) :: {:ok, segments()} | {:error, error()}

related?(a, b)

@spec related?(segments(), segments()) :: boolean()

render(segments)

@spec render(term()) :: {:ok, rendered()} | {:error, error()}

render!(segments)

@spec render!(term()) :: rendered()

render_descendant_prefix(segments)

@spec render_descendant_prefix(term()) :: {:ok, rendered()} | {:error, error()}

render_descendant_prefix!(segments)

@spec render_descendant_prefix!(term()) :: rendered()