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

core: terms from the RDF.NS.RDF namespace are directly accessible from the top-level RDF module

Browse source
This commit is contained in:
Marcel Otto 2017-06-10 23:08:49 +02:00
parent f3d0ce35f5
commit d83a0c508d
7 changed files with 88 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
lib/rdf.ex
View file

@ -117,14 +117,16 @@ defmodule RDF do
def resource?(_), do: false
################################################################################
# temporary manual RDF vocab definitions
# TODO: These should be defined as a vocabulary
for term <- ~w[type subject predicate object first rest value]a do
defdelegate unquote(term)(), to: RDF.NS.RDF
defdelegate unquote(term)(s, o), to: RDF.NS.RDF
defdelegate unquote(term)(s, o1, o2), to: RDF.NS.RDF
defdelegate unquote(term)(s, o1, o2, o3), to: RDF.NS.RDF
defdelegate unquote(term)(s, o1, o2, o3, o4), to: RDF.NS.RDF
defdelegate unquote(term)(s, o1, o2, o3, o4, o5), to: RDF.NS.RDF
end
@rdf_type URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
def type, do: @rdf_type
@rdf_langString URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
def langString, do: @rdf_langString
defdelegate langString(), to: RDF.NS.RDF
defdelegate unquote(nil)(), to: RDF.NS.RDF
end

4
lib/rdf/datatype.ex
View file

@ -57,9 +57,11 @@ defmodule RDF.Datatype do
@callback valid?(literal :: RDF.Literal.t) :: boolean
@lang_string RDF.uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
# TODO: This mapping should be created dynamically and be extendable, to allow user-defined datatypes ...
@mapping %{
RDF.langString => RDF.LangString,
@lang_string => RDF.LangString,
XSD.string => RDF.String,
XSD.integer => RDF.Integer,
XSD.double => RDF.Double,

2
lib/rdf/datatypes/lang_string.ex
View file

@ -3,7 +3,7 @@ defmodule RDF.LangString do
`RDF.Datatype` for RDF langString.
"""
use RDF.Datatype, id: RDF.langString
use RDF.Datatype, id: RDF.uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
def build_literal(value, lexical, %{language: language} = opts) do

4
lib/rdf/literal.ex
View file

@ -11,7 +11,7 @@ defmodule RDF.Literal do
# to be able to pattern-match on plain types
@xsd_string XSD.string
@lang_string RDF.langString
@lang_string RDF.uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
@plain_types [@xsd_string, @lang_string]
@ -62,7 +62,7 @@ defmodule RDF.Literal do
def new(value, %{language: language} = opts) when not is_nil(language) do
if is_binary(value) do
if opts[:datatype] in [nil, RDF.langString] do
if opts[:datatype] in [nil, @lang_string] do
RDF.LangString.new(value, opts)
else
raise ArgumentError, "datatype with language must be rdf:langString"

31
lib/rdf/namespace.ex
View file

@ -27,23 +27,21 @@ defmodule RDF.Namespace do
"""
def resolve_term(expr)
def resolve_term(uri = %URI{}),
do: uri
def resolve_term(namespaced_term) when is_atom(namespaced_term),
do: namespaced_term |> to_string() |> do_resolve_term()
def resolve_term(uri = %URI{}), do: uri
def resolve_term(namespaced_term) when is_atom(namespaced_term) do
namespaced_term
|> to_string()
|> do_resolve_term()
end
defp do_resolve_term("Elixir." <> _ = namespaced_term) do
{term, namespace} =
namespaced_term
|> Module.split
|> List.pop_at(-1)
{term, namespace} = {String.to_atom(term), Module.concat(namespace)}
if Keyword.has_key?(namespace.__info__(:functions), :__resolve_term__) do
namespace.__resolve_term__(term)
else
raise RDF.Namespace.UndefinedTermError,
"#{namespaced_term} is not a term on a RDF.Namespace"
end
do_resolve_term(Module.concat(namespace), String.to_atom(term))
end
defp do_resolve_term(namespaced_term) do
@ -51,4 +49,15 @@ defmodule RDF.Namespace do
"#{namespaced_term} is not a term on a RDF.Namespace"
end
defp do_resolve_term(RDF, term), do: do_resolve_term(RDF.NS.RDF, term)
defp do_resolve_term(namespace, term) do
if Keyword.has_key?(namespace.__info__(:functions), :__resolve_term__) do
namespace.__resolve_term__(term)
else
raise RDF.Namespace.UndefinedTermError,
"#{namespace} is not a RDF.Namespace"
end
end
end

4
lib/rdf/utils/resource_classifier.ex
View file

@ -2,13 +2,15 @@ defmodule RDF.Utils.ResourceClassifier do
alias RDF.Description
@rdf_type RDF.uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
@doc """
Determines if the given resource is RDF property by
"""
def property?(resource, data) do
with %Description{} = description <- RDF.Data.description(data, resource) do
property_by_domain?(description) or
property_by_rdf_type?(Description.get(description, RDF.type))
property_by_rdf_type?(Description.get(description, @rdf_type))
end
# || property_by_predicate_usage?(resource, data)
end

42
test/unit/vocabulary_namespace_test.exs
View file

@ -591,4 +591,46 @@ defmodule RDF.Vocabulary.NamespaceTest do
end
end
describe "term resolution on the top-level RDF module" do
test "capitalized terms" do
assert RDF.uri(RDF.Property) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Property")
assert RDF.uri(RDF.Statement) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement")
assert RDF.uri(RDF.List) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#List")
assert RDF.uri(RDF.Nil) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil")
assert RDF.uri(RDF.Seq) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq")
assert RDF.uri(RDF.Bag) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Bag")
assert RDF.uri(RDF.Alt) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Alt")
assert RDF.uri(RDF.LangString) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
assert RDF.uri(RDF.PlainLiteral) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral")
assert RDF.uri(RDF.XMLLiteral) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral")
assert RDF.uri(RDF.HTML) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML")
assert RDF.uri(RDF.Property) == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#Property")
end
test "lowercase terms" do
assert RDF.type == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
assert RDF.subject == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject")
assert RDF.predicate == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate")
assert RDF.object == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#object")
assert RDF.first == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#first")
assert RDF.rest == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest")
assert RDF.value == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#value")
assert RDF.langString == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
assert RDF.nil == URI.parse("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil")
end
test "description DSL" do
alias TestNS.EX
assert RDF.type( EX.S, 1) == RDF.NS.RDF.type( EX.S, 1)
assert RDF.subject( EX.S, 1, 2) == RDF.NS.RDF.subject( EX.S, 1, 2)
assert RDF.predicate(EX.S, 1, 2, 3) == RDF.NS.RDF.predicate(EX.S, 1, 2, 3)
assert RDF.object( EX.S, 1, 2, 3, 4) == RDF.NS.RDF.object( EX.S, 1, 2, 3, 4)
assert RDF.first( EX.S, 1, 2, 3, 4, 5) == RDF.NS.RDF.first( EX.S, 1, 2, 3, 4, 5)
assert RDF.rest( EX.S, [1, 2, 3, 4, 5, 6]) == RDF.NS.RDF.rest( EX.S, [1, 2, 3, 4, 5, 6])
assert RDF.value( EX.S, [1, 2, 3, 4, 5, 6, 7]) == RDF.NS.RDF.value( EX.S, [1, 2, 3, 4, 5, 6, 7])
end
end
end