Coverage report: /development/source/library/org/datagraph/spocq-shard/src/core/encoding/json-ld/parameters.lisp

KindCoveredAll%
expression0104 0.0
branch010 0.0
Key
Not instrumented
Conditionalized out
Executed
Not executed
 
Both branches taken
One branch taken
Neither branch taken
1
 ;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: org.datagraph.spocq.implementation; -*-
2
 
3
 (in-package :org.datagraph.spocq.implementation)
4
 
5
 
6
 (defparameter json-ld:*base-iri* nil
7
   "The base iri of the currently processed json document unless overridden by an invocation argument")
8
 
9
 (defun json-ld:base-iri ()
10
   json-ld:*base-iri*)
11
 
12
 (defparameter *json-ld-context-references* nil
13
   "A dynamically managed context set which indicates whether a location is being or has been processed
14
  in order to limit duplicate processing and preclude recursive references.")
15
 
16
 (defparameter json-ld:*compact* t)
17
 
18
 (defparameter json-ld:*context* nil)
19
 
20
 (defparameter json-ld:*embed* t)
21
 
22
 (defparameter json-ld:*explicit* nil)
23
 
24
 (defparameter json-ld:*frame* nil)
25
 
26
 (defparameter json-ld::*print-pretty* nil)
27
 
28
 (defparameter json-ld::encode-simple-string-datatype* t
29
   "If true, json-ld expanded encoding introduces string tpe also for simple strings")
30
 
31
 (defparameter json-ld:*verbose* nil)
32
 
33
 (defmethod (setf configuration-parameter)
34
            ((value t) (parameter (eql |urn:dydra|:|compact|)))
35
   (setf (configuration-parameter :compact) value))
36
                          
37
 (defmethod (setf configuration-parameter)
38
            ((value t) (parameter (eql :compact)))
39
   (typecase value
40
     ((member :|true| t :|false| nil)
41
      (setq json-ld:*compact* (ecase value
42
                                ((:|true| t) t)
43
                                ((:|false| nil) nil))))
44
     (string
45
      (if (setf value (find-symbol value :keyword))
46
          (setf (configuration-parameter :compact) value)
47
          (error "Invalid compact: ~s." value)))
48
     (t
49
      (error "Invalid compact: ~s." value))))
50
 
51
 
52
 (defmethod (setf configuration-parameter)
53
            ((value t) (parameter (eql |urn:dydra|:|context|)))
54
   (setf (configuration-parameter :context) value))
55
 
56
 (defmethod (setf configuration-parameter)
57
            ((value spocq:iri) (parameter (eql :context)))
58
   (setq json-ld:*context* value))
59
 
60
 (defmethod (setf configuration-parameter)
61
            ((value string) (parameter (eql :context)))
62
   (setq json-ld:*context* value))
63
 
64
 
65
 (defmethod (setf configuration-parameter)
66
            ((value t) (parameter (eql |urn:dydra|:|embed|)))
67
   (setf (configuration-parameter :embed) value))
68
 
69
 (defmethod (setf configuration-parameter)
70
            ((value t) (parameter (eql :embed)))
71
   (typecase value
72
     ((member :|true| t :|false| nil)
73
      (setq json-ld:*embed* (ecase value
74
                              ((:|true| t) t)
75
                              ((:|false| nil) nil))))
76
     (string
77
      (if (setf value (find-symbol value :keyword))
78
          (setf (configuration-parameter :embed) value)
79
          (error "Invalid embed: ~s." value)))
80
     (t
81
      (error "Invalid embed: ~s." value))))
82
 
83
 (defmethod (setf configuration-parameter)
84
            ((value t) (parameter (eql :expand)))
85
   (typecase value
86
     ((member :|true| t :|false| nil)
87
      (setf (configuration-parameter :compact)
88
            (ecase value
89
              ((:|true| t) :|false|)
90
              ((:|false| nil) :|true|))))
91
     (string
92
      (if (setf value (find-symbol value :keyword))
93
          (setf (configuration-parameter :expand) value)
94
          (error "Invalid expand: ~s." value)))
95
     (t
96
      (error "Invalid expand: ~s." value))))
97
 
98
 (defmethod (setf configuration-parameter)
99
            ((value t) (parameter (eql |urn:dydra|:|explicit|)))
100
   (setf (configuration-parameter :explicit) value))
101
 
102
 (defmethod (setf configuration-parameter)
103
            ((value t) (parameter (eql :explicit)))
104
   (typecase value
105
     ((member :|true| t :|false| nil)
106
      (setq json-ld:*explicit* (ecase value
107
                                 ((:|true| t) t)
108
                                 ((:|false| nil) nil))))
109
     (string
110
      (if (setf value (find-symbol value :keyword))
111
          (setf (configuration-parameter :explicit) value)
112
          (error "Invalid explicit: ~s." value)))
113
     (t
114
      (error "Invalid explicit: ~s." value))))
115
 
116
 (defmethod (setf configuration-parameter)
117
            ((value t) (parameter (eql :flatten)))
118
   (typecase value
119
     ((member :|true| t :|false| nil)
120
      (setf (configuration-parameter :embed)
121
            (ecase value
122
              ((:|true| t) :|false|)
123
              ((:|false| nil) :|true|))))
124
     (string
125
      (if (setf value (find-symbol value :keyword))
126
          (setf (configuration-parameter :flatten) value)
127
          (error "Invalid flatten: ~s." value)))
128
     (t
129
      (error "Invalid flatten: ~s." value))))