Spork

(argparse description &keys options)

Parse `(dyn :args)` according to options. If the arguments are incorrect,
will return nil and print usage information.

Each option is a table or struct that specifies a flag or option
for the script. The name of the option should be a string, specified
via `(argparse/argparse "..." op1-name {...} op2-name {...} ...)`. A help option
and usage text is automatically generated for you.

The keys in each option table are as follows:

* `:kind` - What kind of option is this? One of `:flag`, `:multi`, `:option`, or
 `:accumulate`. A flag can either be on or off, a multi is a flag that can be provided
 multiple times, each time adding 1 to a returned integer, an option is a key that
 will be set in the returned table, and accumulate means an option can be specified
 0 or more times, each time appending a value to an array.
* `:short` - Single letter for shorthand access.
* `:help` - Help text for the option, explaining what it is.
* `:default` - Default value for the option.
* `:required` - Whether or not an option is required.
* `:short-circuit` - Whether or not to stop parsing and fail if this option is hit.
* `:action` - A function that will be invoked when the option is parsed.

There is also a special option name `:default` that will be invoked on arguments
that do not start with a -- or -. Use this option to collect unnamed
arguments to your script. This is separate from the `:default` key in option specifiers.

After "--", every argument is treated as an unnamed argument.

Once parsed, values are accessible in the returned table by the name
of the option. For example `(result "verbose")` will check if the verbose
flag is enabled.

(decode s)

Converts a base64 encoded string to its binary representation of any format
(UTF-8, binary, ..).

(encode s)

Converts a string of any format (UTF-8, binary, ..) to base64 encoding.

(crc/make-variant size polynomial &opt init byte-flip xorout)

Create a CRC function based on the given polynomial, initial value, xourout, and whether to invert input bytes.

(crc/named-variant name)

Get a named CRC variant.

(check cron &opt time local)

Check if a given time matches a cron specifier.

(next-timestamp cron &opt time local)

Given a cron schedule, get the next instance on the cron tab after time

(parse-cron str)

Parse a cron string into a valid cron schedule object

(go-nursery nurse f &opt value)

Spawn a fiber into a nursery, similar to ev/go.

(join-nursery nurse)

Suspend the current fiber until the nursery is emptied.

(multithread-service thread-main n-threads)

Run instances of a function over multiple threads. On failures, restart the failed thread. Normal function returns will not trigger a restart.

(nursery)

Group a number of fibers into a single object for structured concurrency

(pcall f n)

Call a function n times (in parallel) for side effects. Each function is called with an integer argument indicating a fiber index. Returns nil.

(pdag f dag &opt n-workers)

Executes a dag by calling f on every node in the graph. Can set the number of workers for parallel execution. The graph is represented as a table mapping nodes to arrays of child nodes. Each node will only be evaluated after all children have been evaluated. Modifying `dag` inside `f` will not affect the scheduling of workers. Returns a table mapping each node to the result of `(f node)`.

(pmap f data &opt n-workers)

Map `f` over data in parallel, optionally limiting parallelism to `n` workers.

(pmap-full f data)

Function form of `ev/gather`. If any of the sibling fibers error, all other siblings will be canceled. Returns the gathered results in an array. `data` can be any indexed data structure.

(pmap-limited f data n-workers)

Similar to pmap-full, but only runs work n-ways parallel.

(spawn-nursery nurse & body)

Similar to ev/spawn but associate spawned fibers with a nursery

(wait-cancel & body)

Wait forever until the current fiber is canceled, and then run some cleanup code.

(format source)

Format a string of source code to a buffer.

(format-file file)

Format a file

(format-print source)

Format a string of source code and print the result.

(concat & xs)

Concatenate one or more generators or iterables into a single generator.

(cycle ds)

Repeatedly yield the elements of `ds`, looping back to the beginning when finished.

(drop n ds)

Drop `n` elements from `ds`.

(drop-until p ds)

Drop elements from `ds` until `p` is true.

(drop-while p ds)

Drop elements from `ds` while `p` is true.

(filter p ds)

Create a generator that filters `ds` with `p`.

(from-iterable ds)

Create a new generator around any iterable data structure.

(map f ds)

Create a generator that maps `f` over `ds`.

(mapcat f ds)

