antoniogarrote / clojure-grizzly-trial

a sample clojure-grizzly adapter based on jruby-grizzly

This URL has Read+Write access

clojure-grizzly-trial / com / agh / webserver / framework / persistence / rdf / vocabularies / xsd.clj
100644 112 lines (81 sloc) 2.757 kb
raw blame history 
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

(comment
  "XML Schema vocabulary"
)
 
(ns com.agh.webserver.framework.persistence.rdf.vocabularies.xsd)
 
(use 'com.agh.webserver.framework.persistence.rdf)
 
(defmethod rdf-ns :xsd [x]
  "XMLSchema namespace: http://www.w3.org/2001/XMLSchema#"
  (struct uri "http://www.w3.org/2001/XMLSchema#" :xsd))
 
(defn xsd-string []
  (build-uri (rdf-ns :xsd) "string"))
 
(defn xsd-float []
  (build-uri (rdf-ns :xsd) "float"))
 
(defn xsd-decimal []
  (build-uri (rdf-ns :xsd) "decimal"))
 
(defn xsd-double []
  (build-uri (rdf-ns :xsd) "double"))
 
 
(defn literal-string
  "Builds a new literal string"
  ([value]
     (build-literal value))
  ([value lang]
     (build-literal value lang)))
 
(defn literal-decimal
  "Builds a new literal decimal"
  ([value]
     (build-literal value (xsd-decimal))))
 
(defn literal-double
  "Builds a new literal double"
  ([value]
     (build-literal value (xsd-double))))
 
(defn literal-float
  "Builds a new literal float"
  ([value]
     (build-literal value (xsd-float))))
 
;; to-rdf conversions
(defmethod to-rdf #=java.lang.Double [something]
  (literal-double something))
 
(defmethod to-rdf #=java.lang.Float [something]
  (literal-float something))
 
(defmethod to-rdf #=java.lang.Number [something]
  (literal-decimal something))
 
 
(comment
  "Tests"
)
 
(use 'clojure.contrib.test-is)
 
(deftest test-xsd-ns
  (is (= (rdf-ns :xsd)
         {:prefix "http://www.w3.org/2001/XMLSchema#", :value :xsd})))
 
(deftest test-xsd-string
  (is (= (xsd-string)
         {:prefix :xsd, :value "string"})))
 
(deftest test-literal-string-1
  (is (= (literal-string "test")
         {:value "test" :datatype {:prefix :xsd, :value "string"} :lang ""})))
 
(deftest test-literal-string-2
  (is (= (literal-string "test" "en-GB")
         {:value "test" :datatype {:prefix :xsd, :value "string"} :lang "en-GB"})))
 
(deftest test-xsd-float
  (is (= (xsd-float)
         {:prefix :xsd, :value "float"})))
 
(deftest test-xsd-decimal
  (is (= (xsd-decimal)
         {:prefix :xsd, :value "decimal"})))
 
(deftest test-xsd-double
  (is (= (xsd-double)
         {:prefix :xsd, :value "double"})))
 
(deftest test-literal-decimal
  (is (= (literal-decimal 1)
         {:value 1  :lang "" :datatype {:prefix :xsd, :value "decimal"}})))
 
(deftest test-literal-float
  (is (= (literal-float 1.0)
         {:value 1.0  :lang "" :datatype {:prefix :xsd, :value "float"}})))
 
(deftest test-literal-double
  (is (= (literal-double 2)
         {:value 2  :lang "" :datatype {:prefix :xsd, :value "double"}})))
 
(deftest test-to-rdf-double
  (is (= (to-rdf 2.0)
         {:value 2.0 :lang "" :datatype {:prefix :xsd, :value "double"}})))
 
 
(deftest test-to-rdf-decimal
  (is (= (to-rdf 2)
         {:value 2 :lang "" :datatype {:prefix :xsd, :value "decimal"}})))