donut.system — party.donut/system 0.0.202

*system* clj/s

alias-component clj/s

(alias-component component-id)

creates a component that just provides an instance defined elsewhere in the system

assoc-many clj/s

(assoc-many m assocs)

(assoc-many m prefix assocs)

(assoc-many {} {[:foo :bar] :bux}) => {:foo {:bar :bux}

cache-component clj/s

(cache-component {:keys [:donut.system/start :donut.system/stop]
                  :as component-def}
                 &
                 [cache-key])

cache component instance so that it's preserved between start/stop. takes as its argument a component def which must at least have a ::start signal handler that's a function. Useful for e.g. not restarting a threadpool for every test.

::stop signal won't fire unless instance is removed from component-instance-cache

instances are cached by [group-name component-name cache-key]

Component clj/s

component-dependencies clj/s

(component-dependencies system component-id)

Set of all references to other components

component-doc clj/s

(component-doc system component-id)

component-id clj/s

(component-id ref)

component-ids clj/s

(component-ids system & [facet-key])

component-instance-cache clj/s

component? clj/s

ComponentGroup clj/s

Components are grouped. This theoretically helps if publishing a component library. It also helps when creating multiple instances of the same collection of components because components are allowed to have local refs. See TODO for more details.

ComponentGroupName clj/s

ComponentGroups clj/s

ComponentId clj/s

ComponentLike clj/s

Component-like data shows up in ::defs, ::resolved-defs, and ::instances. None of these are the component per se, but they are the way the component manifests in that context.

ComponentName clj/s

ComponentSelection clj/s

default-signals clj/s

which graph sort order to follow to apply signal, and where to put result

dependency-pairs clj/s

(dependency-pairs system)

Pairs of [A B], where A is component that depends on B

describe-component clj/s

(describe-component system component-id)

describe-components clj/s

(describe-components system)

describe-system clj/s

(describe-system system)

DonutRef clj/s

DonutSystem clj/s

flat-assoc-in clj/s

(flat-assoc-in m p v)

flat-get-in clj/s

(flat-get-in m p)

Graph clj/s

Graphs are used to specify component dependency order and signal application order.

group-ref-exception clj/s

(group-ref-exception _system
                     referencing-component-id
                     referenced-component-group-name)

group-ref? clj/s

(group-ref? ref)

init-system clj/s

(init-system maybe-system signal-name)

instance clj/s

(instance system)

(instance system [component-group component-name :as component-id])

Get a specific component instance. With no arguments returns set of all component names.

local-ref clj/s

(local-ref k)

LocalRef clj/s

MinComponent clj/s

Check that at least one of the signals is present

named-system clj/s multimethod

A way to name different system, e.g. :test, :dev, :prod, etc.

OrderGraphs clj/s

Topsorted and reverse-topsorted graphs are generated once when a system is initialized and assoc'c into the system. These graphs are used when applying signals.

Plugin clj/s

PluginSystem clj/s

Ref clj/s

ref clj/s

(ref k)

ref-exception clj/s

(ref-exception _system referencing-component-id referenced-component-id)

ref-key clj/s

ref-type clj/s

ref? clj/s

RefKey clj/s

Registry clj/s

registry-instance clj/s

(registry-instance system registry-key)

Returns a component instance for a given key, rather than a given path. Relies on ::registry mapping registry keys to component paths.

For cases where libraries want to use component instances without having to rely on hard-coded paths.

required-component clj/s

A placeholder component used to communicate that a component needs to be provided.

resolved clj/s

(resolved {:keys [:donut.system/component-id :donut.system/resolved-defs]})

resume clj/s

(resume system)

select-components clj/s

(select-components system component-keys)

You can scope down what component keys to use. In subsequent interactions with a system, use only those component keys.

signal clj/s

(signal system signal-name)

SignalConfig clj/s

The set of signals your system can respond to is configurable. To apply a signal, the system needs to know in what order components should be traversed.

start clj/s

(start config-name)

(start config-name component-def-overrides)

(start config-name component-def-overrides component-ids)

stop clj/s

(stop system)

stop-failed-system clj/s

(stop-failed-system)

(stop-failed-system e)

Will attempt to stop a system that threw an exception when starting

strk clj/s

(strk & xs)

Like str but with keywords

subsystem-component clj/s

(subsystem-component subsystem & [imports])

Decorates a subsystem so that it can respond to signals when embedded in a parent component.

suspend clj/s

(suspend system)

system clj/s

(system sconf)

(system sconf component-def-overrides)

(system sconf component-def-overrides selected-components)

specify a system or a system named registered with config, and optionally provide overrides

system-fixture clj/s

(system-fixture system)

To be used with use-fixtures

system? clj/s

update-many clj/s

(update-many m update-many-with-map)

Map of many paths to update, and their update fns

validate-instance-with-malli clj/s

(validate-instance-with-malli {:keys [:donut.system/instance ->validation
                                      :donut.system/system]})

helper function for validating component instances with malli if a schema is present.

with-*system* clj/s macro

(with-*system* system & body)

Start a system and bind it to system. Stop system after body.