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

Add RDF.Term.coerce/1

Browse source
This commit is contained in:
Marcel Otto 2018-09-16 04:02:53 +02:00
parent 7e7f6e7189
commit edfdb186d0
7 changed files with 319 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CHANGELOG.md
View file

@ -11,7 +11,7 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
- top-level alias functions for constructors of the basic datatypes
- top-level constant functions `RDF.true` and `RDF.false` for the two boolean
RDF.Literal values
`RDF.Literal` values
- `RDF.Decimal` datatype for `xsd:decimal` literals and support for decimal
literals in Turtle encoder
- `RDF.Numeric` with a list of all numeric datatypes and shared functions for
@ -22,6 +22,7 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
from the XPath and SPARQL specs on `RDF.Boolean`
- various functions on the `RDF.DateTime` and `RDF.Time` datatypes
- `RDF.term?/1`
- `RDF.Term.coerce/1` which converts native Elixir values to a proper RDF term
- `RDF.Term.equal?/2` and `RDF.Term.equal_value?/2`
- `RDF.LangString.match_language?/2`
- possibility to configure an application-specific default base IRI; for now it

8
lib/rdf/datatype.ex
View file

@ -69,6 +69,8 @@ defmodule RDF.Datatype do
@doc """
Checks if the value of two `RDF.Literal`s of this datatype are equal.
Non-RDF terms are tried to be coerced via `RDF.Term.coerce/1` before comparison.
Returns `nil` when the given arguments are not comparable as literals of this datatype.
The default implementation of the `_using__` macro compares the values of the
@ -213,6 +215,12 @@ defmodule RDF.Datatype do
canonical(literal1).value == canonical(literal2).value
end
def equal_value?(%RDF.Literal{} = left, right) when not is_nil(right) do
unless RDF.term?(right) do
equal_value?(left, RDF.Term.coerce(right))
end
end
def equal_value?(_, _), do: nil

9
lib/rdf/datatypes/numeric.ex
View file

@ -71,13 +71,18 @@ defmodule RDF.Numeric do
do: equal_decimal_value?(left, right)
def equal_value?(%Literal{datatype: left_datatype, value: left},
%Literal{datatype: right_datatype, value: right})
do
%Literal{datatype: right_datatype, value: right}) do
if type?(left_datatype) and type?(right_datatype) do
left == right
end
end
def equal_value?(%RDF.Literal{} = left, right) when not is_nil(right) do
unless RDF.term?(right) do
equal_value?(left, RDF.Term.coerce(right))
end
end
def equal_value?(_, _), do: nil
defp equal_decimal_value?(%D{} = left, %D{} = right), do: D.equal?(left, right)

8
lib/rdf/literal.ex
View file

@ -222,6 +222,8 @@ defmodule RDF.Literal do
@doc """
Checks if two `RDF.Literal`s of this datatype are equal.
Non-RDF terms are tried to be coerced via `RDF.Term.coerce/1` before comparison.
Returns `nil` when the given arguments are not comparable as Literals.
see <https://www.w3.org/TR/rdf-concepts/#section-Literal-Equality>
@ -248,6 +250,12 @@ defmodule RDF.Literal do
def equal_value?(left, %RDF.Literal{datatype: %RDF.IRI{value: @xsd_any_uri}} = right),
do: RDF.IRI.equal_value?(left, right)
def equal_value?(%RDF.Literal{} = left, right) when not is_nil(right) do
unless RDF.term?(right) do
equal_value?(left, RDF.Term.coerce(right))
end
end
def equal_value?(_, _), do: nil
end

72
lib/rdf/term.ex
View file

