Add RDF.Term.coerce/1

CHANGELOG.md

@@ -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 

lib/rdf/datatype.ex

@@ -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
 
 

lib/rdf/datatypes/numeric.ex

@@ -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})
+                   %Literal{datatype: right_datatype, value: right}) do
-  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)

lib/rdf/literal.ex

@@ -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

lib/rdf/term.ex

@@ -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

test/unit/equality_test.exs

@@ -72,7 +72,15 @@ 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")},
@@ -82,6 +90,8 @@ defmodule RDF.EqualityTest do
     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
 
@@ -110,17 +120,27 @@ 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},
+      {RDF.false, nil},
-      {nil,            RDF.true},
+      {RDF.true,  42},
       {RDF.true,  RDF.string("FALSE")},
-      {RDF.integer(0), RDF.true},
+      {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 "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
 
@@ -162,8 +182,23 @@ 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")},
     ]
 
@@ -171,6 +206,8 @@ defmodule RDF.EqualityTest do
     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
 
@@ -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 "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

test/unit/term_test.exs

@@ -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