diff --git a/CHANGELOG.md b/CHANGELOG.md index 6114161..52b6af6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,17 @@ This project adheres to [Semantic Versioning](http://semver.org/) and [Keep a CHANGELOG](http://keepachangelog.com). +## Unreleased + +### Added + +- top-level alias functions for constructors of the basic datatypes + + +[Compare v0.4.1...HEAD](https://github.com/marcelotto/rdf-ex/compare/v0.4.1...HEAD) + + + ## 0.4.1 - 2018-03-19 ### Added diff --git a/README.md b/README.md index d8ff615..31ce425 100644 --- a/README.md +++ b/README.md @@ -329,7 +329,7 @@ iex> RDF.literal(42, datatype: XSD.double).value 42.0 ``` -For all of these supported XSD datatypes there're `RDF.Datatype`s available that allow the creation of `RDF.Literal`s with the respective datatype: +For all of these supported XSD datatypes there're `RDF.Datatype`s available that allow the creation of `RDF.Literal`s with the respective datatype. Their `new` constructor function can be called also via the alias functions on the top-level `RDF` namespace. ```elixir iex> RDF.Double.new("0042").value @@ -337,15 +337,18 @@ iex> RDF.Double.new("0042").value iex> RDF.Double.new(42).value 42.0 + +iex> RDF.double(42).value +42.0 ``` The `RDF.Literal.valid?/1` function checks if a given literal is valid according to the [XML schema datatype] specification. ```elixir -iex> RDF.Literal.valid? RDF.Integer.new("42") +iex> RDF.Literal.valid? RDF.integer("42") true -iex> RDF.Literal.valid? RDF.Integer.new("foo") +iex> RDF.Literal.valid? RDF.integer("foo") false ``` @@ -354,31 +357,31 @@ If you want to prohibit the creation of invalid literals, you can use the `new!` A RDF literal is bound to the lexical form of the initially given value. This lexical representation can be retrieved with the `RDF.Literal.lexical/1` function: ```elixir -iex> RDF.Literal.lexical RDF.Integer.new("0042") +iex> RDF.Literal.lexical RDF.integer("0042") "0042" -iex> RDF.Literal.lexical RDF.Integer.new(42) +iex> RDF.Literal.lexical RDF.integer(42) "42" ``` Although two literals might have the same value, they are not equal if they don't have the same lexical form: ```elixir -iex> RDF.Integer.new("0042").value == RDF.Integer.new("42").value +iex> RDF.integer("0042").value == RDF.integer("42").value true -iex> RDF.Integer.new("0042") == RDF.Integer.new("42") +iex> RDF.integer("0042") == RDF.integer("42") false ``` The `RDF.Literal.canonical/1` function returns the given literal with its canonical lexical form according its datatype: ```elixir -iex> RDF.Integer.new("0042") |> RDF.Literal.canonical |> RDF.Literal.lexical +iex> RDF.integer("0042") |> RDF.Literal.canonical |> RDF.Literal.lexical "42" -iex> RDF.Literal.canonical(RDF.Integer.new("0042")) == - RDF.Literal.canonical(RDF.Integer.new("42")) +iex> RDF.Literal.canonical(RDF.integer("0042")) == + RDF.Literal.canonical(RDF.integer("42")) true ``` @@ -394,13 +397,13 @@ The `RDF.Triple` and `RDF.Quad` modules both provide a function `new` for such t ```elixir iex> RDF.triple(EX.S, EX.p, 1) -{~I, ~I, RDF.Integer.new(1)} +{~I, ~I, RDF.integer(1)} iex> RDF.triple {EX.S, EX.p, 1} -{~I, ~I, RDF.Integer.new(1)} +{~I, ~I, RDF.integer(1)} iex> RDF.quad(EX.S, EX.p, 1, EX.Graph) -{~I, ~I, RDF.Integer.new(1), +{~I, ~I, RDF.integer(1), ~I} iex> RDF.triple {EX.S, 1, EX.O} @@ -413,7 +416,7 @@ If you want to explicitly create a quad in the default graph context, you can us ```elixir iex> RDF.quad(EX.S, EX.p, 1, nil) -{~I, ~I, RDF.Integer.new(1), nil} +{~I, ~I, RDF.integer(1), nil} ``` diff --git a/VERSION b/VERSION index 267577d..7532512 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.4.1 +0.4.2-dev diff --git a/lib/rdf.ex b/lib/rdf.ex index ad77841..66a0516 100644 --- a/lib/rdf.ex +++ b/lib/rdf.ex @@ -121,16 +121,26 @@ defmodule RDF do defdelegate list?(resource, graph), to: RDF.List, as: :node? defdelegate list?(description), to: RDF.List, as: :node? - def list(native_list), - do: RDF.List.from(native_list) - - def list(head, %Graph{} = graph), - do: RDF.List.new(head, graph) - - def list(native_list, opts), - do: RDF.List.from(native_list, opts) - + def list(native_list), do: RDF.List.from(native_list) + def list(head, %Graph{} = graph), do: RDF.List.new(head, graph) + def list(native_list, opts), do: RDF.List.from(native_list, opts) + defdelegate string(value), to: RDF.String, as: :new + defdelegate string(value, opts), to: RDF.String, as: :new + defdelegate lang_string(value), to: RDF.LangString, as: :new + defdelegate lang_string(value, opts), to: RDF.LangString, as: :new + defdelegate boolean(value), to: RDF.Boolean, as: :new + defdelegate boolean(value, opts), to: RDF.Boolean, as: :new + defdelegate integer(value), to: RDF.Integer, as: :new + defdelegate integer(value, opts), to: RDF.Integer, as: :new + defdelegate double(value), to: RDF.Double, as: :new + defdelegate double(value, opts), to: RDF.Double, as: :new + defdelegate date(value), to: RDF.Date, as: :new + defdelegate date(value, opts), to: RDF.Date, as: :new + defdelegate time(value), to: RDF.Time, as: :new + defdelegate time(value, opts), to: RDF.Time, as: :new + defdelegate date_time(value), to: RDF.DateTime, as: :new + defdelegate date_time(value, opts), to: RDF.DateTime, as: :new for term <- ~w[type subject predicate object first rest value]a do defdelegate unquote(term)(), to: RDF.NS.RDF diff --git a/test/unit/rdf_test.exs b/test/unit/rdf_test.exs index 10064c2..122ef04 100644 --- a/test/unit/rdf_test.exs +++ b/test/unit/rdf_test.exs @@ -2,4 +2,13 @@ defmodule RDFTest do use RDF.Test.Case doctest RDF + + test "Datatype constructor alias functions" do + RDF.Datatype.modules + |> Enum.each(fn datatype -> + "rdf/" <> alias_name = datatype |> Macro.underscore + assert apply(RDF, String.to_atom(alias_name), [1]) == datatype.new(1) + end) + end + end