defmodule CTE.Adapter.Memory do
@moduledoc """
Basic implementation of the CTE, using the memory for persisting the models. Adapter provided as a convenient way of using CTE in tests or during the development
"""
use CTE.Adapter
@doc false
def descendants(pid, ancestor, opts) do
GenServer.call(pid, {:descendants, ancestor, opts})
end
@doc false
def ancestors(pid, descendant, opts) do
GenServer.call(pid, {:ancestors, descendant, opts})
end
@doc false
def insert(pid, leaf, ancestor, opts) do
GenServer.call(pid, {:insert, leaf, ancestor, opts})
end
@doc """
Delete a leaf or a subtree.
To delete a leaf node set the limit option to: 1, and in this particular case
all the nodes that reference the leaf will be assigned to the leaf's immediate ancestor
If limit is 0, then the leaf and its descendants will be deleted
"""
def delete(pid, leaf, opts \\ [limit: 1])
def delete(pid, leaf, opts) do
leaf? = Keyword.get(opts, :limit, 1) == 1
GenServer.call(pid, {:delete, leaf, leaf?, opts})
end
@doc false
def move(pid, leaf, ancestor, opts) do
GenServer.call(pid, {:move, leaf, ancestor, opts})
end
@doc false
def tree(pid, leaf, opts) do
GenServer.call(pid, {:tree, leaf, opts})
end
@doc false
def handle_call({:tree, leaf, opts}, _from, config) do
%CTE{paths: paths, nodes: nodes} = config
descendants_opts = [itself: true] ++ Keyword.take(opts, [:depth])
descendants = _descendants(leaf, descendants_opts, config)
subtree =
Enum.filter(paths, fn
[ancestor, descendant, _] ->
ancestor in descendants && descendant in descendants
end)
nodes =
Enum.reduce(subtree, %{}, fn [ancestor, descendant, _depth], acc ->
Map.merge(acc, %{
ancestor => Map.get(nodes, ancestor),
descendant => Map.get(nodes, descendant)
})
end)
{:reply, {:ok, %{paths: subtree, nodes: nodes}}, config}
end
@doc false
def handle_call({:delete, leaf, true, _opts}, _from, %CTE{paths: paths} = config) do
leaf_parent =
case _ancestors(leaf, [itself: false], config) do
[leaf_parent | _ancestors] -> leaf_parent
_ -> nil
end
paths =
paths
|> Enum.reduce([], fn
[_leaf, ^leaf, _], acc -> acc
[^leaf, descendant, _depth], acc -> [[leaf_parent, descendant, 1] | acc]
p, acc -> [p | acc]
end)
|> Enum.reverse()
{:reply, :ok, %{config | paths: paths}}
end
@doc false
def handle_call({:delete, leaf, _subtree, opts}, _from, %{paths: paths} = config) do
opts = Keyword.put(opts, :itself, true)
descendants = _descendants(leaf, opts, config) || []
paths =
Enum.filter(paths, fn [_ancestor, descendant, _] ->
descendant not in descendants
end)
{:reply, :ok, %{config | paths: paths}}
end
@doc false
def handle_call({:move, leaf, ancestor, _opts}, _from, config) do
%CTE{paths: paths} = config
ex_ancestors = _ancestors(leaf, [itself: true], config)
{descendants_paths, _} = descendants_collector(leaf, [itself: true], config)
descendants = Enum.map(descendants_paths, fn [_, descendant, _] -> descendant end)
paths_with_leaf =
paths
|> Enum.filter(fn [ancestor, descendant, _] ->
ancestor in ex_ancestors and descendant in descendants and ancestor != descendant
end)
paths_without_leaf = Enum.filter(paths, &(&1 not in paths_with_leaf))
{new_ancestors_paths, _} =
ancestors_collector(ancestor, [itself: true], %{config | paths: paths_without_leaf})
new_paths =
for [ancestor, _, super_tree_depth] <- [[leaf, leaf, -1] | new_ancestors_paths],
[_, descendant, subtree_depth] <- descendants_paths,
into: [] do
[ancestor, descendant, super_tree_depth + subtree_depth + 1]
end
|> Enum.reverse()
{:reply, :ok, %{config | paths: paths_without_leaf ++ new_paths}}
end
@doc false
def handle_call({:insert, leaf, ancestor, opts}, _from, config) do
case _insert(leaf, ancestor, opts, config) do
{:ok, new_paths, config} -> {:reply, {:ok, new_paths}, config}
err -> {:reply, {:error, err}, config}
end
end
@doc false
def handle_call({:ancestors, descendant, opts}, _from, config) do
result =
_ancestors(descendant, opts, config)
|> Enum.reverse()
{:reply, {:ok, result}, config}
end
@doc false
def handle_call({:descendants, ancestor, opts}, _from, config) do
result =
_descendants(ancestor, opts, config)
|> Enum.reverse()
{:reply, {:ok, result}, config}
end
@doc false
defp _descendants(ancestor, opts, config) do
descendants_collector(ancestor, opts, config)
|> depth(opts, config)
|> selected(opts, config)
end
@doc false
defp descendants_collector(ancestor, opts, config) do
mapper = fn paths -> Enum.map(paths, fn [_, descendant, _] -> descendant end) end
fn path, {acc_paths, _mapper, size} = acc, itself? ->
case path do
[^ancestor, ^ancestor, _] when not itself? ->
acc
[^ancestor, _descendant, _depth] = descendants ->
{[descendants | acc_paths], mapper, size + 1}
_ ->
acc
end
end
|> _find_leaves(opts, config)
end
@doc false
defp _ancestors(descendant, opts, config) do
ancestors_collector(descendant, opts, config)
|> depth(opts, config)
|> selected(opts, config)
end
@doc false
defp ancestors_collector(descendant, opts, config) do
mapper = fn paths -> Enum.map(paths, fn [ancestor, _, _] -> ancestor end) end
fn path, {acc_paths, _mapper, size} = acc, itself? ->
case path do
[^descendant, ^descendant, _] when not itself? ->
acc
[_ancestor, ^descendant, _depth] = ancestors ->
{[ancestors | acc_paths], mapper, size + 1}
_ ->
acc
end
end
|> _find_leaves(opts, config)
end
@doc false
defp _insert(leaf, ancestor, _opts, config) do
%CTE{nodes: nodes, paths: paths} = config
case Map.has_key?(nodes, ancestor) do
true ->
{leaf_new_ancestors, _} = ancestors_collector(ancestor, [itself: true], config)
new_paths =
leaf_new_ancestors
|> Enum.reduce([[leaf, leaf, 0]], fn [ancestor, _, depth], acc ->
[[ancestor, leaf, depth + 1] | acc]
end)
acc_paths = paths ++ new_paths
config = %{config | paths: acc_paths}
{:ok, new_paths, config}
_ ->
{:error, :no_ancestor, config}
end
end
@doc false
defp _find_leaves(fun, opts, %CTE{paths: paths}) do
itself? = Keyword.get(opts, :itself, false)
limit = Keyword.get(opts, :limit, 0)
{leaves_paths, mapper, _size} =
paths
|> Enum.reduce_while({[], & &1, 0}, fn path, acc ->
{_, _, sz} = dsz = fun.(path, acc, itself?)
if limit == 0 or sz < limit, do: {:cont, dsz}, else: {:halt, dsz}
end)
{leaves_paths, mapper}
end
@doc false
defp depth({leaves_paths, mapper}, opts, _config) do
leaves_paths =
if depth = Keyword.get(opts, :depth) do
leaves_paths
|> Enum.filter(fn [_, _, depth_] -> depth_ <= max(depth, 0) end)
else
leaves_paths
end
{leaves_paths, mapper}
end
@doc false
defp selected({leaves_paths, mapper}, opts, %CTE{nodes: nodes}) do
leaves = mapper.(leaves_paths)
if Keyword.get(opts, :nodes, false) do
Enum.map(leaves, &Map.get(nodes, &1))
else
leaves
end
end
end
