-module(lightspeed@diff).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/diff.gleam").
-export([target/1, operation/1, carries_html/1, slot/2, keyed_node/2, keyed_patch_plan/3, encode_stream/1, encode/1, decode_stream/1, decode/1, decode_error_to_string/1]).
-export_type([dynamic_slot/0, keyed_node/0, patch/0, decode_error/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(" Patch model and codec for rendered updates.\n").
-type dynamic_slot() :: {dynamic_slot, binary(), binary()}.
-type keyed_node() :: {keyed_node, binary(), binary()}.
-type patch() :: {replace, binary(), binary()} |
{append, binary(), binary()} |
{prepend, binary(), binary()} |
{remove, binary()} |
{replace_segments, binary(), binary(), binary(), list(dynamic_slot())} |
{update_segments, binary(), binary(), list(dynamic_slot())} |
{upsert_keyed, binary(), binary(), binary()} |
{remove_keyed, binary(), binary()} |
{reorder_keyed, binary(), list(binary())}.
-type decode_error() :: empty_payload |
{unknown_payload_tag, binary()} |
{bad_field_count, binary(), integer(), integer()} |
{invalid_integer, binary()} |
{unsupported_version, integer()} |
{missing_dictionary_entry, integer()} |
{malformed_operation, binary()} |
invalid_escape_sequence.
-file("src/lightspeed/diff.gleam", 54).
?DOC(" Return the target selector or id for a patch.\n").
-spec target(patch()) -> binary().
target(Patch) ->
case Patch of
{replace, Target, _} ->
Target;
{append, Target@1, _} ->
Target@1;
{prepend, Target@2, _} ->
Target@2;
{remove, Target@3} ->
Target@3;
{replace_segments, Target@4, _, _, _} ->
Target@4;
{update_segments, Target@5, _, _} ->
Target@5;
{upsert_keyed, Target@6, _, _} ->
Target@6;
{remove_keyed, Target@7, _} ->
Target@7;
{reorder_keyed, Target@8, _} ->
Target@8
end.
-file("src/lightspeed/diff.gleam", 69).
?DOC(" Return the patch operation name.\n").
-spec operation(patch()) -> binary().
operation(Patch) ->
case Patch of
{replace, _, _} ->
<<"replace"/utf8>>;
{append, _, _} ->
<<"append"/utf8>>;
{prepend, _, _} ->
<<"prepend"/utf8>>;
{remove, _} ->
<<"remove"/utf8>>;
{replace_segments, _, _, _, _} ->
<<"replace_segments"/utf8>>;
{update_segments, _, _, _} ->
<<"update_segments"/utf8>>;
{upsert_keyed, _, _, _} ->
<<"upsert_keyed"/utf8>>;
{remove_keyed, _, _} ->
<<"remove_keyed"/utf8>>;
{reorder_keyed, _, _} ->
<<"reorder_keyed"/utf8>>
end.
-file("src/lightspeed/diff.gleam", 84).
?DOC(" True when a patch carries HTML content.\n").
-spec carries_html(patch()) -> boolean().
carries_html(Patch) ->
case Patch of
{remove, _} ->
false;
{update_segments, _, _, _} ->
false;
{remove_keyed, _, _} ->
false;
{reorder_keyed, _, _} ->
false;
_ ->
true
end.
-file("src/lightspeed/diff.gleam", 95).
?DOC(" Build one dynamic slot value.\n").
-spec slot(binary(), binary()) -> dynamic_slot().
slot(Name, Value) ->
{dynamic_slot, Name, Value}.
-file("src/lightspeed/diff.gleam", 100).
?DOC(" Build one keyed node.\n").
-spec keyed_node(binary(), binary()) -> keyed_node().
keyed_node(Key, Html) ->
{keyed_node, Key, Html}.
-file("src/lightspeed/diff.gleam", 238).
-spec keyed_lookup(list(keyed_node()), binary()) -> {ok, binary()} |
{error, nil}.
keyed_lookup(Nodes, Key) ->
case Nodes of
[] ->
{error, nil};
[{keyed_node, Node_key, Html} | Rest] ->
case Node_key =:= Key of
true ->
{ok, Html};
false ->
keyed_lookup(Rest, Key)
end
end.
-file("src/lightspeed/diff.gleam", 220).
-spec keyed_removals(binary(), list(keyed_node()), list(keyed_node())) -> list(patch()).
keyed_removals(Target, Previous, Current) ->
case Previous of
[] ->
[];
[{keyed_node, Key, _} | Rest] ->
case keyed_lookup(Current, Key) of
{ok, _} ->
keyed_removals(Target, Rest, Current);
{error, nil} ->
[{remove_keyed, Target, Key} |
keyed_removals(Target, Rest, Current)]
end
end.
-file("src/lightspeed/diff.gleam", 194).
-spec keyed_upserts(binary(), list(keyed_node()), list(keyed_node())) -> list(patch()).
keyed_upserts(Target, Previous, Current) ->
case Current of
[] ->
[];
[{keyed_node, Key, Html} | Rest] ->
case keyed_lookup(Previous, Key) of
{ok, Previous_html} ->
case Previous_html =:= Html of
true ->
keyed_upserts(Target, Previous, Rest);
false ->
[{upsert_keyed, Target, Key, Html} |
keyed_upserts(Target, Previous, Rest)]
end;
{error, nil} ->
[{upsert_keyed, Target, Key, Html} |
keyed_upserts(Target, Previous, Rest)]
end
end.
-file("src/lightspeed/diff.gleam", 864).
-spec concat(list(FLQ), list(FLQ)) -> list(FLQ).
concat(Left, Right) ->
case Left of
[] ->
Right;
[Entry | Rest] ->
[Entry | concat(Rest, Right)]
end.
-file("src/lightspeed/diff.gleam", 105).
?DOC(" Build a keyed update plan from previous and current collections.\n").
-spec keyed_patch_plan(binary(), list(keyed_node()), list(keyed_node())) -> list(patch()).
keyed_patch_plan(Target, Previous, Current) ->
concat(
keyed_upserts(Target, Previous, Current),
keyed_removals(Target, Previous, Current)
).
-file("src/lightspeed/diff.gleam", 903).
-spec escape_chars(list(binary()), binary()) -> binary().
escape_chars(Chars, Acc) ->
case Chars of
[] ->
Acc;
[Char | Rest] ->
case Char of
<<"\\"/utf8>> ->
escape_chars(Rest, <<Acc/binary, "\\\\"/utf8>>);
<<"|"/utf8>> ->
escape_chars(Rest, <<Acc/binary, "\\|"/utf8>>);
_ ->
escape_chars(Rest, <<Acc/binary, Char/binary>>)
end
end.
-file("src/lightspeed/diff.gleam", 899).
-spec escape_field(binary()) -> binary().
escape_field(Value) ->
escape_chars(gleam@string:to_graphemes(Value), <<""/utf8>>).
-file("src/lightspeed/diff.gleam", 892).
-spec join_fields_loop(list(binary()), binary()) -> binary().
join_fields_loop(Fields, Acc) ->
case Fields of
[] ->
Acc;
[Field | Rest] ->
join_fields_loop(
Rest,
<<<<Acc/binary, "|"/utf8>>/binary,
(escape_field(Field))/binary>>
)
end.
-file("src/lightspeed/diff.gleam", 885).
-spec join_fields(list(binary())) -> binary().
join_fields(Fields) ->
case Fields of
[] ->
<<""/utf8>>;
[Field | Rest] ->
join_fields_loop(Rest, escape_field(Field))
end.
-file("src/lightspeed/diff.gleam", 443).
-spec index_of(list(binary()), binary(), integer()) -> integer().
index_of(Values, Target, Index) ->
case Values of
[] ->
0;
[Value | Rest] ->
case Value =:= Target of
true ->
Index;
false ->
index_of(Rest, Target, Index + 1)
end
end.
-file("src/lightspeed/diff.gleam", 439).
-spec encode_index(list(binary()), binary()) -> binary().
encode_index(Dictionary, Value) ->
erlang:integer_to_binary(index_of(Dictionary, Value, 0)).
-file("src/lightspeed/diff.gleam", 408).
-spec encode_key_tokens(list(binary()), list(binary()), list(binary())) -> list(binary()).
encode_key_tokens(Keys, Dictionary, Tokens_rev) ->
case Keys of
[] ->
lists:reverse(Tokens_rev);
[Key | Rest] ->
encode_key_tokens(
Rest,
Dictionary,
[encode_index(Dictionary, Key) | Tokens_rev]
)
end.
-file("src/lightspeed/diff.gleam", 878).
-spec join_tokens_loop(list(binary()), binary()) -> binary().
join_tokens_loop(Tokens, Acc) ->
case Tokens of
[] ->
Acc;
[Token | Rest] ->
join_tokens_loop(
Rest,
<<<<Acc/binary, ","/utf8>>/binary, Token/binary>>
)
end.
-file("src/lightspeed/diff.gleam", 871).
-spec join_tokens(list(binary())) -> binary().
join_tokens(Tokens) ->
case Tokens of
[] ->
<<""/utf8>>;
[Token | Rest] ->
join_tokens_loop(Rest, Token)
end.
-file("src/lightspeed/diff.gleam", 423).
-spec encode_dynamic_slot_tokens(
list(dynamic_slot()),
list(binary()),
list(binary())
) -> list(binary()).
encode_dynamic_slot_tokens(Dynamic_slots, Dictionary, Tokens_rev) ->
case Dynamic_slots of
[] ->
lists:reverse(Tokens_rev);
[{dynamic_slot, Name, Value} | Rest] ->
encode_dynamic_slot_tokens(
Rest,
Dictionary,
[encode_index(Dictionary, Value),
encode_index(Dictionary, Name) |
Tokens_rev]
)
end.
-file("src/lightspeed/diff.gleam", 333).
-spec encode_operation(patch(), list(binary())) -> binary().
encode_operation(Patch, Dictionary) ->
case Patch of
{replace, Target, Html} ->
join_tokens(
[<<"r"/utf8>>,
encode_index(Dictionary, Target),
encode_index(Dictionary, Html)]
);
{append, Target@1, Html@1} ->
join_tokens(
[<<"a"/utf8>>,
encode_index(Dictionary, Target@1),
encode_index(Dictionary, Html@1)]
);
{prepend, Target@2, Html@2} ->
join_tokens(
[<<"p"/utf8>>,
encode_index(Dictionary, Target@2),
encode_index(Dictionary, Html@2)]
);
{remove, Target@3} ->
join_tokens([<<"x"/utf8>>, encode_index(Dictionary, Target@3)]);
{replace_segments, Target@4, Fingerprint, Static_html, Dynamic_slots} ->
join_tokens(
concat(
[<<"s"/utf8>>,
encode_index(Dictionary, Target@4),
encode_index(Dictionary, Fingerprint),
encode_index(Dictionary, Static_html),
erlang:integer_to_binary(erlang:length(Dynamic_slots))],
encode_dynamic_slot_tokens(Dynamic_slots, Dictionary, [])
)
);
{update_segments, Target@5, Fingerprint@1, Dynamic_slots@1} ->
join_tokens(
concat(
[<<"u"/utf8>>,
encode_index(Dictionary, Target@5),
encode_index(Dictionary, Fingerprint@1),
erlang:integer_to_binary(erlang:length(Dynamic_slots@1))],
encode_dynamic_slot_tokens(Dynamic_slots@1, Dictionary, [])
)
);
{upsert_keyed, Target@6, Key, Html@3} ->
join_tokens(
[<<"k"/utf8>>,
encode_index(Dictionary, Target@6),
encode_index(Dictionary, Key),
encode_index(Dictionary, Html@3)]
);
{remove_keyed, Target@7, Key@1} ->
join_tokens(
[<<"q"/utf8>>,
encode_index(Dictionary, Target@7),
encode_index(Dictionary, Key@1)]
);
{reorder_keyed, Target@8, Keys} ->
join_tokens(
concat(
[<<"o"/utf8>>,
encode_index(Dictionary, Target@8),
erlang:integer_to_binary(erlang:length(Keys))],
encode_key_tokens(Keys, Dictionary, [])
)
)
end.
-file("src/lightspeed/diff.gleam", 318).
-spec encode_operations(list(patch()), list(binary()), list(binary())) -> list(binary()).
encode_operations(Patches, Dictionary, Operation_fields_rev) ->
case Patches of
[] ->
lists:reverse(Operation_fields_rev);
[Patch | Rest] ->
encode_operations(
Rest,
Dictionary,
[encode_operation(Patch, Dictionary) | Operation_fields_rev]
)
end.
-file("src/lightspeed/diff.gleam", 279).
-spec dynamic_slot_strings(list(dynamic_slot())) -> list(binary()).
dynamic_slot_strings(Dynamic_slots) ->
case Dynamic_slots of
[] ->
[];
[{dynamic_slot, Name, Value} | Rest] ->
[Name, Value | dynamic_slot_strings(Rest)]
end.
-file("src/lightspeed/diff.gleam", 260).
-spec patch_strings(patch()) -> list(binary()).
patch_strings(Patch) ->
case Patch of
{replace, Target, Html} ->
[Target, Html];
{append, Target@1, Html@1} ->
[Target@1, Html@1];
{prepend, Target@2, Html@2} ->
[Target@2, Html@2];
{remove, Target@3} ->
[Target@3];
{replace_segments, Target@4, Fingerprint, Static_html, Dynamic_slots} ->
concat(
[Target@4, Fingerprint, Static_html],
dynamic_slot_strings(Dynamic_slots)
);
{update_segments, Target@5, Fingerprint@1, Dynamic_slots@1} ->
concat(
[Target@5, Fingerprint@1],
dynamic_slot_strings(Dynamic_slots@1)
);
{upsert_keyed, Target@6, Key, Html@3} ->
[Target@6, Key, Html@3];
{remove_keyed, Target@7, Key@1} ->
[Target@7, Key@1];
{reorder_keyed, Target@8, Keys} ->
concat([Target@8], Keys)
end.
-file("src/lightspeed/diff.gleam", 307).
-spec contains_string(list(binary()), binary()) -> boolean().
contains_string(Values, Target) ->
case Values of
[] ->
false;
[Value | Rest] ->
case Value =:= Target of
true ->
true;
false ->
contains_string(Rest, Target)
end
end.
-file("src/lightspeed/diff.gleam", 300).
-spec add_unique(list(binary()), binary()) -> list(binary()).
add_unique(Dictionary, Value) ->
case contains_string(Dictionary, Value) of
true ->
Dictionary;
false ->
concat(Dictionary, [Value])
end.
-file("src/lightspeed/diff.gleam", 290).
-spec add_all_unique(list(binary()), list(binary())) -> list(binary()).
add_all_unique(Dictionary, Values) ->
case Values of
[] ->
Dictionary;
[Value | Rest] ->
add_all_unique(add_unique(Dictionary, Value), Rest)
end.
-file("src/lightspeed/diff.gleam", 249).
-spec build_dictionary(list(patch()), list(binary())) -> list(binary()).
build_dictionary(Patches, Dictionary) ->
case Patches of
[] ->
Dictionary;
[Patch | Rest] ->
build_dictionary(
Rest,
add_all_unique(Dictionary, patch_strings(Patch))
)
end.
-file("src/lightspeed/diff.gleam", 122).
?DOC(" Encode a patch stream with dictionary compression.\n").
-spec encode_stream(list(patch())) -> binary().
encode_stream(Patches) ->
Dictionary = build_dictionary(Patches, []),
Operation_fields = encode_operations(Patches, Dictionary, []),
Fields = concat(
concat(
concat(
[<<"ps"/utf8>>,
erlang:integer_to_binary(1),
erlang:integer_to_binary(erlang:length(Dictionary))],
Dictionary
),
[erlang:integer_to_binary(erlang:length(Operation_fields))]
),
Operation_fields
),
join_fields(Fields).
-file("src/lightspeed/diff.gleam", 117).
?DOC(" Encode one patch into a versioned compressed stream.\n").
-spec encode(patch()) -> binary().
encode(Patch) ->
encode_stream([Patch]).
-file("src/lightspeed/diff.gleam", 839).
-spec dictionary_value(list(binary()), integer()) -> {ok, binary()} |
{error, decode_error()}.
dictionary_value(Dictionary, Index) ->
case Index < 0 of
true ->
{error, {missing_dictionary_entry, Index}};
false ->
case Dictionary of
[] ->
{error, {missing_dictionary_entry, Index}};
[Entry | Rest] ->
case Index =:= 0 of
true ->
{ok, Entry};
false ->
dictionary_value(Rest, Index - 1)
end
end
end.
-file("src/lightspeed/diff.gleam", 857).
-spec parse_int(binary()) -> {ok, integer()} | {error, decode_error()}.
parse_int(Value) ->
case gleam_stdlib:parse_int(Value) of
{ok, Parsed} ->
{ok, Parsed};
{error, _} ->
{error, {invalid_integer, Value}}
end.
-file("src/lightspeed/diff.gleam", 829).
-spec decode_dictionary_value(binary(), list(binary())) -> {ok, binary()} |
{error, decode_error()}.
decode_dictionary_value(Index_text, Dictionary) ->
case parse_int(Index_text) of
{error, Error} ->
{error, Error};
{ok, Index} ->
dictionary_value(Dictionary, Index)
end.
-file("src/lightspeed/diff.gleam", 803).
-spec decode_dynamic_slot_pairs(
list(binary()),
list(binary()),
list(dynamic_slot())
) -> {ok, list(dynamic_slot())} | {error, decode_error()}.
decode_dynamic_slot_pairs(Slot_tokens, Dictionary, Dynamic_slots_rev) ->
case Slot_tokens of
[] ->
{ok, lists:reverse(Dynamic_slots_rev)};
[Name_index, Value_index | Rest] ->
case decode_dictionary_value(Name_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Name} ->
case decode_dictionary_value(Value_index, Dictionary) of
{error, Error@1} ->
{error, Error@1};
{ok, Value} ->
decode_dynamic_slot_pairs(
Rest,
Dictionary,
[{dynamic_slot, Name, Value} |
Dynamic_slots_rev]
)
end
end;
_ ->
{error, {malformed_operation, <<"dynamic_slot_pair"/utf8>>}}
end.
-file("src/lightspeed/diff.gleam", 783).
-spec decode_dynamic_slots(binary(), list(binary()), list(binary())) -> {ok,
list(dynamic_slot())} |
{error, decode_error()}.
decode_dynamic_slots(Slot_count_text, Slot_tokens, Dictionary) ->
case parse_int(Slot_count_text) of
{error, Error} ->
{error, Error};
{ok, Slot_count} ->
case erlang:length(Slot_tokens) =:= (Slot_count * 2) of
false ->
{error,
{bad_field_count,
<<"dynamic_slots"/utf8>>,
Slot_count * 2,
erlang:length(Slot_tokens)}};
true ->
decode_dynamic_slot_pairs(Slot_tokens, Dictionary, [])
end
end.
-file("src/lightspeed/diff.gleam", 757).
-spec decode_update_segment_patch(
binary(),
binary(),
binary(),
list(binary()),
list(binary())
) -> {ok, patch()} | {error, decode_error()}.
decode_update_segment_patch(
Target_index,
Fingerprint_index,
Slot_count_text,
Slot_tokens,
Dictionary
) ->
case decode_dictionary_value(Target_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Target} ->
case decode_dictionary_value(Fingerprint_index, Dictionary) of
{error, Error@1} ->
{error, Error@1};
{ok, Fingerprint} ->
case decode_dynamic_slots(
Slot_count_text,
Slot_tokens,
Dictionary
) of
{error, Error@2} ->
{error, Error@2};
{ok, Dynamic_slots} ->
{ok,
{update_segments,
Target,
Fingerprint,
Dynamic_slots}}
end
end
end.
-file("src/lightspeed/diff.gleam", 723).
-spec decode_segment_patch(
binary(),
binary(),
binary(),
binary(),
list(binary()),
list(binary())
) -> {ok, patch()} | {error, decode_error()}.
decode_segment_patch(
Target_index,
Fingerprint_index,
Static_index,
Slot_count_text,
Slot_tokens,
Dictionary
) ->
case decode_dictionary_value(Target_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Target} ->
case decode_dictionary_value(Fingerprint_index, Dictionary) of
{error, Error@1} ->
{error, Error@1};
{ok, Fingerprint} ->
case decode_dictionary_value(Static_index, Dictionary) of
{error, Error@2} ->
{error, Error@2};
{ok, Static_html} ->
case decode_dynamic_slots(
Slot_count_text,
Slot_tokens,
Dictionary
) of
{error, Error@3} ->
{error, Error@3};
{ok, Dynamic_slots} ->
{ok,
{replace_segments,
Target,
Fingerprint,
Static_html,
Dynamic_slots}}
end
end
end
end.
-file("src/lightspeed/diff.gleam", 679).
-spec decode_key_indexes(list(binary()), list(binary()), list(binary())) -> {ok,
list(binary())} |
{error, decode_error()}.
decode_key_indexes(Key_indexes, Dictionary, Keys_rev) ->
case Key_indexes of
[] ->
{ok, lists:reverse(Keys_rev)};
[Key_index | Rest] ->
case decode_dictionary_value(Key_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Key} ->
decode_key_indexes(Rest, Dictionary, [Key | Keys_rev])
end
end.
-file("src/lightspeed/diff.gleam", 650).
-spec decode_reorder_patch(binary(), binary(), list(binary()), list(binary())) -> {ok,
patch()} |
{error, decode_error()}.
decode_reorder_patch(Target_index, Key_count_text, Key_indexes, Dictionary) ->
case decode_dictionary_value(Target_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Target} ->
case parse_int(Key_count_text) of
{error, Error@1} ->
{error, Error@1};
{ok, Key_count} ->
case erlang:length(Key_indexes) =:= Key_count of
false ->
{error,
{bad_field_count,
<<"reorder_keyed_keys"/utf8>>,
Key_count,
erlang:length(Key_indexes)}};
true ->
case decode_key_indexes(Key_indexes, Dictionary, []) of
{error, Error@2} ->
{error, Error@2};
{ok, Keys} ->
{ok, {reorder_keyed, Target, Keys}}
end
end
end
end.
-file("src/lightspeed/diff.gleam", 712).
-spec map_patch_name_error({ok, patch()} | {error, decode_error()}, binary()) -> {ok,
patch()} |
{error, decode_error()}.
map_patch_name_error(Result, Patch_name) ->
case Result of
{ok, Patch} ->
{ok, Patch};
{error, {malformed_operation, _}} ->
{error, {malformed_operation, Patch_name}};
{error, Error} ->
{error, Error}
end.
-file("src/lightspeed/diff.gleam", 694).
-spec decode_binary_patch(
binary(),
binary(),
binary(),
list(binary()),
fun((binary(), binary()) -> patch())
) -> {ok, patch()} | {error, decode_error()}.
decode_binary_patch(
Patch_name,
Target_index,
Html_index,
Dictionary,
Constructor
) ->
_pipe = case decode_dictionary_value(Target_index, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Target} ->
case decode_dictionary_value(Html_index, Dictionary) of
{error, Error@1} ->
{error, Error@1};
{ok, Html} ->
{ok, Constructor(Target, Html)}
end
end,
map_patch_name_error(_pipe, Patch_name).
-file("src/lightspeed/diff.gleam", 552).
-spec decode_operation(binary(), list(binary())) -> {ok, patch()} |
{error, decode_error()}.
decode_operation(Operation_field, Dictionary) ->
Tokens = gleam@string:split(Operation_field, <<","/utf8>>),
case Tokens of
[<<"r"/utf8>>, Target_index, Html_index] ->
decode_binary_patch(
<<"replace"/utf8>>,
Target_index,
Html_index,
Dictionary,
fun(Field@0, Field@1) -> {replace, Field@0, Field@1} end
);
[<<"a"/utf8>>, Target_index@1, Html_index@1] ->
decode_binary_patch(
<<"append"/utf8>>,
Target_index@1,
Html_index@1,
Dictionary,
fun(Field@0, Field@1) -> {append, Field@0, Field@1} end
);
[<<"p"/utf8>>, Target_index@2, Html_index@2] ->
decode_binary_patch(
<<"prepend"/utf8>>,
Target_index@2,
Html_index@2,
Dictionary,
fun(Field@0, Field@1) -> {prepend, Field@0, Field@1} end
);
[<<"x"/utf8>>, Target_index@3] ->
case decode_dictionary_value(Target_index@3, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Target} ->
{ok, {remove, Target}}
end;
[<<"k"/utf8>>, Target_index@4, Key_index, Html_index@3] ->
case decode_dictionary_value(Target_index@4, Dictionary) of
{error, Error@1} ->
{error, Error@1};
{ok, Target@1} ->
case decode_dictionary_value(Key_index, Dictionary) of
{error, Error@2} ->
{error, Error@2};
{ok, Key} ->
case decode_dictionary_value(
Html_index@3,
Dictionary
) of
{error, Error@3} ->
{error, Error@3};
{ok, Html} ->
{ok, {upsert_keyed, Target@1, Key, Html}}
end
end
end;
[<<"q"/utf8>>, Target_index@5, Key_index@1] ->
case decode_dictionary_value(Target_index@5, Dictionary) of
{error, Error@4} ->
{error, Error@4};
{ok, Target@2} ->
case decode_dictionary_value(Key_index@1, Dictionary) of
{error, Error@5} ->
{error, Error@5};
{ok, Key@1} ->
{ok, {remove_keyed, Target@2, Key@1}}
end
end;
[<<"o"/utf8>>, Target_index@6, Key_count | Key_indexes] ->
decode_reorder_patch(
Target_index@6,
Key_count,
Key_indexes,
Dictionary
);
[<<"s"/utf8>>,
Target_index@7,
Fingerprint_index,
Static_index,
Slot_count |
Slot_tokens] ->
decode_segment_patch(
Target_index@7,
Fingerprint_index,
Static_index,
Slot_count,
Slot_tokens,
Dictionary
);
[<<"u"/utf8>>,
Target_index@8,
Fingerprint_index@1,
Slot_count@1 |
Slot_tokens@1] ->
decode_update_segment_patch(
Target_index@8,
Fingerprint_index@1,
Slot_count@1,
Slot_tokens@1,
Dictionary
);
_ ->
{error, {malformed_operation, Operation_field}}
end.
-file("src/lightspeed/diff.gleam", 537).
-spec decode_operations(list(binary()), list(binary()), list(patch())) -> {ok,
list(patch())} |
{error, decode_error()}.
decode_operations(Operation_fields, Dictionary, Patches_rev) ->
case Operation_fields of
[] ->
{ok, lists:reverse(Patches_rev)};
[Operation_field | Rest] ->
case decode_operation(Operation_field, Dictionary) of
{error, Error} ->
{error, Error};
{ok, Patch} ->
decode_operations(Rest, Dictionary, [Patch | Patches_rev])
end
end.
-file("src/lightspeed/diff.gleam", 518).
-spec split_n(list(binary()), integer(), list(binary())) -> {ok,
{list(binary()), list(binary())}} |
{error, decode_error()}.
split_n(Values, Count, Acc_rev) ->
case Count < 0 of
true ->
{error, {malformed_operation, <<"negative_count"/utf8>>}};
false ->
case Count of
0 ->
{ok, {lists:reverse(Acc_rev), Values}};
_ ->
case Values of
[] ->
{error,
{malformed_operation,
<<"insufficient_fields"/utf8>>}};
[Value | Rest] ->
split_n(Rest, Count - 1, [Value | Acc_rev])
end
end
end.
-file("src/lightspeed/diff.gleam", 481).
-spec decode_dictionary_and_operations(binary(), list(binary())) -> {ok,
list(patch())} |
{error, decode_error()}.
decode_dictionary_and_operations(Dictionary_count_text, Rest_fields) ->
case parse_int(Dictionary_count_text) of
{error, Error} ->
{error, Error};
{ok, Dictionary_count} ->
case split_n(Rest_fields, Dictionary_count, []) of
{error, Error@1} ->
{error, Error@1};
{ok, {Dictionary, Operation_count_and_fields}} ->
case Operation_count_and_fields of
[Operation_count_text | Operation_fields] ->
case parse_int(Operation_count_text) of
{error, Error@2} ->
{error, Error@2};
{ok, Operation_count} ->
case erlang:length(Operation_fields) =:= Operation_count of
false ->
{error,
{bad_field_count,
<<"operation_fields"/utf8>>,
Operation_count,
erlang:length(
Operation_fields
)}};
true ->
decode_operations(
Operation_fields,
Dictionary,
[]
)
end
end;
_ ->
{error,
{bad_field_count,
<<"operation_count"/utf8>>,
1,
0}}
end
end
end.
-file("src/lightspeed/diff.gleam", 454).
-spec decode_fields(list(binary())) -> {ok, list(patch())} |
{error, decode_error()}.
decode_fields(Fields) ->
case Fields of
[Tag, Version_text, Dictionary_count_text | Rest] ->
case Tag of
<<"ps"/utf8>> ->
case parse_int(Version_text) of
{error, Error} ->
{error, Error};
{ok, Version} ->
case Version =:= 1 of
false ->
{error, {unsupported_version, Version}};
true ->
decode_dictionary_and_operations(
Dictionary_count_text,
Rest
)
end
end;
_ ->
{error, {unknown_payload_tag, Tag}}
end;
_ ->
{error,
{bad_field_count,
<<"stream_header"/utf8>>,
3,
erlang:length(Fields)}}
end.
-file("src/lightspeed/diff.gleam", 919).
-spec split_chars(list(binary()), binary(), list(binary()), boolean()) -> {ok,
list(binary())} |
{error, decode_error()}.
split_chars(Chars, Current, Fields_rev, Escaped) ->
case Chars of
[] ->
case Escaped of
true ->
{error, invalid_escape_sequence};
false ->
{ok, lists:reverse([Current | Fields_rev])}
end;
[Char | Rest] ->
case Escaped of
true ->
split_chars(
Rest,
<<Current/binary, Char/binary>>,
Fields_rev,
false
);
false ->
case Char of
<<"\\"/utf8>> ->
split_chars(Rest, Current, Fields_rev, true);
<<"|"/utf8>> ->
split_chars(
Rest,
<<""/utf8>>,
[Current | Fields_rev],
false
);
_ ->
split_chars(
Rest,
<<Current/binary, Char/binary>>,
Fields_rev,
false
)
end
end
end.
-file("src/lightspeed/diff.gleam", 915).
-spec split_fields(binary()) -> {ok, list(binary())} | {error, decode_error()}.
split_fields(Payload) ->
split_chars(gleam@string:to_graphemes(Payload), <<""/utf8>>, [], false).
-file("src/lightspeed/diff.gleam", 161).
?DOC(" Decode a patch stream.\n").
-spec decode_stream(binary()) -> {ok, list(patch())} | {error, decode_error()}.
decode_stream(Payload) ->
case Payload of
<<""/utf8>> ->
{error, empty_payload};
_ ->
case split_fields(Payload) of
{error, Error} ->
{error, Error};
{ok, Fields} ->
decode_fields(Fields)
end
end.
-file("src/lightspeed/diff.gleam", 146).
?DOC(" Decode one patch from a versioned compressed stream.\n").
-spec decode(binary()) -> {ok, patch()} | {error, decode_error()}.
decode(Payload) ->
case decode_stream(Payload) of
{error, Error} ->
{error, Error};
{ok, Patches} ->
case Patches of
[Patch] ->
{ok, Patch};
_ ->
{error,
{malformed_operation,
<<"expected_single_patch:"/utf8,
(erlang:integer_to_binary(
erlang:length(Patches)
))/binary>>}}
end
end.
-file("src/lightspeed/diff.gleam", 173).
?DOC(" Stable error labels for logs and adapter failures.\n").
-spec decode_error_to_string(decode_error()) -> binary().
decode_error_to_string(Error) ->
case Error of
empty_payload ->
<<"empty_payload"/utf8>>;
{unknown_payload_tag, Tag} ->
<<"unknown_payload_tag:"/utf8, Tag/binary>>;
{bad_field_count, Stage, Expected, Actual} ->
<<<<<<<<<<"bad_field_count:"/utf8, Stage/binary>>/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(Expected))/binary>>/binary,
":"/utf8>>/binary,
(erlang:integer_to_binary(Actual))/binary>>;
{invalid_integer, Value} ->
<<"invalid_integer:"/utf8, Value/binary>>;
{unsupported_version, Version} ->
<<"unsupported_version:"/utf8,
(erlang:integer_to_binary(Version))/binary>>;
{missing_dictionary_entry, Index} ->
<<"missing_dictionary_entry:"/utf8,
(erlang:integer_to_binary(Index))/binary>>;
{malformed_operation, Reason} ->
<<"malformed_operation:"/utf8, Reason/binary>>;
invalid_escape_sequence ->
<<"invalid_escape_sequence"/utf8>>
end.
