summaryrefslogtreecommitdiff
path: root/haunt.scm
blob: 425df2af6d2e1074955ed24b0cd9a968a0661493 (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
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
;;; Copyright © 2018 David Thompson <davet@gnu.org>
;;;
;;; This program is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU General Public License as
;;; published by the Free Software Foundation; either version 3 of the
;;; License, or (at your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;; General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program.  If not, see
;;; <http://www.gnu.org/licenses/>.

(define (add-to-load-path* directory)
  (unless (member directory %load-path)
    (add-to-load-path directory)))

(add-to-load-path* "/home/dave/Code/guile-syntax-highlight")

(use-modules (haunt asset)
             (haunt builder blog)
             (haunt builder atom)
             (haunt builder assets)
             (haunt html)
             (haunt page)
             (haunt post)
             (haunt reader)
             (haunt reader commonmark)
             (haunt site)
             (haunt utils)
             (commonmark)
             (syntax-highlight)
             (syntax-highlight scheme)
             (syntax-highlight xml)
             (syntax-highlight c)
             (sxml match)
             (sxml transform)
             (texinfo)
             (texinfo html)
             (srfi srfi-1)
             (srfi srfi-19)
             (ice-9 rdelim)
             (ice-9 regex)
             (ice-9 match)
             (web uri))

(define (date year month day)
  "Create a SRFI-19 date for the given YEAR, MONTH, DAY"
  (let ((tzoffset (tm:gmtoff (localtime (time-second (current-time))))))
    (make-date 0 0 0 0 day month year tzoffset)))

(define (stylesheet name)
  `(link (@ (rel "stylesheet")
            (href ,(string-append "/css/" name ".css")))))

(define (anchor content uri)
  `(a (@ (href ,uri)) ,content))

(define %cc-by-sa-link
  '(a (@ (href "https://creativecommons.org/licenses/by-sa/4.0/"))
      "Creative Commons Attribution Share-Alike 4.0 International"))

(define %cc-by-sa-button
  '(a (@ (class "cc-button")
         (href "https://creativecommons.org/licenses/by-sa/4.0/"))
      (img (@ (src "https://licensebuttons.net/l/by-sa/4.0/80x15.png")))))

(define %piwik-code
  '((script (@ (type "text/javascript") (src "/js/piwik.js")))
    (noscript
     (p (img (@ (src "//stats.dthompson.us/piwik.php?idsite=1")
                (style "border:0;")
                (alt "")))))))

