Add RDF.Term.value/1

CHANGELOG.md

@@ -5,6 +5,16 @@ This project adheres to [Semantic Versioning](http://semver.org/) and
 [Keep a CHANGELOG](http://keepachangelog.com).
 
 
+## Unreleased
+
+### Added
+
+- `RDF.Term.value/1` returning the native Elixir value of a RDF term
+
+[Compare v0.5.1...HEAD](https://github.com/marcelotto/rdf-ex/compare/v0.5.1...HEAD)
+
+
+
 ## 0.5.1 - 2018-09-17
 
 ### Fixed

lib/rdf/term.ex

@@ -63,15 +63,41 @@ defprotocol RDF.Term do
   Converts a given value into a RDF term.
 
   Returns `nil` if the given value is not convertible into any valid RDF.Term.
+
+  ## Examples
+
+      iex> RDF.Term.coerce("foo")
+      ~L"foo"
+      iex> RDF.Term.coerce(42)
+      RDF.integer(42)
+
   """
   def coerce(value)
 
+  @doc """
+  Returns the native Elixir value of a RDF term.
+
+  Returns `nil` if the given value is not a a valid RDF term or a value convertible to a RDF term.
+
+  ## Examples
+
+      iex> RDF.Term.value(~I<http://example.com/>)
+      "http://example.com/"
+      iex> RDF.Term.value(~L"foo")
+      "foo"
+      iex> RDF.integer(42) |> RDF.Term.value()
+      42
+
+  """
+  def value(term)
+
 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
+  def value(term),                do: term.value
   def term?(_),                   do: true
 end
 
@@ -79,6 +105,7 @@ 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
+  def value(term),                do: to_string(term)
   def term?(_),                   do: true
 end
 
@@ -86,6 +113,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -93,6 +121,7 @@ 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
+  def value(term),                do: term.value  || RDF.Literal.lexical(term)
   def term?(_),                   do: true
 end
 
@@ -106,6 +135,10 @@ defimpl RDF.Term, for: Atom do
   def coerce(false), do: RDF.false
   def coerce(_),     do: nil
 
+  def value(true),  do: true
+  def value(false), do: false
+  def value(_),     do: nil
+
   def term?(_), do: false
 end
 
@@ -113,6 +146,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -120,6 +154,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -127,6 +162,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -134,6 +170,7 @@ defimpl RDF.Term, for: Decimal 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.Decimal.new(term)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -141,6 +178,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -148,6 +186,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -155,6 +194,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -162,6 +202,7 @@ 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)
+  def value(term),                do: term
   def term?(_),                   do: false
 end
 
@@ -169,5 +210,6 @@ defimpl RDF.Term, for: Any do
   def equal?(term1, term2), do: term1 == term2
   def equal_value?(_, _),   do: nil
   def coerce(_),            do: nil
+  def value(_),             do: nil
   def term?(_),             do: false
 end

test/unit/term_test.exs

@@ -65,4 +65,66 @@ defmodule RDF.TermTest do
       assert self() |> RDF.Term.coerce() == nil
     end
   end
+
+  describe "value/1" do
+    test "with RDF.IRI" do
+      assert RDF.Term.value(~I<http://example.com/>) == "http://example.com/"
+    end
+
+    test "with RDF.BlankNode" do
+      assert RDF.Term.value(~B<foo>) == "_:foo"
+    end
+
+    test "with a valid RDF.Literal" do
+      assert RDF.Term.value(~L"foo") == "foo"
+    end
+
+    test "with an invalid RDF.Literal" do
+      assert RDF.integer("foo") |> RDF.Term.value() == "foo"
+    end
+
+    test "with boolean" do
+      assert RDF.Term.value(true) == true
+      assert RDF.Term.value(false) == false
+    end
+
+    test "with string" do
+      assert RDF.Term.value("foo") == "foo"
+    end
+
+    test "with integer" do
+      assert RDF.Term.value(42) == 42
+    end
+
+    test "with float" do
+      assert RDF.Term.value(3.14) == 3.14
+    end
+
+    test "with decimal" do
+      assert D.new(3.14) |> RDF.Term.value() == D.new(3.14)
+    end
+
+    test "with datetime" do
+      assert DateTime.from_iso8601("2002-04-02T12:00:00+00:00") |> elem(1) |> RDF.Term.value() ==
+             DateTime.from_iso8601("2002-04-02T12:00:00+00:00") |> elem(1)
+      assert ~N"2002-04-02T12:00:00" |> RDF.Term.value() == ~N"2002-04-02T12:00:00"
+    end
+
+    test "with date" do
+      assert ~D"2002-04-02" |> RDF.Term.value() == ~D"2002-04-02"
+    end
+
+    test "with time" do
+      assert ~T"12:00:00" |> RDF.Term.value() == ~T"12:00:00"
+    end
+
+    test "with reference" do
+      ref = make_ref()
+      assert RDF.Term.value(ref) == ref
+    end
+
+    test "with inconvertible values" do
+      assert self() |> RDF.Term.value() == nil
+    end
+  end
 end