defmodule RDF.Vocabulary.Namespace do @moduledoc """ Defines a RDF Vocabulary as a `RDF.Namespace`. ## Strict vocabularies What is a strict vocabulary and why should I use them over non-strict vocabularies and define all terms ... ## Defining a vocabulary There are two basic ways to define a vocabulary: 1. You can define all terms manually. 2. You can load all terms from a specified namespace in a given dataset or graph. Either way, you'll first have to define a new module for your vocabulary: defmodule Example do use RDF.Vocabulary.Namespace defvocab EX, base_uri: "http://www.example.com/ns/", terms: ~w[Foo bar] # Your term definitions end The `base_uri` argument with the URI prefix of all the terms in the defined vocabulary is required and expects a valid URI ending with either a `"/"` or a `"#"`. ## Reflection `__base_uri__` and `__terms__` ... """ @vocabs_dir "priv/vocabs" defmacro __using__(_opts) do quote do import unquote(__MODULE__) end end @doc """ Defines a `RDF.Namespace` module for a RDF vocabulary. """ defmacro defvocab(name, opts) do base_uri = base_uri!(opts) file = file!(opts) terms = terms!(opts) strict = Keyword.get(opts, :strict, true) case_separated_terms = group_terms_by_case(terms) lowercased_terms = Map.get(case_separated_terms, :lowercased, []) capitalized_terms = Map.get(case_separated_terms, :capitalized, []) quote do vocabdoc = Module.delete_attribute(__MODULE__, :vocabdoc) defmodule unquote(name) do @moduledoc vocabdoc @behaviour RDF.Namespace if unquote(file) do @external_resource unquote(file) end @base_uri unquote(base_uri) def __base_uri__, do: @base_uri @strict unquote(strict) def __strict__, do: @strict @lowercased_terms unquote(lowercased_terms |> Enum.map(&String.to_atom/1)) @capitalized_terms unquote(capitalized_terms |> Enum.map(&String.to_atom/1)) @terms @lowercased_terms ++ @capitalized_terms def __terms__, do: @terms define_vocab_terms unquote(lowercased_terms), unquote(base_uri) if @strict do def __resolve_term__(term) do if Enum.member?(@capitalized_terms, term) do term_to_uri(@base_uri, term) else raise RDF.Namespace.UndefinedTermError, "undefined term #{term} in strict vocabulary #{__MODULE__}" end end else def __resolve_term__(term) do term_to_uri(@base_uri, term) end def unquote(:"$handle_undefined_function")(term, args) do term_to_uri(@base_uri, term) end end Module.delete_attribute(__MODULE__, :tmp_uri) end end end defp base_uri!(opts) do base_uri = Keyword.fetch!(opts, :base_uri) unless String.ends_with?(base_uri, ["/", "#"]) do raise RDF.Namespace.InvalidVocabBaseURIError, "a base_uri without a trailing '/' or '#' is invalid" else base_uri end end def terms!(opts) do cond do Keyword.has_key?(opts, :file) -> opts |> Keyword.delete(:file) |> Keyword.put(:data, load_file(file!(opts))) |> terms! data = Keyword.get(opts, :data) -> # TODO: support also RDF.Datasets ... data = unless match?(%RDF.Graph{}, data) do # TODO: find an alternative to Code.eval_quoted {data, _ } = Code.eval_quoted(data, [], data_env()) data else data end data_vocab_terms(data, Keyword.fetch!(opts, :base_uri)) terms = Keyword.get(opts, :terms) -> # TODO: find an alternative to Code.eval_quoted - We want to support that the terms can be given as sigils ... {terms, _ } = Code.eval_quoted(terms, [], data_env()) terms |> Enum.map(&to_string/1) true -> raise KeyError, key: ~w[terms data file], term: opts end end def file!(opts) do if file = Keyword.get(opts, :file) do cond do File.exists?(file) -> file File.exists?(expanded_file = Path.expand(file, @vocabs_dir)) -> expanded_file true -> raise File.Error, path: file, action: "find", reason: :enoent end end end defp load_file(file) do RDF.NTriples.read_file!(file) end defp data_env do __ENV__ end defmacro define_vocab_terms(terms, base_uri) do Enum.map terms, fn term -> # TODO: Why does this way of precompiling the URI not work? We're getting an "invalid quoted expression: %URI{...}" # uri = term_to_uri(base_uri, term) # quote bind_quoted: [uri: Macro.escape(uri), term: String.to_atom(term)] do ## @doc "<#{@tmp_uri}>" # def unquote(term)() do # unquote(uri) # end # end # Temporary workaround: quote do @tmp_uri term_to_uri(@base_uri, unquote(term)) @doc "<#{@tmp_uri}>" def unquote(term |> String.to_atom)(), do: @tmp_uri end end end defp data_vocab_terms(data, base_uri) do data |> RDF.Graph.resources # TODO: support also RDF.Datasets ... # filter URIs |> Stream.filter(fn %URI{} -> true _ -> false end) |> Stream.map(&to_string/1) |> Stream.map(&(strip_base_uri(&1, base_uri))) |> Enum.filter(&vocab_term?/1) end defp group_terms_by_case(terms) do Enum.group_by terms, fn term -> if lowercase?(term), do: :lowercased, else: :capitalized end end defp lowercase?(term) when is_atom(term), do: Atom.to_string(term) |> lowercase? defp lowercase?(term), do: term =~ ~r/^\p{Ll}/u defp strip_base_uri(uri, base_uri) do if String.starts_with?(uri, base_uri) do String.replace_prefix(uri, base_uri, "") end end defp vocab_term?(term) when is_binary(term) do not String.contains?(term, "/") end defp vocab_term?(_), do: false @doc false def term_to_uri(base_uri, term) do URI.parse(base_uri <> to_string(term)) end end