-
Notifications
You must be signed in to change notification settings - Fork 4
/
format.ex
118 lines (94 loc) · 3.61 KB
/
format.ex
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
defmodule SPARQL.Query.Result.Format do
@moduledoc """
A behaviour for SPARQL query result formats.
A `SPARQL.Query.Result.Format` for a format can be implemented like this
defmodule SomeFormat do
use SPARQL.Query.Result.Format
import RDF.Sigils
@id ~I<http://example.com/some_format>
@name :some_format
@extension "ext"
@media_type "application/some-format"
end
When `@id`, `@name`, `@extension` and `@media_type` module attributes are
defined the resp. behaviour functions are generated automatically and return
these values.
Then you'll have to do the main work by implementing a
`RDF.Serialization.Encoder` and a `RDF.Serialization.Decoder` for the format.
By default, it is assumed that these are defined in `Encoder` and `Decoder`
modules under the module of the format, i.e. in the example above in
`SomeFormat.Encoder` and `SomeFormat.Decoder`.
If you want them in another module, you'll have to override the `encoder/0`
and/or `decoder/0` functions in your `SPARQL.Query.Result.Format` module.
"""
@doc """
An IRI of the SPARQL query result format.
"""
@callback id :: RDF.IRI.t
@doc """
An name atom of the SPARQL query result format under which it can referenced.
"""
@callback name :: atom
@doc """
The usual file extension for the SPARQL query result format.
"""
@callback extension :: binary
@doc """
The MIME type of the SPARQL query result format.
"""
@callback media_type :: binary
@doc """
A list of the supported query forms of the SPARQL query result format.
"""
@callback supported_query_forms :: [SPARQL.Query.forms]
@doc """
The `SPARQL.Query.Result.Format.Decoder` module for the result format.
"""
@callback decoder :: module
@doc """
The `SPARQL.Query.Result.Format.Encoder` module for the result format.
"""
@callback encoder :: module
defmacro __using__(_) do
quote bind_quoted: [], unquote: true do
@behaviour unquote(__MODULE__)
@decoder __MODULE__.Decoder
@encoder __MODULE__.Encoder
def decoder, do: @decoder
def encoder, do: @encoder
defdelegate decode(results, opts \\ []), to: @decoder
defdelegate decode!(results, opts \\ []), to: @decoder
# defdelegate encode(content, opts \\ []), to: @encoder
# defdelegate encode!(content, opts \\ []), to: @encoder
# This is just to be API-compatible to RDF.Serialization.format.
# TODO: Should we introduce a similar Reader-/Writer-functionality here or introduce RDF.Serialization.decode?
defdelegate read_string(results, opts \\ []), to: __MODULE__, as: :decode
defoverridable [decoder: 0, encoder: 0]
@before_compile unquote(__MODULE__)
end
end
defmacro __before_compile__(_env) do
quote do
if !Module.defines?(__MODULE__, {:id, 0}) &&
Module.get_attribute(__MODULE__, :id) do
def id, do: @id
end
if !Module.defines?(__MODULE__, {:name, 0}) &&
Module.get_attribute(__MODULE__, :name) do
def name, do: @name
end
if !Module.defines?(__MODULE__, {:extension, 0}) &&
Module.get_attribute(__MODULE__, :extension) do
def extension, do: @extension
end
if !Module.defines?(__MODULE__, {:media_type, 0}) &&
Module.get_attribute(__MODULE__, :media_type) do
def media_type, do: @media_type
end
if !Module.defines?(__MODULE__, {:supported_query_forms, 0}) &&
Module.get_attribute(__MODULE__, :supported_query_forms) do
def supported_query_forms, do: @supported_query_forms
end
end
end
end