Rename RDF.Literal.datatype/1 and similar functions to datatype_id/1

lib/rdf/literal.ex

@@ -214,8 +214,8 @@ defmodule RDF.Literal do
   ############################################################################
   # functions delegating to the RDF.Literal.Datatype of a RDF.Literal
 
-  @spec datatype(t) :: IRI.t()
-  def datatype(%__MODULE__{literal: %datatype{} = literal}), do: datatype.datatype(literal)
+  @spec datatype_id(t) :: IRI.t()
+  def datatype_id(%__MODULE__{literal: %datatype{} = literal}), do: datatype.datatype_id(literal)
 
   @spec language(t) :: String.t() | nil
   def language(%__MODULE__{literal: %datatype{} = literal}), do: datatype.language(literal)

lib/rdf/literal/datatype.ex

@@ -48,7 +48,7 @@ defmodule RDF.Literal.Datatype do
   @doc """
   The datatype IRI of the given `RDF.Literal`.
   """
-  @callback datatype(Literal.t | literal) :: IRI.t()
+  @callback datatype_id(Literal.t | literal) :: IRI.t()
 
   @doc """
   The language of the given `RDF.Literal` if present.
@@ -203,8 +203,8 @@ defmodule RDF.Literal.Datatype do
       end
 
       @impl unquote(__MODULE__)
-      def datatype(%Literal{literal: literal}), do: datatype(literal)
-      def datatype(%__MODULE__{}), do: @id
+      def datatype_id(%Literal{literal: literal}), do: datatype_id(literal)
+      def datatype_id(%__MODULE__{}), do: @id
 
       @impl unquote(__MODULE__)
       def language(%Literal{literal: literal}), do: language(literal)
@@ -298,7 +298,7 @@ defmodule RDF.Literal.Datatype do
       # RDF.Literal/new/1, to bypass the unnecessary datatype checks.
       defp literal(datatype_literal), do: %Literal{literal: datatype_literal}
 
-      defoverridable datatype: 1,
+      defoverridable datatype_id: 1,
                      language: 1,
                      cast: 1,
                      do_cast: 1,

lib/rdf/literal/datatype/registry.ex

@@ -166,7 +166,7 @@ defmodule RDF.Literal.Datatype.Registry do
   Returns the `RDF.Literal.Datatype` for a datatype IRI.
   """
   @spec datatype(Literal.t | IRI.t | String.t) :: Literal.Datatype.t
-  def datatype(%Literal{} = literal), do: Literal.datatype(literal)
+  def datatype(%Literal{} = literal), do: literal.literal.__struct__
   def datatype(%IRI{} = id), do: id |> to_string() |> datatype()
   def datatype(id) when maybe_ns_term(id), do: id |> Namespace.resolve_term!() |> datatype()
   def datatype(id) when is_binary(id), do: Registration.datatype(id)

lib/rdf/literal/datatypes/generic.ex

@@ -48,8 +48,8 @@ defmodule RDF.Literal.Generic do
   end
 
   @impl Datatype
-  def datatype(%Literal{literal: literal}), do: datatype(literal)
-  def datatype(%__MODULE__{} = literal), do: literal.datatype
+  def datatype_id(%Literal{literal: literal}), do: datatype_id(literal)
+  def datatype_id(%__MODULE__{} = literal), do: literal.datatype
 
   @impl Datatype
   def value(%Literal{literal: literal}), do: value(literal)

lib/rdf/serializations/ntriples_encoder.ex

@@ -37,7 +37,7 @@ defmodule RDF.NTriples.Encoder do
   end
 
   def term(%Literal{} = literal) do
