├── doc └── intro.md ├── test └── clj_turtle │ └── core_test.clj ├── project.clj ├── src └── clj_turtle │ └── core.clj ├── LICENSE └── README.md /doc/intro.md: -------------------------------------------------------------------------------- 1 | # Introduction to clj-turtle 2 | 3 | TODO: write [great documentation](http://jacobian.org/writing/what-to-write/) 4 | -------------------------------------------------------------------------------- /test/clj_turtle/core_test.clj: -------------------------------------------------------------------------------- 1 | (ns clj-turtle.core-test 2 | (:require [clojure.test :refer :all] 3 | [clj-turtle.core :refer :all])) 4 | 5 | (deftest a-test 6 | (testing "FIXME, I fail." 7 | (is (= 0 1)))) 8 | -------------------------------------------------------------------------------- /project.clj: -------------------------------------------------------------------------------- 1 | (defproject clj-turtle "0.1.3" 2 | :description "A Clojure Domain Specific Language (DSL) for RDF/Turtle" 3 | :url "https://github.com/structureddynamics/clj-turtle" 4 | :license {:name "Eclipse Public License" 5 | :url "http://www.eclipse.org/legal/epl-v10.html"} 6 | :dependencies [[org.clojure/clojure "1.6.0"]] 7 | :target-path "target/%s") 8 | -------------------------------------------------------------------------------- /src/clj_turtle/core.clj: -------------------------------------------------------------------------------- 1 | (ns clj-turtle.core 2 | (:require [clojure.string :as string])) 3 | 4 | (defn- md5 5 | "Generate a MD5 hash from an input string" 6 | [s] 7 | (apply str 8 | (map (partial format "%02x") 9 | (.digest (doto (java.security.MessageDigest/getInstance "MD5") 10 | .reset 11 | (.update (.getBytes s))))))) 12 | 13 | (defn- escape 14 | "Escape data literal for the Turtle data format." 15 | [s] 16 | (-> s 17 | str 18 | (string/replace #"\"" "\\\\\""))) 19 | 20 | (defn rdf 21 | "Generate RDF/Turtle serialized data from a set of triples defined by clj-turtle." 22 | [& rest] 23 | (loop [forms rest 24 | n3 ""] 25 | (if-not (empty? forms) 26 | (if (and (get (into [] forms) 3) 27 | (vector? (nth forms 3))) 28 | (recur (drop 4 forms) 29 | (apply str n3 (nth forms 0) (nth forms 1) (nth forms 2)" .\n" 30 | (let [iri (str "rei:" (md5 (str (nth forms 0) (nth forms 1) (nth forms 2))))] 31 | (->> (nth forms 3) 32 | (map #(str "<" iri "> " %1 " .\n")) 33 | (apply str (str "<" iri "> .\n" 34 | "<" iri "> " (nth forms 0) " .\n" 35 | "<" iri "> " (nth forms 1) " .\n" 36 | "<" iri "> " (nth forms 2) " .\n")))))) 37 | (recur (drop 3 forms) 38 | (apply str n3 (nth forms 0) (nth forms 1) (nth forms 2)" .\n"))) 39 | n3))) 40 | 41 | (def turtle "Alias for the (rdf) function" rdf) 42 | 43 | (defmacro defns 44 | "Create a new namespace that can be used to create the clj-turtle triples" 45 | [prefix namespace] 46 | (let [entity (gensym "entity-") 47 | body (gensym "body-")] 48 | `(defn ~prefix 49 | [~entity & ~body] 50 | (str "<" ~namespace (name ~entity) "> " (apply str (rest ~body)))))) 51 | 52 | (defn iri 53 | "Serialize a URI where you provide the full URI as a string" 54 | [uri] 55 | (str "<" uri "> ")) 56 | 57 | (defn a 58 | "Specify the rdf:type of an entity being described" 59 | [] 60 | (str " ")) 61 | 62 | (defn literal 63 | "[v] String that represents the literal value to create. 64 | [lang] (optional) Keyword referring to the ISO 639-1 language code 65 | [type] (optional) Namespace function or string that refers to a 66 | datatype to specify for the literal value 67 | 68 | Usages: 69 | ; specify a simple literal 70 | (literal \"bob\") 71 | 72 | ; specify the language of the literal 73 | (literal \"bob\" :lang :en) 74 | 75 | ; if the namespace 'xsd' has been defined 76 | (literal \"bob\" :type (xsd :string)) 77 | 78 | ; if you want to use an abreviated URI you can do this that way 79 | (literal \"bob\" :type \"xsd:string\")" 80 | [v & {:keys [lang type] 81 | :or [lang nil 82 | type nil]}] 83 | (apply str 84 | (str "\"\"\"" (if (keyword? v) 85 | (escape (name v)) 86 | (escape v))"\"\"\"") 87 | (if lang 88 | (str "@" (name lang)) 89 | (when type 90 | (str "^^" (name type)))))) 91 | 92 | (defn rei 93 | "Reify a clj-turtle triple" 94 | [& rest] 95 | (loop [forms rest 96 | statements []] 97 | (if-not (empty? forms) 98 | (recur (drop 2 forms) 99 | (into statements [(apply str (nth forms 0) (nth forms 1))])) 100 | statements))) 101 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC 2 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM 3 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 4 | 5 | 1. DEFINITIONS 6 | 7 | "Contribution" means: 8 | 9 | a) in the case of the initial Contributor, the initial code and 10 | documentation distributed under this Agreement, and 11 | 12 | b) in the case of each subsequent Contributor: 13 | 14 | i) changes to the Program, and 15 | 16 | ii) additions to the Program; 17 | 18 | where such changes and/or additions to the Program originate from and are 19 | distributed by that particular Contributor. A Contribution 'originates' from 20 | a Contributor if it was added to the Program by such Contributor itself or 21 | anyone acting on such Contributor's behalf. Contributions do not include 22 | additions to the Program which: (i) are separate modules of software 23 | distributed in conjunction with the Program under their own license 24 | agreement, and (ii) are not derivative works of the Program. 25 | 26 | "Contributor" means any person or entity that distributes the Program. 27 | 28 | "Licensed Patents" mean patent claims licensable by a Contributor which are 29 | necessarily infringed by the use or sale of its Contribution alone or when 30 | combined with the Program. 31 | 32 | "Program" means the Contributions distributed in accordance with this 33 | Agreement. 34 | 35 | "Recipient" means anyone who receives the Program under this Agreement, 36 | including all Contributors. 37 | 38 | 2. GRANT OF RIGHTS 39 | 40 | a) Subject to the terms of this Agreement, each Contributor hereby grants 41 | Recipient a non-exclusive, worldwide, royalty-free copyright license to 42 | reproduce, prepare derivative works of, publicly display, publicly perform, 43 | distribute and sublicense the Contribution of such Contributor, if any, and 44 | such derivative works, in source code and object code form. 45 | 46 | b) Subject to the terms of this Agreement, each Contributor hereby grants 47 | Recipient a non-exclusive, worldwide, royalty-free patent license under 48 | Licensed Patents to make, use, sell, offer to sell, import and otherwise 49 | transfer the Contribution of such Contributor, if any, in source code and 50 | object code form. This patent license shall apply to the combination of the 51 | Contribution and the Program if, at the time the Contribution is added by the 52 | Contributor, such addition of the Contribution causes such combination to be 53 | covered by the Licensed Patents. The patent license shall not apply to any 54 | other combinations which include the Contribution. No hardware per se is 55 | licensed hereunder. 56 | 57 | c) Recipient understands that although each Contributor grants the licenses 58 | to its Contributions set forth herein, no assurances are provided by any 59 | Contributor that the Program does not infringe the patent or other 60 | intellectual property rights of any other entity. Each Contributor disclaims 61 | any liability to Recipient for claims brought by any other entity based on 62 | infringement of intellectual property rights or otherwise. As a condition to 63 | exercising the rights and licenses granted hereunder, each Recipient hereby 64 | assumes sole responsibility to secure any other intellectual property rights 65 | needed, if any. For example, if a third party patent license is required to 66 | allow Recipient to distribute the Program, it is Recipient's responsibility 67 | to acquire that license before distributing the Program. 68 | 69 | d) Each Contributor represents that to its knowledge it has sufficient 70 | copyright rights in its Contribution, if any, to grant the copyright license 71 | set forth in this Agreement. 72 | 73 | 3. REQUIREMENTS 74 | 75 | A Contributor may choose to distribute the Program in object code form under 76 | its own license agreement, provided that: 77 | 78 | a) it complies with the terms and conditions of this Agreement; and 79 | 80 | b) its license agreement: 81 | 82 | i) effectively disclaims on behalf of all Contributors all warranties and 83 | conditions, express and implied, including warranties or conditions of title 84 | and non-infringement, and implied warranties or conditions of merchantability 85 | and fitness for a particular purpose; 86 | 87 | ii) effectively excludes on behalf of all Contributors all liability for 88 | damages, including direct, indirect, special, incidental and consequential 89 | damages, such as lost profits; 90 | 91 | iii) states that any provisions which differ from this Agreement are offered 92 | by that Contributor alone and not by any other party; and 93 | 94 | iv) states that source code for the Program is available from such 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on 96 | or through a medium customarily used for software exchange. 97 | 98 | When the Program is made available in source code form: 99 | 100 | a) it must be made available under this Agreement; and 101 | 102 | b) a copy of this Agreement must be included with each copy of the Program. 103 | 104 | Contributors may not remove or alter any copyright notices contained within 105 | the Program. 106 | 107 | Each Contributor must identify itself as the originator of its Contribution, 108 | if any, in a manner that reasonably allows subsequent Recipients to identify 109 | the originator of the Contribution. 110 | 111 | 4. COMMERCIAL DISTRIBUTION 112 | 113 | Commercial distributors of software may accept certain responsibilities with 114 | respect to end users, business partners and the like. While this license is 115 | intended to facilitate the commercial use of the Program, the Contributor who 116 | includes the Program in a commercial product offering should do so in a 117 | manner which does not create potential liability for other Contributors. 118 | Therefore, if a Contributor includes the Program in a commercial product 119 | offering, such Contributor ("Commercial Contributor") hereby agrees to defend 120 | and indemnify every other Contributor ("Indemnified Contributor") against any 121 | losses, damages and costs (collectively "Losses") arising from claims, 122 | lawsuits and other legal actions brought by a third party against the 123 | Indemnified Contributor to the extent caused by the acts or omissions of such 124 | Commercial Contributor in connection with its distribution of the Program in 125 | a commercial product offering. The obligations in this section do not apply 126 | to any claims or Losses relating to any actual or alleged intellectual 127 | property infringement. In order to qualify, an Indemnified Contributor must: 128 | a) promptly notify the Commercial Contributor in writing of such claim, and 129 | b) allow the Commercial Contributor tocontrol, and cooperate with the 130 | Commercial Contributor in, the defense and any related settlement 131 | negotiations. The Indemnified Contributor may participate in any such claim 132 | at its own expense. 133 | 134 | For example, a Contributor might include the Program in a commercial product 135 | offering, Product X. That Contributor is then a Commercial Contributor. If 136 | that Commercial Contributor then makes performance claims, or offers 137 | warranties related to Product X, those performance claims and warranties are 138 | such Commercial Contributor's responsibility alone. Under this section, the 139 | Commercial Contributor would have to defend claims against the other 140 | Contributors related to those performance claims and warranties, and if a 141 | court requires any other Contributor to pay any damages as a result, the 142 | Commercial Contributor must pay those damages. 143 | 144 | 5. NO WARRANTY 145 | 146 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON 147 | AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER 148 | EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR 149 | CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A 150 | PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the 151 | appropriateness of using and distributing the Program and assumes all risks 152 | associated with its exercise of rights under this Agreement , including but 153 | not limited to the risks and costs of program errors, compliance with 154 | applicable laws, damage to or loss of data, programs or equipment, and 155 | unavailability or interruption of operations. 156 | 157 | 6. DISCLAIMER OF LIABILITY 158 | 159 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY 160 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, 161 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION 162 | LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 163 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 164 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE 165 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY 166 | OF SUCH DAMAGES. 167 | 168 | 7. GENERAL 169 | 170 | If any provision of this Agreement is invalid or unenforceable under 171 | applicable law, it shall not affect the validity or enforceability of the 172 | remainder of the terms of this Agreement, and without further action by the 173 | parties hereto, such provision shall be reformed to the minimum extent 174 | necessary to make such provision valid and enforceable. 175 | 176 | If Recipient institutes patent litigation against any entity (including a 177 | cross-claim or counterclaim in a lawsuit) alleging that the Program itself 178 | (excluding combinations of the Program with other software or hardware) 179 | infringes such Recipient's patent(s), then such Recipient's rights granted 180 | under Section 2(b) shall terminate as of the date such litigation is filed. 181 | 182 | All Recipient's rights under this Agreement shall terminate if it fails to 183 | comply with any of the material terms or conditions of this Agreement and 184 | does not cure such failure in a reasonable period of time after becoming 185 | aware of such noncompliance. If all Recipient's rights under this Agreement 186 | terminate, Recipient agrees to cease use and distribution of the Program as 187 | soon as reasonably practicable. However, Recipient's obligations under this 188 | Agreement and any licenses granted by Recipient relating to the Program shall 189 | continue and survive. 190 | 191 | Everyone is permitted to copy and distribute copies of this Agreement, but in 192 | order to avoid inconsistency the Agreement is copyrighted and may only be 193 | modified in the following manner. The Agreement Steward reserves the right to 194 | publish new versions (including revisions) of this Agreement from time to 195 | time. No one other than the Agreement Steward has the right to modify this 196 | Agreement. The Eclipse Foundation is the initial Agreement Steward. The 197 | Eclipse Foundation may assign the responsibility to serve as the Agreement 198 | Steward to a suitable separate entity. Each new version of the Agreement will 199 | be given a distinguishing version number. The Program (including 200 | Contributions) may always be distributed subject to the version of the 201 | Agreement under which it was received. In addition, after a new version of 202 | the Agreement is published, Contributor may elect to distribute the Program 203 | (including its Contributions) under the new version. Except as expressly 204 | stated in Sections 2(a) and 2(b) above, Recipient receives no rights or 205 | licenses to the intellectual property of any Contributor under this 206 | Agreement, whether expressly, by implication, estoppel or otherwise. All 207 | rights in the Program not expressly granted under this Agreement are 208 | reserved. 209 | 210 | This Agreement is governed by the laws of the State of New York and the 211 | intellectual property laws of the United States of America. No party to this 212 | Agreement will bring a legal action under this Agreement more than one year 213 | after the cause of action arose. Each party waives its rights to a jury trial 214 | in any resulting litigation. 215 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # clj-turtle 2 | 3 | `clj-turtle` is a really simple Clojure DSL to produce compatible `RDF/Turtle` data. 4 | 5 | The Turtle code that is produced by this DSL is currently quite verbose. This means that all the URIs are extended, that the triple quotes are used and that the triples are fully described. 6 | 7 | The goal of this DSL is to be able to easily generate RDF data from Clojure code. One good example where `cjl-turtle` is used is when RDF data needs to be generated for adding information in a [Open Semantic Framework] [1] (OSF) instance using the `clj-osf` DSL. 8 | 9 | With the six operators described in the `API` section below, we are able to describe any kind of data in RDF by following a few syntactic conventions as defined in the DSL. 10 | 11 | 12 | ## Installation 13 | 14 | ### Using Linengen 15 | 16 | You can easily install `clj-turtle` using Linengen. The only thing you have to do is to add Add `[clj-turtle "0.1.3"]` as a dependency to your `project.clj`. 17 | 18 | Then make sure that you downloaded this dependency by running the `lein deps` command. 19 | 20 | ## API 21 | 22 | * `rdf`/`turtle` 23 | * Generate RDF/Turtle serialized data from a set of triples defined by clj-turtle. 24 | * `defns` 25 | * Create a new namespace that can be used to create the clj-turtle triples 26 | * `rei` 27 | * Reify a clj-turtle triple 28 | * `iri` 29 | * Serialize a URI where you provide the full URI as a string 30 | * `literal` 31 | * Serialize a literal value 32 | * `a` 33 | * Specify the rdf:type of an entity being described 34 | 35 | ## Usage 36 | 37 | ### Working with namespaces 38 | 39 | The core of this DSL is the `defns` operator. What this operator does is to give you the possibility to create the namespaces you want to use to describe your data. Every time you use a namespace, it will generate a URI reference in the triple(s) that will be serialized in `Turtle`. 40 | 41 | However, it is not necessary to create a new namespace every time you want to serialize Trutle data. In some cases, you may not even know what the namespace is since you have the full URI in hands already. It is why there is the `iri` function that let you serialize a full URI without having to use a namespace. 42 | 43 | Namespaces are just shorthand versions of full URIs that mean to make your code cleaner an easier to read and maintain. 44 | 45 | ### Syntatic rules 46 | 47 | Here are the general syntactix rules that you have to follow when creating triples in a `(rdf)` or `(turtle)` statement: 48 | 49 | 1. Wrap all the code using the `(rdf)` or the `(turtle)` operator 50 | 2. Every triple need to be explicit. This means that every time you want to create a new triple, you have to mention the `subject`, `predicate` and the `object` of the triple 51 | 3. A fourth "reification" element can be added using the `rei` operator 52 | 4. The first parameter of any function can be any kind of value: `keywords`, `strings`, `integer`, `double`, etc. They will be properly serialized as strings in Turtle. 53 | 54 | ### Strings and Keywords 55 | 56 | As specified in the syntactic rules, at any time, you can use a `string`, a `integer`, a `double` a `keyword` or any other kind of vaue as input of the defined namespaces or the other API calls. You only have to use the way that is more convenient for you or that is the cleanest for your taste. 57 | 58 | ### More about reification 59 | 60 | Note: RDF reification is quite a different concept than Clojure's `reify` macro. So carefully read this section to understand the meaning of the concept in this context. 61 | 62 | In RDF, reifying a triple means that we want to add additional information about a specific triple. Let's take this example: 63 | 64 | ```clojure 65 | (rdf 66 | (foo :bar) (iron :prefLabel) (literal "Bar")) 67 | ``` 68 | 69 | In this example, we have a triple that specify the preferred label of the `:bar` entity. Now, let's say that we want to add "meta" information about that specific triple, like the date when this triple got added to the system for example. 70 | 71 | That additional information is considered the "forth" element of a triple. It is defined like this: 72 | 73 | 74 | ```clojure 75 | (rdf 76 | (foo :bar) (iron :prefLabel) (literal "Bar") (rei 77 | (foo :date) (literal "2014-10-25" :type :xsd:dateTime))) 78 | ``` 79 | 80 | What we do here is to specify additional information regarding the triple itself. In this case, it is the date when the triple got added into our system. 81 | 82 | So, reification statements are really "meta information" about triples. Also not that reification statements doesn't change the semantic of the description of the entities. 83 | 84 | ## Examples 85 | 86 | Now let's see how we can use `clj-turtle` with a series of example. For each example, you will have the `clj-turtle` code and the `RDF/Turtle` code that is generated from that code. 87 | 88 | ### Create a new namespace 89 | 90 | The first thing we have to do is define the namespaces we will want to use in our code. 91 | 92 | ```clojure 93 | (defns iron "http://purl.org/ontology/iron#") 94 | (defns foo "http://purl.org/ontology/foo#") 95 | (defns owl "http://www.w3.org/2002/07/owl#") 96 | (defns rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#") 97 | (defns xsd "http://www.w3.org/2001/XMLSchema#") 98 | ``` 99 | 100 | ### Create a simple triple 101 | 102 | The simplest example is to create a simple triple. What this triple does is to define the preferred label of a `:bar` entity: 103 | 104 | ```clojure 105 | (rdf 106 | (foo :bar) (iron :prefLabel) (literal "Bar")) 107 | ``` 108 | 109 | Output: 110 | 111 | ``` 112 | """Bar""" . 113 | ``` 114 | 115 | ### Create a series of triples 116 | 117 | This example shows how we can describe more than one attribute for our `bar` entity: 118 | 119 | ```clojure 120 | (rdf 121 | (foo :bar) (a) (owl :Thing) 122 | (foo :bar) (iron :prefLabel) (literal "Bar") 123 | (foo :bar) (iron :altLabel) (literal "Foo")) 124 | ``` 125 | 126 | Output: 127 | 128 | ``` 129 | . 130 | """Bar""" . 131 | """Foo""" . 132 | ``` 133 | 134 | Note: we prefer having one triple per line. However, it is possible to have all the triples in one line, but this will produce less readable code: 135 | 136 | ### Just use keywords 137 | 138 | It is possible to use `keywords` everywhere, even in `(literals)` 139 | 140 | ```clojure 141 | (rdf 142 | (foo :bar) (a) (owl :Thing) 143 | (foo :bar) (iron :prefLabel) (literal :Bar) 144 | (foo :bar) (iron :altLabel) (literal :Foo)) 145 | ``` 146 | 147 | Output: 148 | 149 | ``` 150 | . 151 | """:Bar""" . 152 | """:Foo""" . 153 | ``` 154 | 155 | ### Just use strings 156 | 157 | It is possible to use `strings` everywhere, even in `namespaces`: 158 | 159 | ```clojure 160 | (rdf 161 | (foo "bar") (a) (owl "Thing") 162 | (foo "bar") (iron :prefLabel) (literal "Bar") 163 | (foo "bar") (iron :altLabel) (literal "Foo")) 164 | ``` 165 | 166 | Output: 167 | 168 | ``` 169 | . 170 | """Bar""" . 171 | """Foo""" . 172 | ``` 173 | 174 | ### Specifying a datatype in a literal 175 | 176 | It is possible to specify a `datatype` for every `(literal)` you are defining. You only have to use the `:type` option and to specify a `XSD` datatype as value: 177 | 178 | ```clojure 179 | (rdf 180 | (foo "bar") (foo :probability) (literal 0.03 :type :xsd:double)) 181 | ``` 182 | 183 | Equivalent code are: 184 | 185 | ```clojure 186 | (rdf 187 | (foo "bar") (foo :probability) (literal 0.03 :type (xsd :double))) 188 | ``` 189 | 190 | ```clojure 191 | (rdf 192 | (foo "bar") (foo :probability) (literal 0.03 :type (iri "http://www.w3.org/2001/XMLSchema#double"))) 193 | ``` 194 | 195 | Output: 196 | 197 | ``` 198 | """0.03"""^^xsd:double . 199 | ``` 200 | 201 | ### Specifying a language for a literal 202 | 203 | It is possible to specify a language string using the `:lang` option. The language tag should be a compatible ISO 639-1 language tag. 204 | 205 | ```clojure 206 | (rdf 207 | (foo "bar") (iron :prefLabel) (literal "Robert" :lang :fr)) 208 | ``` 209 | 210 | Output: 211 | 212 | ``` 213 | """Robert"""@fr . 214 | ``` 215 | 216 | ### Defining a type using the `a` operator 217 | 218 | It is possible to use the `(a)` predicate as a shortcut to define the `rdf:type` of an entity: 219 | 220 | ```clojure 221 | (rdf 222 | (foo "bar") (a) (owl "Thing")) 223 | ``` 224 | 225 | Output: 226 | 227 | ``` 228 | . 229 | ``` 230 | 231 | This is a shortcut for: 232 | 233 | ```clojure 234 | (rdf 235 | (foo "bar") (rdf :type) (owl "Thing")) 236 | ``` 237 | 238 | 239 | ### Specifying a full URI using the `iri` operator 240 | 241 | It is possible to define a `subject`, a `predicate` or an `object` using the `(iri)` operator if you want to defined them using the full URI of the entity: 242 | 243 | ```clojure 244 | (rdf 245 | (iri "http://purl.org/ontology/foo#bar") (iri "http://www.w3.org/1999/02/22-rdf-syntax-ns#type) (iri http://www.w3.org/2002/07/owl#Type)) 246 | ``` 247 | 248 | Output: 249 | 250 | ``` 251 | . 252 | ``` 253 | 254 | 255 | ### Simple reification 256 | 257 | It is possible to reify any triple suing the `(rei)` operator as the forth element of a triple: 258 | 259 | ```clojure 260 | (rdf 261 | (foo :bar) (iron :prefLabel) (literal "Bar") (rei 262 | (foo :date) (literal "2014-10-25" :type :xsd:dateTime))) 263 | ``` 264 | 265 | Output: 266 | 267 | ``` 268 | """Bar""" . 269 | . 270 | . 271 | . 272 | """Bar""" . 273 | """2014-10-25"""^^xsd:dateTime . 274 | ``` 275 | 276 | ### Reify multiple properties 277 | 278 | It is possible to add multiple reification statements: 279 | 280 | ```clojure 281 | (rdf 282 | (foo :bar) (iron :prefLabel) (literal "Bar") (rei 283 | (foo :date) (literal "2014-10-25" :type :xsd:dateTime) 284 | (foo :bar) (literal 0.37))) 285 | ``` 286 | 287 | Output: 288 | 289 | ``` 290 | """Bar""" . 291 | . 292 | . 293 | . 294 | """Bar""" . 295 | """2014-10-25"""^^xsd:dateTime . 296 | """0.37""" . 297 | ``` 298 | 299 | ### Using clj-turtle with clj-osf 300 | 301 | `clj-turtle` is meant to be used in Clojure code to simplify the creation of RDF data. Here is an example of how `clj-turtle` can be used to generate RDF data to feed to the [OSF Crud: Create] [2] web service endpoint via the `clj-osf` DSL: 302 | 303 | ```clojure 304 | [require '[clj-osf.crud :as crud]) 305 | 306 | (crud/create 307 | (crud/dataset "http://test.com/datasets/foo") 308 | (crud/document 309 | (rdf 310 | (iri link) (a) (bibo :Article) 311 | (iri link) (iron :prefLabel) (literal "Some article"))) 312 | (crud/is-rdf-n3) 313 | (crud/full-indexation-mode)) 314 | ``` 315 | 316 | ### Using the `turtle` alias operator 317 | 318 | Depending on your taste, it is possible to use the `(turtle)` operator instead of the `(rdf)` one to generate the RDF/Turtle code: 319 | 320 | ```clojure 321 | (turtle 322 | (foo "bar") (iron :prefLabel) (literal "Robert" :lang :fr)) 323 | ``` 324 | 325 | Output: 326 | 327 | ``` 328 | """Robert"""@fr . 329 | ``` 330 | 331 | ### Merging `clj-turtle` 332 | 333 | Depending the work you have to do in your Clojure application, you may have to generate the Turtle data using a more complex flow of operations. However, this is not an issue for `clj-turtle` since the only thing you have to do is to concatenate the triples you are creating. You can do so using a simple call to the `str` function, or you can create more complex processing using loopings, mappins, etc that endup with a `(apply str)` to generate the final Turtle string. 334 | 335 | ```clojure 336 | (str 337 | (rdf 338 | (foo "bar") (a) (owl "Thing")) 339 | (rdf 340 | (foo "bar") (iron :prefLabel) (literal "Bar") 341 | (foo "bar") (iron :altLabel) (literal "Foo"))) 342 | ``` 343 | 344 | Output: 345 | 346 | ``` 347 | . 348 | """Bar""" . 349 | """Foo""" . 350 | ``` 351 | 352 | 353 | 354 | 355 | ## License 356 | 357 | Copyright © 2014 Structured Dynamics LLC. 358 | 359 | Distributed under the Eclipse Public License either version 1.0 360 | 361 | [1]:http://opensemanticframework.org 362 | [2]:http://wiki.opensemanticframework.org/index.php/CRUD:_Create --------------------------------------------------------------------------------