Current section
Files
Jump to
Current section
Files
src/embeds@env.erl
-module(embeds@env).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/embeds/env.gleam").
-export([string/1, generate/1, get_variables/3, list/2, default_parse/2, typed_parse/1, typed_parse_fallback/2, int/1, float/1, bool/1, main/0]).
-export_type([options/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(
" `embeds/env` generates a Gleam module containing constants and zero-argument\n"
" functions based on environment variables.\n"
"\n"
" This module is intended to be run as a CLI tool during your build process:\n"
" ```sh\n"
" gleam run -m embeds/env -- --help\n"
" ```\n"
"\n"
" The functions exposed in this module can also be used directly to support\n"
" advanced use cases inside custom pre-build scripts.\n"
).
-type options() :: {options,
binary(),
binary(),
fun((binary(), binary()) -> embeds@generate:code()),
binary(),
gleam@option:option(gleam@regexp:regexp())}.
-file("src/embeds/env.gleam", 402).
-spec chop_prefix(binary(), binary()) -> {ok, binary()} | {error, nil}.
chop_prefix(String, Prefix) ->
case {gleam_stdlib:string_pop_grapheme(String),
gleam_stdlib:string_pop_grapheme(Prefix)} of
{{ok, {Ch1, String@1}}, {ok, {Ch2, Prefix@1}}} when Ch1 =:= Ch2 ->
chop_prefix(String@1, Prefix@1);
{_, {error, nil}} ->
{ok, String};
{_, _} ->
{error, nil}
end.
-file("src/embeds/env.gleam", 296).
?DOC(" A string parser, just passing through the value\n").
-spec string(binary()) -> embeds@generate:code().
string(Value) ->
{constant, gleam@string:inspect(Value)}.
-file("src/embeds/env.gleam", 85).
?DOC(
" Generate Gleam modules, containing constants for all found variables.\n"
" Exported for easier integration with other build tools.\n"
"\n"
" ## Example\n"
"\n"
" ```gleam\n"
" import embeds/env\n"
" import embeds/generate\n"
" import gleam/option\n"
" import gleam/io\n"
"\n"
" pub fn main() {\n"
" let result = env.generate(env.Options(\n"
" module: \"build_env\",\n"
" header: generate.default_header,\n"
" parse: env.default_parse,\n"
" prefix: \"BUILD_\",\n"
" regex: option.None,\n"
" ))\n"
"\n"
" case result {\n"
" Ok(Nil) -> Nil\n"
" Error(errs) -> io.println_error(generate.describe_errors(errs))\n"
" }\n"
" }\n"
" ```\n"
).
-spec generate(options()) -> {ok, nil} | {error, list(embeds@generate:error())}.
generate(Options) ->
embeds@generate:guard_gleam_project(
fun() ->
{options, Module, Header, Parse, Prefix, Regex} = Options,
Defs = get_variables(Module, Prefix, Regex),
Wrapped_parse = fun(Name, Code) -> case Code of
{text, Text} ->
Parse(Name, Text);
{binary, _} ->
skip
end end,
embeds@generate:generate(Defs, Header, Wrapped_parse, true)
end
).
-file("src/embeds/env.gleam", 367).
?DOC(
" Get all variables from the environment matching a prefix and a regex,\n"
" and convert them into definitions.\n"
).
-spec get_variables(
binary(),
binary(),
gleam@option:option(gleam@regexp:regexp())
) -> list(embeds@generate:definition()).
get_variables(Module, Prefix, Regex) ->
gleam@list:filter_map(
maps:to_list(envoy_ffi:all()),
fun(_use0) ->
{Key, Value} = _use0,
gleam@result:'try'(
chop_prefix(Key, Prefix),
fun(Var_name) -> gleam@result:'try'(case Regex of
{some, Regex@1} ->
case gleam@regexp:scan(Regex@1, Var_name) of
[{match, _, [{some, Matched} | _]} | _] ->
{ok, Matched};
[_ | _] ->
{ok, Var_name};
[] ->
{error, nil}
end;
none ->
{ok, Var_name}
end, fun(Var_name@1) ->
Var_name@2 = embeds@generate:to_gleam_identifier(
Var_name@1
),
{ok,
{definition,
Key,
fun() -> {ok, {text, Value}} end,
0,
Module,
Var_name@2}}
end) end
)
end
).
-file("src/embeds/env.gleam", 335).
?DOC(
" A parser for lists.\n"
" Common separators might be `:` or `,`\n"
).
-spec list(fun((binary()) -> embeds@generate:code()), binary()) -> fun((binary()) -> embeds@generate:code()).
list(Item_parser, Separator) ->
fun(Value) ->
List = gleam@string:split(Value, Separator),
Result = begin
gleam@list:try_fold(
List,
{[], true},
fun(_use0, Value@1) ->
{Parts, Is_const} = _use0,
case Item_parser(gleam@string:trim(Value@1)) of
skip ->
{ok, {Parts, Is_const}};
{generate_error, Error} ->
{error, Error};
{constant, Code} ->
{ok, {[Code | Parts], Is_const}};
{function_body, Code@1} ->
{ok, {[Code@1 | Parts], false}}
end
end
)
end,
case Result of
{ok, {Parts@1, Is_const@1}} ->
Code@2 = gleam@string:inspect(lists:reverse(Parts@1)),
case Is_const@1 of
true ->
{constant, Code@2};
false ->
{function_body, Code@2}
end;
{error, Err} ->
{generate_error, Err}
end
end.
-file("src/embeds/env.gleam", 55).
?DOC(
" A default parse function, converting environment variables into\n"
" string constants.\n"
).
-spec default_parse(binary(), binary()) -> embeds@generate:code().
default_parse(_, Value) ->
{constant, gleam@string:inspect(Value)}.
-file("src/embeds/env.gleam", 267).
?DOC(
" A function taking a list of `(key, parser)` pairs, and turning them\n"
" into a parse function to be used in `Options`.\n"
" \n"
" This allows you to generate other types of variables, instead of just strings.\n"
" \n"
" ## Example\n"
" \n"
" ```gleam\n"
" let options = env.Options(\n"
" module: \"build_env\",\n"
" header: generate.default_header,\n"
" prefix: \"BUILD_\",\n"
" regex: option.None,\n"
" parse: env.typed_parse([\n"
" #(\"BUILD_ENV\", string),\n"
" #(\"BUILD_REVISION\", int),\n"
" #(\"BUILD_ENABLE_AWESOMENESS\", bool)\n"
" ]),\n"
" )\n"
" ```\n"
).
-spec typed_parse(list({binary(), fun((binary()) -> embeds@generate:code())})) -> fun((binary(), binary()) -> embeds@generate:code()).
typed_parse(Definitions) ->
fun(Key, Value) -> case gleam@list:key_find(Definitions, Key) of
{ok, Parser} ->
Parser(gleam@string:trim(Value));
{error, nil} ->
skip
end end.
-file("src/embeds/env.gleam", 283).
?DOC(
" A variant of `typed_parse` that takes an additional fallback function\n"
" used when the variable is not found inside of `definitions`.\n"
" \n"
" Using `default_parse` as the fallback is useful to include all\n"
" variables not found in `definitions` as simple string constants.\n"
).
-spec typed_parse_fallback(
list({binary(), fun((binary()) -> embeds@generate:code())}),
fun((binary(), binary()) -> embeds@generate:code())
) -> fun((binary(), binary()) -> embeds@generate:code()).
typed_parse_fallback(Definitions, Fallback) ->
fun(Key, Value) -> case gleam@list:key_find(Definitions, Key) of
{ok, Parser} ->
Parser(gleam@string:trim(Value));
{error, nil} ->
Fallback(Key, Value)
end end.
-file("src/embeds/env.gleam", 301).
?DOC(" A parser for integers literals\n").
-spec int(binary()) -> embeds@generate:code().
int(Value) ->
embeds@generate:result_to_const(
begin
gleam@result:map(
begin
_pipe = gleam_stdlib:parse_int(Value),
gleam@result:replace_error(
_pipe,
<<"Invalid integer: "/utf8, Value/binary>>
)
end,
fun(N) -> gleam@string:inspect(N) end
)
end
).
-file("src/embeds/env.gleam", 313).
?DOC(" A parser for floating-point literals\n").
-spec float(binary()) -> embeds@generate:code().
float(Value) ->
embeds@generate:result_to_const(
begin
gleam@result:map(
begin
_pipe = gleam_stdlib:parse_float(Value),
gleam@result:replace_error(
_pipe,
<<"Invalid number: "/utf8, Value/binary>>
)
end,
fun(N) -> gleam@string:inspect(N) end
)
end
).
-file("src/embeds/env.gleam", 324).
?DOC(" A parser for boolean flags\n").
-spec bool(binary()) -> embeds@generate:code().
bool(Value) ->
Sanitized = gleam@string:trim(string:lowercase(Value)),
Bool = case Sanitized of
<<"true"/utf8>> ->
true;
<<"yes"/utf8>> ->
true;
<<"on"/utf8>> ->
true;
<<"1"/utf8>> ->
true;
_ ->
false
end,
{constant, gleam@string:inspect(Bool)}.
-file("src/embeds/env.gleam", 191).
-spec parse_definitions(list(binary())) -> {ok,
list({binary(), fun((binary()) -> embeds@generate:code())})} |
{error, list(embeds@generate:error())}.
parse_definitions(Args) ->
embeds@internal:traverse_map(
Args,
fun(Arg) -> case gleam@string:split(Arg, <<":"/utf8>>) of
[Name, Type_name] ->
Name@1 = gleam@string:trim(Name),
case gleam@string:trim(string:lowercase(Type_name)) of
<<"bool"/utf8>> ->
{ok, {Name@1, fun bool/1}};
<<"int"/utf8>> ->
{ok, {Name@1, fun int/1}};
<<"float"/utf8>> ->
{ok, {Name@1, fun float/1}};
<<"string"/utf8>> ->
{ok, {Name@1, fun string/1}};
_ ->
{error,
[{invalid_argument,
<<""/utf8>>,
Arg,
<<"Invalid type name: "/utf8,
Type_name/binary>>}]}
end;
_ ->
{error,
[{invalid_argument,
<<""/utf8>>,
Arg,
<<"Invalid type definition"/utf8>>}]}
end end
).
-file("src/embeds/env.gleam", 120).
-spec generate_cmd() -> glint:command(nil).
generate_cmd() ->
glint:command_help(
<<<<<<<<"Generate Gleam modules containing String constants of whitelisted environment variables.\n\n\n"/utf8,
"By default, environment variables starting with `BUILD_' will be included, and a module called build_env will be generated.\n\n"/utf8>>/binary,
"The generted constants have this prefix stripped.\n\n\n"/utf8>>/binary,
"You can optionally provide a list of NAME:TYPE pairs to generate constants of other types instead.\n\n"/utf8>>/binary,
"Valid types names are: int, float, bool, string"/utf8>>,
fun() ->
glint:flag(
begin
_pipe = glint:string_flag(<<"module"/utf8>>),
_pipe@1 = glint:flag_default(_pipe, <<"build_env"/utf8>>),
glint:flag_help(
_pipe@1,
<<"Name of the generated Gleam module (default: build_env)"/utf8>>
)
end,
fun(Module_name) ->
glint:flag(
begin
_pipe@2 = glint:string_flag(<<"prefix"/utf8>>),
_pipe@3 = glint:flag_default(
_pipe@2,
<<"BUILD_"/utf8>>
),
glint:flag_help(
_pipe@3,
<<"Only environment variables matching this prefix will be included, and the prefix will be stripped from their name. (default: BUILD_)"/utf8>>
)
end,
fun(Prefix) ->
glint:flag(
begin
_pipe@4 = glint:string_flag(
<<"filter"/utf8>>
),
glint:flag_help(
_pipe@4,
<<"Use a regular expression to match environment variables. If a capture group exists, it will be used as the variable name. If both prefix and regex are given, the prefix will be stripped first."/utf8>>
)
end,
fun(Filter) ->
glint:command(
fun(_, Args, Flags) ->
Module@1 = case Module_name(Flags) of
{ok, Module} -> Module;
_assert_fail ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"embeds/env"/utf8>>,
function => <<"generate_cmd"/utf8>>,
line => 154,
value => _assert_fail,
start => 4797,
'end' => 4839,
pattern_start => 4808,
pattern_end => 4818}
)
end,
Prefix@2 = case Prefix(Flags) of
{ok, Prefix@1} -> Prefix@1;
_assert_fail@1 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"embeds/env"/utf8>>,
function => <<"generate_cmd"/utf8>>,
line => 155,
value => _assert_fail@1,
start => 4842,
'end' => 4879,
pattern_start => 4853,
pattern_end => 4863}
)
end,
Filter@1 = begin
_pipe@5 = Filter(Flags),
gleam@option:from_result(
_pipe@5
)
end,
Result = begin
gleam@result:'try'(
case Filter@1 of
{some, Filter@2} ->
case gleam@regexp:from_string(
Filter@2
) of
{ok, Regex} ->
{ok,
{some,
Regex}};
{error,
{compile_error,
Error,
_}} ->
{error,
[{invalid_argument,
<<"filter"/utf8>>,
Filter@2,
Error}]}
end;
none ->
{ok, none}
end,
fun(Regex@1) ->
gleam@result:'try'(
parse_definitions(
Args
),
fun(Definitions) ->
Options = {options,
embeds@generate:to_gleam_module_name(
Module@1
),
<<"//// Generated by `embeds`, manual edits are futile"/utf8>>,
typed_parse_fallback(
Definitions,
fun default_parse/2
),
Prefix@2,
Regex@1},
generate(
Options
)
end
)
end
)
end,
case Result of
{ok, nil} ->
nil;
{error, Errs} ->
gleam_stdlib:println_error(
embeds@generate:describe_errors(
Errs
)
)
end,
nil
end
)
end
)
end
)
end
)
end
).
-file("src/embeds/env.gleam", 113).
?DOC(" runs generate using command line arguments to fill out the arguments.\n").
-spec main() -> nil.
main() ->
_pipe = glint:new(),
_pipe@1 = glint:pretty_help(_pipe, glint:default_pretty_help()),
_pipe@2 = glint:add(_pipe@1, [], generate_cmd()),
glint:run(_pipe@2, erlang:element(4, argv:load())).