scm/document-markup.scm

   1 ;;;; This file is part of LilyPond, the GNU music typesetter.
   2 ;;;;
   3 ;;;; Copyright (C) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
   4 ;;;;                 Jan Nieuwenhuizen <janneke@gnu.org>
   5 ;;;;
   6 ;;;; LilyPond is free software: you can redistribute it and/or modify
   7 ;;;; it under the terms of the GNU General Public License as published by
   8 ;;;; the Free Software Foundation, either version 3 of the License, or
   9 ;;;; (at your option) any later version.
  10 ;;;;
  11 ;;;; LilyPond is distributed in the hope that it will be useful,
  12 ;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ;;;; GNU General Public License for more details.
  15 ;;;;
  16 ;;;; You should have received a copy of the GNU General Public License
  17 ;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18
  19
  20 (define (doc-markup-function-properties func)
  21   (let ((properties (hashq-ref markup-functions-properties func))
  22         (prop-strings (list)))
  23     (for-each (lambda (prop-spec)
  24                 (set! prop-strings
  25                       (if (list? prop-spec)
  26                           ;; either (prop value) or (prop)
  27                           (cons (if (null? (cdr prop-spec))
  28                                     (format #f "@item @code{~a}\n" (car prop-spec))
  29                                     (format #f "@item @code{~a} (~a)\n"
  30                                             (car prop-spec)
  31                                             (let ((default (cadr prop-spec)))
  32                                               (if (and (list? default)
  33                                                        (null? default))
  34                                                   "'()"
  35                                                   default))))
  36                                 prop-strings)
  37                           ;; a markup command: get its properties
  38                           ;; FIXME: avoid cyclical references
  39                           (append (doc-markup-function-properties prop-spec)
  40                                   prop-strings))))
  41               (or properties (list)))
  42     prop-strings))
  43
  44 (define (doc-markup-function func)
  45   (let* ((doc-str  (procedure-documentation func))
  46          (f-name (symbol->string (procedure-name  func)))
  47          (c-name (regexp-substitute/global #f "-markup(-list)?$" f-name  'pre "" 'post))
  48          (sig (object-property func 'markup-signature))
  49          (arg-names (let ((arg-list (cadr (procedure-source func))))
  50                       (if (list? arg-list)
  51                           (map symbol->string (cddr arg-list))
  52                           (make-list (length sig) "arg"))))
  53          (sig-type-names (map type-name sig))
  54          (signature-str
  55           (string-join
  56            (map (lambda (x) (string-append
  57                              "@var{" (car x) "} ("  (cadr x) ")" ))
  58                 (zip arg-names  sig-type-names))
  59            " " )))
  60
  61     (string-append
  62      "\n\n@item @code{\\" c-name "} " signature-str
  63      "\n@funindex \\" c-name "\n"
  64      "\n@cindex \\" c-name "\n"
  65      (if (string? doc-str)
  66          doc-str
  67          "")
  68      (let ((prop-strings (doc-markup-function-properties func)))
  69        (if (null? prop-strings)
  70            "\n"
  71            (string-append "\n\n\nUsed properties:\n@itemize\n"
  72                           (string-concatenate prop-strings)
  73                           "@end itemize\n"))))))
  74
  75 (define (markup-function<? a b)
  76   (ly:string-ci<? (symbol->string (procedure-name a)) (symbol->string (procedure-name b))))
  77
  78 (define (markup-category-doc-node category)
  79   (let* ((category-string (symbol->string category))
  80          (category-name (string-capitalize
  81                          (regexp-substitute/global
  82                           #f "-" category-string 'pre " " 'post)))
  83          (markup-functions (hash-fold (lambda (markup-function dummy functions)
  84                                         (cons markup-function functions))
  85                                       '()
  86                                       (hashq-ref markup-functions-by-category
  87                                                  category))))
  88     (make <texi-node>
  89       #:appendix #t
  90       #:name category-name
  91       #:desc ""
  92       #:text (string-append
  93               "@table @asis"
  94               (string-concatenate
  95                (map doc-markup-function
  96                     (sort markup-functions markup-function<?)))
  97               "\n@end table"))))
  98
  99 (define (markup-doc-node)
 100   (make <texi-node>
 101     #:appendix #t
 102     #:name "Text markup commands"
 103     #:desc ""
 104     #:text "The following commands can all be used inside @code{\\markup @{ @}}."
 105     #:children (let* (;; when a new category is defined, update `ordered-categories'
 106                       (ordered-categories '(font align graphic music instrument-specific-markup accordion-registers other))
 107                       (raw-categories (hash-fold (lambda (category functions categories)
 108                                                    (cons category categories))
 109                                                  (list)
 110                                                  markup-functions-by-category))
 111                       (categories (append ordered-categories
 112                                           (filter (lambda (cat)
 113                                                     (not (memq cat ordered-categories)))
 114                                                   raw-categories))))
 115                  (map markup-category-doc-node categories))))
 116
 117 (define (markup-list-doc-string)
 118   (string-append
 119    "@table @asis"
 120    (string-concatenate
 121     (map doc-markup-function
 122          (sort (hash-fold (lambda (markup-list-function dummy functions)
 123                             (cons markup-list-function functions))
 124                           '()
 125                           markup-list-functions)
 126                markup-function<?)))
 127    "\n@end table"))