blob: eb89fc764bab62ff400c640107358221eea07c35 (
plain)
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
|
;;;; hypnotisml.lisp
(in-package #:hypnotisml)
;;; UTILITIES
(let ((counter 0)
(hostid (sxhash (list (lisp-implementation-type)
(lisp-implementation-version)
(machine-version)
(machine-type)
(software-version)
(uiop:hostname)))))
(defun make-uid ()
"returns a unique string"
(format nil "~36r~36r"
(sxhash (incf counter))
(sxhash (list (get-universal-time)
hostid)))))
;;; CLASSES
(defun keyword-plist-p (xs)
(and (listp xs)
(evenp (length xs))
(cl:loop
:for x :in xs :by #'cddr
:always (keywordp x)
:never (find x keys)
:collect x :into keys)))
(deftype keyword-plist ()
'(satisfies keyword-plist-p))
(defstruct styles list)
(defmethod print-object ((ob styles) stream)
(format stream "style=~a" (styles-list ob)))
(def:class dom-node ())
(defstruct attribs list)
(defmethod print-object ((ob attribs) stream)
(format stream "~{~a=~a~^ ~}" (attribs-list ob)))
(defun dom-node-p (x) (typep x 'dom-node))
(defun node-list-p (es)
(and
(listp es)
(cl:loop :for e :in es :always (dom-node-p e))))
(deftype node-list ()
'(satisfies node-list-p))
(defun ensure-node (thing)
(etypecase thing
(dom-node thing)
(string (make-instance 'text :content thing))))
(def:class element (dom-node)
(tag :type keyword
:initform (error 'tag-required)
:documentation "HTML tag.")
(id :prefix
:ro :noarg
:type string
:initform (make-uid)
:documentation "A unique id, because id attribute.")
(style attributes
:prefix
:initform nil)
(elements :type node-list)
:documentation "The base class for all UI elements.")
(def:var *indent* :doc "Current indentation" :init 0)
(defmethod print-object ((object element) stream)
(indent stream)
(write-string "<" stream)
(with-slots (tag attributes style) object
(format stream "~a:~a" (class-name (class-of object)) tag)
(when attributes
(format stream " ~a" attributes))
(when style
(format stream " ~a" style))
(write-string ">" stream)
(terpri stream))
(let ((*indent* (+ 2 *indent*)))
(cl:loop :for elem :in (elements object) :do (print-object elem stream))))
(defun elementp (x) (typep x 'element))
(def:class text (dom-node)
(content :type string :initform ""))
(defun indent (stream)
(cl:loop :repeat *indent* :do (write-char #\space stream)))
(defmethod print-object ((ob text) stream)
(indent stream)
(format stream "~s~%" (content ob)))
(def:class vertical (element)
:default-initargs (:tag :div))
(def:class horizontal (element)
:default-initargs (:tag :div))
;;; PROTOCOL
(defgeneric html (elem stream)
(:documentation "Renders an element as HTML"))
(defun $ (&rest plist)
(check-type plist keyword-plist)
(make-styles :list plist))
(defun $= (elem &rest plist)
(check-type plist keyword-plist)
(cl:loop
:for (prop val) :on plist :by #'cddr
:do (setf (getf (element-style elem) prop) val))
elem)
(defun @ (&rest plist)
(check-type plist keyword-plist)
(make-attribs :list plist))
(defun @= (elem &rest plist)
(check-type plist keyword-plist)
(cl:loop
:for (prop val) :on plist :by #'cddr
:do (setf (gethash (element-attributes elem) prop) val))
elem)
;;; LAYOUT FUNCTIONS
(defun <row> (&rest elems)
(make-instance 'horizontal
:tag :div
:elements (mapcar #'ensure-node elems)))
(defun <col> (&rest elems)
(make-instance 'vertical
:tag :div
:elements (mapcar #'ensure-node elems)))
;;; ELEM BUILDERS
(macrolet ((defelems (&body tags)
(let ((elements (gensym "elements"))
(styles (gensym "styles"))
(attribs (gensym "attribs"))
(tags (remove-duplicates tags)))
`(progn
,@(cl:loop
:for tag :in tags
:for fname := (a:symbolicate #\< tag #\>)
:collect `(defun ,fname (&rest contents)
(let ((,styles
(find-if #'styles-p contents))
(,attribs
(find-if #'attribs-p contents))
(,elements
(cl:loop
:for c :in contents
:when (or (stringp c) (dom-node-p c))
:collect (ensure-node c))))
(make-instance 'element
:tag ,(a:make-keyword tag)
:style ,styles
:attributes ,attribs
:elements ,elements))))))))
(defelems
a
abbr
address
area
article
aside
audio
b
base
bdi
bdo
blockquote
body
br
button
canvas
caption
cite
code
col
colgroup
data
datalist
dd
del
details
dfn
dialog
div
dl
dt
em
embed
fieldset
figcaption
figuregure
footer
form
h1 h2 h3 h4 h5 h6
head
header
hgroup
hr
html
i
iframe
img
input
ins
kbd
label
legend
label
legend
li
link
main
map
mark
menu
meta
meter
nav
noscript
object
ol
optgroup
option
output
p
param
pre
progress
q
rp
rt
ruby
s
samp
script
section
script
section
select
small
source
span
strong
style
sub
summary
sup
table
tbody
td
textarea
tfoot
th
thead
time
title
tr
track
ul
var
video
wbr))
|