jsonld-ex/lib/json/ld/compaction.ex
2017-03-22 00:35:05 +01:00

550 lines
27 KiB
Elixir

defmodule JSON.LD.Compaction do
@moduledoc nil
import JSON.LD.Utils
alias JSON.LD.Context
def compact(input, context, options \\ %JSON.LD.Options{}) do
with options = JSON.LD.Options.new(options),
active_context = JSON.LD.context(context),
inverse_context = Context.inverse(active_context),
expanded = JSON.LD.expand(input, options)
do
result =
case do_compact(expanded, active_context, inverse_context, nil, options.compact_arrays) do
[] ->
%{}
result when is_list(result) ->
%{compact_iri("@graph", active_context, inverse_context) => result}
result ->
result
end
if Context.empty?(active_context),
do: result,
else: Map.put(result, "@context", context["@context"] || context)
end
end
defp do_compact(element, active_context, inverse_context, active_property,
compact_arrays \\ true)
# 1) If element is a scalar, it is already in its most compact form, so simply return element.
defp do_compact(element, _, _, _, _)
when is_binary(element) or is_number(element) or is_boolean(element),
do: element
# 2) If element is an array
defp do_compact(element, active_context, inverse_context, active_property, compact_arrays)
when is_list(element) do
result = Enum.reduce(element, [], fn (item, result) ->
case do_compact(item, active_context, inverse_context, active_property, compact_arrays) do
nil -> result
compacted_item -> [compacted_item | result]
end
end) |> Enum.reverse
if compact_arrays and length(result) == 1 and
is_nil((term_def = active_context.term_defs[active_property]) && term_def.container_mapping) do
List.first(result)
else
result
end
end
# 3) Otherwise element is a JSON object.
defp do_compact(element, active_context, inverse_context, active_property, compact_arrays)
when is_map(element) do
# 4)
if (Map.has_key?(element, "@value") or Map.has_key?(element, "@id")) and
scalar?(result = compact_value(element, active_context, inverse_context, active_property)) do
result
else
# 5)
inside_reverse = active_property == "@reverse"
# 6) + 7)
element
|> Enum.sort_by(fn {expanded_property , _} -> expanded_property end)
|> Enum.reduce(%{}, fn ({expanded_property, expanded_value}, result) ->
cond do
# 7.1)
expanded_property in ~w[@id @type] ->
# 7.1.1)
compacted_value =
if is_binary(expanded_value) do
compact_iri(expanded_value, active_context, inverse_context, nil,
expanded_property == '@type')
# 7.1.2)
else
# 7.1.2.1)
# TODO: RDF.rb calls also Array#compact
if(is_list(expanded_value),
do: expanded_value,
else: [expanded_value])
# 7.1.2.2)
|> Enum.reduce([], fn (expanded_type, compacted_value) ->
compacted_value ++
[compact_iri(expanded_type, active_context, inverse_context, nil, true)]
end)
# 7.1.2.3)
|> case(do: (
[compacted_value] -> compacted_value
compacted_value -> compacted_value))
end
# 7.1.3)
alias = compact_iri(expanded_property, active_context, inverse_context, nil, true)
# 7.1.4)
Map.put(result, alias, compacted_value)
# 7.2)
expanded_property == "@reverse" ->
# 7.2.1)
compacted_value = do_compact(expanded_value, active_context, inverse_context, "@reverse")
# 7.2.2)
{compacted_value, result} =
Enum.reduce compacted_value, {%{}, result},
fn ({property, value}, {compacted_value, result}) ->
term_def = active_context.term_defs[property]
# 7.2.2.1)
if term_def.reverse_property do
# 7.2.2.1.1)
if (!compact_arrays or term_def.container_mapping == "@set") and
!is_list(value) do
value = [value]
end
# 7.2.2.1.2) + 7.2.2.1.3)
{compacted_value, merge_compacted_value(result, property, value)}
else
{Map.put(compacted_value, property, value), result}
end
end
# 7.2.3)
unless Enum.empty?(compacted_value) do
# 7.2.3.1)
alias = compact_iri("@reverse", active_context, inverse_context, nil, true)
# 7.2.3.2)
Map.put(result, alias, compacted_value)
else
result
end
# 7.3)
expanded_property == "@index" &&
(term_def = active_context.term_defs[active_property]) &&
term_def.container_mapping == "@index" ->
result
|> IO.inspect(label: "7.3")
# 7.4)
expanded_property in ~w[@index @value @language] ->
# 7.4.1)
alias = compact_iri(expanded_property, active_context, inverse_context, nil, true)
# 7.4.2)
Map.put(result, alias, expanded_value)
true ->
# 7.5)
if expanded_value == [] do
# 7.5.1)
item_active_property =
compact_iri(expanded_property, active_context, inverse_context,
expanded_value, true, inside_reverse)
# 7.5.2)
result = Map.update(result, item_active_property, [], fn
value when not is_list(value) -> [value]
value -> value
end)
end
# 7.6)
Enum.reduce(expanded_value, result, fn (expanded_item, result) ->
# 7.6.1)
item_active_property =
compact_iri(expanded_property, active_context, inverse_context,
expanded_item, true, inside_reverse)
# 7.6.2)
term_def = active_context.term_defs[item_active_property]
container = (term_def && term_def.container_mapping) || nil
# 7.6.3)
value = (is_map(expanded_item) && expanded_item["@list"]) || expanded_item
compacted_item =
do_compact(value, active_context, inverse_context,
item_active_property, compact_arrays)
# 7.6.4)
if list?(expanded_item) do
# 7.6.4.1)
unless is_list(compacted_item),
do: compacted_item = [compacted_item]
# 7.6.4.2)
unless container == "@list" do
# 7.6.4.2.1)
compacted_item = %{
# TODO: Spec fixme? We're setting vocab to true, as RDF.rb does it, but this is not mentioned in the spec
compact_iri("@list", active_context, inverse_context, nil, true) =>
compacted_item}
# 7.6.4.2.2)
if Map.has_key?(expanded_item, "@index") do
compacted_item = Map.put(compacted_item,
compact_iri("@index", active_context, inverse_context),
expanded_item["@index"])
end
# 7.6.4.3)
else
if Map.has_key?(result, item_active_property),
do: raise JSON.LD.CompactionToListOfListsError,
message: "The compacted document contains a list of lists as multiple lists have been compacted to the same term."
end
end
# 7.6.5)
if container in ~w[@language @index] do
map_object = result[item_active_property] || %{}
if container == "@language" and Map.has_key?(compacted_item, "@value"),
do: compacted_item = compacted_item["@value"]
map_key = expanded_item[container]
map_object = merge_compacted_value(map_object, map_key, compacted_item)
Map.put(result, item_active_property, map_object)
# 7.6.6)
else
if !is_list(compacted_item) and (!compact_arrays or
container in ~w[@set @list] or expanded_property in ~w[@list @graph]),
do: compacted_item = [compacted_item]
merge_compacted_value(result, item_active_property, compacted_item)
end
end)
end
end)
end
end
defp merge_compacted_value(map, key, value) do
Map.update map, key, value, fn
old_value when is_list(old_value) and is_list(value) ->
old_value ++ value
old_value when is_list(old_value) ->
old_value ++ [value]
old_value when is_list(value) ->
[old_value | value]
old_value ->
[old_value, value]
end
end
@doc """
IRI Compaction
Details at <https://www.w3.org/TR/json-ld-api/#iri-compaction>
"""
def compact_iri(iri, active_context, inverse_context,
value \\ nil, vocab \\ false, reverse \\ false)
# 1) If iri is null, return null.
def compact_iri(nil, _, _, _, _, _), do: nil
def compact_iri(iri, active_context, inverse_context, value, vocab, reverse) do
# 2) If vocab is true and iri is a key in inverse context:
term = if vocab && Map.has_key?(inverse_context, iri) do
# 2.1) Initialize default language to active context's default language, if it has one, otherwise to @none.
default_language = active_context.default_language || "@none"
# 2.3) Initialize type/language to @language, and type/language value to @null. These two variables will keep track of the preferred type mapping or language mapping for a term, based on what is compatible with value.
type_language = "@language"
type_language_value = "@null"
# 2.2) Initialize containers to an empty array. This array will be used to keep track of an ordered list of preferred container mappings for a term, based on what is compatible with value.
# 2.4) If value is a JSON object that contains the key @index, then append the value @index to containers.
containers = if index?(value), do: ["@index"], else: []
cond do
# 2.5) If reverse is true, set type/language to @type, type/language value to @reverse, and append @set to containers.
reverse ->
containers = containers ++ ["@set"]
type_language = "@type"
type_language_value = "@reverse"
# 2.6) Otherwise, if value is a list object, then set type/language and type/language value to the most specific values that work for all items in the list as follows:
list?(value) ->
# 2.6.1) If @index is a not key in value, then append @list to containers.
if not index?(value),
do: containers = containers ++ ["@list"]
# 2.6.2) Initialize list to the array associated with the key @list in value.
list = value["@list"]
# 2.6.3) Initialize common type and common language to null. If list is empty, set common language to default language.
{common_type, common_language} = {nil, nil}
if Enum.empty?(list) do
common_language = default_language
else
# 2.6.4) For each item in list:
{common_type, common_language} = Enum.reduce_while list, {common_type, common_language},
fn (item, {common_type, common_language}) ->
# 2.6.4.1) Initialize item language to @none and item type to @none.
{item_type, item_language} = {"@none", "@none"}
# 2.6.4.2) If item contains the key @value:
if Map.has_key?(item, "@value") do
cond do
# 2.6.4.2.1) If item contains the key @language, then set item language to its associated value.
Map.has_key?(item, "@language") ->
item_language = item["@language"]
# 2.6.4.2.2) Otherwise, if item contains the key @type, set item type to its associated value.
Map.has_key?(item, "@type") ->
item_type = item["@type"]
# 2.6.4.2.3) Otherwise, set item language to @null.
true ->
item_language = "@null"
end
# 2.6.4.3) Otherwise, set item type to @id.
else
item_type = "@id"
end
cond do
# 2.6.4.4) If common language is null, set it to item language.
is_nil(common_language) ->
common_language = item_language
# 2.6.4.5) Otherwise, if item language does not equal common language and item contains the key @value, then set common language to @none because list items have conflicting languages.
item_language != common_language and Map.has_key?(item, "@value") ->
common_language = "@none"
true ->
end
cond do
# 2.6.4.6) If common type is null, set it to item type.
is_nil(common_type) ->
common_type = item_type
# 2.6.4.7) Otherwise, if item type does not equal common type, then set common type to @none because list items have conflicting types.
item_type != common_type ->
common_type = "@none"
true ->
end
# 2.6.4.8) If common language is @none and common type is @none, then stop processing items in the list because it has been detected that there is no common language or type amongst the items.
if common_language == "@none" and common_type == "@none" do
{:halt, {common_type, common_language}}
else
{:cont, {common_type, common_language}}
end
end
# 2.6.5) If common language is null, set it to @none.
if is_nil(common_language), do: common_language = "@none"
# 2.6.6) If common type is null, set it to @none.
if is_nil(common_type), do: common_type = "@none"
# 2.6.7) If common type is not @none then set type/language to @type and type/language value to common type.
if common_type != "@none" do
type_language = "@type"
type_language_value = common_type
# 2.6.8) Otherwise, set type/language value to common language.
else
type_language_value = common_language
end
end
# 2.7) Otherwise
true ->
# 2.7.1) If value is a value object:
if is_map(value) and Map.has_key?(value, "@value") do
# 2.7.1.1) If value contains the key @language and does not contain the key @index, then set type/language value to its associated value and append @language to containers.
if Map.has_key?(value, "@language") and not Map.has_key?(value, "@index") do
type_language_value = value["@language"]
containers = containers ++ ["@language"]
else
# 2.7.1.2) Otherwise, if value contains the key @type, then set type/language value to its associated value and set type/language to @type.
if Map.has_key?(value, "@type") do
type_language_value = value["@type"]
type_language = "@type"
end
end
# 2.7.2) Otherwise, set type/language to @type and set type/language value to @id.
else
type_language = "@type"
type_language_value = "@id"
end
# 2.7.3) Append @set to containers.
containers = containers ++ ["@set"]
end
# 2.8) Append @none to containers. This represents the non-existence of a container mapping, and it will be the last container mapping value to be checked as it is the most generic.
containers = containers ++ ["@none"]
# 2.9) If type/language value is null, set it to @null. This is the key under which null values are stored in the inverse context entry.
if is_nil(type_language_value), do: type_language_value = "@null"
# 2.10) Initialize preferred values to an empty array. This array will indicate, in order, the preferred values for a term's type mapping or language mapping.
preferred_values = []
# 2.11) If type/language value is @reverse, append @reverse to preferred values.
if type_language_value == "@reverse",
do: preferred_values = preferred_values ++ ["@reverse"]
# 2.12) If type/language value is @id or @reverse and value has an @id member:
if type_language_value in ~w[@id @reverse] and is_map(value) and Map.has_key?(value, "@id") do
# 2.12.1) If the result of using the IRI compaction algorithm, passing active context, inverse context, the value associated with the @id key in value for iri, true for vocab, and true for document relative has a term definition in the active context with an IRI mapping that equals the value associated with the @id key in value, then append @vocab, @id, and @none, in that order, to preferred values.
# TODO: Spec fixme? document_relative is not a specified parameter of compact_iri
compact_id = compact_iri(value["@id"], active_context, inverse_context, nil, true)
if (term_def = active_context.term_defs[compact_id]) && term_def.iri_mapping == value["@id"] do
preferred_values = preferred_values ++ ~w[@vocab @id @none]
# 2.12.2) Otherwise, append @id, @vocab, and @none, in that order, to preferred values.
else
preferred_values = preferred_values ++ ~w[@id @vocab @none]
end
# 2.13) Otherwise, append type/language value and @none, in that order, to preferred values.
else
preferred_values = preferred_values ++ [type_language_value, "@none"]
end
# 2.14) Initialize term to the result of the Term Selection algorithm, passing inverse context, iri, containers, type/language, and preferred values.
select_term(inverse_context, iri, containers, type_language, preferred_values)
end
cond do
# 2.15) If term is not null, return term.
not is_nil(term) ->
term
# 3) At this point, there is no simple term that iri can be compacted to. If vocab is true and active context has a vocabulary mapping:
# 3.1) If iri begins with the vocabulary mapping's value but is longer, then initialize suffix to the substring of iri that does not match. If suffix does not have a term definition in active context, then return suffix.
vocab && active_context.vocab &&
String.starts_with?(iri, active_context.vocab) &&
(suffix = String.replace_prefix(iri, active_context.vocab, "")) != "" &&
is_nil(active_context.term_defs[suffix]) ->
suffix
true ->
# 4) The iri could not be compacted using the active context's vocabulary mapping. Try to create a compact IRI, starting by initializing compact IRI to null. This variable will be used to tore the created compact IRI, if any.
compact_iri =
# 5) For each key term and value term definition in the active context:
Enum.reduce(active_context.term_defs, nil, fn ({term, term_def}, compact_iri) ->
cond do
# 5.1) If the term contains a colon (:), then continue to the next term because terms with colons can't be used as prefixes.
String.contains?(term, ":") ->
compact_iri
# 5.2) If the term definition is null, its IRI mapping equals iri, or its IRI mapping is not a substring at the beginning of iri, the term cannot be used as a prefix because it is not a partial match with iri. Continue with the next term.
is_nil(term_def) || term_def.iri_mapping == iri ||
not String.starts_with?(iri, term_def.iri_mapping) ->
compact_iri
true ->
# 5.3) Initialize candidate by concatenating term, a colon (:), and the substring of iri that follows after the value of the term definition's IRI mapping.
candidate = term <> ":" <> (String.split_at(iri, String.length(term_def.iri_mapping)) |> elem(1))
# 5.4) If either compact IRI is null or candidate is shorter or the same length but lexicographically less than compact IRI and candidate does not have a term definition in active context or if the term definition has an IRI mapping that equals iri and value is null, set compact IRI to candidate.
# TODO: Spec fixme: The specified expression is pretty ambiguous without brackets ...
# TODO: Spec fixme: "if the term definition has an IRI mapping that equals iri" is already catched in 5.2, so will never happen here ...
if (is_nil(compact_iri) or shortest_or_least?(candidate, compact_iri)) and
(is_nil(active_context.term_defs[candidate]) or
(term_def.iri_mapping == iri and is_nil(value))) do
candidate
else
compact_iri
end
end
end)
cond do
# 6) If compact IRI is not null, return compact IRI.
not is_nil(compact_iri) ->
compact_iri
# 7) If vocab is false then transform iri to a relative IRI using the document's base IRI.
not vocab ->
remove_base(iri, active_context.base_iri)
# 8) Finally, return iri as is.
true ->
iri
end
end
end
defp shortest_or_least?(a, b) do
(a_len = String.length(a)) < (b_len = String.length(b)) or
(a_len == b_len and a < b)
end
defp remove_base(iri, nil), do: iri
defp remove_base(iri, base) do
base_len = String.length(base)
if String.starts_with?(iri, base) and String.at(iri, base_len) in ~w(? #) do
String.split_at(iri, base_len) |> elem(1)
else
case URI.parse(base) do
%URI{path: nil} -> iri
base ->
do_remove_base(iri, %URI{base | path: Path.dirname(base.path)}, 0)
end
end
end
defp do_remove_base(iri, base, index) do
base_str = URI.to_string(base)
cond do
String.starts_with?(iri, base_str) ->
case String.duplicate("../", index) <>
(String.split_at(iri, String.length(base_str)) |> elem(1)) do
"" -> "./"
rel -> rel
end
base.path == "/" -> iri
true ->
do_remove_base(iri, %URI{base | path: Path.dirname(base.path)}, index + 1)
end
end
@doc """
Value Compaction
Details at <https://www.w3.org/TR/json-ld-api/#value-compaction>
"""
def compact_value(value, active_context, inverse_context, active_property) do
term_def = active_context.term_defs[active_property]
# 1) Initialize number members to the number of members value contains.
number_members = Enum.count(value)
# 2) If value has an @index member and the container mapping associated to active property is set to @index, decrease number members by 1.
number_members =
if Map.has_key?(value, "@index") and term_def.container_mapping == "@index",
do: number_members - 1, else: number_members
# 3) If number members is greater than 2, return value as it cannot be compacted.
unless number_members > 2 do
{type_mapping, language_mapping} = if term_def,
do: {term_def.type_mapping, term_def.language_mapping},
else: {nil, nil}
cond do
# 4) If value has an @id member
id = Map.get(value, "@id") ->
cond do
# 4.1) If number members is 1 and the type mapping of active property is set to @id, return the result of using the IRI compaction algorithm, passing active context, inverse context, and the value of the @id member for iri.
number_members == 1 and type_mapping == "@id" ->
compact_iri(id, active_context, inverse_context)
# 4.2) Otherwise, if number members is 1 and the type mapping of active property is set to @vocab, return the result of using the IRI compaction algorithm, passing active context, inverse context, the value of the @id member for iri, and true for vocab.
number_members == 1 and type_mapping == "@vocab" ->
compact_iri(id, active_context, inverse_context, nil, true)
# 4.3) Otherwise, return value as is.
true ->
value
end
# 5) Otherwise, if value has an @type member whose value matches the type mapping of active property, return the value associated with the @value member of value.
(type = Map.get(value, "@type")) && type == type_mapping ->
value["@value"]
# 6) Otherwise, if value has an @language member whose value matches the language mapping of active property, return the value associated with the @value member of value.
(language = Map.get(value, "@language")) &&
# TODO: Spec fixme: doesn't specify to check default language as well
language in [language_mapping, active_context.default_language] ->
value["@value"]
true ->
# 7) Otherwise, if number members equals 1 and either the value of the @value member is not a string, or the active context has no default language, or the language mapping of active property is set to null,, return the value associated with the @value member.
if number_members == 1 and
(not is_binary(value_value = value["@value"]) or
!active_context.default_language or
# TODO: Spec fixme: doesn't specify to check default language as well
Context.language(active_context, active_property) == nil) do
value_value
# 8) Otherwise, return value as is.
else
value
end
end
else
value
end
end
@doc """
Term Selection
Details at <https://www.w3.org/TR/json-ld-api/#term-selection>
"""
def select_term(inverse_context, iri, containers, type_language, preferred_values) do
container_map = inverse_context[iri]
Enum.find_value containers, fn container ->
if type_language_map = container_map[container] do
value_map = type_language_map[type_language]
Enum.find_value preferred_values, fn item -> value_map[item] end
end
end
end
end