AkkomaGang/rdf-ex
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

core: fix and improve behaviour of overwriting the default contexts with add, put and delete of RDF.Dataset

Browse source
This commit is contained in:
Marcel Otto 2017-06-07 00:48:08 +02:00
parent cd5636528f
commit 38ee0ca44b
3 changed files with 249 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

192
lib/rdf/dataset.ex
View file

@ -90,27 +90,28 @@ defmodule RDF.Dataset do
@doc """
Adds triples and quads to a `RDF.Dataset`.
The optional third argument `graph_context` defaulting to `nil` for the default
graph, specifies the graph to which the statements are added.
Note: This also applies when adding a named graph. Its name is ignored over
`graph_context` and its default value.
The optional third `graph_context` argument allows to set a different
destination graph to which the statements are added, ignoring the graph context
of given quads or the name of given graphs.
"""
def add(dataset, statements, graph_context \\ nil)
def add(dataset, statements, graph_context \\ false)
def add(dataset, statements, graph_context) when is_list(statements) do
with graph_context = convert_graph_name(graph_context) do
with graph_context = graph_context && convert_graph_name(graph_context) do
Enum.reduce statements, dataset, fn (statement, dataset) ->
add(dataset, statement, graph_context)
end
end
end
def add(dataset, {subject, predicate, objects}, false),
do: add(dataset, {subject, predicate, objects, nil})
def add(dataset, {subject, predicate, objects}, graph_context),
do: add(dataset, {subject, predicate, objects, graph_context})
def add(%RDF.Dataset{name: name, graphs: graphs},
{subject, predicate, objects, graph_context}, _) do
{subject, predicate, objects, graph_context}, false) do
with graph_context = convert_graph_name(graph_context) do
updated_graphs =
Map.update(graphs, graph_context,
@ -120,6 +121,12 @@ defmodule RDF.Dataset do
end
end
def add(%RDF.Dataset{} = dataset, {subject, predicate, objects, _}, graph_context),
do: add(dataset, {subject, predicate, objects, graph_context}, false)
def add(%RDF.Dataset{} = dataset, %Description{} = description, false),
do: add(dataset, description, nil)
def add(%RDF.Dataset{name: name, graphs: graphs},
%Description{} = description, graph_context) do
with graph_context = convert_graph_name(graph_context) do
@ -133,23 +140,25 @@ defmodule RDF.Dataset do
end
end
def add(%RDF.Dataset{name: name, graphs: graphs}, %Graph{} = graph,
graph_context) do
with graph_context = convert_graph_name(graph_context) do
%RDF.Dataset{name: name,
graphs:
Map.update(graphs, graph_context, Graph.new(graph_context, graph), fn current ->
current |> Graph.add(graph)
end)
}
end
def add(%RDF.Dataset{name: name, graphs: graphs}, %Graph{} = graph, false) do
%RDF.Dataset{name: name,
graphs:
Map.update(graphs, graph.name, graph, fn current ->
Graph.add(current, graph)
end)
}
end
def add(%RDF.Dataset{} = dataset, %RDF.Dataset{} = other_dataset, _) do
Enum.reduce graphs(other_dataset), dataset, fn (graph, dataset) ->
add(dataset, graph)
def add(%RDF.Dataset{} = dataset, %Graph{} = graph, graph_context),
do: add(dataset, %Graph{graph | name: convert_graph_name(graph_context)}, false)
def add(%RDF.Dataset{} = dataset, %RDF.Dataset{} = other_dataset, graph_context) do
with graph_context = graph_context && convert_graph_name(graph_context) do
Enum.reduce graphs(other_dataset), dataset, fn (graph, dataset) ->
add(dataset, graph, graph_context)
end
end
end
end
@doc """
@ -165,30 +174,17 @@ defmodule RDF.Dataset do
iex> RDF.Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}]) |>
...> RDF.Dataset.put([{EX.S1, EX.P2, EX.O3}, {EX.S2, EX.P2, EX.O3}])
RDF.Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S1, EX.P2, EX.O3}, {EX.S2, EX.P2, EX.O3}])
Note: When using a map to pass the statements you'll have to take care for yourselve to
avoid using subject key clashes due to using inconsistent, semantically equivalent forms.
iex> RDF.Dataset.put(RDF.Dataset.new, %{
...> EX.S => [{EX.P, EX.O1}],
...> {EX.S, nil} => [{EX.P, EX.O2}]})
RDF.Dataset.new({EX.S, EX.P, EX.O2})
The last always always wins in these cases. This decision was made to mitigate
performance drawbacks. The list form will always take care of this for you:
iex> RDF.Dataset.put(RDF.Dataset.new, [
...> {EX.S, EX.P, EX.O1},
...> {EX.S, EX.P, EX.O2, nil}])
RDF.Dataset.new({EX.S, EX.P, EX.O1}, {EX.S, EX.P, EX.O2})
"""
def put(dataset, statements, graph_context \\ nil)
def put(dataset, statements, graph_context \\ false)
def put(%RDF.Dataset{} = dataset, {subject, predicate, objects}, false),
do: put(dataset, {subject, predicate, objects, nil})
def put(%RDF.Dataset{} = dataset, {subject, predicate, objects}, graph_context),
do: put(dataset, {subject, predicate, objects, graph_context})
def put(%RDF.Dataset{name: name, graphs: graphs},
{subject, predicate, objects, graph_context}, _) do
{subject, predicate, objects, graph_context}, false) do
with graph_context = convert_graph_name(graph_context) do
new_graph =
case graphs[graph_context] do
@ -202,15 +198,28 @@ defmodule RDF.Dataset do
end
end
def put(%RDF.Dataset{} = dataset, statements, graph_context)
when is_list(statements) do
def put(%RDF.Dataset{} = dataset, {subject, predicate, objects, _}, graph_context),
do: put(dataset, {subject, predicate, objects, graph_context}, false)
def put(%RDF.Dataset{} = dataset, statements, false) when is_list(statements) do
do_put dataset, Enum.group_by(statements,
fn
{s, _, _} -> {s, nil}
{s, _, _, nil} -> {s, nil}
{s, _, _, c} -> {s, convert_graph_name(c)}
end,
fn
{_, p, o, _} -> {p, o}
{_, p, o} -> {p, o}
end)
end
def put(%RDF.Dataset{} = dataset, statements, graph_context) when is_list(statements) do
with graph_context = convert_graph_name(graph_context) do
put dataset, Enum.group_by(statements,
do_put dataset, Enum.group_by(statements,
fn
{s, _, _, nil} -> s
{s, _, _, c} -> {s, c}
{s, _, _} when is_nil(graph_context) -> s
{s, _, _} -> {s, graph_context}
{s, _, _, _} -> {s, graph_context}
{s, _, _} -> {s, graph_context}
end,
fn
{_, p, o, _} -> {p, o}
@ -219,6 +228,9 @@ defmodule RDF.Dataset do
end
end
def put(%RDF.Dataset{} = dataset, %Description{} = description, false),
do: put(dataset, description, nil)
def put(%RDF.Dataset{name: name, graphs: graphs},
%Description{} = description, graph_context) do
with graph_context = convert_graph_name(graph_context) do
@ -232,39 +244,37 @@ defmodule RDF.Dataset do
end
end
def put(%RDF.Dataset{name: name, graphs: graphs}, %Graph{} = graph,
graph_context) do
with graph_context = convert_graph_name(graph_context) do
%RDF.Dataset{name: name,
graphs:
Map.update(graphs, graph_context, Graph.new(graph_context, graph), fn current ->
current |> Graph.put(graph)
end)
}
def put(%RDF.Dataset{name: name, graphs: graphs}, %Graph{} = graph, false) do
%RDF.Dataset{name: name,
graphs:
Map.update(graphs, graph.name, graph, fn current ->
Graph.put(current, graph)
end)
}
end
def put(%RDF.Dataset{} = dataset, %Graph{} = graph, graph_context),
do: put(dataset, %Graph{graph | name: convert_graph_name(graph_context)}, false)
def put(%RDF.Dataset{} = dataset, %RDF.Dataset{} = other_dataset, graph_context) do
with graph_context = graph_context && convert_graph_name(graph_context) do
Enum.reduce graphs(other_dataset), dataset, fn (graph, dataset) ->
put(dataset, graph, graph_context)
end
end
end
def put(%RDF.Dataset{} = dataset, %RDF.Dataset{} = other_dataset, _) do
Enum.reduce graphs(other_dataset), dataset, fn (graph, dataset) ->
put(dataset, graph)
end
end
def put(%RDF.Dataset{} = dataset, statements, graph_context)
when is_map(statements) do
with graph_context = convert_graph_name(graph_context) do
Enum.reduce statements, dataset,
fn ({subject_with_context, predications}, dataset) ->
put(dataset, subject_with_context, predications, graph_context)
end
end
defp do_put(%RDF.Dataset{} = dataset, statements) when is_map(statements) do
Enum.reduce statements, dataset,
fn ({subject_with_context, predications}, dataset) ->
do_put(dataset, subject_with_context, predications)
end
end
def put(%RDF.Dataset{name: name, graphs: graphs},
{subject, graph_context}, predications, default_graph_context)
defp do_put(%RDF.Dataset{name: name, graphs: graphs},
{subject, graph_context}, predications)
when is_list(predications) do
with graph_context = graph_context || default_graph_context,
graph_context = convert_graph_name(graph_context) do
with graph_context = convert_graph_name(graph_context) do
graph = Map.get(graphs, graph_context, Graph.new(graph_context))
new_graphs = graphs
|> Map.put(graph_context, Graph.put(graph, subject, predications))
@ -272,50 +282,56 @@ defmodule RDF.Dataset do
end
end
def put(%RDF.Dataset{} = dataset, subject, predications, graph_context)
when is_list(predications),
do: put(dataset, {subject, graph_context}, predications, graph_context)
@doc """
Deletes statements from a `RDF.Dataset`.
The optional third argument `graph_context` defaulting to `nil` for the default
graph, specifies the graph from which the statements are deleted.
Note that this also applies when deleting a named graph. Its name is ignored over
`graph_context` and its default value.
The optional third `graph_context` argument allows to set a different
destination graph from which the statements are deleted, ignoring the graph
context of given quads or the name of given graphs.
Note: When the statements to be deleted are given as another `RDF.Dataset`,
the dataset name must not match dataset name of the dataset from which the statements
are deleted. If you want to delete only datasets with matching names, you can
use `RDF.Data.delete/2`.
"""
def delete(dataset, statements, graph_context \\ nil)
def delete(dataset, statements, graph_context \\ false)
def delete(%RDF.Dataset{} = dataset, statements, graph_context) when is_list(statements) do
with graph_context = convert_graph_name(graph_context) do
with graph_context = graph_context && convert_graph_name(graph_context) do
Enum.reduce statements, dataset, fn (statement, dataset) ->
delete(dataset, statement, graph_context)
end
end
end
def delete(%RDF.Dataset{} = dataset, {_, _, _} = statement, false),
do: do_delete(dataset, nil, statement)
def delete(%RDF.Dataset{} = dataset, {_, _, _} = statement, graph_context),
do: do_delete(dataset, graph_context, statement)
def delete(%RDF.Dataset{} = dataset, {subject, predicate, objects, graph_context}, _),
def delete(%RDF.Dataset{} = dataset, {subject, predicate, objects, graph_context}, false),
do: do_delete(dataset, graph_context, {subject, predicate, objects})
def delete(%RDF.Dataset{} = dataset, {subject, predicate, objects, _}, graph_context),
do: do_delete(dataset, graph_context, {subject, predicate, objects})
def delete(%RDF.Dataset{} = dataset, %Description{} = description, false),
do: do_delete(dataset, nil, description)
def delete(%RDF.Dataset{} = dataset, %Description{} = description, graph_context),
do: do_delete(dataset, graph_context, description)
def delete(%RDF.Dataset{} = dataset, %RDF.Graph{name: name} = graph, false),
do: do_delete(dataset, name, graph)
def delete(%RDF.Dataset{} = dataset, %RDF.Graph{} = graph, graph_context),
do: do_delete(dataset, graph_context, graph)
def delete(%RDF.Dataset{} = dataset, %RDF.Dataset{graphs: graphs}, _) do
def delete(%RDF.Dataset{} = dataset, %RDF.Dataset{graphs: graphs}, graph_context) do
Enum.reduce graphs, dataset, fn ({_, graph}, dataset) ->
delete(dataset, graph)
delete(dataset, graph, graph_context)
end
end

2
test/support/rdf_case.ex
View file

@ -75,7 +75,7 @@ defmodule RDF.Test.Case do
def unnamed_dataset, do: Dataset.new
def named_dataset(name \\ EX.GraphName), do: Dataset.new(name)
def named_dataset(name \\ EX.DatasetName), do: Dataset.new(name)
def unnamed_dataset?(%Dataset{name: nil}), do: true
def unnamed_dataset?(_), do: false

165
test/unit/dataset_test.exs
View file

@ -124,7 +124,6 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate, EX.Object})
end
test "a convertible triple" do
assert Dataset.add(dataset(),
{"http://example.com/Subject", EX.predicate, EX.Object})
@ -137,6 +136,13 @@ defmodule RDF.DatasetTest do
|> dataset_includes_statement?({EX.Subject, EX.predicate, EX.Object, EX.GraphName})
end
test "a quad and an overwriting graph context " do
assert Dataset.add(dataset(), {EX.Subject, EX.predicate, EX.Object, EX.Graph}, EX.Other)
|> dataset_includes_statement?({EX.Subject, EX.predicate, EX.Object, EX.Other})
assert Dataset.add(dataset(), {EX.Subject, EX.predicate, EX.Object, EX.Graph}, nil)
|> dataset_includes_statement?({EX.Subject, EX.predicate, EX.Object})
end
test "statements with multiple objects" do
ds = Dataset.add(dataset(), {EX.Subject1, EX.predicate1, [EX.Object1, EX.Object2]})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
@ -147,7 +153,7 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object2, EX.GraphName})
end
test "a list of triples without specification the default context" do
test "a list of triples without specification of the default context" do
ds = Dataset.add(dataset(), [
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
@ -158,18 +164,27 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3, EX.Object3})
end
test "a list of triples with specification the default context" do
test "a list of triples with specification of the default context" do
ds = Dataset.add(dataset(), [
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
{EX.Subject3, EX.predicate3, EX.Object3, nil}
{EX.Subject3, EX.predicate3, EX.Object3}
], EX.Graph)
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3, EX.Object3, EX.Graph})
ds = Dataset.add(dataset(), [
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
{EX.Subject3, EX.predicate3, EX.Object3}
], nil)
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1, nil})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2, nil})
assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3, EX.Object3, nil})
end
test "a list of quads" do
test "a list of quads without specification of the default context" do
ds = Dataset.add(dataset(), [
{EX.Subject, EX.predicate1, EX.Object1, EX.Graph1},
{EX.Subject, EX.predicate2, EX.Object2, nil},
@ -180,6 +195,26 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1, EX.Object1, EX.Graph2})
end
test "a list of quads with specification of the default context" do
ds = Dataset.add(dataset(), [
{EX.Subject, EX.predicate1, EX.Object1, EX.Graph1},
{EX.Subject, EX.predicate2, EX.Object2, nil},
{EX.Subject, EX.predicate1, EX.Object1, EX.Graph2}
], EX.Graph)
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1, EX.Object1, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate2, EX.Object2, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1, EX.Object1, EX.Graph})
ds = Dataset.add(dataset(), [
{EX.Subject, EX.predicate1, EX.Object1, EX.Graph1},
{EX.Subject, EX.predicate2, EX.Object2, nil},
{EX.Subject, EX.predicate1, EX.Object1, EX.Graph2}
], nil)
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1, EX.Object1, nil})
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate2, EX.Object2, nil})
assert dataset_includes_statement?(ds, {EX.Subject, EX.predicate1, EX.Object1, nil})
end
test "a list of mixed triples and quads" do
ds = Dataset.add(dataset(), [
{EX.Subject1, EX.predicate1, EX.Object1, EX.GraphName},
@ -189,7 +224,7 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject3, EX.predicate3, EX.Object3, nil})
end
test "a Description" do
test "a Description without specification of the default context" do
ds = Dataset.add(dataset(), Description.new(EX.Subject1, [
{EX.predicate1, EX.Object1},
{EX.predicate2, EX.Object2},
@ -197,6 +232,16 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
end
test "a Description with specification of the default context" do
ds = Dataset.add(dataset(), Description.new(EX.Subject1, [
{EX.predicate1, EX.Object1},
{EX.predicate2, EX.Object2},
]), nil)
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
ds = Dataset.add(ds, Description.new({EX.Subject1, EX.predicate3, EX.Object3}), EX.Graph)
assert Enum.count(ds) == 3
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
@ -204,7 +249,7 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate3, EX.Object3, EX.Graph})
end
test "an unnamed Graph" do
test "an unnamed Graph without specification of the default context" do
ds = Dataset.add(dataset(), Graph.new([
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
@ -219,6 +264,23 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3})
end
test "an unnamed Graph with specification of the default context" do
ds = Dataset.add(dataset(), Graph.new([
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
]), nil)
assert unnamed_graph?(Dataset.default_graph(ds))
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2, EX.Object3}), nil)
assert unnamed_graph?(Dataset.default_graph(ds))
assert Enum.count(ds) == 3
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3})
ds = Dataset.add(ds, Graph.new({EX.Subject1, EX.predicate2, EX.Object3}), EX.Graph)
assert unnamed_graph?(Dataset.default_graph(ds))
@ -230,17 +292,38 @@ defmodule RDF.DatasetTest do
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3, EX.Graph})
end
test "a named Graph" do
test "a named Graph without specification of the default context" do
ds = Dataset.add(dataset(), Graph.new(EX.Graph1, [
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
]))
assert Dataset.graph(ds, EX.Graph1)
assert named_graph?(Dataset.graph(ds, EX.Graph1), uri(EX.Graph1))
assert unnamed_graph?(Dataset.default_graph(ds))
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1, EX.Graph1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2, EX.Graph1})
ds = Dataset.add(ds, Graph.new(EX.Graph2, {EX.Subject1, EX.predicate2, EX.Object3}))
assert Dataset.graph(ds, EX.Graph2)
assert named_graph?(Dataset.graph(ds, EX.Graph2), uri(EX.Graph2))
assert unnamed_graph?(Dataset.default_graph(ds))
assert Enum.count(ds) == 3
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1, EX.Graph1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2, EX.Graph1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3, EX.Graph2})
end
test "a named Graph with specification of the default context" do
ds = Dataset.add(dataset(), Graph.new(EX.Graph1, [
{EX.Subject1, EX.predicate1, EX.Object1},
{EX.Subject1, EX.predicate2, EX.Object2},
]), nil)
refute Dataset.graph(ds, EX.Graph1)
assert unnamed_graph?(Dataset.default_graph(ds))
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
ds = Dataset.add(ds, Graph.new(EX.Graph2, {EX.Subject1, EX.predicate2, EX.Object3}))
ds = Dataset.add(ds, Graph.new(EX.Graph2, {EX.Subject1, EX.predicate2, EX.Object3}), nil)
refute Dataset.graph(ds, EX.Graph2)
assert unnamed_graph?(Dataset.default_graph(ds))
assert Enum.count(ds) == 3
@ -268,12 +351,14 @@ defmodule RDF.DatasetTest do
ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2, EX.Object3}))
ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2, EX.Object3, EX.Graph}))
ds = Dataset.add(ds, Dataset.new({EX.Subject1, EX.predicate2, EX.Object4}), EX.Graph)
assert ds.name == nil
assert Enum.count(ds) == 4
assert Enum.count(ds) == 5
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object4, EX.Graph})
end
test "a named Dataset" do
@ -287,12 +372,14 @@ defmodule RDF.DatasetTest do
ds = Dataset.add(ds, Dataset.new(EX.DS2, {EX.Subject1, EX.predicate2, EX.Object3}))
ds = Dataset.add(ds, Dataset.new(EX.DS2, {EX.Subject1, EX.predicate2, EX.Object3, EX.Graph}))
ds = Dataset.add(ds, Dataset.new(EX.DS2, {EX.Subject1, EX.predicate2, EX.Object4}), EX.Graph)
assert ds.name == uri(EX.DatasetName)
assert Enum.count(ds) == 4
assert Enum.count(ds) == 5
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate1, EX.Object1})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object2})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.Subject1, EX.predicate2, EX.Object4, EX.Graph})
end
test "a list of Descriptions" do
@ -340,7 +427,7 @@ defmodule RDF.DatasetTest do
end
describe "put" do
test "a list of triples" do
test "a list of statements without specification of the default context" do
ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}])
|> RDF.Dataset.put([
{EX.S1, EX.P2, EX.O3, EX.Graph},
@ -350,12 +437,45 @@ defmodule RDF.DatasetTest do
assert Dataset.statement_count(ds) == 5
assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1})
assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)})
assert dataset_includes_statement?(ds, {EX.S1, EX.P2, EX.O3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4, EX.Graph})
end
test "a list of statements with specification of the default context" do
ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}])
|> RDF.Dataset.put([
{EX.S1, EX.P1, EX.O3, EX.Graph},
{EX.S1, EX.P2, bnode(:foo), nil},
{EX.S2, EX.P2, EX.O3, EX.Graph},
{EX.S2, EX.P2, EX.O4}], nil)
assert Dataset.statement_count(ds) == 5
assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O3})
assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo)})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O2, EX.Graph})
ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2, EX.Graph}])
|> RDF.Dataset.put([
{EX.S1, EX.P1, EX.O3},
{EX.S1, EX.P1, EX.O4, EX.Graph},
{EX.S1, EX.P2, bnode(:foo), nil},
{EX.S2, EX.P2, EX.O3, EX.Graph},
{EX.S2, EX.P2, EX.O4}], EX.Graph)
assert Dataset.statement_count(ds) == 6
assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O1})
assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S1, EX.P1, EX.O4, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S1, EX.P2, bnode(:foo), EX.Graph})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O3, EX.Graph})
assert dataset_includes_statement?(ds, {EX.S2, EX.P2, EX.O4, EX.Graph})
end
test "a Description" do
ds = Dataset.new([{EX.S1, EX.P1, EX.O1}, {EX.S2, EX.P2, EX.O2}, {EX.S1, EX.P3, EX.O3}])
|> RDF.Dataset.put(Description.new(EX.S1, [{EX.P3, EX.O4}, {EX.P2, bnode(:foo)}]))
@ -494,6 +614,8 @@ defmodule RDF.DatasetTest do
assert Dataset.delete(dataset1, Graph.new({EX.S1, EX.p1, EX.O1})) == Dataset.new
assert Dataset.delete(dataset2, Graph.new({EX.S1, EX.p1, EX.O1})) ==
Dataset.new({EX.S2, EX.p2, EX.O2, EX.Graph})
assert Dataset.delete(dataset2, Graph.new(EX.Graph, {EX.S2, EX.p2, EX.O2})) == dataset1
assert Dataset.delete(dataset2, Graph.new(EX.Graph, {EX.S2, EX.p2, EX.O2})) == dataset1
assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2, EX.O2}), EX.Graph) == dataset1
assert Dataset.delete(dataset2, Graph.new({EX.S2, EX.p2, EX.O2}), EX.Graph) == dataset1
assert Dataset.delete(dataset3, Graph.new([
@ -504,6 +626,15 @@ defmodule RDF.DatasetTest do
{EX.S2, EX.p2, [EX.O1, EX.O2], EX.Graph1},
{EX.S3, EX.p3, [~B<foo>, ~L"bar"], EX.Graph2},
])
assert Dataset.delete(dataset3, Graph.new(EX.Graph2, [
{EX.S1, EX.p1, [EX.O1, EX.O2]},
{EX.S2, EX.p2, EX.O3},
{EX.S3, EX.p3, ~B<foo>},
])) == Dataset.new([
{EX.S1, EX.p1, EX.O1},
{EX.S2, EX.p2, [EX.O1, EX.O2], EX.Graph1},
{EX.S3, EX.p3, [~L"bar"], EX.Graph2},
])
assert Dataset.delete(dataset3, Graph.new({EX.S3, EX.p3, ~B<foo>}), EX.Graph2) ==
Dataset.new([
{EX.S1, EX.p1, EX.O1},
@ -512,14 +643,6 @@ defmodule RDF.DatasetTest do
])
end
test "the name of a graph is ignored",
%{dataset1: dataset1, dataset2: dataset2} do
assert Dataset.delete(dataset1, Graph.new(EX.Graph, {EX.S1, EX.p1, EX.O1})) == Dataset.new
assert Dataset.delete(dataset2, Graph.new(EX.Graph, {EX.S1, EX.p1, EX.O1})) ==
Dataset.new({EX.S2, EX.p2, EX.O2, EX.Graph})
assert Dataset.delete(dataset2, Graph.new(EX.Graph, {EX.S2, EX.p2, EX.O2})) == dataset2
end
test "multiple statements with a Dataset",
%{dataset1: dataset1, dataset2: dataset2} do
assert Dataset.delete(dataset1, dataset1) == Dataset.new