Accept binaries as Unix-like paths

[dumbbell]

Currently a Khepri path is either a native path (a list of atoms, binaries and conditions) or a Unix-like path which is an Erlang string.

Several other Beam languages such as Elixir or Gleam implement strings as Erlang binaries. Therefore, it would be nice to extend Unix-like path to accept binaries as well. This should be even simpler to parse because we don't have to determine if the passed list is a native path or a Unix-like string!

The easy part is to update khepri_path:from_string/1 to accept and parse binaries. The boring part is to update all function specs... A new type should be introduced to include khepri_path:path(), string() and binary().

[the-mikedavis]

I see a TODO for changing that path/0 to node_path/0:

khepri/src/khepri_path.erl

Lines 83 to 91 in 686a160

	-type node_id() :: atom() | binary().
	%% A node name.
	-type component() :: node_id() | ?ROOT_NODE | ?THIS_NODE | ?PARENT_NODE.
	%% Component name in a path to a node.
	%% TODO: Rename to node_path()
	-type path() :: [component()].
	%% Path to a node.

What would you think about types like these?

%% (renamed from `path/0`)
-type node_path() :: [component()].
%% A native path to a node.

-type unix_path() :: string() | binary().
%% A path as a string or binary.

-type path() :: unix_path() | node_path().
%% A path to a node. Either a string, binary, or a native path.

Edit: oh actually it looks like the new type should be string() | binary() | khepri_path:pattern(), no?

[dumbbell]

I was thinking of using the same naming as the documentation:

%% In khepri_path.erl

-type native_path() :: [component()].
-type native_pattern() :: [pattern_component()].

-type unix_path() :: string() | binary().
-type unix_pattern() :: string() | binary().

-type path() :: native_path() | unix_path().
-type pattern() :: native_pattern() | unix_pattern().

I wanted to keep path and pattern distinct because most if not all functions accept a pattern (which a path is a subset of), but return values contain paths only, not patterns.

What do you think? Do you suggest better names than "native" or "Unix"?

[michaelklishin]

What constitutes a "native pattern"? I assume a UNIX pattern is slash-separated? If so, slash_separated or fs_like_path could be slightly more descriptive?

[the-mikedavis]

If I understand it correctly, native paths are the internal representation for paths

[stock, wood, <<"oak">>].

and then unix paths are a convenient string-based syntax that can be translated into native paths

khepri_path:from_string("/:stock/:wood/oak").
%%=> [stock, wood, <<"oak">>]

With patterns being a supertype that also allows conditions from khepri_condition:

%% native pattern:
[stock,
 #if_all{conditions = [wood,
                       #if_node_exists{exists = true}]},
 oak].

I like the connotations of "unix" and "native" but unix isn't totally perfect because the :atom syntax doesn't have an equivalent in unix paths. Maybe there's a good word that describes unix paths as a convenient syntax (similar to "native" implying that native paths are the internal representation)?

[michaelklishin]

So they are list paths and slash-separated or filesystem-like paths.