(define (link name uri)
  `(a (@ (href ,uri)) ,name))

(define* (centered-image url #:optional alt)
  `(img (@ (class "centered-image")
           (src ,url)
           ,@(if alt
                 `((alt ,alt))
                 '()))))

(define (first-paragraph post)
  (let loop ((sxml (post-sxml post))
             (result '()))
    (match sxml
      (() (reverse result))
      ((or (('p ...) _ ...) (paragraph _ ...))
       (reverse (cons paragraph result)))
      ((head . tail)
       (loop tail (cons head result))))))

(define dthompson-theme
  (theme #:name "dthompson"
         #:layout
         (lambda (site title body)
           `((doctype "html")
             (head
              (meta (@ (charset "utf-8")))
              (title ,(string-append title " — " (site-title site)))
              ,(stylesheet "reset")
              ,(stylesheet "fonts")
              ,(stylesheet "dthompson"))
             (body
              (div (@ (class "container"))
                   (div (@ (class "nav"))
                        (ul (li ,(link "David Thompson" "/"))
                            (li (@ (class "fade-text")) " ")
                            (li ,(link "About" "/about.html"))
                            (li ,(link "Blog" "/index.html"))
                            (li ,(link "Projects" "/projects.html"))))
                   ,body
                   (footer (@ (class "text-center"))
                           (p (@ (class "copyright"))
                              "© 2018 David Thompson"
                              ,%cc-by-sa-button)
                           (p "The text and images on this site are
free culture works available under the " ,%cc-by-sa-link " license.")
                           (p "This website is built with "
                              (a (@ (href "http://haunt.dthompson.us"))
                                 "Haunt")
                              ", a static site generator written in "
                              (a (@ (href "https://gnu.org/software/guile"))
                                 "Guile Scheme")
                              ".")))
              ,%piwik-code)))
         #:post-template
         (lambda (post)
           `((h1 (@ (class "title")),(post-ref post 'title))
             (div (@ (class "date"))
                  ,(date->string (post-date post)
                                 "~B ~d, ~Y"))
             (div (@ (class "post"))
                  ,(post-sxml post))))
         #:collection-template
         (lambda (site title posts prefix)
           (define (post-uri post)
             (string-append "/" (or prefix "")
                            (site-post-slug site post) ".html"))

           `((h1 ,title)
             ,(map (lambda (post)
                     (let ((uri (string-append "/"
                                               (site-post-slug site post)
                                               ".html")))
                       `(div (@ (class "summary"))
                             (h2 (a (@ (href ,uri))
                                    ,(post-ref post 'title)))
                             (div (@ (class "date"))
                                  ,(date->string (post-date post)
                                                 "~B ~d, ~Y"))
                             (div (@ (class "post"))
                                  ,(first-paragraph post))
                             (a (@ (href ,uri)) "read more ➔"))))
                   posts)))))

(define %collections
  `(("Recent Blog Posts" "index.html" ,posts/reverse-chronological)))

(define parse-lang
  (let ((rx (make-regexp "-*-[ ]+([a-z]*)[ ]+-*-")))
    (lambda (port)
      (let ((line (read-line port)))
        (match:substring (regexp-exec rx line) 1)))))

(define (maybe-highlight-code lang source)
  (let ((lexer (match lang
                 ('scheme lex-scheme)
                 ('xml    lex-xml)
                 ('c      lex-c)
                 (_ #f))))
    (if lexer
        (highlights->sxml (highlight lexer source))
        source)))

(define (sxml-identity . args) args)

(define (highlight-code . tree)
  (sxml-match tree
    ((code (@ (class ,class) . ,attrs) ,source)
     (let ((lang (string->symbol
                  (string-drop class (string-length "language-")))))
       `(code (@ ,@attrs)
             ,(maybe-highlight-code lang source))))
    (,other other)))

(define (highlight-scheme code)
  `(pre (code ,(highlights->sxml (highlight lex-scheme code)))))

;; Markdown doesn't support video, so let's hack around that!  Find
;; <img> tags with a ".webm" source and substitute a <video> tag.
(define (media-hackery . tree)
  (sxml-match tree
    ((img (@ (src ,src) . ,attrs) . ,body)
     (if (string-suffix? ".webm" src)
         `(video (@ (src ,src) (controls "true"),@attrs) ,@body)
         tree))))

(define %commonmark-rules
  `((code . ,highlight-code)
    (img . ,media-hackery)
    (*text* . ,(lambda (tag str) str))
    (*default* . ,sxml-identity)))

(define (post-process-commonmark sxml)
  (pre-post-order sxml %commonmark-rules))

(define commonmark-reader*
  (make-reader (make-file-extension-matcher "md")
               (lambda (file)
                 (call-with-input-file file
                   (lambda (port)
                     (values (read-metadata-headers port)
                             (post-process-commonmark
                              (commonmark->sxml port))))))))

(define (static-page title file-name body)
  (lambda (site posts)
    (make-page file-name
               (with-layout dthompson-theme site title body)
               sxml->html)))

(define* (project-page #:key name file-name description usage requirements
                       installation manual? license repo releases)
  (define body
    `((h1 ,name)
      ,description
      ,@(if usage
            `((h2 "Usage")
              ,usage)
            '())
      ,@(if manual?
         `((h2 "Documentation")
           (p ,(anchor "View the reference manual"
                       (string-append "/manuals/" repo "/index.html"))))
         '())
      (h2 "Releases")
      (ul ,(map (match-lambda
                  ((version date)
                   (let ((url (string-append "https://files.dthompson.us/"
                                             repo "/" repo "-" version
                                             ".tar.gz")))
                     `(li ,(date->string date "~Y-~m-~d")
                          " — " ,version " — "
                          ,(anchor (string-append repo "-" version ".tar.gz")
                                   url)
                          " — "
                          ,(anchor "GPG signature"
                                   (string-append url ".asc"))))))
                releases))
      (h2 "Requirements")
      (ul ,(map (lambda (requirement)
                  `(li ,requirement))
                requirements))
      (h2 "Installation")
      ,@(if installation
            (list installation)
            `((p ,name " uses the standard GNU build system.  "
                 "To build and install " ,name " from source, run:")
              (pre "./configure
make
make install")))
      (h2 "License")
      (p ,license)
      (h2 "Source Code")
      ,@(let ((url (string-append "https://git.dthompson.us/" repo ".git")))
          `((p ,name " is developed using the Git version control
system. The official repository is hosted at "
               ,(anchor url url))
            (h3 "Anonymous clone")
            (pre "git clone " ,url)))
      (h2 "Community")
      (p "Real-time discussion for " ,name " can be found on the "
         (code "#guile")
         " channel on the Freenode IRC network.")
      (h2 "Contributing")
      (p "Send patches and bug reports to "
         ,(anchor "davet@gnu.org" "mailto:davet@gnu.org")
         ".")))

  (static-page name (string-append "projects/" file-name) body))

(define about-page
  (static-page
   "About Me"
   "about.html"
   `((h2 "Hi.")
     (p "I am a professional software developer, hobbyist gardener,
woodworker, and drummer from Worcester, Massachusetts.")
     (p "I am currently a DevOps engineer at " ,(anchor "Vista Higher
Learning" "http://vistahigherlearning.com")
        ", and formerly a web developer at the "
        ,(anchor "Free Software Foundation." "https://fsf.org"))
     (p "I have a BS in Computer Science from "
        ,(anchor "Worcester State University" "http://worcester.edu") ".")
     (p "If you're into social media, you can follow me on "
        ,(anchor "Mastodon" "https://toot.cat/@dthompson") "."))))

(define projects-page
  (static-page
   "Projects"
   "projects.html"
   `((h1 "Projects")
     (p ,(anchor "Chickadee" "projects/chickadee.html")
        " — Game development toolkit for Guile Scheme")
     (p ,(anchor "guile-SDL2" "projects/guile-sdl2.html")
        " — SDL2 bindings for Guile Scheme")
     (p ,(anchor "guile-syntax-highlight" "projects/guile-syntax-highlight.html")
        " — Syntax highlighting library for Guile Scheme")
     (p ,(anchor "Haunt" "projects/haunt.html")
        " — Functional, hackable static site generator")
     (p ,(anchor "Shroud" "projects/shroud.html")
        " — GPG-based password manager")
     (p ,(anchor "Sly" "projects/sly.html")
        " — Functional reactive game engine")
     (p ,(anchor "srt2vtt" "projects/srt2vtt.html")
        " — SRT to WebVTT subtitle converter"))))

(define sly-page
  (project-page
   #:name "Sly"
   #:file-name "sly.html"
   #:description
   `((p "Sly is a fun, free software 2D/3D game engine written in "
        ,(anchor "Guile Scheme" "https://gnu.org/s/guile") ".")
     ,(centered-image "/images/sly/logo.png" "Sly fox mascot")
     (p "Sly differentiates itself from most other game engines by encouraging
and enabling the use of "
        ,(anchor "live coding"
                 "http://toplap.org/about/")
        " and "
        ,(anchor "functional reactive programming"
                 "https://en.wikipedia.org/wiki/Functional_reactive_programming")
        " techniques.  Sly provides a dynamic live coding environment
that allows games to be built interactively and iteratively without
ever stopping the running program.  A data structure called a “signal”
provides a method of modeling time-varying state that is declarative,
functional, and reactive.")
     (p ,(centered-image "/images/sly/2048.png"))
     (p ,(centered-image "/images/sly/mines.png")))
   #:requirements '("GNU Guile >= 2.0.11"
                    "guile-opengl_ >= 0.1.0"
                    "guile-sdl_ >= 0.5.0"
                    "SDL 1.2.x"
                    "FreeImage >= 3.0"
                    "GNU Scientific Library (GSL)")
   #:license "GNU GPLv3+"
   #:repo "sly"
   #:manual? #t
   #:releases
   `(("0.1" ,(date 2015 11 12)))))

(define guile-sdl2-page
  (project-page
   #:name "Guile-SDL2"
   #:file-name "guile-sdl2.html"
   #:repo "guile-sdl2"
   #:description
   `((p "Guile-SDL2 provides "
        ,(anchor "Guile Scheme" "https://gnu.org/s/guile")
        " bindings for the "
        ,(anchor "SDL2" "http://libsdl.org")
        " C shared library.  The bindings are written in pure Scheme
using Guile's foreign function interface."))
   #:usage
   `((p "Guile-SDL2 provides modules in the "
        (code "(sdl2 ...)")
        " namespace, roughly organized how the SDL2 C header files are
organized.  Low-level bindings are available in the"
        (code "(sdl2 bindings ...)")
        " namespace, but these are not recommended for normal usage.")
     (p "Additionally, SDL2 extension library bindings are available in the
following modules:")
     (ul (li "SDL2_image: " (code "(sdl2 image)"))
         (li "SDL2_mixer: " (code "(sdl2 mixer)"))
         (li "SDL2_ttf: " (code "(sdl2 ttf)")))
     (p "Here is a short “hello, world” example program:")
     ,(highlight-scheme
       "(use-modules (sdl2)
             (sdl2 render)
             (sdl2 surface)
             (sdl2 video))

(define (draw ren)
  (let* ((surface (load-bmp \"hello.bmp\"))
         (texture (surface->texture ren surface)))
    (clear-renderer ren)
    (render-copy ren texture)
    (present-renderer ren)
    (sleep 2)))

(sdl-init)

(call-with-window (make-window)
  (lambda (window)
    (call-with-renderer (make-renderer window) draw)))

(sdl-quit)"))
   #:requirements '("GNU Guile >= 2.0.9"
                    "SDL2 >= 2.0.0"
                    "SDL2_image >= 2.0.0"
                    "SDL2_mixer >= 2.0.0"
                    "SDL2_ttf >= 2.0.0"
                    "GNU Make"
                    "GNU pkg-config")
   #:license "GNU LGPLv3+"
   #:releases
   `(("0.2.0" ,(date 2017 01 20))
     ("0.1.2" ,(date 2016 08 10))
     ("0.1.1" ,(date 2016 01 01))
     ("0.1.0" ,(date 2015 12 22)))))

(define guile-syntax-highlight-page
  (project-page
   #:name "guile-syntax-highlight"
   #:file-name "guile-syntax-highlight.html"
   #:repo "guile-syntax-highlight"
   #:description
   `((p "guile-syntax-highlight is a general-purpose syntax
highlighting library for GNU Guile.  It can parse code written in
various programming languages into a simple s-expression that can be
easily converted to HTML (via SXML) or any other format for
rendering."))
   #:usage
   (highlight-scheme
       "(use-modules (syntax-highlight)
             (syntax-highlight scheme)
             (sxml simple))

(define code
  \"(define (square x) \\\"Return the square of X.\\\" (* x x))\")

;; Get raw highlights list.
(define highlighted-code
  (highlight scheme-highlighter code))

;; Convert to SXML.
(define highlighted-sxml
  (highlights->sxml highlighted-code))

;; Write HTML to stdout.
(display (sxml->xml highlighted-sxml))
(newline)
")
   #:requirements '("GNU Guile >= 2.0"
                    "GNU Make"
                    "GNU pkg-config")
   #:license "GNU LGPLv3+"
   #:releases
   `(("0.1" ,(date 2018 03 10)))))

(define haunt-page
  (project-page
   #:name "Haunt"
   #:file-name "haunt.html"
   #:repo "haunt"
   #:manual? #t
   #:description
   `(,(centered-image "/images/haunt/logo.png" "crudely drawn ghost")
     (p "Haunt is a simple, functional, hackable static site generator
written in Guile Scheme that gives authors the ability to treat
websites as programs.")
     (p "Haunt isn't your average static site generator.  Its mission
is to give authors the full expressive power of Scheme to define every
aspect of their websites are generated.  Haunt uses a simple,
functional build system that allows any type of web page to be built
by writing procedures that return page objects.")
     (p "Haunt has no opinion about what markup language authors
should use to write posts.  Just write the relevant reader procedure
and Haunt will happily work with that format.  Likewise, Haunt has no
opinion about how authors structure their sites.  Haunt ships with
helpful builder procedures that generate simple blogs or Atom feeds,
but authors should feel empowered to tweak them, write replacements,
or add new builders to do things that the Haunt hackers didn't think
of."))
   #:usage
   `((p "Here's what a simple Haunt configuration looks like:")
     ,(call-with-input-file "snippets/haunt.scm" highlight-scheme)
     (p "With the above saved into a file named "
        (code "haunt.scm")
        " and a "
        (code "posts")
        " directory populated with the articles to publish,
the site can be built by running "
        (code "haunt build")
        ".  Once the site is built, running "
        (code "haunt serve")
        " and visiting "
        (code "localhost:8080")
        " in a web browser will show the results of the build
without needing to upload the generated files to a web server."))
   #:requirements '("GNU Guile >= 2.1.4"
                 "guile-reader (for Skribe support, optional)"
                 "guile-commonmark (for Markdown support, optional)")
   #:license "GNU GPLv3+"
   #:releases
   `(("0.2.2" ,(date 2018 03 10))
     ("0.2.1" ,(date 2017 01 23))
     ("0.2"   ,(date 2016 04 24))
     ("0.1"   ,(date 2015 08 08)))))

(define chickadee-page
  (project-page
   #:name "Chickadee"
   #:file-name "chickadee.html"
   #:repo "chickadee"
   #:manual? #t
   #:description
   `((p "Chickadee is a game development toolkit for "
        ,(anchor "Guile Scheme" "https://gnu.org/s/guile")
        " built on top of "
        ,(anchor "SDL2" "http://libsdl.org")
        " and OpenGL.")
     ,(centered-image "/images/chickadee/logo.png" "Chickadee logo")
     (p "Chickadee aims to provide all the features that
parenthetically inclined game developers need to make 2D (and
eventually 3D) games in Scheme, such as:")
     (ul
      (li "extensible, fixed-timestep game loop")
      (li "OpenGL-based rendering engine")
      (li "keyboard, mouse, controller input")
      (li "REPL-driven development model"))
     (p "Here is a simple example:")
     ,(highlight-scheme
       "(use-modules (chickadee)
             (chickadee math vector)
             (chickadee render sprite)
             (chickadee render texture))

(define sprite #f)

(define (load)
  (set! sprite (load-image \"images/chickadee.png\")))

(define (draw alpha)
  (draw-sprite sprite (vec2 256.0 176.0)))

(add-hook! load-hook load)
(add-hook! draw-hook draw)

(run-game)
")
     (p (small ,(anchor "chickadee sprite by Refuzzle, CC0"
                        "http://opengameart.org/content/winter-birds"))))
   #:requirements '("GNU Guile >= 2.1.4"
                    "Guile-SDL2 >= 0.2.0"
                    "Guile-OpenGL >= 0.1.0")
   #:license "GNU GPLv3+"
   #:releases
   `(("0.2.0" ,(date 2017 01 26))
     ("0.1.0" ,(date 2017 01 23)))))

(define shroud-page
  (project-page
   #:name "Shroud"
   #:file-name "shroud.html"
   #:repo "shroud"
   #:description
   `((p "Shroud is a simple secret manager with a command line interface.")
     (p "The password database is stored as a Scheme s-expression
and encrypted with a "
           ,(anchor "GnuPG" "https://gnupg.org")
           " key.  Secrets consist of an arbitrary number of key/value
pairs, making Shroud suitable for more than just password storage.
For copying and pasting secrets into web browsers and other graphical
applications, there is xclip integration."))
   #:requirements '("GNU Guile >= 2.0.9"
                    "GnuPG >= 1.4"
                    "GNU Make"
                    "GNU pkg-config"
                    ("optional: xclip is needed for the "
                     (code "-c")
                     " flag of "
                     (code "shroud show")
                     " to work"))
   #:usage
   `((p "First, create a " (code ".shroud")
        " file in your home directory to hold your
configuration settings.  All you really need to set here is your GPG
user ID i.e. your email address:")
     ,(highlight-scheme
       "'((user-id . \"foo@example.com\"))")
     (p "The "
        (code ".shroud")
        " file is Scheme source code, so any expression that evaluates
to an alist of valid configuration settings is usable by Shroud.")
     (p "Once Shroud is configured, try out the following commands to
get a feel for how things work:")
     (pre
       "# Add a new secret:
shroud hide bank-account username=foobar password=hackme

# Edit an existing secret:
shroud hide --edit bank-account password=hackmepls

# List all secrets:
shroud list

# Show all key/value pairs for a saved secret:
shroud show bank-account

# Show a single value in a secret:
shroud show bank-account password

# Copy a password directly to X clipboard:
shroud show -c bank-account password

# Delete a secret:
shroud remove bank-account")
     (p "Happy shrouding!"))
   #:license "GNU GPLv3+"
   #:releases
   `(("0.1.1" ,(date 2015 10 01))
     ("0.1.0" ,(date 2015 09 29)))))

(define srt2vtt-page
  (project-page
   #:name "srt2vtt"
   #:file-name "srt2vtt.html"
   #:repo "srt2vtt"
   #:description
   `((p "Convert SRT formatted subtitles to WebVTT format for use with
the HTML5 "
        (code "<track>") " tag."))
   #:requirements '("GNU Guile >= 2.0.5")
   #:usage
   `((pre
      "$ srt2vtt --help
Usage: srt2vtt [OPTIONS]
Convert SubRip formatted subtitles to WebVTT format.

  -h, --help             display this help and exit
  -v, --version          display version and exit
  -i, --input=FILE-NAME  read input from FILE-NAME
  -o, --output=FILE-NAME write output to FILE-NAME")
     (p "If " (code "--input")
        " or " (code "--output")
        " is ommitted, read from stdin or stdout, respectively."))
   #:license "GNU GPLv3+"
   #:releases
   `(("0.1" ,(date 2015 02 7)))))

(site #:title "dthompson"
      #:domain "dthompson.us"
      #:default-metadata
      '((author . "David Thompson")
        (email  . "davet@gnu.org"))
      #:readers (list commonmark-reader*)
      #:builders (list (blog #:theme dthompson-theme #:collections %collections)
                       (atom-feed)
                       (atom-feeds-by-tag)
                       about-page
                       projects-page
                       chickadee-page
                       sly-page
                       guile-sdl2-page
                       guile-syntax-highlight-page
                       haunt-page
                       shroud-page
                       srt2vtt-page
                       (static-directory "js")
                       (static-directory "css")
                       (static-directory "fonts")
                       (static-directory "images")
                       (static-directory "videos")
                       (static-directory "src")
                       (static-directory "manuals")))