Map `f` over `ds`, concatenating the results into a new generator.

(range from to)

Create a lazy range.

(run s)

Evaluate `s` for side effects.

(take n ds)

Take `n` elements from iterable `ds`.

(take-until p ds)

Return elements from `ds` until `p` is true.

(take-while p ds)

Return elements from `ds` while `p` is true.

(to-array s)

Consume `s` into a new array.

(default-autocomplete-context buf pos)

Given a buffer and a cursor position, extract a string that will be used as context for autocompletion. Return a position and substring from the buffer to use for autocompletion.

(default-autocomplete-options prefix &)

Default handler to get available autocomplete options for a given substring.

(default-doc-fetch sym w &)

Default handler for Ctrl-G to lookup docstrings in the current environment.

(make-getline &opt autocomplete-context autocomplete-options doc-fetch)

Reads a line of input into a buffer, like `getline`. However, allow looking up entries with a general lookup function rather than a environment table.

Maximal amount of items in the history

The html5 doctype header

(escape x)

Escape characters in a string for HTML

(html data &opt buf)

Render HTML from standard data structures. Fills the provided optional buffer, or new one if it is not provided, with the html bytes.

(raw text)

Get an object that can be used to splice in HTML literals. `text` is not escaped in the output string.

Grammar to parse a cookie header to a series of keys and values.

(cookies nextmw)

Parses cookies into the table under :cookies key

(logger nextmw)

Creates a logging middleware. The logger middleware prints URL route, return status, and elapsed request time.

(middleware x)

Coerce any type to http middleware

Grammar that parses a query string (sans url path and ? character) and returns a table.

(read-body req)

Given a request, read the HTTP body from the connection. Returns the body as a buffer. If the request has no body, returns nil.

(read-request conn buf &opt no-query)

Read an HTTP request header from a connection. Returns a table with the following keys: * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:head-size` - the number of bytes used by the header. * `:method` - the HTTP method used. * `:path` - the path of the resource requested. The following keys are also present, but omitted if the user passes a truthy parameter to `no-query`. * `:route` - path of the resource requested without query string. * `:query-string` - segment of HTTP path after first ? character. * `:query` - the query string parsed into a table. Supports a single string value     for every string key, and any query parameters that aren't given a value are mapped to true.  Note that data is read in chunks and any data after the header terminator is  stored in `:buffer.`

(read-response conn buf)

Read an HTTP response header from a connection. Returns a table with the following keys: * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:head-size` - the number of bytes used by the header. * `:status` - the HTTP status code. * `:message` - the HTTP status message. Note that data is read in chunks and any data after the header terminator is stored in `:buffer.`

(request method url &keys {:headers headers :body body})