-    ~s["#{Literal.lexical(literal)}"^^<#{to_string(Literal.datatype(literal))}>]
+    ~s["#{Literal.lexical(literal)}"^^<#{to_string(Literal.datatype_id(literal))}>]
   end
 
   def term(%BlankNode{} = bnode) do

lib/rdf/serializations/turtle_encoder.ex

@@ -328,7 +328,7 @@ defmodule RDF.Turtle.Encoder do
 
 
   defp typed_literal_term(%Literal{} = literal, state, nesting),
-    do: ~s["#{Literal.lexical(literal)}"^^#{literal |> Literal.datatype() |> term(state, :datatype, nesting)}]
+    do: ~s["#{Literal.lexical(literal)}"^^#{literal |> Literal.datatype_id() |> term(state, :datatype, nesting)}]
 
 
   def prefixed_name(iri, prefixes) do

test/support/xsd_datatype_case.ex

@@ -145,9 +145,9 @@ defmodule RDF.XSD.Datatype.Test.Case do
           end
         end
 
-        test "datatype/1" do
+        test "datatype_id/1" do
           Enum.each(@valid, fn {input, _} ->
-            assert (unquote(datatype).new(input) |> unquote(datatype).datatype()) == RDF.iri(unquote(datatype_iri))
+            assert (unquote(datatype).new(input) |> unquote(datatype).datatype_id()) == RDF.iri(unquote(datatype_iri))
           end)
         end
 

test/unit/datatypes/generic_test.exs

@@ -99,9 +99,9 @@ defmodule RDF.Literal.GenericTest do
     end
   end
 
-  test "datatype/1" do
+  test "datatype_id/1" do
     Enum.each @valid, fn {input, {_, datatype}} ->
-      assert (Generic.new(input, datatype: datatype) |> Generic.datatype()) == RDF.iri(datatype)
+      assert (Generic.new(input, datatype: datatype) |> Generic.datatype_id()) == RDF.iri(datatype)
     end
   end
 

test/unit/datatypes/lang_string_test.exs

@@ -109,9 +109,9 @@ defmodule RDF.LangStringTest do
     end
   end
 
-  test "datatype/1" do
+  test "datatype_id/1" do
     Enum.each @valid, fn {input, {_, language}} ->
-      assert (LangString.new(input, language: language) |> LangString.datatype()) == RDF.iri(LangString.id())
+      assert (LangString.new(input, language: language) |> LangString.datatype_id()) == RDF.iri(LangString.id())
     end
   end
 

test/unit/literal/datatype/registry_test.exs

@@ -66,6 +66,14 @@ defmodule RDF.Literal.Datatype.RegistryTest do
     test "with namespace terms" do
       assert Age == Datatype.Registry.datatype(EX.Age)
     end
+
+    test "with a RDF.Literal" do
+      assert XSD.String == Datatype.Registry.datatype(XSD.string("foo"))
+      assert XSD.Integer == Datatype.Registry.datatype(XSD.integer(42))
+      assert XSD.Byte == Datatype.Registry.datatype(XSD.byte(42))
+      assert RDF.LangString == Datatype.Registry.datatype(~L"foo"en)
+      assert RDF.Literal.Generic == Datatype.Registry.datatype(RDF.literal("foo", datatype: "http://example.com"))
+    end
   end
 
   test "datatype?/1" do

test/unit/literal_test.exs

@@ -227,11 +227,11 @@ defmodule RDF.LiteralTest do
     end
   end
 
-  describe "datatype/1" do
+  describe "datatype_id/1" do
     Enum.each literals(:all_simple), fn literal ->
       @tag literal: literal
       test "simple literal #{inspect literal} has datatype xsd:string", %{literal: literal} do
-        assert Literal.datatype(literal) == NS.XSD.string
+        assert Literal.datatype_id(literal) == NS.XSD.string
       end
     end
 
@@ -249,7 +249,7 @@ defmodule RDF.LiteralTest do
          @tag data: %{literal: literal = Literal.new(value), type: type}
          test "Literal for #{inspect literal} has datatype xsd:#{type}",
               %{data: %{literal: literal, type: type}} do
-           assert Literal.datatype(literal) == apply(NS.XSD, String.to_atom(type), [])
+           assert Literal.datatype_id(literal) == apply(NS.XSD, String.to_atom(type), [])
          end
        end)
   end