303 lines
9.1 KiB
Elixir
303 lines
9.1 KiB
Elixir
defmodule RDF.PrefixMap do
|
|
@moduledoc """
|
|
A mapping a prefix atoms to IRI namespaces.
|
|
|
|
`RDF.PrefixMap` implements the `Enumerable` protocol.
|
|
"""
|
|
|
|
defstruct map: %{}
|
|
|
|
alias RDF.IRI
|
|
|
|
@doc """
|
|
Creates an empty `RDF.PrefixMap`.
|
|
"""
|
|
def new(), do: %__MODULE__{}
|
|
|
|
@doc """
|
|
Creates a new `RDF.PrefixMap`.
|
|
|
|
The prefix mappings can be passed as keyword lists or maps.
|
|
The keys for the prefixes can be given as atoms or strings and will be normalized to atoms.
|
|
The namespaces can be given as `RDF.IRI`s or strings and will be normalized to `RDF.IRI`s.
|
|
"""
|
|
def new(map)
|
|
|
|
def new(%__MODULE__{} = prefix_map), do: prefix_map
|
|
|
|
def new(map) when is_map(map) do
|
|
%__MODULE__{map: Map.new(map, &normalize/1)}
|
|
end
|
|
|
|
def new(map) when is_list(map) do
|
|
map |> Map.new() |> new()
|
|
end
|
|
|
|
defp normalize({prefix, %IRI{} = namespace}) when is_atom(prefix),
|
|
do: {prefix, namespace}
|
|
|
|
defp normalize({prefix, namespace}) when is_binary(prefix),
|
|
do: normalize({String.to_atom(prefix), namespace})
|
|
|
|
defp normalize({prefix, namespace}) when is_binary(namespace),
|
|
do: normalize({prefix, IRI.new(namespace)})
|
|
|
|
defp normalize({prefix, namespace}) when is_atom(namespace) do
|
|
if RDF.Vocabulary.Namespace.vocabulary_namespace?(namespace) do
|
|
normalize({prefix, apply(namespace, :__base_iri__, [])})
|
|
else
|
|
raise ArgumentError,
|
|
"Invalid prefix mapping for #{inspect(prefix)}, #{inspect(namespace)} is not a vocabulary namespace"
|
|
end
|
|
end
|
|
|
|
defp normalize({prefix, namespace}),
|
|
do:
|
|
raise(ArgumentError, "Invalid prefix mapping: #{inspect(prefix)} => #{inspect(namespace)}")
|
|
|
|
@doc """
|
|
Adds a prefix mapping to the given `RDF.PrefixMap`.
|
|
|
|
Unless a mapping of the given prefix to a different namespace already exists,
|
|
an ok tuple is returned, other an error tuple.
|
|
"""
|
|
def add(prefix_map, prefix, namespace)
|
|
|
|
def add(%__MODULE__{map: map}, prefix, %IRI{} = namespace) when is_atom(prefix) do
|
|
if conflicts?(map, prefix, namespace) do
|
|
{:error, "prefix #{inspect(prefix)} is already mapped to another namespace"}
|
|
else
|
|
{:ok, %__MODULE__{map: Map.put(map, prefix, namespace)}}
|
|
end
|
|
end
|
|
|
|
def add(%__MODULE__{} = prefix_map, prefix, namespace) do
|
|
with {prefix, namespace} = normalize({prefix, namespace}) do
|
|
add(prefix_map, prefix, namespace)
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Adds a prefix mapping to the given `RDF.PrefixMap` and raises an exception in error cases.
|
|
"""
|
|
def add!(prefix_map, prefix, namespace) do
|
|
with {:ok, new_prefix_map} <- add(prefix_map, prefix, namespace) do
|
|
new_prefix_map
|
|
else
|
|
{:error, error} -> raise error
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Merges two `RDF.PrefixMap`s.
|
|
|
|
The second prefix map can also be given as any structure which can converted
|
|
to a `RDF.PrefixMap` via `new/1`.
|
|
|
|
If the prefix maps can be merged without conflicts, that is there are no
|
|
prefixes mapped to different namespaces an `:ok` tuple is returned.
|
|
Otherwise an `:error` tuple with the list of prefixes with conflicting
|
|
namespaces is returned.
|
|
|
|
See also `merge/3` which allows you to resolve conflicts with a function.
|
|
"""
|
|
def merge(prefix_map1, prefix_map2)
|
|
|
|
def merge(%__MODULE__{map: map1}, %__MODULE__{map: map2}) do
|
|
with [] <- merge_conflicts(map1, map2) do
|
|
{:ok, %__MODULE__{map: Map.merge(map1, map2)}}
|
|
else
|
|
conflicts -> {:error, conflicts}
|
|
end
|
|
end
|
|
|
|
def merge(%__MODULE__{} = prefix_map, other_prefixes) do
|
|
merge(prefix_map, new(other_prefixes))
|
|
rescue
|
|
FunctionClauseError ->
|
|
raise ArgumentError, "#{inspect(other_prefixes)} is not convertible to a RDF.PrefixMap"
|
|
end
|
|
|
|
@doc """
|
|
Merges two `RDF.PrefixMap`s, resolving conflicts through the given `conflict_resolver` function.
|
|
|
|
The second prefix map can also be given as any structure which can converted
|
|
to a `RDF.PrefixMap` via `new/1`.
|
|
|
|
The given function will be invoked when there are conflicting mappings of
|
|
prefixes to different namespaces; its arguments are `prefix`, `namespace1`
|
|
(the namespace for the prefix in the first prefix map),
|
|
and `namespace2` (the namespace for the prefix in the second prefix map).
|
|
The value returned by the `conflict_resolver` function is used as the namespace
|
|
for the prefix in the resulting prefix map.
|
|
Non-`RDF.IRI` values will be tried to be converted to converted to `RDF.IRI`
|
|
via `RDF.IRI.new` implicitly.
|
|
|
|
If a conflict can't be resolved, the provided function can return `nil`.
|
|
This will result in an overall return of an `:error` tuple with the list of
|
|
prefixes for which the conflict couldn't be resolved.
|
|
|
|
If everything could be merged, an `:ok` tuple is returned.
|
|
|
|
"""
|
|
def merge(prefix_map1, prefix_map2, conflict_resolver)
|
|
|
|
def merge(%__MODULE__{map: map1}, %__MODULE__{map: map2}, conflict_resolver)
|
|
when is_function(conflict_resolver) do
|
|
conflict_resolution = fn prefix, namespace1, namespace2 ->
|
|
case conflict_resolver.(prefix, namespace1, namespace2) do
|
|
nil -> :conflict
|
|
result -> IRI.new(result)
|
|
end
|
|
end
|
|
|
|
with resolved_merge = Map.merge(map1, map2, conflict_resolution),
|
|
[] <- resolved_merge_rest_conflicts(resolved_merge) do
|
|
{:ok, %__MODULE__{map: resolved_merge}}
|
|
else
|
|
conflicts -> {:error, conflicts}
|
|
end
|
|
end
|
|
|
|
def merge(%__MODULE__{} = prefix_map1, prefix_map2, conflict_resolver)
|
|
when is_function(conflict_resolver) do
|
|
merge(prefix_map1, new(prefix_map2), conflict_resolver)
|
|
end
|
|
|
|
def merge(prefix_map1, prefix_map2, nil), do: merge(prefix_map1, prefix_map2)
|
|
|
|
defp resolved_merge_rest_conflicts(map) do
|
|
Enum.reduce(map, [], fn
|
|
{prefix, :conflict}, conflicts -> [prefix | conflicts]
|
|
_, conflicts -> conflicts
|
|
end)
|
|
end
|
|
|
|
defp merge_conflicts(map1, map2) do
|
|
Enum.reduce(map1, [], fn {prefix, namespace}, conflicts ->
|
|
if conflicts?(map2, prefix, namespace) do
|
|
[prefix | conflicts]
|
|
else
|
|
conflicts
|
|
end
|
|
end)
|
|
end
|
|
|
|
defp conflicts?(map, prefix, namespace) do
|
|
(existing_namespace = Map.get(map, prefix)) && existing_namespace != namespace
|
|
end
|
|
|
|
@doc """
|
|
Merges two `RDF.PrefixMap`s and raises an exception in error cases.
|
|
|
|
See `merge/2` and `merge/3` for more information on merging prefix maps.
|
|
"""
|
|
def merge!(prefix_map1, prefix_map2, conflict_resolver \\ nil) do
|
|
with {:ok, new_prefix_map} <- merge(prefix_map1, prefix_map2, conflict_resolver) do
|
|
new_prefix_map
|
|
else
|
|
{:error, conflicts} ->
|
|
raise "conflicting prefix mappings: #{
|
|
conflicts |> Stream.map(&inspect/1) |> Enum.join(", ")
|
|
}"
|
|
end
|
|
end
|
|
|
|
@doc """
|
|
Deletes a prefix mapping from the given `RDF.PrefixMap`.
|
|
"""
|
|
def delete(prefix_map, prefix)
|
|
|
|
def delete(%__MODULE__{map: map}, prefix) when is_atom(prefix) do
|
|
%__MODULE__{map: Map.delete(map, prefix)}
|
|
end
|
|
|
|
def delete(prefix_map, prefix) when is_binary(prefix) do
|
|
delete(prefix_map, String.to_atom(prefix))
|
|
end
|
|
|
|
@doc """
|
|
Drops the given `prefixes` from the given `prefix_map`.
|
|
|
|
If `prefixes` contains prefixes that are not in `prefix_map`, they're simply ignored.
|
|
"""
|
|
def drop(prefix_map, prefixes)
|
|
|
|
def drop(%__MODULE__{map: map}, prefixes) do
|
|
%__MODULE__{
|
|
map:
|
|
Map.drop(
|
|
map,
|
|
Enum.map(prefixes, fn
|
|
prefix when is_binary(prefix) -> String.to_atom(prefix)
|
|
other -> other
|
|
end)
|
|
)
|
|
}
|
|
end
|
|
|
|
@doc """
|
|
Returns the namespace for the given prefix in the given `RDF.PrefixMap`.
|
|
|
|
Returns `nil`, when the given `prefix` is not present in `prefix_map`.
|
|
"""
|
|
def namespace(prefix_map, prefix)
|
|
|
|
def namespace(%__MODULE__{map: map}, prefix) when is_atom(prefix) do
|
|
Map.get(map, prefix)
|
|
end
|
|
|
|
def namespace(prefix_map, prefix) when is_binary(prefix) do
|
|
namespace(prefix_map, String.to_atom(prefix))
|
|
end
|
|
|
|
@doc """
|
|
Returns the prefix for the given namespace in the given `RDF.PrefixMap`.
|
|
|
|
Returns `nil`, when the given `namespace` is not present in `prefix_map`.
|
|
"""
|
|
def prefix(prefix_map, namespace)
|
|
|
|
def prefix(%__MODULE__{map: map}, %IRI{} = namespace) do
|
|
Enum.find_value(map, fn {prefix, ns} -> ns == namespace && prefix end)
|
|
end
|
|
|
|
def prefix(prefix_map, namespace) when is_binary(namespace) do
|
|
prefix(prefix_map, IRI.new(namespace))
|
|
end
|
|
|
|
@doc """
|
|
Returns whether the given prefix exists in the given `RDF.PrefixMap`.
|
|
"""
|
|
def has_prefix?(prefix_map, prefix)
|
|
|
|
def has_prefix?(%__MODULE__{map: map}, prefix) when is_atom(prefix) do
|
|
Map.has_key?(map, prefix)
|
|
end
|
|
|
|
def has_prefix?(prefix_map, prefix) when is_binary(prefix) do
|
|
has_prefix?(prefix_map, String.to_atom(prefix))
|
|
end
|
|
|
|
@doc """
|
|
Returns all prefixes from the given `RDF.PrefixMap`.
|
|
"""
|
|
def prefixes(%__MODULE__{map: map}) do
|
|
Map.keys(map)
|
|
end
|
|
|
|
@doc """
|
|
Returns all namespaces from the given `RDF.PrefixMap`.
|
|
"""
|
|
def namespaces(%__MODULE__{map: map}) do
|
|
Map.values(map)
|
|
end
|
|
|
|
defimpl Enumerable do
|
|
def reduce(%RDF.PrefixMap{map: map}, acc, fun), do: Enumerable.reduce(map, acc, fun)
|
|
|
|
def member?(%RDF.PrefixMap{map: map}, mapping), do: Enumerable.member?(map, mapping)
|
|
def count(%RDF.PrefixMap{map: map}), do: Enumerable.count(map)
|
|
def slice(_prefix_map), do: {:error, __MODULE__}
|
|
end
|
|
end
|