skill-universe 1.1.0

package/README.md

@@ -0,0 +1,24 @@
+# skillc
+
+[![Package Version](https://img.shields.io/hexpm/v/skillc)](https://hex.pm/packages/skillc)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/skillc/)
+
+```sh
+gleam add skillc@1
+```
+```gleam
+import skillc
+
+pub fn main() -> Nil {
+  // TODO: An example of the project in use
+}
+```
+
+Further documentation can be found at <https://hexdocs.pm/skillc>.
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```

package/bin/skillc.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "../build/dev/javascript/skillc/skillc.mjs";
+main();

package/build/dev/javascript/argv/argv.erl

@@ -0,0 +1,12 @@
+-module(argv).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
+
+-export([load/0]).
+-export_type([argv/0]).
+
+-type argv() :: {argv, binary(), binary(), list(binary())}.
+
+-spec load() -> argv().
+load() ->
+    {Runtime, Program, Arguments} = argv_ffi:load(),
+    {argv, Runtime, Program, Arguments}.

package/build/dev/javascript/argv/argv.mjs

@@ -0,0 +1,31 @@
+import { load as do$ } from "./argv_ffi.mjs";
+import { CustomType as $CustomType } from "./gleam.mjs";
+
+export class Argv extends $CustomType {
+  constructor(runtime, program, arguments$) {
+    super();
+    this.runtime = runtime;
+    this.program = program;
+    this.arguments = arguments$;
+  }
+}
+export const Argv$Argv = (runtime, program, arguments$) =>
+  new Argv(runtime, program, arguments$);
+export const Argv$isArgv = (value) => value instanceof Argv;
+export const Argv$Argv$runtime = (value) => value.runtime;
+export const Argv$Argv$0 = (value) => value.runtime;
+export const Argv$Argv$program = (value) => value.program;
+export const Argv$Argv$1 = (value) => value.program;
+export const Argv$Argv$arguments = (value) => value.arguments;
+export const Argv$Argv$2 = (value) => value.arguments;
+
+export function load() {
+  let $ = do$();
+  let runtime;
+  let program;
+  let arguments$;
+  runtime = $[0];
+  program = $[1];
+  arguments$ = $[2];
+  return new Argv(runtime, program, arguments$);
+}

package/build/dev/javascript/argv/argv_ffi.erl

@@ -0,0 +1,27 @@
+-module(argv_ffi).
+
+-export([load/0]).
+
+load() ->
+    Runtime = <<(stringarg(bindir))/binary, "/", (stringarg(progname))/binary>>,
+    PlainArguments = lists:map(
+        fun(Arg) -> unicode:characters_to_binary(Arg, utf8) end, init:get_plain_arguments()
+    ),
+    {Program, Arguments} = case init:get_argument(escript) of
+        % We're in an escript, so the first argument is the executable name
+        {ok, _} ->
+            [P | Rest] = PlainArguments,
+            {P, Rest};
+
+        % We're not in a escript. Assume the cwd is the project root.
+        _ ->
+            {ok, Cwd} = file:get_cwd(),
+            {unicode:characters_to_binary(Cwd, utf8), PlainArguments}
+    end,
+    {Runtime, Program, Arguments}.
+
+stringarg(Name) ->
+    case init:get_argument(Name) of
+        {ok, [[Value]]} -> list_to_binary(Value);
+        _ -> <<>>
+    end.

package/build/dev/javascript/argv/argv_ffi.mjs

@@ -0,0 +1,20 @@
+import { List } from "./gleam.mjs";
+
+export function load() {
+  if (globalThis.process) {
+    const [runtime, program, ...args] = process.argv;
+    return [runtime, program, List.fromArray(args)];
+  }
+
+  if (globalThis.Deno) {
+    const runtime = Deno.execPath();
+    const program = new URL(Deno.mainModule).pathname;
+    const args = List.fromArray(Deno.args);
+    return [runtime, program, args];
+  }
+
+  const runtime = "browser";
+  const program = document.location.toString();
+  const args = List.fromArray([]);
+  return [runtime, program, args];
+}

package/build/dev/javascript/argv/gleam.mjs

@@ -0,0 +1 @@
+export * from "../prelude.mjs";

package/build/dev/javascript/filepath/filepath.erl

@@ -0,0 +1,425 @@
+-module(filepath).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
+
+-export([join/2, split_unix/1, directory_name/1, is_absolute/1, split_windows/1, split/1, base_name/1, extension/1, strip_extension/1, expand/1]).
+
+-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(
+    " Work with file paths in Gleam!\n"
+    "\n"
+    " This library expects paths to be valid unicode. If you need to work with\n"
+    " non-unicode paths you will need to convert them to unicode before using\n"
+    " this library.\n"
+).
+
+-file("src/filepath.gleam", 49).
+-spec relative(binary()) -> binary().
+relative(Path) ->
+    case Path of
+        <<"/"/utf8, Path@1/binary>> ->
+            relative(Path@1);
+
+        _ ->
+            Path
+    end.
+
+-file("src/filepath.gleam", 56).
+-spec remove_trailing_slash(binary()) -> binary().
+remove_trailing_slash(Path) ->
+    case gleam@string:ends_with(Path, <<"/"/utf8>>) of
+        true ->
+            gleam@string:drop_end(Path, 1);
+
+        false ->
+            Path
+    end.
+
+-file("src/filepath.gleam", 35).
+?DOC(
+    " Join two paths together.\n"
+    "\n"
+    " This function does not expand `..` or `.` segments, use the `expand`\n"
+    " function to do this.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " join(\"/usr/local\", \"bin\")\n"
+    " // -> \"/usr/local/bin\"\n"
+    " ```\n"
+).
+-spec join(binary(), binary()) -> binary().
+join(Left, Right) ->
+    _pipe@2 = case {Left, Right} of
+        {_, <<"/"/utf8>>} ->
+            Left;
+
+        {<<""/utf8>>, _} ->
+            relative(Right);
+
+        {<<"/"/utf8>>, <<"/"/utf8, _/binary>>} ->
+            Right;
+
+        {<<"/"/utf8>>, _} ->
+            <<Left/binary, Right/binary>>;
+
+        {_, _} ->
+            _pipe = remove_trailing_slash(Left),
+            _pipe@1 = gleam@string:append(_pipe, <<"/"/utf8>>),
+            gleam@string:append(_pipe@1, relative(Right))
+    end,
+    remove_trailing_slash(_pipe@2).
+
+-file("src/filepath.gleam", 97).
+?DOC(
+    " Split a path into its segments, using `/` as the path separator.\n"
+    "\n"
+    " Typically you would want to use `split` instead of this function, but if you\n"
+    " want non-Windows path behaviour on a Windows system then you can use this\n"
+    " function.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " split(\"/usr/local/bin\", \"bin\")\n"
+    " // -> [\"/\", \"usr\", \"local\", \"bin\"]\n"
+    " ```\n"
+).
+-spec split_unix(binary()) -> list(binary()).
+split_unix(Path) ->
+    _pipe = case gleam@string:split(Path, <<"/"/utf8>>) of
+        [<<""/utf8>>] ->
+            [];
+
+        [<<""/utf8>> | Rest] ->
+            [<<"/"/utf8>> | Rest];
+
+        Rest@1 ->
+            Rest@1
+    end,
+    gleam@list:filter(_pipe, fun(X) -> X /= <<""/utf8>> end).
+
+-file("src/filepath.gleam", 267).
+-spec get_directory_name(list(binary()), binary(), binary()) -> binary().
+get_directory_name(Path, Acc, Segment) ->
+    case Path of
+        [<<"/"/utf8>> | Rest] ->
+            get_directory_name(
+                Rest,
+                <<Acc/binary, Segment/binary>>,
+                <<"/"/utf8>>
+            );
+
+        [First | Rest@1] ->
+            get_directory_name(Rest@1, Acc, <<Segment/binary, First/binary>>);
+
+        [] ->
+            Acc
+    end.
+
+-file("src/filepath.gleam", 259).
+?DOC(
+    " Get the directory name of a path, that is the path without the file name.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " directory_name(\"/usr/local/bin\")\n"
+    " // -> \"/usr/local\"\n"
+    " ```\n"
+).
+-spec directory_name(binary()) -> binary().
+directory_name(Path) ->
+    Path@1 = remove_trailing_slash(Path),
+    case Path@1 of
+        <<"/"/utf8, Rest/binary>> ->
+            get_directory_name(
+                gleam@string:to_graphemes(Rest),
+                <<"/"/utf8>>,
+                <<""/utf8>>
+            );
+
+        _ ->
+            get_directory_name(
+                gleam@string:to_graphemes(Path@1),
+                <<""/utf8>>,
+                <<""/utf8>>
+            )
+    end.
+
+-file("src/filepath.gleam", 294).
+?DOC(
+    " Check if a path is absolute.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " is_absolute(\"/usr/local/bin\")\n"
+    " // -> True\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " is_absolute(\"usr/local/bin\")\n"
+    " // -> False\n"
+    " ```\n"
+).
+-spec is_absolute(binary()) -> boolean().
+is_absolute(Path) ->
+    gleam@string:starts_with(Path, <<"/"/utf8>>).
+
+-file("src/filepath.gleam", 339).
+-spec expand_segments(list(binary()), list(binary())) -> {ok, binary()} |
+    {error, nil}.
+expand_segments(Path, Base) ->
+    case {Base, Path} of
+        {[<<""/utf8>>], [<<".."/utf8>> | _]} ->
+            {error, nil};
+
+        {[], [<<".."/utf8>> | _]} ->
+            {error, nil};
+
+        {[_ | Base@1], [<<".."/utf8>> | Path@1]} ->
+            expand_segments(Path@1, Base@1);
+
+        {_, [<<"."/utf8>> | Path@2]} ->
+            expand_segments(Path@2, Base);
+
+        {_, [S | Path@3]} ->
+            expand_segments(Path@3, [S | Base]);
+
+        {_, []} ->
+            {ok, gleam@string:join(lists:reverse(Base), <<"/"/utf8>>)}
+    end.
+
+-file("src/filepath.gleam", 364).
+-spec root_slash_to_empty(list(binary())) -> list(binary()).
+root_slash_to_empty(Segments) ->
+    case Segments of
+        [<<"/"/utf8>> | Rest] ->
+            [<<""/utf8>> | Rest];
+
+        _ ->
+            Segments
+    end.
+
+-file("src/filepath.gleam", 153).
+-spec pop_windows_drive_specifier(binary()) -> {gleam@option:option(binary()),
+    binary()}.
+pop_windows_drive_specifier(Path) ->
+    Start = gleam@string:slice(Path, 0, 3),
+    Codepoints = gleam@string:to_utf_codepoints(Start),
+    case gleam@list:map(Codepoints, fun gleam@string:utf_codepoint_to_int/1) of
+        [Drive, Colon, Slash] when (((Slash =:= 47) orelse (Slash =:= 92)) andalso (Colon =:= 58)) andalso (((Drive >= 65) andalso (Drive =< 90)) orelse ((Drive >= 97) andalso (Drive =< 122))) ->
+            Drive_letter = gleam@string:slice(Path, 0, 1),
+            Drive@1 = <<(gleam@string:lowercase(Drive_letter))/binary,
+                ":/"/utf8>>,
+            Path@1 = gleam@string:drop_start(Path, 3),
+            {{some, Drive@1}, Path@1};
+
+        _ ->
+            {none, Path}
+    end.
+
+-file("src/filepath.gleam", 120).
+?DOC(
+    " Split a path into its segments, using `/` and `\\` as the path separators. If\n"
+    " there is a drive letter at the start of the path then it is lowercased.\n"
+    "\n"
+    " Typically you would want to use `split` instead of this function, but if you\n"
+    " want Windows path behaviour on a non-Windows system then you can use this\n"
+    " function.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " split(\"/usr/local/bin\", \"bin\")\n"
+    " // -> [\"/\", \"usr\", \"local\", \"bin\"]\n"
+    " ```\n"
+).
+-spec split_windows(binary()) -> list(binary()).
+split_windows(Path) ->
+    {Drive, Path@1} = pop_windows_drive_specifier(Path),
+    Segments = begin
+        _pipe = gleam@string:split(Path@1, <<"/"/utf8>>),
+        gleam@list:flat_map(
+            _pipe,
+            fun(_capture) -> gleam@string:split(_capture, <<"\\"/utf8>>) end
+        )
+    end,
+    Segments@1 = case Drive of
+        {some, Drive@1} ->
+            [Drive@1 | Segments];
+
+        none ->
+            Segments
+    end,
+    case Segments@1 of
+        [<<""/utf8>>] ->
+            [];
+
+        [<<""/utf8>> | Rest] ->
+            [<<"/"/utf8>> | Rest];
+
+        Rest@1 ->
+            Rest@1
+    end.
+
+-file("src/filepath.gleam", 77).
+?DOC(
+    " Split a path into its segments.\n"
+    "\n"
+    " When running on Windows both `/` and `\\` are treated as path separators, and \n"
+    " if the path starts with a drive letter then the drive letter then it is\n"
+    " lowercased.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " split(\"/usr/local/bin\", \"bin\")\n"
+    " // -> [\"/\", \"usr\", \"local\", \"bin\"]\n"
+    " ```\n"
+).
+-spec split(binary()) -> list(binary()).
+split(Path) ->
+    case filepath_ffi:is_windows() of
+        true ->
+            split_windows(Path);
+
+        false ->
+            split_unix(Path)
+    end.
+
+-file("src/filepath.gleam", 240).
+?DOC(
+    " Get the base name of a path, that is the name of the file without the\n"
+    " containing directory.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " base_name(\"/usr/local/bin\")\n"
+    " // -> \"bin\"\n"
+    " ```\n"
+).
+-spec base_name(binary()) -> binary().
+base_name(Path) ->
+    gleam@bool:guard(Path =:= <<"/"/utf8>>, <<""/utf8>>, fun() -> _pipe = Path,
+            _pipe@1 = split(_pipe),
+            _pipe@2 = gleam@list:last(_pipe@1),
+            gleam@result:unwrap(_pipe@2, <<""/utf8>>) end).
+
+-file("src/filepath.gleam", 190).
+?DOC(
+    " Get the file extension of a path.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " extension(\"src/main.gleam\")\n"
+    " // -> Ok(\"gleam\")\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " extension(\"package.tar.gz\")\n"
+    " // -> Ok(\"gz\")\n"
+    " ```\n"
+).
+-spec extension(binary()) -> {ok, binary()} | {error, nil}.
+extension(Path) ->
+    File = base_name(Path),
+    case gleam@string:split(File, <<"."/utf8>>) of
+        [<<""/utf8>>, _] ->
+            {error, nil};
+
+        [_, Extension] ->
+            {ok, Extension};
+
+        [_ | Rest] ->
+            gleam@list:last(Rest);
+
+        _ ->
+            {error, nil}
+    end.
+
+-file("src/filepath.gleam", 219).
+?DOC(
+    " Remove the extension from a file, if it has any.\n"
+    " \n"
+    " ## Examples\n"
+    " \n"
+    " ```gleam\n"
+    " strip_extension(\"src/main.gleam\")\n"
+    " // -> \"src/main\"\n"
+    " ```\n"
+    " \n"
+    " ```gleam\n"
+    " strip_extension(\"package.tar.gz\")\n"
+    " // -> \"package.tar\"\n"
+    " ```\n"
+    " \n"
+    " ```gleam\n"
+    " strip_extension(\"src/gleam\")\n"
+    " // -> \"src/gleam\"\n"
+    " ```\n"
+).
+-spec strip_extension(binary()) -> binary().
+strip_extension(Path) ->
+    case extension(Path) of
+        {ok, Extension} ->
+            gleam@string:drop_end(Path, gleam@string:length(Extension) + 1);
+
+        {error, nil} ->
+            Path
+    end.
+
+-file("src/filepath.gleam", 324).
+?DOC(
+    " Expand `..` and `.` segments in a path.\n"
+    "\n"
+    " If the path has a `..` segment that would go up past the root of the path\n"
+    " then an error is returned. This may be useful to example to ensure that a\n"
+    " path specified by a user does not go outside of a directory.\n"
+    "\n"
+    " If the path is absolute then the result will always be absolute.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " expand(\"/usr/local/../bin\")\n"
+    " // -> Ok(\"/usr/bin\")\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " expand(\"/tmp/../..\")\n"
+    " // -> Error(Nil)\n"
+    " ```\n"
+    "\n"
+    " ```gleam\n"
+    " expand(\"src/../..\")\n"
+    " // -> Error(\"..\")\n"
+    " ```\n"
+).
+-spec expand(binary()) -> {ok, binary()} | {error, nil}.
+expand(Path) ->
+    Is_absolute = is_absolute(Path),
+    Result = begin
+        _pipe = Path,
+        _pipe@1 = split(_pipe),
+        _pipe@2 = root_slash_to_empty(_pipe@1),
+        _pipe@3 = expand_segments(_pipe@2, []),
+        gleam@result:map(_pipe@3, fun remove_trailing_slash/1)
+    end,
+    case Is_absolute andalso (Result =:= {ok, <<""/utf8>>}) of
+        true ->
+            {ok, <<"/"/utf8>>};
+
+        false ->
+            Result
+    end.