@ -27,6 +27,8 @@ defprotocol RDF.Term do
@doc """
Tests for equality of values.
Non-RDF terms are tried to be coerced via `RDF.Term.coerce/1` before comparison.
Returns `nil` if the given terms are not comparable.
see <http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal>
@ -36,24 +38,94 @@ defprotocol RDF.Term do
@fallback_to_any true
def equal_value?(term1, term2)
@doc """
Converts a given value into a RDF term.
Returns `nil` if the given value is not convertible into any valid RDF.Term.
"""
def coerce(value)
end
defimpl RDF.Term, for: RDF.IRI do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.IRI.equal_value?(term1, term2)
def coerce(term), do: term
end
defimpl RDF.Term, for: RDF.BlankNode do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.BlankNode.equal_value?(term1, term2)
def coerce(term), do: term
end
defimpl RDF.Term, for: Reference do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.BlankNode.new(term)
end
defimpl RDF.Term, for: RDF.Literal do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Literal.equal_value?(term1, term2)
def coerce(term), do: term
end
defimpl RDF.Term, for: Atom do
def equal?(term1, term2), do: term1 == term2
def equal_value?(nil, _), do: nil
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(true), do: RDF.true
def coerce(false), do: RDF.false
def coerce(_), do: nil
end
defimpl RDF.Term, for: BitString do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.String.new(term)
end
defimpl RDF.Term, for: Integer do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.Integer.new(term)
end
defimpl RDF.Term, for: Float do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.Double.new(term)
end
defimpl RDF.Term, for: DateTime do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.DateTime.new(term)
end
defimpl RDF.Term, for: NaiveDateTime do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.DateTime.new(term)
end
defimpl RDF.Term, for: Date do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.Date.new(term)
end
defimpl RDF.Term, for: Time do
def equal?(term1, term2), do: term1 == term2
def equal_value?(term1, term2), do: RDF.Term.equal_value?(coerce(term1), term2)
def coerce(term), do: RDF.Time.new(term)
end
defimpl RDF.Term, for: Any do
def equal?(term1, term2), do: term1 == term2
def equal_value?(_, _), do: nil
def coerce(_), do: nil
end

187
test/unit/equality_test.exs
View file

@ -72,17 +72,27 @@ defmodule RDF.EqualityTest do
]
@value_unequal_strings [
]
@value_equal_strings_by_coercion [
{RDF.string("foo"), "foo"},
]
@value_unequal_strings_by_coercion [
{RDF.string("foo"), "bar"},
]
@incomparable_strings [
{RDF.string("42"), 42},
{RDF.lang_string("foo", language: "de"), "foo"},
{RDF.string("foo"), RDF.lang_string("foo", language: "de")},
{RDF.lang_string("foo", language: "de"), RDF.string("foo")},
{RDF.string("foo"), RDF.bnode("foo")},
]
test "term equality", do: assert_term_equal @term_equal_strings
test "term inequality", do: assert_term_unequal @term_unequal_strings
test "value equality", do: assert_value_equal @value_equal_strings
test "value inequality", do: assert_value_unequal @value_unequal_strings
test "incomparability", do: assert_incomparable @incomparable_strings
test "term equality", do: assert_term_equal @term_equal_strings
test "term inequality", do: assert_term_unequal @term_unequal_strings
test "value equality", do: assert_value_equal @value_equal_strings
test "value inequality", do: assert_value_unequal @value_unequal_strings
test "coerced value equality", do: assert_value_equal @value_equal_strings_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_strings_by_coercion
test "incomparability", do: assert_incomparable @incomparable_strings
end
describe "RDF.Boolean" do
@ -110,18 +120,28 @@ defmodule RDF.EqualityTest do
# invalid literals
{RDF.boolean("foo"), RDF.boolean("bar")},
]
@value_equal_booleans_by_coercion [
{RDF.true, true},
{RDF.false, false},
]
@value_unequal_booleans_by_coercion [
{RDF.true, false},
{RDF.false, true},
]
@incomparable_booleans [
{RDF.true, nil},
{nil, RDF.true},
{RDF.true, RDF.string("FALSE")},
{RDF.integer(0), RDF.true},
{RDF.false, nil},
{RDF.true, 42},
{RDF.true, RDF.string("FALSE")},
{RDF.true, RDF.integer(0)},
]
test "term equality", do: assert_term_equal @term_equal_booleans
test "term inequality", do: assert_term_unequal @term_unequal_booleans
test "value equality", do: assert_value_equal @value_equal_booleans
test "value inequality", do: assert_value_unequal @value_unequal_booleans
test "incomparability", do: assert_incomparable @incomparable_booleans
test "term equality", do: assert_term_equal @term_equal_booleans
test "term inequality", do: assert_term_unequal @term_unequal_booleans
test "value equality", do: assert_value_equal @value_equal_booleans
test "value inequality", do: assert_value_unequal @value_unequal_booleans
test "coerced value equality", do: assert_value_equal @value_equal_booleans_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_booleans_by_coercion
test "incomparability", do: assert_incomparable @incomparable_booleans
end
describe "RDF.Numeric" do
@ -162,16 +182,33 @@ defmodule RDF.EqualityTest do
{RDF.decimal("foo"), RDF.decimal("bar")},
{RDF.double("foo"), RDF.double("bar")},
]
@value_equal_numerics_by_coercion [
{RDF.integer(42), 42},
{RDF.integer(42), 42.0},
{RDF.decimal(42), 42},
{RDF.decimal(3.14), 3.14},
{RDF.double(42), 42},
{RDF.double(3.14), 3.14},
]
@value_unequal_numerics_by_coercion [
{RDF.integer(3), 3.14},
{RDF.double(3.14), 3},
{RDF.decimal(3.14), 3},
]
@incomparable_numerics [
{RDF.string("42"), RDF.integer(42)},
{RDF.integer("42"), nil},
{RDF.integer("42"), true},
{RDF.integer("42"), "42"},
{RDF.integer("42"), RDF.string("42")},
]
test "term equality", do: assert_term_equal @term_equal_numerics
test "term inequality", do: assert_term_unequal @term_unequal_numerics
test "value equality", do: assert_value_equal @value_equal_numerics
test "value inequality", do: assert_value_unequal @value_unequal_numerics
test "incomparability", do: assert_incomparable @incomparable_numerics
test "term equality", do: assert_term_equal @term_equal_numerics
test "term inequality", do: assert_term_unequal @term_unequal_numerics
test "value equality", do: assert_value_equal @value_equal_numerics
test "value inequality", do: assert_value_unequal @value_unequal_numerics
test "coerced value equality", do: assert_value_equal @value_equal_numerics_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_numerics_by_coercion
test "incomparability", do: assert_incomparable @incomparable_numerics
end
describe "RDF.DateTime" do
@ -182,7 +219,7 @@ defmodule RDF.EqualityTest do
{RDF.date_time("foo"), RDF.date_time("foo")},
]
@term_unequal_datetimes [
{RDF.date_time("2002-04-02T12:00:00"), RDF.date_time("2002-04-02T17:00:00")},
{RDF.date_time("2002-04-02T12:00:00"), RDF.date_time("2002-04-02T17:00:00")},
# invalid literals
{RDF.date_time("foo"), RDF.date_time("bar")},
]
@ -200,18 +237,96 @@ defmodule RDF.EqualityTest do
# invalid literals
{RDF.date_time("foo"), RDF.date_time("bar")},
]
@value_equal_datetimes_by_coercion [
{RDF.date_time("2002-04-02T12:00:00-01:00"), elem(DateTime.from_iso8601("2002-04-02T12:00:00-01:00"), 1)},
{RDF.date_time("2002-04-02T12:00:00"), ~N"2002-04-02T12:00:00"},
]
@value_unequal_datetimes_by_coercion [
{RDF.date_time("2002-04-02T12:00:00-01:00"), elem(DateTime.from_iso8601("2002-04-02T12:00:00+00:00"), 1)},
]
@incomparable_datetimes [
{RDF.string("2002-04-02T12:00:00-01:00"), RDF.date_time("2002-04-02T12:00:00-01:00")},
{RDF.date_time("2002-04-02T12:00:00-01:00"), RDF.string("2002-04-02T12:00:00-01:00")},
]
test "term equality", do: assert_term_equal @term_equal_datetimes
test "term inequality", do: assert_term_unequal @term_unequal_datetimes
test "value equality", do: assert_value_equal @value_equal_datetimes
test "value inequality", do: assert_value_unequal @value_unequal_datetimes
test "incomparability", do: assert_incomparable @incomparable_datetimes
test "term equality", do: assert_term_equal @term_equal_datetimes
test "term inequality", do: assert_term_unequal @term_unequal_datetimes
test "value equality", do: assert_value_equal @value_equal_datetimes
test "value inequality", do: assert_value_unequal @value_unequal_datetimes
test "coerced value equality", do: assert_value_equal @value_equal_datetimes_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_datetimes_by_coercion
test "incomparability", do: assert_incomparable @incomparable_datetimes
end
describe "RDF.Date" do
@term_equal_dates [
{RDF.date("2002-04-02-01:00"), RDF.date("2002-04-02-01:00")},
{RDF.date("2002-04-02"), RDF.date("2002-04-02")},
# invalid literals
{RDF.date("foo"), RDF.date("foo")},
]
@term_unequal_dates [
{RDF.date("2002-04-01"), RDF.date("2002-04-02")},
# invalid literals
{RDF.date("foo"), RDF.date("bar")},
]
@value_equal_dates [
]
@value_unequal_dates [
]
@value_equal_dates_by_coercion [
{RDF.date("2002-04-02"), Date.from_iso8601!("2002-04-02")},
]
@value_unequal_dates_by_coercion [
{RDF.date("2002-04-02"), Date.from_iso8601!("2002-04-03")},
]
@incomparable_dates [
{RDF.date("2002-04-02"), RDF.string("2002-04-02")},
]
test "term equality", do: assert_term_equal @term_equal_dates
test "term inequality", do: assert_term_unequal @term_unequal_dates
test "value equality", do: assert_value_equal @value_equal_dates
test "value inequality", do: assert_value_unequal @value_unequal_dates
test "coerced value equality", do: assert_value_equal @value_equal_dates_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_dates_by_coercion
test "incomparability", do: assert_incomparable @incomparable_dates
end
describe "RDF.Time" do
@term_equal_times [
{RDF.time("12:00:00+01:00"), RDF.time("12:00:00+01:00")},
{RDF.time("12:00:00"), RDF.time("12:00:00")},
# invalid literals
{RDF.time("foo"), RDF.time("foo")},
]
@term_unequal_times [
{RDF.time("12:00:00"), RDF.time("13:00:00")},
# invalid literals
{RDF.time("foo"), RDF.time("bar")},
]
@value_equal_times [
]
@value_unequal_times [
]
@value_equal_times_by_coercion [
{RDF.time("12:00:00"), Time.from_iso8601!("12:00:00")},
]
@value_unequal_times_by_coercion [
{RDF.time("12:00:00"), Time.from_iso8601!("13:00:00")},
]
@incomparable_times [
{RDF.time("12:00:00"), RDF.string("12:00:00")},
]
test "term equality", do: assert_term_equal @term_equal_times
test "term inequality", do: assert_term_unequal @term_unequal_times
test "value equality", do: assert_value_equal @value_equal_times
test "value inequality", do: assert_value_unequal @value_unequal_times
test "coerced value equality", do: assert_value_equal @value_equal_times_by_coercion
test "coerced value inequality", do: assert_value_unequal @value_unequal_times_by_coercion
test "incomparability", do: assert_incomparable @incomparable_times
end
describe "RDF.Literals with unsupported types" do
@equal_literals [
{RDF.literal("foo", datatype: "http://example.com/datatype"),
@ -264,6 +379,15 @@ defmodule RDF.EqualityTest do
to be: #{inspect expected}
but got: #{inspect result}
"""
result = RDF.Term.equal?(right, left)
assert result == expected, """
expected RDF.Term.equal?(
#{inspect right},
#{inspect left})
to be: #{inspect expected}
but got: #{inspect result}
"""
end
defp assert_value_equality({left, right}, expected) do
@ -275,6 +399,15 @@ defmodule RDF.EqualityTest do
to be: #{inspect expected}
but got: #{inspect result}
"""
result = RDF.Term.equal_value?(right, left)
assert result == expected, """
expected RDF.Term.equal_value?(
#{inspect right},
#{inspect left})
to be: #{inspect expected}
but got: #{inspect result}
"""
end
end

62
test/unit/term_test.exs Normal file
View file

@ -0,0 +1,62 @@
defmodule RDF.TermTest do
use RDF.Test.Case
doctest RDF.Term
describe "coerce/1" do
test "with RDF.IRI" do
assert RDF.Term.coerce(~I<http://example.com/>) == ~I<http://example.com/>
end
test "with RDF.BlankNode" do
assert RDF.Term.coerce(~B<foo>) == ~B<foo>
end
test "with RDF.Literal" do
assert RDF.Term.coerce(~L"foo") == ~L"foo"
end
test "with boolean" do
assert RDF.Term.coerce(true) == RDF.true
assert RDF.Term.coerce(false) == RDF.false
end
test "with string" do
assert RDF.Term.coerce("foo") == ~L"foo"
end
test "with integer" do
assert RDF.Term.coerce(42) == RDF.integer(42)
end
test "with float" do
assert RDF.Term.coerce(3.14) == RDF.double(3.14)
end
test "with datetime" do
assert DateTime.from_iso8601("2002-04-02T12:00:00+00:00") |> elem(1) |> RDF.Term.coerce() ==
DateTime.from_iso8601("2002-04-02T12:00:00+00:00") |> elem(1) |> RDF.datetime()
assert ~N"2002-04-02T12:00:00" |> RDF.Term.coerce() ==
~N"2002-04-02T12:00:00" |> RDF.datetime()
end
test "with date" do
assert ~D"2002-04-02" |> RDF.Term.coerce() ==
~D"2002-04-02" |> RDF.date()
end
test "with time" do
assert ~T"12:00:00" |> RDF.Term.coerce() ==
~T"12:00:00" |> RDF.time()
end
test "with reference" do
ref = make_ref()
assert RDF.Term.coerce(ref) == RDF.bnode(ref)
end
test "with inconvertible values" do
assert self() |> RDF.Term.coerce() == nil
end
end
end