Current section
Files
Jump to
Current section
Files
src/asset.erl
-module(asset).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/asset.gleam").
-export([update_text/2, main/0]).
-export_type([error/0, edit/0, assertion_position/0, option_constructor/0, module_info/0, option_import/0, assertion_function/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.
-type error() :: {parsing_failed, glance:error()} | no_import_found.
-type edit() :: {edit, integer(), integer(), binary()}.
-type assertion_position() :: statement | expression | inside_assertion.
-type option_constructor() :: some_constructor | none_constructor.
-type module_info() :: {module_info,
binary(),
glance:span(),
gleam@option:option(option_import()),
binary()}.
-type option_import() :: {option_import,
binary(),
gleam@option:option(binary()),
gleam@option:option(binary())}.
-type assertion_function() :: be_error |
be_false |
be_none |
be_ok |
be_some |
be_true |
equal |
fail |
not_equal.
-file("src/asset.gleam", 263).
-spec pipe_args(glance:expression(), list(glance:field(glance:expression()))) -> list(glance:field(glance:expression())).
pipe_args(Left, Args) ->
[{unlabelled_field, Left} | Args].
-file("src/asset.gleam", 270).
-spec called_function(glance:expression()) -> {ok,
{gleam@option:option(binary()), binary()}} |
{error, nil}.
called_function(Function) ->
case Function of
{field_access, _, {variable, _, Module}, Name} ->
{ok, {{some, Module}, Name}};
{variable, _, Name@1} ->
{ok, {none, Name@1}};
_ ->
{error, nil}
end.
-file("src/asset.gleam", 478).
-spec replace_or_return(binary(), glance:span(), assertion_position()) -> {binary(),
list(edit())}.
replace_or_return(Text, Location, Position) ->
case Position of
expression ->
{<<""/utf8>>,
[{edit,
erlang:element(2, Location),
erlang:element(3, Location),
Text}]};
statement ->
{<<""/utf8>>,
[{edit,
erlang:element(2, Location),
erlang:element(3, Location),
Text}]};
inside_assertion ->
{Text, []}
end.
-file("src/asset.gleam", 489).
-spec wrap_assert(binary(), assertion_position()) -> binary().
wrap_assert(Assert_, Position) ->
case Position of
expression ->
<<<<"{ "/utf8, Assert_/binary>>/binary, " }"/utf8>>;
inside_assertion ->
<<<<"{ "/utf8, Assert_/binary>>/binary, " }"/utf8>>;
statement ->
Assert_
end.
-file("src/asset.gleam", 501).
-spec option_constructor(option_constructor(), module_info()) -> {binary(),
list(edit())}.
option_constructor(Constructor, Info) ->
{Import_@1, Edits} = case erlang:element(4, Info) of
none ->
Import_ = {option_import, <<"option"/utf8>>, none, none},
{Import_, [{edit, 0, 0, <<"import gleam/option\n"/utf8>>}]};
{some, I} ->
{I, []}
end,
Name@2 = case Constructor of
none_constructor ->
case erlang:element(4, Import_@1) of
none ->
<<(erlang:element(2, Import_@1))/binary, ".None"/utf8>>;
{some, Name} ->
Name
end;
some_constructor ->
case erlang:element(3, Import_@1) of
none ->
<<(erlang:element(2, Import_@1))/binary, ".Some"/utf8>>;
{some, Name@1} ->
Name@1
end
end,
{Name@2, Edits}.
-file("src/asset.gleam", 747).
-spec operator_to_string(glance:binary_operator()) -> binary().
operator_to_string(Name) ->
case Name of
add_float ->
<<"+."/utf8>>;
add_int ->
<<"+"/utf8>>;
'and' ->
<<"&&"/utf8>>;
concatenate ->
<<"<>"/utf8>>;
div_float ->
<<"/."/utf8>>;
div_int ->
<<"/"/utf8>>;
eq ->
<<"=="/utf8>>;
gt_eq_float ->
<<">=."/utf8>>;
gt_eq_int ->
<<">="/utf8>>;
gt_float ->
<<">."/utf8>>;
gt_int ->
<<">"/utf8>>;
lt_eq_float ->
<<"<=."/utf8>>;
lt_eq_int ->
<<"<="/utf8>>;
lt_float ->
<<"<=."/utf8>>;
lt_int ->
<<"<"/utf8>>;
mult_float ->
<<"*."/utf8>>;
mult_int ->
<<"*"/utf8>>;
not_eq ->
<<"!="/utf8>>;
'or' ->
<<"||"/utf8>>;
pipe ->
<<"|>"/utf8>>;
remainder_int ->
<<"%"/utf8>>;
sub_float ->
<<"-."/utf8>>;
sub_int ->
<<"-"/utf8>>
end.
-file("src/asset.gleam", 843).
-spec count_indentation(binary(), integer()) -> integer().
count_indentation(Text, Count) ->
case gleam_stdlib:string_ends_with(Text, <<" "/utf8>>) of
false ->
Count;
true ->
count_indentation(gleam@string:drop_end(Text, 1), Count + 1)
end.
-file("src/asset.gleam", 867).
-spec slice(binary(), integer(), integer()) -> binary().
slice(String, Start, End) ->
Length = case End of
-1 ->
erlang:byte_size(String) - Start;
_ ->
End - Start
end,
binary:part(String, Start, Length).
-file("src/asset.gleam", 630).
-spec do_get_src(binary(), glance:span()) -> binary().
do_get_src(Src, Location) ->
slice(Src, erlang:element(2, Location), erlang:element(3, Location)).
-file("src/asset.gleam", 592).
-spec pipe_to_call(binary(), glance:expression(), glance:expression()) -> binary().
pipe_to_call(Src, Left, Right) ->
{Function@2, Before, After, Label@1} = case Right of
{call, _, Function, Arguments} ->
{Function, [], Arguments, none};
{fn_capture, _, Label, Function@1, Arguments_before, Arguments_after} ->
{Function@1, Arguments_before, Arguments_after, Label};
_ ->
{Right, [], [], none}
end,
Piped_argument = case Label@1 of
none ->
{unlabelled_field, Left};
{some, Label@2} ->
{labelled_field, Label@2, Left}
end,
Arguments@1 = gleam@list:flatten([Before, [Piped_argument], After]),
Argument_strings = gleam@list:map(
Arguments@1,
fun(Argument) -> case Argument of
{labelled_field, Label@3, Item} ->
<<<<Label@3/binary, ": "/utf8>>/binary,
(do_get_src(Src, erlang:element(2, Item)))/binary>>;
{shorthand_field, Label@4} ->
<<Label@4/binary, ":"/utf8>>;
{unlabelled_field, Item@1} ->
do_get_src(Src, erlang:element(2, Item@1))
end end
),
<<<<<<(do_get_src(Src, erlang:element(2, Function@2)))/binary, "("/utf8>>/binary,
(gleam@string:join(Argument_strings, <<", "/utf8>>))/binary>>/binary,
")"/utf8>>.
-file("src/asset.gleam", 837).
-spec find_indent(binary(), integer()) -> integer().
find_indent(Src, Position) ->
Until_position = slice(Src, 0, Position),
count_indentation(Until_position, 0).
-file("src/asset.gleam", 862).
-spec replace_span(binary(), integer(), integer(), binary()) -> binary().
replace_span(String, Start, End, Text) ->
<<<<(slice(String, 0, Start))/binary, Text/binary>>/binary,
(slice(String, End, -1))/binary>>.
-file("src/asset.gleam", 850).
-spec apply_edits(binary(), list(edit())) -> binary().
apply_edits(Contents, Edits) ->
erlang:element(
1,
gleam@list:fold(
Edits,
{Contents, 0},
fun(Acc, Edit) ->
{Contents@1, Offset} = Acc,
Contents@2 = replace_span(
Contents@1,
erlang:element(2, Edit) + Offset,
erlang:element(3, Edit) + Offset,
erlang:element(4, Edit)
),
Edit_offset = (erlang:byte_size(erlang:element(4, Edit)) + erlang:element(
2,
Edit
))
- erlang:element(3, Edit),
Offset@1 = Offset + Edit_offset,
{Contents@2, Offset@1}
end
)
).
-file("src/asset.gleam", 908).
-spec assertion_function(module_info(), gleam@option:option(binary()), binary()) -> {ok,
assertion_function()} |
{error, nil}.
assertion_function(Info, Module, Name) ->
case Module =:= {some, erlang:element(2, Info)} of
false ->
{error, nil};
true ->
case Name of
<<"be_error"/utf8>> ->
{ok, be_error};
<<"be_false"/utf8>> ->
{ok, be_false};
<<"be_none"/utf8>> ->
{ok, be_none};
<<"be_ok"/utf8>> ->
{ok, be_ok};
<<"be_some"/utf8>> ->
{ok, be_some};
<<"be_true"/utf8>> ->
{ok, be_true};
<<"equal"/utf8>> ->
{ok, equal};
<<"fail"/utf8>> ->
{ok, fail};
<<"not_equal"/utf8>> ->
{ok, not_equal};
_ ->
{error, nil}
end
end.
-file("src/asset.gleam", 931).
-spec find_import(
list(glance:definition(glance:import())),
binary(),
module_info()
) -> {ok, module_info()} | {error, nil}.
find_import(Imports, Module, Info) ->
case Imports of
[] ->
case erlang:element(2, Info) of
<<""/utf8>> ->
{error, nil};
_ ->
{ok, Info}
end;
[Import_ | Imports@1] ->
case erlang:element(3, erlang:element(3, Import_)) of
<<"gleam/option"/utf8>> ->
Alias@1 = case erlang:element(4, erlang:element(3, Import_)) of
{some, {named, Alias}} ->
Alias;
{some, {discarded, _}} ->
<<"option"/utf8>>;
none ->
<<"option"/utf8>>
end,
Some_name = begin
_pipe = erlang:element(6, erlang:element(3, Import_)),
_pipe@2 = gleam@list:find_map(
_pipe,
fun(Value) -> case erlang:element(2, Value) of
<<"Some"/utf8>> ->
{ok,
begin
_pipe@1 = erlang:element(
3,
Value
),
gleam@option:unwrap(
_pipe@1,
<<"Some"/utf8>>
)
end};
_ ->
{error, nil}
end end
),
gleam@option:from_result(_pipe@2)
end,
None_name = begin
_pipe@3 = erlang:element(6, erlang:element(3, Import_)),
_pipe@5 = gleam@list:find_map(
_pipe@3,
fun(Value@1) -> case erlang:element(2, Value@1) of
<<"None"/utf8>> ->
{ok,
begin
_pipe@4 = erlang:element(
3,
Value@1
),
gleam@option:unwrap(
_pipe@4,
<<"None"/utf8>>
)
end};
_ ->
{error, nil}
end end
),
gleam@option:from_result(_pipe@5)
end,
find_import(
Imports@1,
Module,
begin
_record = Info,
{module_info,
erlang:element(2, _record),
erlang:element(3, _record),
{some,
{option_import,
Alias@1,
Some_name,
None_name}},
erlang:element(5, _record)}
end
);
M when M =:= Module ->
case erlang:element(4, erlang:element(3, Import_)) of
{some, {named, Alias@2}} ->
find_import(
Imports@1,
Module,
begin
_record@1 = Info,
{module_info,
Alias@2,
erlang:element(
2,
erlang:element(3, Import_)
),
erlang:element(4, _record@1),
erlang:element(5, _record@1)}
end
);
{some, {discarded, _}} ->
{error, nil};
none ->
find_import(
Imports@1,
Module,
begin
_record@2 = Info,
{module_info,
begin
_pipe@6 = gleam@string:split(
Module,
<<"/"/utf8>>
),
_pipe@7 = gleam@list:last(_pipe@6),
gleam@result:unwrap(
_pipe@7,
<<""/utf8>>
)
end,
erlang:element(
2,
erlang:element(3, Import_)
),
erlang:element(4, _record@2),
erlang:element(5, _record@2)}
end
)
end;
_ ->
find_import(Imports@1, Module, Info)
end
end.
-file("src/asset.gleam", 1046).
-spec print_error(binary(), binary(), simplifile:file_error()) -> nil.
print_error(Action, Path, Error) ->
gleam_stdlib:println_error(
<<<<<<<<<<"Failed to "/utf8, Action/binary>>/binary, " "/utf8>>/binary,
Path/binary>>/binary,
": "/utf8>>/binary,
(simplifile:describe_error(Error))/binary>>
).
-file("src/asset.gleam", 1013).
-spec collect_files(binary()) -> list({binary(), binary()}).
collect_files(Directory) ->
case simplifile_erl:read_directory(Directory) of
{error, Error} ->
print_error(<<"read directory"/utf8>>, Directory, Error),
[];
{ok, Items} ->
gleam@list:flat_map(
Items,
fun(Item) ->
Path = filepath:join(Directory, Item),
case simplifile_erl:is_directory(Path) of
{ok, true} ->
collect_files(Path);
{ok, false} ->
case filepath:extension(Path) of
{ok, <<"gleam"/utf8>>} ->
case simplifile:read(Path) of
{ok, Contents} ->
[{Path, Contents}];
{error, Error@1} ->
print_error(
<<"read file"/utf8>>,
Path,
Error@1
),
[]
end;
_ ->
[]
end;
{error, Error@2} ->
print_error(<<"read file"/utf8>>, Path, Error@2),
[]
end
end
)
end.
-file("src/asset.gleam", 1052).
-spec print_usage() -> nil.
print_usage() ->
gleam_stdlib:println(
<<"Usage: asset update [directory]
Flags:
-m <test module> Changes the target module to replace, defaults to `gleeunit/should`."/utf8>>
).
-file("src/asset.gleam", 1061).
-spec glance_error(glance:error()) -> binary().
glance_error(Error) ->
case Error of
unexpected_end_of_input ->
<<"Unexpected end of input"/utf8>>;
{unexpected_token, Token, Position} ->
<<<<<<<<"Unexpected token at position "/utf8,
(erlang:integer_to_binary(
erlang:element(2, Position)
))/binary>>/binary,
": `"/utf8>>/binary,
(glexer@token:to_source(Token))/binary>>/binary,
"`"/utf8>>
end.
-file("src/asset.gleam", 191).
-spec do_expression(
glance:expression(),
module_info(),
integer(),
assertion_position()
) -> list(edit()).
do_expression(Ast, Info, Statement_start, Position) ->
case Ast of
{binary_operator, Location, Name, Left, Right} ->
_pipe = case Name of
pipe ->
pipe(Left, Right, Location, Info, Statement_start, Position);
_ ->
{error, nil}
end,
_pipe@1 = gleam@result:map(_pipe, fun gleam@pair:second/1),
gleam@result:lazy_unwrap(
_pipe@1,
fun() -> expressions([Left, Right], Info, Statement_start) end
);
{bit_string, _, _} ->
[];
{block, _, Body} ->
statements(Body, Info);
{call, Location@1, Function, Arguments} ->
_pipe@2 = call(
Location@1,
Function,
Arguments,
Info,
Statement_start,
Position
),
_pipe@3 = gleam@result:map(_pipe@2, fun gleam@pair:second/1),
gleam@result:lazy_unwrap(
_pipe@3,
fun() ->
lists:append(
expression(Function, Info, Statement_start),
fields(Arguments, Info, Statement_start)
)
end
);
{'case', _, Subjects, Cs} ->
lists:append(
expressions(Subjects, Info, Statement_start),
clauses(Cs, Info, Statement_start)
);
{echo, _, Value} ->
optional(Value, Info, Statement_start);
{field_access, _, Container, _} ->
expression(Container, Info, Statement_start);
{float, _, _} ->
[];
{fn, _, _, _, Body@1} ->
statements(Body@1, Info);
{fn_capture, _, _, Function@1, Arguments_before, Arguments_after} ->
gleam@list:flatten(
[expression(Function@1, Info, Statement_start),
fields(Arguments_before, Info, Statement_start),
fields(Arguments_after, Info, Statement_start)]
);
{int, _, _} ->
[];
{list, _, Elements, Rest} ->
case Rest of
none ->
expressions(Elements, Info, Statement_start);
{some, Rest@1} ->
expressions([Rest@1 | Elements], Info, Statement_start)
end;
{negate_bool, _, Value@1} ->
expression(Value@1, Info, Statement_start);
{negate_int, _, Value@2} ->
expression(Value@2, Info, Statement_start);
{panic, _, Message} ->
optional(Message, Info, Statement_start);
{record_update, _, _, _, Record, Fields} ->
expressions(
[Record |
gleam@list:filter_map(
Fields,
fun(Field) ->
gleam@option:to_result(
erlang:element(3, Field),
nil
)
end
)],
Info,
Statement_start
);
{string, _, _} ->
[];
{todo, _, Message@1} ->
optional(Message@1, Info, Statement_start);
{tuple, _, Elements@1} ->
expressions(Elements@1, Info, Statement_start);
{tuple_index, _, Tuple, _} ->
expression(Tuple, Info, Statement_start);
{variable, _, _} ->
[]
end.
-file("src/asset.gleam", 183).
-spec expression(glance:expression(), module_info(), integer()) -> list(edit()).
expression(Expression, Info, Statement_start) ->
do_expression(Expression, Info, Statement_start, expression).
-file("src/asset.gleam", 119).
-spec expressions(list(glance:expression()), module_info(), integer()) -> list(edit()).
expressions(Expressions, Info, Statement_start) ->
gleam@list:flat_map(
Expressions,
fun(_capture) -> expression(_capture, Info, Statement_start) end
).
-file("src/asset.gleam", 127).
-spec statement(glance:statement(), module_info()) -> list(edit()).
statement(Statement, Info) ->
case Statement of
{assert, Location, Value, Message} ->
case Message of
none ->
expression(Value, Info, erlang:element(2, Location));
{some, Message@1} ->
expressions(
[Value, Message@1],
Info,
erlang:element(2, Location)
)
end;
{assignment, Location@1, Kind, _, _, Value@1} ->
case Kind of
{let_assert, none} ->
expression(Value@1, Info, erlang:element(2, Location@1));
'let' ->
expression(Value@1, Info, erlang:element(2, Location@1));
{let_assert, {some, Message@2}} ->
expressions(
[Value@1, Message@2],
Info,
erlang:element(2, Location@1)
)
end;
{expression, E} ->
do_expression(
E,
Info,
erlang:element(2, erlang:element(2, E)),
statement
);
{use, Location@2, _, Function} ->
expression(Function, Info, erlang:element(2, Location@2))
end.
-file("src/asset.gleam", 112).
-spec statements(list(glance:statement()), module_info()) -> list(edit()).
statements(Statements, Info) ->
gleam@list:flat_map(
Statements,
fun(_capture) -> statement(_capture, Info) end
).
-file("src/asset.gleam", 93).
-spec find_edits(list(glance:definition(glance:function_())), module_info()) -> list(edit()).
find_edits(Functions, Info) ->
_pipe = Functions,
_pipe@1 = gleam@list:flat_map(
_pipe,
fun(Definition) ->
statements(erlang:element(7, erlang:element(3, Definition)), Info)
end
),
_pipe@2 = gleam@list:prepend(
_pipe@1,
{edit,
erlang:element(2, erlang:element(3, Info)),
erlang:element(3, erlang:element(3, Info)) + 1,
<<""/utf8>>}
),
gleam@list:sort(
_pipe@2,
fun(A, B) ->
_pipe@3 = gleam@int:compare(
erlang:element(2, A),
erlang:element(2, B)
),
gleam@order:break_tie(
_pipe@3,
gleam@int:compare(erlang:element(3, A), erlang:element(3, B))
)
end
).
-file("src/asset.gleam", 42).
?DOC(
" Updates a single file to use `assert` syntax. Accepts the target module to\n"
" replace. `gleeunit/should` should be used for most cases.\n"
).
-spec update_text(binary(), binary()) -> {ok, binary()} | {error, error()}.
update_text(Contents, Target_module) ->
case glance:module(Contents) of
{error, Error} ->
{error, {parsing_failed, Error}};
{ok, Module} ->
Info = {module_info, <<""/utf8>>, {span, 0, 0}, none, Contents},
case find_import(erlang:element(2, Module), Target_module, Info) of
{error, _} ->
{error, no_import_found};
{ok, Import_} ->
Edits = find_edits(erlang:element(6, Module), Import_),
Result = apply_edits(Contents, Edits),
{ok, Result}
end
end.
-file("src/asset.gleam", 71).
-spec update_file(binary(), binary(), binary()) -> nil.
update_file(Path, Contents, Target_module) ->
case update_text(Contents, Target_module) of
{error, no_import_found} ->
gleam_stdlib:println_error(
<<<<<<"No references to `"/utf8, Target_module/binary>>/binary,
"` found in "/utf8>>/binary,
Path/binary>>
);
{error, {parsing_failed, Error}} ->
gleam_stdlib:println_error(
<<<<<<"Failed to parse file "/utf8, Path/binary>>/binary,
": "/utf8>>/binary,
(glance_error(Error))/binary>>
);
{ok, Text} ->
case simplifile:write(Path, Text) of
{error, Error@1} ->
print_error(<<"write to file"/utf8>>, Path, Error@1);
{ok, _} ->
gleam_stdlib:println_error(
<<"Successfully updated "/utf8, Path/binary>>
)
end
end.
-file("src/asset.gleam", 30).
-spec update(binary(), binary()) -> nil.
update(Directory, Module) ->
Files = collect_files(Directory),
gleam@list:each(
Files,
fun(Pair) ->
update_file(
erlang:element(1, Pair),
erlang:element(2, Pair),
Module
)
end
).
-file("src/asset.gleam", 18).
?DOC(" Call the `asset` CLI.\n").
-spec main() -> nil.
main() ->
Argv = argv:load(),
case erlang:element(4, Argv) of
[<<"update"/utf8>>] ->
update(<<"."/utf8>>, <<"gleeunit/should"/utf8>>);
[<<"update"/utf8>>, Directory] ->
update(Directory, <<"gleeunit/should"/utf8>>);
[<<"update"/utf8>>, <<"-m"/utf8>>, Module] ->
update(<<"."/utf8>>, Module);
[<<"update"/utf8>>, Directory@1, <<"-m"/utf8>>, Module@1] ->
update(Directory@1, Module@1);
_ ->
print_usage()
end.
-file("src/asset.gleam", 147).
-spec optional(
gleam@option:option(glance:expression()),
module_info(),
integer()
) -> list(edit()).
optional(Optional, Info, Statement_start) ->
case Optional of
{some, E} ->
expression(E, Info, Statement_start);
none ->
[]
end.
-file("src/asset.gleam", 158).
-spec fields(list(glance:field(glance:expression())), module_info(), integer()) -> list(edit()).
fields(Fields, Info, Statement_start) ->
gleam@list:flat_map(Fields, fun(Field) -> case Field of
{shorthand_field, _} ->
[];
{unlabelled_field, Item} ->
expression(Item, Info, Statement_start);
{labelled_field, _, Item} ->
expression(Item, Info, Statement_start)
end end).
-file("src/asset.gleam", 171).
-spec clauses(list(glance:clause()), module_info(), integer()) -> list(edit()).
clauses(Clauses, Info, Statement_start) ->
gleam@list:flat_map(
Clauses,
fun(Clause) -> case erlang:element(3, Clause) of
none ->
expression(erlang:element(4, Clause), Info, Statement_start);
{some, Guard} ->
expressions(
[erlang:element(4, Clause), Guard],
Info,
Statement_start
)
end end
).
-file("src/asset.gleam", 560).
-spec get_src(glance:expression(), module_info(), integer()) -> {binary(),
list(edit())}.
get_src(Expression, Info, Statement_start) ->
_pipe = case Expression of
{variable, _, Name} ->
{ok, {Name, []}};
{binary_operator, Location, pipe, Left, Right} ->
case pipe(
Left,
Right,
Location,
Info,
Statement_start,
inside_assertion
) of
{ok, Value} ->
{ok, Value};
{error, _} ->
case Left of
{binary_operator, _, pipe, _, _} ->
{error, nil};
_ ->
{ok,
{pipe_to_call(
erlang:element(5, Info),
Left,
Right
),
[]}}
end
end;
{call, Location@1, Function, Arguments} ->
call(
Location@1,
Function,
Arguments,
Info,
Statement_start,
inside_assertion
);
_ ->
{error, nil}
end,
gleam@result:lazy_unwrap(
_pipe,
fun() ->
{do_get_src(erlang:element(5, Info), erlang:element(2, Expression)),
[]}
end
).
-file("src/asset.gleam", 288).
-spec pipe(
glance:expression(),
glance:expression(),
glance:span(),
module_info(),
integer(),
assertion_position()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
pipe(Left, Right, Location, Info, Statement_start, Position) ->
case Right of
{field_access, _, {variable, _, Module}, Name} ->
transform_assertion(
{some, Module},
Name,
Location,
pipe_args(Left, []),
Info,
Statement_start,
Position
);
{variable, _, Name@1} ->
transform_assertion(
none,
Name@1,
Location,
pipe_args(Left, []),
Info,
Statement_start,
Position
);
{call, _, Function, Arguments} ->
_pipe = Function,
_pipe@1 = called_function(_pipe),
gleam@result:'try'(
_pipe@1,
fun(Pair) ->
{Module@1, Name@2} = Pair,
transform_assertion(
Module@1,
Name@2,
Location,
pipe_args(Left, Arguments),
Info,
Statement_start,
Position
)
end
);
_ ->
{error, nil}
end.
-file("src/asset.gleam", 374).
-spec transform_assertion(
gleam@option:option(binary()),
binary(),
glance:span(),
list(glance:field(glance:expression())),
module_info(),
integer(),
assertion_position()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
transform_assertion(
Module,
Name,
Location,
Arguments,
Info,
Statement_start,
Position
) ->
case assertion_function(Info, Module, Name) of
{error, _} ->
{error, nil};
{ok, be_error} ->
transform_variant_check(
Arguments,
Location,
<<"Error"/utf8>>,
Info,
Statement_start,
Position
);
{ok, be_false} ->
transform_bool_check(
Arguments,
Location,
false,
Info,
Position,
Statement_start
);
{ok, be_none} ->
case Arguments of
[{unlabelled_field, Value}] ->
Precedence = glance:precedence(eq),
{Value@1, Expr_edits} = maybe_wrap(
Value,
Info,
Precedence,
Statement_start
),
{None, Import_edits} = option_constructor(
none_constructor,
Info
),
Assert_ = <<<<<<"assert "/utf8, Value@1/binary>>/binary,
" == "/utf8>>/binary,
None/binary>>,
{Value@2, Edits} = replace_or_return(
wrap_assert(Assert_, Position),
Location,
Position
),
{ok,
{Value@2,
gleam@list:flatten(
[Import_edits, Expr_edits, Edits]
)}};
_ ->
{error, nil}
end;
{ok, be_ok} ->
transform_variant_check(
Arguments,
Location,
<<"Ok"/utf8>>,
Info,
Statement_start,
Position
);
{ok, be_some} ->
{Some, Import_edits@1} = option_constructor(some_constructor, Info),
Result = transform_variant_check(
Arguments,
Location,
Some,
Info,
Statement_start,
Position
),
gleam@result:map(
Result,
fun(Pair) ->
{erlang:element(1, Pair),
lists:append(Import_edits@1, erlang:element(2, Pair))}
end
);
{ok, be_true} ->
transform_bool_check(
Arguments,
Location,
true,
Info,
Position,
Statement_start
);
{ok, equal} ->
transform_comparison(
Arguments,
Location,
<<"=="/utf8>>,
Info,
Position,
Statement_start
);
{ok, not_equal} ->
transform_comparison(
Arguments,
Location,
<<"!="/utf8>>,
Info,
Position,
Statement_start
);
{ok, fail} ->
{ok, replace_or_return(<<"panic"/utf8>>, Location, Position)}
end.
-file("src/asset.gleam", 775).
-spec transform_variant_check(
list(glance:field(glance:expression())),
glance:span(),
binary(),
module_info(),
integer(),
assertion_position()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
transform_variant_check(
Arguments,
Location,
Variant_name,
Info,
Statement_start,
Position
) ->
case Arguments of
[{unlabelled_field, Value}] ->
{Value@1, Value_edits} = get_src(Value, Info, Statement_start),
Variable_name = case Position of
expression ->
<<"value"/utf8>>;
inside_assertion ->
<<"value"/utf8>>;
statement ->
<<"_"/utf8>>
end,
Newline = case Position of
expression ->
Indent = find_indent(
erlang:element(5, Info),
Statement_start
),
<<"\n"/utf8,
(gleam@string:repeat(<<" "/utf8>>, Indent))/binary>>;
inside_assertion ->
Indent = find_indent(
erlang:element(5, Info),
Statement_start
),
<<"\n"/utf8,
(gleam@string:repeat(<<" "/utf8>>, Indent))/binary>>;
statement ->
<<""/utf8>>
end,
Assignment = <<<<<<<<<<<<"let assert "/utf8, Variant_name/binary>>/binary,
"("/utf8>>/binary,
Variable_name/binary>>/binary,
") = "/utf8>>/binary,
Value@1/binary>>/binary,
Newline/binary>>,
case Position of
expression ->
{ok,
{Variable_name,
[{edit,
Statement_start,
Statement_start,
Assignment},
{edit,
erlang:element(2, Location),
erlang:element(3, Location),
Variable_name} |
Value_edits]}};
statement ->
{ok,
{Variable_name,
[{edit,
erlang:element(2, Location),
erlang:element(3, Location),
Assignment} |
Value_edits]}};
inside_assertion ->
{ok,
{Variable_name,
[{edit,
Statement_start,
Statement_start,
Assignment} |
Value_edits]}}
end;
_ ->
{error, nil}
end.
-file("src/asset.gleam", 344).
-spec call(
glance:span(),
glance:expression(),
list(glance:field(glance:expression())),
module_info(),
integer(),
assertion_position()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
call(Location, Function, Arguments, Info, Statement_start, Position) ->
_pipe = Function,
_pipe@1 = called_function(_pipe),
gleam@result:'try'(
_pipe@1,
fun(Pair) ->
{Module, Name} = Pair,
transform_assertion(
Module,
Name,
Location,
Arguments,
Info,
Statement_start,
Position
)
end
).
-file("src/asset.gleam", 528).
-spec maybe_wrap(glance:expression(), module_info(), integer(), integer()) -> {binary(),
list(edit())}.
maybe_wrap(Expression, Info, Precedence, Statement_start) ->
{Expr_src, Edits} = get_src(Expression, Info, Statement_start),
Was_transformed = case Expression of
{binary_operator, _, pipe, {binary_operator, _, pipe, _, _}, _} ->
false;
{binary_operator, _, pipe, _, _} ->
true;
_ ->
false
end,
Expr = case Expression of
{binary_operator, _, Name, _, _} when not Was_transformed ->
case glance:precedence(Name) > Precedence of
true ->
Expr_src;
false ->
<<<<"{ "/utf8, Expr_src/binary>>/binary, " }"/utf8>>
end;
_ ->
Expr_src
end,
{Expr, Edits}.
-file("src/asset.gleam", 634).
-spec transform_comparison(
list(glance:field(glance:expression())),
glance:span(),
binary(),
module_info(),
assertion_position(),
integer()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
transform_comparison(
Arguments,
Location,
Operator,
Info,
Position,
Statement_start
) ->
Precedence = glance:precedence(eq),
case Arguments of
[{unlabelled_field, Left}, {unlabelled_field, Right}] ->
{Left@1, Left_edits} = maybe_wrap(
Left,
Info,
Precedence,
Statement_start
),
{Right@1, Right_edits} = maybe_wrap(
Right,
Info,
Precedence,
Statement_start
),
Assert_ = <<<<<<<<<<"assert "/utf8, Left@1/binary>>/binary,
" "/utf8>>/binary,
Operator/binary>>/binary,
" "/utf8>>/binary,
Right@1/binary>>,
{Value, Edits} = replace_or_return(
wrap_assert(Assert_, Position),
Location,
Position
),
{ok, {Value, gleam@list:flatten([Left_edits, Right_edits, Edits])}};
_ ->
{error, nil}
end.
-file("src/asset.gleam", 694).
-spec invert_value(glance:expression(), module_info(), integer()) -> {ok,
{binary(), list(edit())}} |
{error, nil}.
invert_value(Value, Info, Statement_start) ->
case Value of
{binary_operator, _, Name, Left, Right} ->
Inverted_name = case Name of
add_float ->
{error, nil};
add_int ->
{error, nil};
concatenate ->
{error, nil};
div_float ->
{error, nil};
div_int ->
{error, nil};
mult_float ->
{error, nil};
mult_int ->
{error, nil};
pipe ->
{error, nil};
remainder_int ->
{error, nil};
sub_float ->
{error, nil};
sub_int ->
{error, nil};
'and' ->
{error, nil};
'or' ->
{error, nil};
eq ->
{ok, not_eq};
gt_eq_float ->
{ok, lt_float};
gt_eq_int ->
{ok, lt_int};
gt_float ->
{ok, lt_eq_float};
gt_int ->
{ok, lt_eq_int};
lt_eq_float ->
{ok, gt_float};
lt_eq_int ->
{ok, gt_int};
lt_float ->
{ok, gt_eq_float};
lt_int ->
{ok, gt_eq_int};
not_eq ->
{ok, eq}
end,
case Inverted_name of
{ok, Name@1} ->
Precedence = glance:precedence(Name@1),
{Left@1, Left_edits} = maybe_wrap(
Left,
Info,
Precedence,
Statement_start
),
{Right@1, Right_edits} = maybe_wrap(
Right,
Info,
Precedence,
Statement_start
),
Edits = lists:append(Left_edits, Right_edits),
Operator_string = operator_to_string(Name@1),
{ok,
{<<<<<<<<Left@1/binary, " "/utf8>>/binary,
Operator_string/binary>>/binary,
" "/utf8>>/binary,
Right@1/binary>>,
Edits}};
{error, _} ->
{error, nil}
end;
_ ->
{error, nil}
end.
-file("src/asset.gleam", 660).
-spec transform_bool_check(
list(glance:field(glance:expression())),
glance:span(),
boolean(),
module_info(),
assertion_position(),
integer()
) -> {ok, {binary(), list(edit())}} | {error, nil}.
transform_bool_check(
Arguments,
Location,
Check_for,
Info,
Position,
Statement_start
) ->
case Arguments of
[{unlabelled_field, Value}] ->
{Assert_, Value_edits} = case Check_for of
false ->
case invert_value(Value, Info, Statement_start) of
{ok, {Inverted, Edits}} ->
{<<"assert "/utf8, Inverted/binary>>, Edits};
{error, _} ->
{Value@1, Edits@1} = maybe_wrap(
Value,
Info,
100,
Statement_start
),
{<<"assert !"/utf8, Value@1/binary>>, Edits@1}
end;
true ->
{Value@2, Edits@2} = get_src(Value, Info, Statement_start),
{<<"assert "/utf8, Value@2/binary>>, Edits@2}
end,
{Value@3, Edits@3} = replace_or_return(
wrap_assert(Assert_, Position),
Location,
Position
),
{ok, {Value@3, lists:append(Value_edits, Edits@3)}};
_ ->
{error, nil}
end.