Make an HTTP request to a server. Returns a table contain response information. * `:head-size` - number of bytes in the http header * `:headers` - table mapping header names to header values. Header names are lowercase. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:status` - HTTP status code as an integer. * `:message` - HTTP status message. * `:body` - Bytes of the response body.

PEG for parsing HTTP requests

PEG for parsing HTTP responses

(router routes)

Creates a router middleware. A router will dispatch to different routes based on the URL path.

(send-response conn response &opt buf)

Send an HTTP response over a connection. Will automatically use chunked encoding if body is not a byte sequence. `response` should be a table with the following keys: * `:headers` - optional headers to write * `:status` - integer status code to write * `:body` - optional byte sequence or iterable (for chunked body) for returning contents. The iterable can be lazy, i.e. for streaming    data.

(server handler &opt host port)

Makes a simple http server. By default it binds to 0.0.0.0:8000, returns a new server stream. Simply wraps http/server-handler with a net/server.

(server-handler conn handler)

A simple connection handler for an HTTP server. When a connection is accepted. Call this with a handler function to handle the connect. The handler will be called with one argument, the request table, which will contain the following keys: * `:head-size` - number of bytes in the http header. * `:headers` - table mapping header names to header values. * `:connection` - the connection stream for the header. * `:buffer` - the buffer instance that may contain extra bytes. * `:path` - HTTP path. * `:method` - HTTP method, as a string.

Mapping of HTTP status codes to their status message.

Grammar to parse a URL into domain, port, and path triplet. Only supports the http:// protocol.

(add-bindings-as-routes server &opt env)

Add all local functions defined with :path metadata to a server. Will read from the :schema, :doc, :path, and :route-doc metadata to determine how the route behaves.

(add-route server path docstring schema handler &opt read-mime render-mime)

Add a single manually route to a server. Prefer using `httpf/add-bindings-as-routes` for the usual case.

(default-payload-wrapper payload)

Add some metadata to all responses

(listen server &opt host port n-workers)

Start server

(server &opt parent)

Create a new server.

(json/decode json-source &opt keywords nils)

Returns a janet object after parsing JSON. If keywords is truthy, string keys will be converted to keywords. If nils is truthy, null will become nil instead of the keyword :null.

(json/encode x &opt tab newline buf)

Encodes a janet value in JSON (utf-8). tab and newline are optional byte sequence which are used to format the output JSON. if buf is provided, the formated JSON is append to buf instead of a new buffer. Returns the modifed buffer.

Dynamic binding to front matter after parsing, compilation, and evaluation, of markup completes.

The htmlgen source that can be used to generate a document with htmlgen/html.

(add-loader)

Allow importing and requiring markup as a module

(anchor name & content)

Create an in-page anchor for a local link.

(bigger content)

Make span element with bigger font

(blockquote content)

Make a block quote element

(center content)

Center some content

(code content)

Make code element with class mendoza-code

(codeblock lang &opt source)

Inline code or codeblock

Make a div element

Make a em element

(hr)

Add a horizontal rule

(html source)

Embed some raw html

(image src alt)

Make an image element

Make a li element

(link url &opt content)

Create an anchor link

(markup source &opt env where)

Parse mendoza markup and evaluate it returning an htmlgen document tree.

(mdz-loader path &)

Loader for the mdz format

Make a ol element

Make a p element

Make a pre element

(section name content)

Create a section. Usually used to embed different parts of the content document into different parts of the main page.

(smaller content)

Make span element with smaller font

Make a strong element

Make a sub element

Make a sup element

(tag name content)

Wrap some content in an html tag. If you need attributes or other properties, you may want to use raw HTML via the html function.

Make a td element

Make a th element

Make a tr element

Make a u element

Make a ul element

(always x)

Return a function that discards any arguments and always returns `x`.

(antepenultimate xs)

Get the third-to-last element from an indexed data structure.

(caperr & body)

Captures the standart error output of the variadic `body` and returns it
as a buffer.

(capout & body)

Captures the standart output of the variadic `body` and returns it as
a buffer.

(cond-> val & clauses)

Threading conditional macro. It takes `val` to mutate,
and `clauses` pairs with condition and operation to which the `val`,
is put as first argument. All conditions are tried and
for truthy conditions the operation is executed.
Returns the value mutated if any condition is truthy.

(cond->> val & clauses)

Threading conditional macro. It takes `val` to mutate,
and `clauses` pairs of condition and operation to which the `val`,
is put as last argument. All conditions are tried and
for truthy the operation is ran.
Returns mutated value if any condition is truthy.

(dedent & xs)

Remove indentation after concatenating the arguments. Works by removing
leading whitespace, and then removing that same pattern of whitepsace after
new lines.

(defs & bindings)

Defines many constants as in let `bindings`, but without creating new scope.

(dfs data visit-leaf &opt node-before node-after get-children seen)

Do a depth first, pre-order traversal over a data structure.
Also allow for callbacks before and after visiting the children
of a node. Also allow for a custom `get-children` function to
change traversal as needed. Will detect cycles if an empty table
is passed as the `seen` parameter, which is used to cached values
that have been visited.

(do-def c d & body)

Convenience macro for defining constant named `c` with value `d` before `body`
and returning it after evaluating `body`, that presumably modifies 
the `c` refered content. For example buffer, table or array.

(do-var v d & body)

Convenience macro for defining varible named `v` with value `d` before `body`
and returning it after evaluating `body`, that presumably modifies `v`.

(format-table buf-into data &opt columns header-mapping column-mapping)

Same as print-table but pushes table into a buffer.

(gett ds & keys)

Recursive macro (get). Similar to get-in, but keys are variadic argument.

(insert-sorted arr <? & xs)

Insert elements in `arr` such that it remains sorted by the comparator. If
`arr` is not sorted beforehand, the results are undefined. Returns `arr`.

(insert-sorted-by arr f & xs)

Insert elements in `arr` such that it remains sorted by the value returned
when `f` is called with the element, comparing the values with <. If `arr` is
not sorted beforehand, the results are undefined. Returns `arr`.

(int->string int &opt base)

Stringify an integer in a particular base. Defaults to decimal (base 10).

(int/ & xs)

Perform integer division.

(log level & args)

Print to a dynamic binding stream if that stream is set, otherwise do
nothing. Evaluate to nil. 
For example, `(log :err "value error: %V" my-value)` will print 
to `(dyn :err)` only if `(dyn :err)` has been set.

(make prototype & pairs)

Convenience macro for creating new table from even number of kvs pairs in a variadic `table-or-pairs`
arguments and setting its prototype to `prototype`.
Factory function for creating new objects from prototypes.

(make-id &opt prefix)

Create a random, printable keyword id with 10 bytes of entropy
with an optional prefix.

(map-keys f data)

Returns new table with function `f` applied to `data`'s
keys recursively.

(map-vals f data)

Returns new table with function `f` applied to `data`'s values.

(penultimate xs)

Get the second-to-last element from an indexed data structure.

(print-table data &opt columns header-mapping column-mapping)

Iterate through the rows of a data structure and print a table in a human
readable way, with padding and heading information. Can optionally provide
a function use to print a row, as well as optionally select column keys
for each row. Lastly, a `header-mapping` dictionary can be provided that
changes the printed header names by mapping column keys to the desired
header name. If no mapping is found, then the column key will be used as
the header name. Returns nil.

(randomize-array arr &opt rng)

Randomizes array using the fisher-yates shuffle, takes an optional random
number generator.

(second xs)

Get the second element from an indexed data structure.

(select-keys data keyz)

Returns new table with selected `keyz` from dictionary `data`.

(set* tgts exprs)

Parallel `set` function. Takes a list of targets and
expressions, evaluates all the expressions, and then
assigns them to the targets. Each target can be a variable
or a 2-tuple, just like in the normal `set` special form.

(string->int str &opt base)

Parse an integer in the given base. Defaults to decimal (base 10). Differs
from scan-number in that this does not recognize floating point notation.

(table-filter pred dict)

Filter a key-value structure info a table. Semantics are the same as for
built-in `filter`, except that `pred` takes two arguments (key and value.)
Does not consider prototypes.

(third xs)

Get the third element from an indexed data structure.

(trim-prefix prefix str)

Trim the specified prefix of a string if it has one

(trim-suffix suffix str)

Trim the specified suffix of a string if it has one

(until cnd & body)

Repeat `body` while the `cnd` is false.
Equivalent to (while (not cnd) ;body).

(vars & bindings)

Defines many variables as in let `bindings`, but without creating new scope.

(make-proto stream &opt pack unpack)

Create both a send an recv function from a stream, as with `make-send` and `make-recv`.

(make-recv stream &opt unpack)

Get a function that, when invoked, gets the next message from a readable stream. Provide an optional unpack function that will parse the received buffer.

(make-send stream &opt pack)

Create a function that when called with a msgs sends that msg. Provide an optional pack function that will convert a message to a string.

(client &opt host port name)

Connect to a repl server. The default host is "127.0.0.1" and the default port is "9365".

Default host to run server on and connect to.

Default port to run the net repl.

(server &opt host port env cleanup welcome-msg)

Start a repl server. The default host is "127.0.0.1" and the default port is "9365". Calling this will start a TCP server that exposes a repl into the given env. If no env is provided, a new env will be created per connection. If env is a function, that function will be invoked with the name and stream on each connection to generate an environment. `cleanup` is an optional function that will be called for each stream after closing if provided. `welcome-msg` is an optional string or function (welcome-msg client-name) to generate a message to print for the client on connection.

(server-single &opt host port env cleanup welcome-msg)

Short-hand for serving up a a repl that has a single environment table in it. `env` must be a proper env table, not a function as is possible in netrepl/server.

(posix/abspath path)

Coerce a path to be absolute.

(posix/abspath? path)

Check if a path is absolute.

(posix/basename path)

Gets the base file name of a path.

Platform delimiter

(posix/dirname path)

Gets the directory name of a path.

(ext path)

Get the file extension for a path.

(posix/join & els)

Join path elements together.

(posix/normalize path)

Normalize a path. This removes . and .. in the path, as well as empty path elements.

(posix/parts path)

Split a path into its parts.

(posix/abspath path)

Coerce a path to be absolute.

(posix/abspath? path)

Check if a path is absolute.

(posix/basename path)

Gets the base file name of a path.

Platform delimiter

(posix/dirname path)

Gets the directory name of a path.

(ext path)

Get the file extension for a path.

(posix/join & els)

Join path elements together.

(posix/normalize path)

Normalize a path. This removes . and .. in the path, as well as empty path elements.

(posix/parts path)

Split a path into its parts.

(posix/relpath source target)

Get the relative path between two subpaths.

Platform separator

(posix/relpath source target)

Get the relative path between two subpaths.

Platform separator

(win32/abspath path)

Coerce a path to be absolute.

(win32/abspath? path)

Check if a path is absolute.

(win32/basename path)

Gets the base file name of a path.

Platform delimiter

(win32/dirname path)

Gets the directory name of a path.

(ext path)

Get the file extension for a path.

(win32/join & els)

Join path elements together.

(win32/normalize path)

Normalize a path. This removes . and .. in the path, as well as empty path elements.

(win32/parts path)

Split a path into its parts.

(win32/relpath source target)

Get the relative path between two subpaths.

Platform separator

(rawterm/begin &opt on-winch)

Begin raw terminal functionality. Return a stream that can be read from to get input.

(rawterm/buffer-traverse bytes index delta &opt skip-zerowidth)

Move to a new position in a buffer from index by incrementing by `delta` codepoints. Can also skip zero-width codepoints if desired.

(rawterm/ctrl-z)

A handler that a user can use to handle ctrl-z from input to suspend the current process.

(rawterm/end)

End raw terminal functionality.

(rawterm/getch &opt into)

Get a byte of input from stdin, without blocking if possible. Returns a buffer.

(rawterm/isatty)

Check if the current stdin is a tty.

(rawterm/monowidth bytes &opt start-index end-index)

Measure the monospace width of a string.

(rawterm/rune-monowidth rune)

Get the monospace width of a rune. Returns either 0, 1, or 2.

(rawterm/size)

Get the number of rows and columns visible in the terminal as tuple [rows cols]

(rawterm/slice-monowidth bytes columns &opt start-index into)

Get a byte slice that will fit into a number of columns.

(compile pattern)

Compile a subset of regex to a PEG if pattern is a string. If pattern is a PEG, will return the PEG as is.

(find reg text &opt start)

Similar to peg/find, but for regexes.

(find-all reg text &opt start)

Similar to peg/find-all, but for regexes.

(match reg text &opt start)

Similar to peg/match, but for regexes.

Peg used to generate peg source code from a regular expression string.

(replace reg rep text &opt start)

Similar to peg/replace, but for regexes.

(replace-all reg rep text &opt start)

Similar to peg/replace-all, but for regexes.

(source pattern)

Compile a subset of regex to PEG source code.

(client &opt host port name)

Create an RPC client. The default host is "127.0.0.1" and the default port is "9366". Returns a table of async functions that can be used to make remote calls. This table also contains a :close function that can be used to close the connection.

Default host to run server on and connect to.

Default port to run the net repl.

(server functions &opt host port workers-per-connection)

Create an RPC server. The default host is "127.0.0.1" and the default port is "9366". Also must take a dictionary of functions that clients can call.

(make-predicate schema)

Generate a function that can be used to validate a data structure. This is the function form of `predicate`.

(make-validator schema)

Generate a function that can be used to validate a data structure. This is the function form of `validator`.

(predicate pattern)

Make a validation predicate given a certain schema.

(validator pattern)

Make a validation function of one argument. A validation function will throw an error on validation failure, otherwise, it will return the argument.

The currently running service manager, if there is one

The currently running service, if there is one

(add-service service-name main-function & args)

Spawn a service

(all-services)

Get a list of running services

(get-manager)

Get the current manager. If no manager exists, create one.

(get-service)

Get the current service. If not in a service, raise an error

(make-manager &opt log-dir)

Group a number of fibers into a single object for structured concurrency. Also includes utilities for running services like servers in the background.

(print-all &opt filter-fn)

Print a table of all running services.

(remove-service service-name)

Remove a service

(set-title title)

Set a textual description of the service to describe what it is doing currently

(start-service service-name)

Start or restart a service

(stop-service service-name &opt reason)

Stop a running service

(wait)

Once a number of services have been spawned, call `wait` to block the fiber until the manager is canceled. This lets a manager fiber behave as a service itself.

(copy src dest)

Copy a file or directory recursively from one location to another.
Expects input to be unix style paths

(copy-file src-path dst-path)

Copy a file from source to destination. Creates all directories in the path to the destination file if they do not exist.

(create-dirs dir-path)

Create all directories in path specified as string including itself.

(devnull)

get the /dev/null equivalent of the current platform as an open file

(exec-slurp & args)

Read stdout of subprocess and return it trimmed in a string.

(exec-slurp-all & args)

Read stdout and stderr of subprocess and return it trimmed in a struct with :err and :out containing the output as string.
This will also return the exit code under the :status key.

(exists? path)

Check if the given file or directory exists. (Follows symlinks)

(list-all-files dir &opt into)

List the files in the given directory recursively. Return the paths to all files found, relative to the current working directory if the given path is a relative path, or as an absolute path otherwise.

(make-new-file file-path &opt mode)

Create and open a file, creating all the directories leading to the file if they do not exist, and return it. By default, open as a writable file (mode is `:w`).

(rm path)

Remove a directory and all sub directories recursively.

(scan-directory dir func)

Scan a directory recursively, applying the given function on all files and directories in a depth-first manner. This function has no effect if the directory does not exist.

(tarray/buffer array|size)

Return typed array buffer or create a new buffer.

(tarray/copy-bytes src sindex dst dindex &opt count)

Copy count elements (default 1) of src array from index sindex to dst array at position dindex memory can overlap.

(tarray/length array|buffer)

Return typed array or buffer size.

(tarray/new type size &opt stride offset tarray|buffer)

Create new typed array.

(tarray/properties array)

Return typed array properties as a struct.

(tarray/slice tarr &opt start end)

Takes a slice of a typed array from start to end. The range is half open, [start, end). Indexes can also be negative, indicating indexing from the end of the end of the typed array. By default, start is 0 and end is the size of the typed array. Returns a new janet array.

(tarray/swap-bytes src sindex dst dindex &opt count)

Swap count elements (default 1) between src array from index sindex and dst array at position dindex memory can overlap.

(all-tasks tasker &opt detailed)

Get an array of all task ids for which there is still data on disk. If `detailed` is truthy, return full task metadata instead of ids.

(cancel-task tasker task-id)

Cancel a queued or running task.

(close-queues tasker)

Prevent any tasks from being added to queues. When an executor finishes it's current job, if there are any, it will terminate. When all executors complete, the call to `run-executors` will complete.

Default expiration time (1 day)

Default task priority

Default location of task records

Name of the file for logging errors

Maximum allowed priority (lower priority tasks will execute first)

Minimum allowed priority (lower priority tasks will execute first)

(new-tasker &opt task-directory queues queue-size)

Create queues and various settings to run tasks. Create a new tasker table.

Name of the file for general logging

(queue-task tasker argv &opt note priority qname timeout expiration input)

Add a task specification to a queue. Supply an argv string array that will be used to invoke s a subprocess. The optional `note` parameter is just a textual note for task trackingv. The `priority` parameter should be an integer between 0 and 9 inclusive, default is 4. Lower priority jobs in the same queue will be executed by higher priority. Use input to pass in generic, unstructured input to a task.

(run-cleanup tasker)

Delete old expired jobs saved on disk

(run-executors tasker &opt workers-per-queue pre-task post-task)

Start a number of executors to run tasks as with `tasker/spawn-executors`, and then wait for all executors to complete.

(spawn-executors tasker &opt qnames workers-per-queue pre-task post-task)

Start a number of executors to run tasks. Tasks can be added to a queue by calling queue-task. A single tasker object can make multiple calls to spawn-executors.

A tuple of all possible statuses that a task can have.

(task-file tasker task-id &opt file-name)

Get a log file for a path. By default, will get a path to out.log.

Name of the task metadata file

(task-status tasker task-id)

Look up the status of a given task by id.

(add-loader)

Adds the custom template loader to Janet's module/loaders and update module/paths.

Base environment for rendering

(compile str)

Compile a Temple template into a function which will return a
rendered buffer.

The resulting function should receive the template arguments in the
&keys format.

(create source &opt where)

Compile a template string into a function. Optionally provide a location where the source is from to improve debugging. Returns the template function.

(assert x &opt e)

Override's the default assert with some nice error handling.

(assert-docs path)

Assert that all symbols, when module on the path is required,
have proper doc string

(assert-error msg & forms)

Test passes if forms error.

(assert-no-error msg & forms)

Test passes if forms do not error.

(assert-not x &opt e)

Invert assert.

(capture-stderr & body)

Runs the form and captures stderr. Returns tuple with result of the form
and a string with captured stderr.

(capture-stdout & body)

Runs the form and captures stdout. Returns tuple with result of the form
and a string with captured stdout.

(end-suite)

Ends test suite, prints summary and exits if any have failed.

(start-suite &opt name)

Starts test suite.

(suppress-stderr & body)

Suppreses stdout from the body

(suppress-stdout & body)

Suppreses stdout from the body

(timeit form &opt tag)

Time the execution of `form` using `os/clock` before and after,
and print the result to stdout. returns: result of executing `form`.
Uses `tag` (default "Elapsed time:") to tag the printout.

(utf8/decode-rune buf &opt start)

Read a UTF-8 encoded Unicode codepoint from the buffer which starts at the given index. Returns a tuple [value width], where width = number of bytes consumed. If at the end of buffer or the buffer contains malformed UTF-8, returns [nil 0].

(utf8/encode-rune rune &opt buf)

Encode a Unicode codepoint into the end of a buffer.

(utf8/prefix->width c)

Given the first byte in an UTF-8 sequence, get the number of bytes that the codepoint sequence takes up, including the prefix byte.

(zip/add-bytes writer path data &opt comment flags)

Add a byte sequence to the zip writer.

(zip/add-file writer path filename &opt comment flags)

Add a file to the zip writer.

(zip/compress bytes &opt level into)

Compress data and write to a buffer. Different compression levels can be used - higher compression levels trade smaller output with longer compression times. Returns `into`. If `into` not provided, a new buffer is created.

(zip/decompress bytes &opt into)

Decompress data and write to a buffer. If an `into` buffer is not provided, a new buffer will be created.

(zip/extract reader idx-or-filename &opt into flags)

Extract a file from the zip archive, either to memory or to a file on disk.

(zip/file-directory? reader idx)

Check if a file index is a directory.

(zip/file-encrypted? reader idx)

Check if a file is encrypted inside an archive.

(zip/file-supported? reader idx)

Check if a file is supported with this verstion of miniz.

(zip/get-filename reader idx)

Convert a file index index in the archive to a filename.

(zip/locate-file reader path &opt comment flags)

Get the index of a particular filename in the archive.

(zip/read-bytes bytes &opt flags)

Read a byte sequence as a zip archive. Returns a new zip reader.

(zip/read-file filename &opt flags)

Read a file as a zip archive. Returns a new zip reader.

(zip/reader-close reader)

Close a reader and free related memory.

(zip/reader-count reader)

Get the number of files inside the zip archive. The files can be indexed 

(zip/stat reader idx)

Get stat information of file. Returns a new struct with the following fields:

* :index - integer index in master directory
* :version-made-by - zip verstion
* :version-needed - zip version needed to unzip
* :bit-flag
* :method - compression method
* :time - file time
* :crc32 - checksum of file contents
* :comp-size - size of file when compressed
* :uncomp-size - size of file when uncompressed
* :filename
* :comment
* :internal-attr
* :external-attr

(zip/version)

Get the version string of the underlying miniz library.

(zip/write-buffer)

Create a new zip archive writer that write to memory.

(zip/write-file dest-path)

Create a new zip archive writer that will write into an archive file.

(zip/writer-close writer)

Close a ZipWriter.

(zip/writer-finalizer writer)

Finalize a writer, writing any zip files to disk. Return the writer.