Macaw.Data.Operations (macaw_data v0.5.3)

macaw_data's own package of operations, the registry, and running them (spec/04).

The package. __members__/0 is the table operations of spec/04 §4 and the statistics of §5, each a module implementing Macaw.Data.Transform or Macaw.Data.Aggregate.

The registry (registry/1) is built from an explicit list of packages, this one always among them: default closed, and a module that is merely loaded is not reachable (spec/04 §2).

Running. validate/3 checks a list of nodes against the registry and the context, answering every fault at once; apply/4 runs checked nodes in order over a table; aggregate/4 reduces values by a named aggregate; outputs/4 names the columns after every node. Each fault is {path, reason} (spec/04 §3.1) and format_error/1 words one.

iex> alias Macaw.Data.Operations
iex> registry = Operations.registry([Macaw.Data.Test.Ops])
iex> {:ok, table} = Operations.apply(registry, [%{op: "double", field: "v"}], [%{v: 2}], %{})
iex> Macaw.Data.Table.rows(table)
[%{:v => 2, "double" => 4}]
iex> Operations.validate(registry, [%{op: "doubel"}], %{})
{:error, [{[0, "op"], {:unknown, :transform, "doubel"}}]}

Summary

Types

fault()

A fault: the path (a node's index, then its key) and the reason (spec/04 §3.1).

Functions

__members__()

The modules of macaw_data's package: its table operations and statistics.

aggregate(registry, name)

The aggregate named name, by spelling: {:ok, module} or :error.

aggregate(registry, name, values, options)

The value of values by the aggregate named name, its options checked against its declaration and every nil reading dropped: {:ok, value} or {:error, faults}, each fault at its option's key ([] for the name itself).

aggregates(registry)

Every aggregate's name, sorted.

apply(registry, nodes, source, context \\ %{})

The nodes run in order over source, a Macaw.Data.Table or anything Macaw.Data.Table.from/2 reads, each step's table the next one's input: {:ok, table}, or validate/3's {:error, faults} before any step runs. A step whose reading is wrong only at run time raises ArgumentError naming the step (spec/04 §3.1).

apply!(registry, nodes, source, context \\ %{})

As apply/4, raising ArgumentError naming every fault.

columns(table)

A table's columns in order, each with its type: what outputs/2 is given.

digest(registry)

A digest of every member's name and module, which a compile cache keys by.

format_error(arg)

One fault as a sentence.

outputs(registry, nodes, columns, context \\ %{})

The columns after every node, by each transform's outputs/2, over input columns ([{name, type}]): {:ok, columns} or validate/3's {:error, faults}.

packages(registry)

The registry's packages, this one first.

registry(packages \\ [])

The registry of this package and packages, in order, each once (spec/04 §2). Raises ArgumentError for a module that is not a package, a member implementing no behavior, a name two members of one behavior share, and an aggregate declaring a step's key.

same?(a, b)

Whether two readings are one value: equal, or an atom and a string spelling it, so a category is one value whichever spelling a row or a node gives it (spec/04 §4.1).

step_keys()

The keys of the steps that name an aggregate, which an aggregate may not declare.

table(rows, columns)

A table of rows with columns, in their order and of their types, each read from a row by either spelling (Macaw.Data.Table.get/2): how a member that works on rows answers the table its outputs/2 names.

transform(registry, name)

The transform named name, by spelling: {:ok, module} or :error.

transforms(registry)

Every transform's name, sorted.

validate(registry, nodes, context)

Every node checked (spec/04 §3.1): {:ok, checked}, each node's options by their strings with defaults filled in, enum values their atoms, a named aggregate its module and a frame-bound "plot" the frame's width in whole pixels; or {:error, faults}, every fault of every node, ordered by path.