5819eec0cf
It turned out that the costs of separating the XSD datatypes are too high and probably not worth the effort, since with its limited scope probably nobody would want to use XSD.ex outside of the RDF.ex context anyway.
108 lines
3 KiB
Elixir
108 lines
3 KiB
Elixir
defmodule RDF.Test.Case do
|
|
use ExUnit.CaseTemplate
|
|
|
|
use RDF.Vocabulary.Namespace
|
|
defvocab EX,
|
|
base_iri: "http://example.com/",
|
|
terms: [], strict: false
|
|
|
|
alias RDF.{Dataset, Graph, Description, IRI}
|
|
import RDF, only: [iri: 1]
|
|
|
|
using do
|
|
quote do
|
|
alias RDF.{Dataset, Graph, Description, IRI, XSD}
|
|
alias unquote(__MODULE__).EX
|
|
|
|
import RDF, only: [iri: 1, literal: 1, bnode: 1]
|
|
import unquote(__MODULE__)
|
|
|
|
import RDF.Sigils
|
|
|
|
@compile {:no_warn_undefined, RDF.Test.Case.EX}
|
|
end
|
|
end
|
|
|
|
###############################
|
|
# RDF.Description
|
|
|
|
def description, do: Description.new(EX.Subject)
|
|
def description(content), do: Description.add(description(), content)
|
|
|
|
def description_of_subject(%Description{subject: subject}, subject),
|
|
do: true
|
|
def description_of_subject(_, _),
|
|
do: false
|
|
|
|
def empty_description(%Description{predications: predications}),
|
|
do: predications == %{}
|
|
|
|
def description_includes_predication(desc, {predicate, object}) do
|
|
desc.predications
|
|
|> Map.get(predicate, %{})
|
|
|> Enum.member?({object, nil})
|
|
end
|
|
|
|
###############################
|
|
# RDF.Graph
|
|
|
|
def graph, do: unnamed_graph()
|
|
|
|
def unnamed_graph, do: Graph.new
|
|
|
|
def named_graph(name \\ EX.GraphName), do: Graph.new(name: name)
|
|
|
|
def unnamed_graph?(%Graph{name: nil}), do: true
|
|
def unnamed_graph?(_), do: false
|
|
|
|
def named_graph?(%Graph{name: %IRI{}}), do: true
|
|
def named_graph?(_), do: false
|
|
def named_graph?(%Graph{name: name}, name), do: true
|
|
def named_graph?(_, _), do: false
|
|
|
|
def empty_graph?(%Graph{descriptions: descriptions}),
|
|
do: descriptions == %{}
|
|
|
|
def graph_includes_statement?(graph, {subject, _, _} = statement) do
|
|
graph.descriptions
|
|
|> Map.get(iri(subject), %{})
|
|
|> Enum.member?(statement)
|
|
end
|
|
|
|
|
|
###############################
|
|
# RDF.Dataset
|
|
|
|
def dataset, do: unnamed_dataset()
|
|
|
|
def unnamed_dataset, do: Dataset.new
|
|
|
|
def named_dataset(name \\ EX.DatasetName), do: Dataset.new(name: name)
|
|
|
|
def unnamed_dataset?(%Dataset{name: nil}), do: true
|
|
def unnamed_dataset?(_), do: false
|
|
|
|
def named_dataset?(%Dataset{name: %IRI{}}), do: true
|
|
def named_dataset?(_), do: false
|
|
def named_dataset?(%Dataset{name: name}, name), do: true
|
|
def named_dataset?(_, _), do: false
|
|
|
|
def empty_dataset?(%Dataset{graphs: graphs}), do: graphs == %{}
|
|
|
|
def dataset_includes_statement?(dataset, {_, _, _} = statement) do
|
|
dataset
|
|
|> Dataset.default_graph
|
|
|> graph_includes_statement?(statement)
|
|
end
|
|
|
|
def dataset_includes_statement?(dataset, {subject, predicate, objects, nil}),
|
|
do: dataset_includes_statement?(dataset, {subject, predicate, objects})
|
|
|
|
def dataset_includes_statement?(dataset,
|
|
{subject, predicate, objects, graph_context}) do
|
|
dataset.graphs
|
|
|> Map.get(iri(graph_context), named_graph(graph_context))
|
|
|> graph_includes_statement?({subject, predicate, objects})
|
|
end
|
|
|
|
end
|