This is the staple Reference Manual, version 2.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 15 07:46:43 2024 GMT+0.
staple/staple.asdstaple-package-recording/staple-package-recording.asdstaple-code-parser/staple-code-parser.asdstaple/package.lispstaple/toolkit.lispstaple/xref.lispstaple/transform.lispstaple/code-format.lispstaple/clip.lispstaple/page.lispstaple/project.lispstaple/inference.lispstaple/documentation.lispstaple-package-recording/recording.lispstaple-code-parser/package.lispstaple-code-parser/environment.lispstaple-code-parser/walker.lispstaple-code-parser/special-forms.lispstaple-code-parser/standard-forms.lispstaple-code-parser/to-definitions.lispstaple-code-parser/documentation.lispThe main system appears first, followed by any subsystem dependency.
stapleA tool to generate documentation about Lisp projects through an HTML template.
Yukari Hafner <shinmera@tymoon.eu>
Yukari Hafner <shinmera@tymoon.eu>
(GIT https://github.com/Shinmera/staple.git)
zlib
2.0.0
staple-package-recording (system).
staple-code-parser (system).
babel (system).
clip (system).
cl-ppcre (system).
definitions (system).
pathname-utils (system).
language-codes (system).
documentation-utils (system).
package.lisp (file).
toolkit.lisp (file).
xref.lisp (file).
transform.lisp (file).
code-format.lisp (file).
clip.lisp (file).
page.lisp (file).
project.lisp (file).
inference.lisp (file).
documentation.lisp (file).
staple-package-recordingCollects information about packages being defined with an ASDF system.
Yukari Hafner <shinmera@tymoon.eu>
Yukari Hafner <shinmera@tymoon.eu>
(GIT https://github.com/Shinmera/staple.git)
zlib
1.0.1
recording.lisp (file).
staple-code-parserA code parser tool for documentation markup
Yukari Hafner <shinmera@tymoon.eu>
Yukari Hafner <shinmera@tymoon.eu>
(GIT https://github.com/Shinmera/staple.git)
zlib
1.0.0
alexandria (system).
definitions (system).
concrete-syntax-tree (system).
concrete-syntax-tree-lambda-list (system).
concrete-syntax-tree-destructuring (system).
eclector (system).
eclector-concrete-syntax-tree (system).
documentation-utils (system).
package.lisp (file).
environment.lisp (file).
walker.lisp (file).
special-forms.lisp (file).
standard-forms.lisp (file).
to-definitions.lisp (file).
documentation.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
staple/staple.asdstaple-package-recording/staple-package-recording.asdstaple-code-parser/staple-code-parser.asdstaple/package.lispstaple/toolkit.lispstaple/xref.lispstaple/transform.lispstaple/code-format.lispstaple/clip.lispstaple/page.lispstaple/project.lispstaple/inference.lispstaple/documentation.lispstaple-package-recording/recording.lispstaple-code-parser/package.lispstaple-code-parser/environment.lispstaple-code-parser/walker.lispstaple-code-parser/special-forms.lispstaple-code-parser/standard-forms.lispstaple-code-parser/to-definitions.lispstaple-code-parser/documentation.lispstaple-package-recording/staple-package-recording.asdstaple-package-recording (system).
staple-code-parser/staple-code-parser.asdstaple-code-parser (system).
staple/toolkit.lisppackage.lisp (file).
staple (system).
absolute-source-location (function).
definition-id (generic function).
definition-importance (generic function).
definition-order (generic function).
ensure-package (function).
ensure-package-definition (function).
extract-language (function).
find-files (function).
load-system-quietly (function).
maybe-lang-docstring (function).
preferred-definition (function).
purify-arglist (function).
read-file (function).
relative-path (generic function).
sort-definitions (function).
stream-designator (type).
url-encode (function).
with-stream (macro).
case* (macro).
compact (function).
do-directory-tree (macro).
ensure-stream (function).
ensure-system (function).
extract-author-email (function).
extract-author-name (function).
map-directory-tree (function).
merge-plists (function).
prefix-p (function).
read-value (function).
skip-to-source-form (function).
split (function).
stream-value (function).
system-field (function).
system-name (method).
system-name (method).
titleize (function).
unlist (function).
with-value-restart (macro).
staple/xref.lisptoolkit.lisp (file).
staple (system).
define-xref-resolver (macro).
find-definitions-for-identifier (function).
remove-xref-resolver (function).
resolve-xref (function).
xref (generic function).
xref-resolver (function).
(setf xref-resolver) (function).
*xref-resolvers* (special variable).
parse-lisp-token (function).
parse-symbol (function).
staple/transform.lispxref.lisp (file).
staple (system).
compile-source (generic function).
define-source-compiler (macro).
pathname-type->type (function).
(setf pathname-type->type) (function).
*pathname-type-type-map* (special variable).
staple/code-format.lisptransform.lisp (file).
staple (system).
markup-code-block (function).
markup-code-reference (function).
markup-code-snippets (function).
markup-code-snippets-ignoring-errors (function).
make-xref-link (function).
remove-overlaps (function).
staple/page.lispclip.lisp (file).
staple (system).
*page* (special variable).
compiled-page (class).
current-commit (method).
definition-wanted-p (generic function).
definitions (generic function).
definitions-index-page (class).
format-documentation (generic function).
generate (generic function).
initialize-instance (method).
input (reader method).
(setf input) (writer method).
input-page (class).
language (reader method).
(setf language) (writer method).
output (reader method).
(setf output) (writer method).
packages (reader method).
(setf packages) (writer method).
(setf packages) (method).
page (class).
page-siblings (generic function).
page-variants (generic function).
print-object (method).
project (reader method).
(setf project) (writer method).
relative-path (method).
relative-path (method).
relative-path (method).
resolve-source-link (generic function).
shared-initialize (method).
shared-initialize (method).
static-page (class).
system (reader method).
(setf system) (writer method).
(setf system) (method).
system-page (class).
template-data (generic function).
templated-page (class).
title (reader method).
(setf title) (writer method).
*current-commit-cache* (special variable).
github-project-root (function).
gitlab-project-root (function).
staple/project.lisppage.lisp (file).
staple (system).
*load-prohibited-systems* (special variable).
extension-file (generic function).
find-project (generic function).
generate (method).
generate (method).
infer-project (generic function).
load-extension (function).
output (reader method).
(setf output) (writer method).
pages (generic reader).
(setf pages) (writer method).
project (class).
relative-path (method).
relative-path (method).
simple-project (class).
*loaded-extensions* (special variable).
make-extension-load-table (function).
staple/inference.lispproject.lisp (file).
staple (system).
*default-template* (special variable).
*document-patterns* (special variable).
*image-patterns* (special variable).
compile-source (method).
definition-wanted-p (method).
definition-wanted-p (method).
definition-wanted-p (method).
definition-wanted-p (method).
definition-wanted-p (method).
document (reader method).
(setf document) (writer method).
document-package (reader method).
(setf document-package) (writer method).
documents (method).
filename (method).
images (method).
images (reader method).
(setf images) (writer method).
infer-project (method).
initialize-instance (method).
no-known-output-directory (condition).
output-directory (method).
page-type (method).
simple-page (class).
subsystems (method).
system (reader method).
template (method).
template-data (method).
staple/documentation.lispinference.lisp (file).
staple (system).
staple-package-recording/recording.lispstaple-package-recording (system).
package-system (method).
package-system (method).
packages (method).
packages (method).
(setf packages) (method).
(setf packages) (method).
*before-load-packages* (special variable).
*system-packages* (special variable).
efind-package (function).
staple-code-parser/package.lispstaple-code-parser (system).
staple-code-parser/environment.lisppackage.lisp (file).
staple-code-parser (system).
augment-environment! (function).
augmented-environment (function).
environment (class).
lookup (method).
(setf lookup) (method).
ensure-namespace (function).
namespace (function).
namespaces (reader method).
parent (reader method).
staple-code-parser/walker.lispenvironment.lisp (file).
staple-code-parser (system).
define-walk-compound-form (macro).
define-walker-form (macro).
evaluate-expression (method).
interpret-symbol (method).
parse (method).
placeholder (class).
placeholder-intern (reader method).
placeholder-name (reader method).
placeholder-package (reader method).
print-object (method).
read-toplevel (method).
read-toplevel (method).
read-toplevel (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk (method).
walk-atom (method).
walk-atom (method).
walk-bindings (function).
walk-body (function).
walk-implicit-progn (function).
walk-lambda-like (function).
client (class).
staple-code-parser/special-forms.lispwalker.lisp (file).
staple-code-parser (system).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
walk-form (method).
staple-code-parser/standard-forms.lispspecial-forms.lisp (file).
staple-code-parser (system).
maybe-unquote (function).
perform-and-record-macro-expansion (function).
staple-code-parser/to-definitions.lispstandard-forms.lisp (file).
staple-code-parser (system).
define-definition-resolver (macro).
define-sub-results (macro).
find-definitions (method).
find-definitions (method).
find-definitions (method).
find-definitions (method).
find-definitions (method).
find-definitions (method).
parse-result->definition-list (function).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
sub-results (method).
tie-to-source (function).
staple-code-parser/documentation.lispto-definitions.lisp (file).
staple-code-parser (system).
Packages are listed by definition order.
staple-code-parserorg.shirakumo.staple.code-parser
alexandria.
common-lisp.
augment-environment! (function).
augmented-environment (function).
define-definition-resolver (macro).
define-sub-results (macro).
define-walk-compound-form (macro).
define-walker-form (macro).
environment (class).
find-definitions (generic function).
lookup (generic function).
(setf lookup) (generic function).
parse (generic function).
parse-result->definition-list (function).
placeholder (class).
placeholder-intern (generic reader).
placeholder-name (generic reader).
placeholder-package (generic reader).
read-toplevel (generic function).
sub-results (generic function).
tie-to-source (function).
walk (generic function).
walk-atom (generic function).
walk-bindings (function).
walk-body (function).
walk-form (generic function).
walk-implicit-progn (function).
walk-lambda-like (function).
client (class).
ensure-namespace (function).
maybe-unquote (function).
namespace (function).
namespaces (generic reader).
parent (generic reader).
perform-and-record-macro-expansion (function).
stapleorg.shirakumo.staple
common-lisp.
staple-package-recording.
*default-template* (special variable).
*document-patterns* (special variable).
*image-patterns* (special variable).
*load-prohibited-systems* (special variable).
*page* (special variable).
absolute-source-location (function).
compile-source (generic function).
compiled-page (class).
current-commit (generic function).
define-source-compiler (macro).
define-xref-resolver (macro).
definition-id (generic function).
definition-importance (generic function).
definition-order (generic function).
definition-wanted-p (generic function).
definitions (generic function).
definitions-index-page (class).
document (generic reader).
(setf document) (generic writer).
document-package (generic reader).
(setf document-package) (generic writer).
documents (generic function).
ensure-package (function).
ensure-package-definition (function).
extension-file (generic function).
extract-language (function).
filename (generic function).
find-definitions-for-identifier (function).
find-files (function).
find-project (generic function).
format-documentation (generic function).
generate (generic function).
images (generic function).
(setf images) (generic writer).
infer-project (generic function).
input (generic reader).
(setf input) (generic writer).
input-page (class).
language (generic reader).
(setf language) (generic writer).
load-extension (function).
load-system-quietly (function).
markup-code-block (function).
markup-code-reference (function).
markup-code-snippets (function).
markup-code-snippets-ignoring-errors (function).
maybe-lang-docstring (function).
no-known-output-directory (condition).
output (generic reader).
(setf output) (generic writer).
output-directory (generic function).
page (class).
page-siblings (generic function).
page-type (generic function).
page-variants (generic function).
pages (generic reader).
(setf pages) (generic writer).
pathname-type->type (function).
(setf pathname-type->type) (function).
preferred-definition (function).
project (generic reader).
(setf project) (generic writer).
project (class).
purify-arglist (function).
read-file (function).
relative-path (generic function).
remove-xref-resolver (function).
resolve-source-link (generic function).
resolve-xref (function).
simple-page (class).
simple-project (class).
sort-definitions (function).
static-page (class).
stream-designator (type).
subsystems (generic function).
system (generic reader).
(setf system) (generic function).
system-page (class).
template (generic function).
template-data (generic function).
templated-page (class).
title (generic reader).
(setf title) (generic writer).
url-encode (function).
with-stream (macro).
xref (generic function).
xref-resolver (function).
(setf xref-resolver) (function).
*current-commit-cache* (special variable).
*loaded-extensions* (special variable).
*pathname-type-type-map* (special variable).
*xref-resolvers* (special variable).
case* (macro).
compact (function).
do-directory-tree (macro).
ensure-stream (function).
ensure-system (function).
extract-author-email (function).
extract-author-name (function).
github-project-root (function).
gitlab-project-root (function).
make-extension-load-table (function).
make-xref-link (function).
map-directory-tree (function).
merge-plists (function).
parse-lisp-token (function).
parse-symbol (function).
prefix-p (function).
read-value (function).
remove-overlaps (function).
skip-to-source-form (function).
split (function).
stream-value (function).
system-field (function).
system-name (generic function).
titleize (function).
unlist (function).
with-value-restart (macro).
staple-package-recordingorg.shirakumo.staple.recording
common-lisp.
package-system (generic function).
packages (slot).
packages (generic function).
(setf packages) (generic function).
*before-load-packages* (special variable).
*system-packages* (special variable).
efind-package (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Pathname to the default Clip template used for simple pages.
See SIMPLE-PAGE
A list of regular expression patterns that recognise document files.
An expression in this list should match the filename of a file that denotes a documentation body file.
A list of regular expression patterns that recognise image files.
An expression in this list should match the filename of a file that denotes an image file.
A list of ASDF:SYSTEM instances that should not be loaded for extensions.
This is a curated list of special systems that cause problems when
being loaded as part of the LOAD-EXTENSION mechanism.
See LOAD-EXTENSION
Variable bound to the current page during generation.
See PAGE
See GENERATE
Shorthand to define a find-definitions method and destructure the arguments of the parse result.
See FIND-DEFINITIONS
Defines a new source compiler variant.
This is a shorthand that sets the PATHNAME-TYPE->TYPE association and
defines a new method on COMPILE-SOURCE to handle the conversion.
Thus, the TYPE should be a keyword identifying the source type, and
PATHNAME-TYPES should be an enumeration of known file types that are
used for this kind of conversion. You may also leave this empty if you
are defining a source type conversion that is not usually backed by
explicit files.
See PATHNAME-TYPE->TYPE
See COMPILE-SOURCE
Shorthand to define a sub-results method and destructure the arguments of the parse result.
See SUB-RESULTS
Shorthand to define a WALK-FORM method.
Adds local functions for WALK and WALK-IMPLICIT-PROGN that
automatically pass the environment along so you don’t need to repeat
it.
See WALK-FORM
Shorthand to define simple walker forms.
The FORM should be a destructuring description of the kind of form to
walk. The return value of the BODY should be the list of additional
arguments for the parse result. The type and source of the parse
result are automatically added for you.
If you need control over the type or source, look at
DEFINE-WALK-COMPOUND-FORM instead.
See DEFINE-WALK-COMPOUND-FORM
Defines a new cross-reference resolver function.
The lambda-list should accept one required argument, the definition
instance to find a cross-reference for.
The name can be either a name for the resolver, or a list of name
and priority number.
See XREF-RESOLVER
See REMOVE-XREF-RESOLVER
See RESOLVE-XREF
Handles stream opening and closing, returning a useful value.
Essentially this calls ENSURE-STREAM on the designator and the args.
Upon unwinding, CLOSE is called on the stream. On successful exit of
the body, STREAM-VALUE is returned.
See ENSURE-STREAM
See STREAM-VALUE
Translates the given Definitions source-location into an absolute one.
This will read the source file to determine the absolute row/line and
col/char pointed at by the source-location. It returns another plist
of the following keys:
:FILE — The same as in the input.
:OFFSET — The absolute file-position offset.
:ROW — The row/line of the offset.
:COL — The col/char of the offset.
Returns NIL if the file cannot be found, the source-location is NIL,
or the file cannot be parsed.
See SKIP-TO-SOURCE-FORM
Augments the given environment with the new values for the given names.
Returns the modified environment.
See LOOKUP
See ENVIRONMENT
Returns a new environment with the changed values in place.
The old environment is a parent to the new one.
See AUGMENT-ENVIRONMENT!
See ENVIRONMENT
Turns the given thing into a CL:PACKAGE.
If the thing cannot be coerced, an error is signalled.
Turns the given thing into a DEFINITIONS:PACKAGE.
If the thing cannot be coerced, an error is signalled.
Attempts to find a valid two or three-letter language code in the string.
If a code can be found, two values are returned: the code itself and
the list of names for the language the code points to.
See LANGUAGE-CODES:NAMES
Attempts to find all definitions for the given symbol identifier.
The symbol is given in two parts – as its name, and package.
The list of returned definitions may optionally be filtered by the
given type argument.
If no package is given, the definitions are attempted to be found in
the packages stored in *PAGE*, or the CL package.
See *PAGE*
See PACKAGES
See DEFINITIONS:FIND-DEFINITIONS
Find all files in the directory tree that match one of the patterns.
The patterns should be regular expressions suitable for CL-PPCRE. They
are matched against the file-namestrings of the files in the directory
tree.
See DO-DIRECTORY-TREE
Loads the extension file of the system.
This ensures that all Staple extensions and customisations that the
system might need are present and loaded when the documentation is
generated.
It proceeds as follows:
1. The argument is coerced to an ASDF:SYSTEM
2. If the system was already involved in a LOAD-EXTENSION call within
this call tree, NIL is returned immediately.
3. Otherwise the system is loaded via ASDF:LOAD-SYSTEM, with warnings
and standard-output muffled.
4. For each dependency registered for the system, LOAD-EXTENSION is
called again to ensure dependant extensions are loaded first.
5. The EXTENSION-FILE, if present, is LOADed.
6. The system is returned.
See ASDF:LOAD-SYSTEM
See CL:LOAD
Loads the given ASDF:SYSTEM quietly.
This muffles warnings and suppresses *standard-output*.
See ASDF:LOAD-SYSTEM
Transforms the node’s content treating it as a code block.
Only the textual contents of the node are inspected, any other kinds of tag that may be a child to the block will be removed by this.
All definitions that are recognised in this that have a result for
XREF will be marked up by an <a> tag with the class "xref".
Note that the value of *PACKAGE* matters for the parsing of the
code blocks, as a full READ and walk is performed on it to find
symbols and their usage in the code snippet.
Note also that if invalid code or non-lisp code is encountered an
error may be signalled by the reader.
See XREF
See STAPLE-CODE-PARSER:PARSE
See STAPLE-CODE-PARSER:PARSE-RESULT->DEFINITION-LIST
Transforms the node’s content treating it as a definition reference.
Only the textual contents of the node are inspected, any other kinds of tag that may be a child to the block will be removed by this.
This simply uses XREF on the textual content and if a result is
returned, inserts an <a> tag with the class "xref" to provide the
link.
See XREF
Attempts to mark up the code snippets in the given HTML text.
This looks for <code> tags within the given HTML and will try to
automatically insert xref links. It performs transformations as
follows: Each <code> tag that is direct child to a <pre> tag is
transformed using MARKUP-CODE-BLOCK, with the intention that the
<code> element contains full code snippets. <code> tags without a
<pre> parent will be transformed using MARKUP-CODE-REFERENCE,
with the idea that these will only contain single symbol names that
represent direct references to definitions.
If an error occurs during the markup of a tag, a SKIP-TAG restart
will be available to allow skipping that particular tag.
The return value of this function is a PLUMP:NODE if the argument
is also a PLUMP:NODE, and a STRING if the argument is either a
STRING or a PATHNAME.
See MARKUP-CODE-BLOCK
See MARKUP-CODE-REFERENCE
Marks up the code snippets ignoring parts that fail during markup.
See MARKUP-CODE-SNIPPETS
Attempts to find a docstring for the given definition in the given language.
If the multilang-documentation system is loaded, then this consults
MULTILANG-DOCUMENTATION:DOCUMENTATION using the DEFINITIONS:OBJECT
and T as arguments, and alternatively the DEFINITIONS:DESIGNATOR and
DEFINITIONS:TYPE. If either the system is not loaded, or it fails to
return anything for both queries, it falls back to just returning the
DEFINITIONS:DOCUMENTATION.
See MULTILANG-DOCUMENTATION:DOCUMENTATION
See DEFINITIONS:DOCUMENTATION
Turn the parse-result into a list of definitions and source locations.
For instance:
((:CALL (0 . 10) (:VARIABLE (1 . 5) NULL) (:LITERAL (6 . 9) NIL)))
=> ((#<DEFINITIONS:FUNCTION NULL> (1 . 5)))
This uses FIND-DEFINITIONS to find suitable definitions for a parse
result, as well as SUB-RESULTS to traverse the parse result tree.
See FIND-DEFINITIONS
See SUB-RESULTS
Returns a keyword for the given pathname-type, if it is known.
If ERRORP is non-NIL and no type can be found, an error is signalled.
When used as a setf-place, the value should be a list of pathname-type
strings that should be associated with the given type. Note that this
is overriding, meaning that previous associations to the given type
are removed.
See COMPILE-SOURCE
See DEFINE-SOURCE-COMPILER
Returns the list sorted such that the most important, or preferred definitions, come first.
See DEFINITION-IMPORTANCE
Purifies the given arguments list / lambda-list.
This function is useful for presenting the user-interface part of
a lambda-list. Thus it trims all extraneous information that the
user of a function or macro does not need to know about.
Specifically this does the following, depending on the current
lambda-list-keyword in the arglist:
REQUIRED — The argument is purified recursively if it is a
list, and retained verbatim otherwise.
&OPTIONAL — Only the variable name is retained.
&KEY — Only the variable’s keyword-name is retained.
&WHOLE — The argument is removed.
&ENVIRONMENT — The argument is removed.
&AUX — The argument is removed.
Reads the given file to a string and returns it.
Removes the cross-reference resolver of the given name.
See XREF-RESOLVER
Calls each cross-reference resolver with the definition until one returns a valid reference.
See XREF-RESOLVER
See DEFINE-XREF-RESOLVER
Sorts the list of definitions into a natural order.
Definitions of different type are sorted by DEFINITION-ORDER.
Definitions of the same type are sorted by STRING< using
DEFINITIONS:NAME as the key.
The sort is performed stably.
See DEFINITION-ORDER
Turns each def into a list of source and def.
Performs percent, or url-encoding of the string.
Walk the set of LET bindings in the environment.
Returns a list of cons cells where the CAR is the variable definition
of the binding and the cdr is the parse result of the value.
See WALK
Same as WALK-IMPLICIT-PROGN, but filters out declarations from the cst.
See WALK-IMPLICIT-PROGN
Walks the CST as a list of forms and returns the list of parse-results for each form.
See WALK
Walk a lambda-like structure.
Parses the lambda-list and body forms appropriately and returns a
parse-result for a lambda. The given parser is used to process the
lambda-list.
See WALK-IMPLICIT-PROGN
Accessor to the cross-reference resolver of the given name.
The resolver should be a function of one argument, a definition
instance. It should return either NIL, or a URL string.
Default xref-resolvers for the current page that’s being generated,
and the common-lisp package, are defined.
It is useful to define addition resolvers if you have some kind of source of documentation that you would like to be able to link to.
Resolvers allow an optional priority number to control in which
order they’re invoked. When reading the resolver, the priority is
returned as the second value.
See REMOVE-XREF-RESOLVER
See DEFINE-XREF-RESOLVER
See RESOLVE-XREF
Compiles the source to a usable format, interpreting it as the given type.
The following argument combinations have specifically defined
behaviour:
Source: Type: Explanation:
——————————————————————–
PATHNAME (EQL T) — COMPILE-SOURCE is called again using the
pathname’s pathname-type as type argument.
PATHNAME T — COMPILE-SOURCE is called again using the
contents of the file in string form as source
argument.
T STRING — COMPILE-SOURCE is called again using the type
returned by PATHNAME-TYPE->TYPE as the type
argument.
You should add methods to this function specialising on a particular
source type to handle the translation appropriately.
See PATHNAME-TYPE->TYPE
See DEFINE-SOURCE-COMPILER
pathname) (page simple-page)) ¶string) (type (eql :text))) ¶string) (type (eql :html))) ¶pathname) (type (eql t))) ¶pathname) type) ¶string)) ¶Returns a string representing a unique ID for the given definition.
This is useful for creating links and anchors for definitions in a document.
Returns a number for the given definition, used to determine if one definition should receive precedence over another.
By default, the following sorting is applied:
DEFINITIONS:CALLABLE 30
DEFINITIONS:TYPE 20
DEFINITIONS:VARIABLE 10
DEFINITIONS:DEFINITION 0
DEFINITIONS:METHOD -10
See PREFERRED-DEFINITION
Returns a number for the given definition, used for sorting.
The higher the number, the earlier the definition should appear in the
sorting.
By default, the following sorting is applied:
DEFINITIONS:PACKAGE 200
DEFINITIONS:CONSTANT 190
DEFINITIONS:SYMBOL-MACRO 180
DEFINITIONS:SPECIAL-VARIABLE 170
DEFINITIONS:VARIABLE 160
DEFINITIONS:CLASS 150
DEFINITIONS:CONDITION 140
DEFINITIONS:STRUCTURE 130
DEFINITIONS:TYPE-DEFINITION 120
DEFINITIONS:TYPE 110
DEFINITIONS:ACCESSOR 100
DEFINITIONS:FUNCTION 90
DEFINITIONS:GENERIC-FUNCTION 80
DEFINITIONS:METHOD 70
DEFINITIONS:COMPILER-MACRO 60
DEFINITIONS:MACRO 50
DEFINITIONS:SETF-EXPANDER 40
DEFINITIONS:CALLABLE 30
DEFINITIONS:METHOD-COMBINATION 20
DEFINITIONS:GLOBAL-DEFINITION 10
DEFINITIONS:DEFINITION 0
See SORT-DEFINITIONS
package)) ¶constant)) ¶symbol-macro)) ¶special-variable)) ¶variable)) ¶class)) ¶condition)) ¶structure)) ¶type-definition)) ¶type)) ¶function)) ¶generic-function)) ¶method)) ¶compiler-macro)) ¶macro)) ¶setf-expander)) ¶callable)) ¶method-combination)) ¶global-definition)) ¶definition)) ¶This function should return T if the definition should be included in the page’s definitions index.
See DEFINITIONS-INDEX-PAGE
declaration) (project simple-page)) ¶compiler-macro) (project simple-page)) ¶package) (project simple-page)) ¶method) (project simple-page)) ¶definition) (project simple-page)) ¶definition) (page definitions-index-page)) ¶This function should return a list of applicable definitions for the given page and package.
By default this will simply compute /all/ definitions in the package
and only keeping wanted ones by DEFINITION-WANTED-P.
The returned list of definitions is always sorted in the natural order
as described by SORT-DEFINITIONS.
See DEFINITION-WANTED-P
See SORT-DEFINITIONS
definitions-index-page) package) ¶Accessor for the document the simple-page will include in its body.
This should be a pathname to a file that can be parsed by
COMPILE-SOURCE.
See SIMPLE-PAGE
See COMPILE-SOURCE
simple-page)) ¶automatically generated reader method
simple-page)) ¶automatically generated writer method
simple-page)) ¶automatically generated reader method
simple-page)) ¶automatically generated writer method
Returns a list of pathnames to documents relevant for the given system.
By default this will attempt a heuristic by searching for files that
can be parsed by PATHNAME-TYPE->TYPE, and match one of the
*DOCUMENT-PATTERNS* within the system’s source directory.
You may add a method specialising on a particular system to change
which documents are used for an inferred project.
See PATHNAME-TYPE->TYPE
See *DOCUMENT-PATTERNS*
See INFER-PROJECT
system)) ¶Returns the Staple extension source file for the ASDF:SYSTEM.
By default this is a file called "staple.ext.lisp" within the
system’s source directory.
This function may return NIL to indicate that the system has no
extension file.
See ASDF:SYSTEM-SOURCE-DIRECTORY
Returns a suitable pathname making up the filename of the page.
By default for simple-pages this is the name "index" followed by
the language code of the page, if the language is not :en or :eng,
and the type "html".
See SIMPLE-PAGE
simple-page)) ¶Returns any matching definitions for the given parse result.
All parse results have the structure of (TYPE SOURCE . ARGS).
Thus you can simply destructure it and pass the arguments to this
function to retrieve its definitions.
See DEFINE-DEFINITION-RESOLVER
(eql function)) source args0) ¶(eql :type)) source args0) ¶(eql :variable)) source args0) ¶(eql :macro)) source args0) ¶(eql :call)) source args0) ¶Find and return the project for the given project designator.
Typically the project designator will be an ASDF:SYSTEM.
If you want to define a custom project for your system, you should
add a method specialising on your system instance to this function
and have it return the appropriately filled out project instance.
By default this will first call LOAD-EXTENSION on the system, and will
then call itself again if it can now find new methods specialising
either on the system’s instance or its name as a keyword. Otherwise
it simply returns NIL.
See LOAD-EXTENSION
Formats the definition according to the page’s preferences.
This function should be called to retrieve fully formatted HTML to
use as the documentation for a given definition on a page.
By default this will call MAYBE-LANG-DOCSTRING on the definition and
the page’s language to retrieve the raw docstring, and then call
FORMAT-DOCUMENTATION again with the docstring and the page.
If a string is passed, it will by default parse it in the "See"
style wherein each Line beginning with "See" is treated as a line
indicating a source cross-reference. The rest of the line is
interpreted as a designator for another definition and is turned into
an xref link if possible.
If you would prefer other documentation styles, you should add a
method specialising on a custom page type, then use that page type in
your project.
See DEFINITIONS-INDEX-PAGE
See MAYBE-LANG-DOCSTRING
See XREF
string) (page definitions-index-page)) ¶null) (page definitions-index-page)) ¶definition) (page definitions-index-page)) ¶Generate the outputs of the given object.
The value returned by this function should be some kind of identifier of the outputs that were generated by the call to this function. In the case of a page, this will be the output file or result produced by the page. In the case of a project, this will typically be the project itself, and a list of the results from the pages it generated.
If this function is called with something that isn’t a project or page
then the argument is treated as a potential ASDF:SYSTEM and is coerced
to one by ASDF:FIND-SYSTEM. It will then try to find a project for the
system by first consulting FIND-PROJECT, and then INFER-PROJECT. If
both FIND-PROJECT and INFER-PROJECT fail, an error is signalled.
Otherwise, GENERATE is called on the newly retrieved project.
See PAGE
See PROJECT
See *PAGE*
See FIND-PROJECT
See INFER-PROJECT
templated-page) &key if-exists compact) ¶compiled-page) &key if-exists compact) ¶static-page) &key if-exists) ¶input-page) &key) ¶Returns a list of pathnames to images relevant for the given system.
By default this will attempt a heuristic by searching for files that match one of the *IMAGE-PATTERNS* within the system’s source directory.
You may add a method specialising on a particular system to change
which images are used for an inferred project.
See *IMAGE-PATTERNS*
See INFER-PROJECT
system)) ¶simple-page)) ¶automatically generated reader method
simple-page)) ¶automatically generated writer method
Attempts to infer a project suitable for the given ASDF:SYSTEM.
By default this consults a variety of functions and attempts to build
a suitable SIMPLE-PROJECT instance that should document the system.
If you want to control how the documentation is generated, you may
either specialise the functions INFER-PROJECT uses, or construct your
own project entirely by specialising on FIND-PROJECT instead.
INFER-PROJECT proceeds as follows:
1. If no :OUTPUT-DIRECTORY is given, it is found via OUTPUT-DIRECTORY.
2. If no :DOCUMENTS are given, they are found via DOCUMENTS.
3. If no :IMAGES are given, they are found via IMAGES.
4. If no :PAGE-TYPE is given, it is found via PAGE-TYPE.
5. If no :TEMPLATE is given, it is found via TEMPLATE.
6. If no :PACKAGES are given, they are found via PACKAGES.
7. If no :SUBSYSTEMS are given, they are found via SUBSYSTEMS.
8. If no output directory is known, a recoverable error of type
NO-KNOWN-OUTPUT-DIRECTORY is signalled. You may use the USE-VALUE
restart to provide a new output directory.
9. Each entry in the subsystems list may either be an ASDF system, or a
list of an ASDF system and the same keyword arguments as above. The
properties are inferred as follows:
9.1 If no :OUTPUT-DIRECTORY is given, a subdirectory by the name of the
subsystem within the primary system’s output directory is used.
9.2 If no :DOCUMENTS are given, they are found via DOCUMENTS.
9.3 If no :IMAGES are given, they are found via IMAGES, or the primary
system’s images are used.
9.4 If no :PAGE-TYPE is given, it is found via PAGE-TYPE, or the primary
system’s page-type is used.
9.5 If no :TEMPLATE is given, it is found via TEMPLATE, or the primary
system’s template is used.
9.6 If no :PACKAGES are given, they are found via PACKAGES.
9.7 If the subsystem’s source directory is the same as the primary
system’s, and the list of documents are the same, the subsystem’s
document list is emptied to avoid the subsystem using documents
intended for the primary system.
9.8 All documents for the subsystem are removed from the documents list
for the primary system.
9.9 For each document for the subsystem, a page of page-type is
constructed, passing the template as :INPUT, the output directory
as :OUTPUT, the system as :SYSTEM, the document as :DOCUMENT, the
list of images as :IMAGES, and the list of packages as :PACKAGES.
9.10. If the documents list is empty, a single page of page-type is
constructed with the same arguments as before, except the
:DOCUMENT being NIL.
9.11. For each pathname in the images list a page of type STATIC-PAGE is
constructed that will copy the image file into the
OUTPUT-DIRECTORY while preserving pathname name and type.
10. For each pathname in the documents list a page of page-type is
constructed, passing the template as :INPUT, the output directory
as :OUTPUT, the system as :SYSTEM, the document’s pathname as
:DOCUMENT, the list of images as :IMAGES, and the list of packages
as :PACKAGES.
11. If the documents list is empty, a single page of page-type is
constructed with the same arguments as before, except the :DOCUMENT
being NIL.
12. For each pathname in the images list a page of type STATIC-PAGE is
constructed that will copy the image file into the OUTPUT-DIRECTORY
while preserving pathname name and type.
13. A SIMPLE-PROJECT instance is constructed and returned with those
pages as the :PAGES argument.
See OUTPUT-DIRECTORY
See DOCUMENTS
See IMAGES
See PACKAGES
See PAGE-TYPE
See TEMPLATE
See SUBSYSTEMS
See *DEFAULT-TEMPLATE*
See NO-KNOWN-OUTPUT-DIRECTORY
See CL:USE-VALUE
See STATIC-PAGE
See SIMPLE-PROJECT
Accessor to the input of the page.
The input should be a STREAM-DESIGNATOR, meaning that it can be
resolved to a stream via ENSURE-STREAM. Typically it will be a
pathname pointing to the file from which the page’s input should be
ready.
See INPUT-PAGE
input-page)) ¶automatically generated reader method
input-page)) ¶automatically generated writer method
Accessor to the language of a page.
The language should be a two or three-letter short-code that uniquely
identifies the language as a keyword. See the ISO-639 language codes for
all available options.
See PAGE
Looks up the name in the namespace of the environment.
This will traverse the environment chain upwards until no parent can
be found anymore in case the current environment’s namespace does not
contain the value.
When used as a setf place the value is always stored in the given
environment’s namespace.
See NAMESPACE
See ENVIRONMENT
environment)) ¶environment)) ¶Accessor to the output of a page.
The output should be a STREAM-DESIGNATOR, meaning that it can be
resolved to a stream via ENSURE-STREAM. Typically it will be a
pathname pointing to the file into which the page’s contents should be
stored.
See PAGE
Returns the output directory to which documentation for the given system should be output.
By default this returns the "doc/" subdirectory within the system’s
source directory.
You may add a method specialising on a particular system to change
where the resulting content is stored for an inferred project.
See ASDF:SYSTEM-SOURCE-DIRECTORY
See INFER-PROJECT
system)) ¶Returns the system associated with the package.
This is typically the system that defines the package, if the package
was recorded through Staple’s package recording mechanism. If this
automated detection is not smart enough, you may supply methods on
this function to specify the correct system for a package.
See CL:PACKAGE
Accessor to the list of packages associated with the instance.
This will always return a list of PACKAGE instances, not package
designators. If passed an ASDF:SYSTEM instance, it will return the
list of packages that were either recorded explicitly for the system
during loading, or were either inferred or explicitly set for the
system. If passed a DEFINITIONS-INDEX-PAGE instance, it will return
the list of packages that should be put into the index. For anything
else it will try to coerce the argument to an ASDF:SYSTEM via
ASDF:FIND-SYSTEM.
See ASDF:SYSTEM
See DEFINITIONS-INDEX-PAGE
definitions-index-page)) ¶automatically generated reader method
symbol)) ¶system)) ¶definitions-index-page)) ¶definitions-index-page)) ¶automatically generated writer method
system)) ¶Returns the type of the page that should be used for the given system’s inferred project.
By default this returns ’SIMPLE-PAGE
You may add a method specialising on a particular system to change
which page-type is used for an inferred project.
See SIMPLE-PAGE
See INFER-PROJECT
system)) ¶Returns the list of pages that the project generates.
See PAGE
See PROJECT
simple-project)) ¶automatically generated reader method
simple-project)) ¶automatically generated writer method
Parses the input and returns a list of parse results, each for one toplevel.
First uses READ-TOPLEVEL to read all toplevel forms, then uses WALK
for each of the read CSTs to turn them into parse results.
See READ-TOPLEVEL
See WALK
Returns whether the symbol being read is an internal or external symbol.
See PLACEHOLDER
placeholder)) ¶automatically generated reader method
Returns the symbol-name of the symbol this is a placeholder for.
See PLACEHOLDER
placeholder)) ¶automatically generated reader method
name.
Returns the symbol-package name of the symbol this is a placeholder for.
See PLACEHOLDER
placeholder)) ¶automatically generated reader method
Accessor to the page’s project.
See PAGE
Reads the toplevel of an input.
The INPUT may be a string, pathname, or a stream (by default). Returns a list of CSTs representing all toplevel forms that were read.
Return the relative path from the second argument to the first.
By default the following cases are handled:
To: From: Explanation:
——————————————————————–
PATHNAME PATHNAME — Computes the relative pathname.
PAGE T — Delegates using OUTPUT.
T PAGE — Delegates using OUTPUT.
PROJECT T — Delegates using OUTPUT.
T PROJECT — Delegates using OUTPUT.
PAGE (EQL T) — Delegates using PROJECT.
See PATHNAME-UTILS:RELATIVE-PATH
See OUTPUT
See PROJECT
See PAGE
Resolve the link to a source file to a URI.
The source should be either a definition or a source spec. In case of
a definition, the function is called again with the source spec as
computed by ABSOLUTE-SOURCE-LOCATION on DEFINITIONS:SOURCE-LOCATION.
A source spec should be a plist of the following possible keys:
:FILE — An absolute pathname to the source file. Required. :ROW — An optional row/line to which to point within the file. :COL — An optional col/char to which to point within the line.
By default this will try a "best effort" resolution, meaning
relative links if the file’s path is a subpath of the page’s output.
Otherwise it will fall back to a "file://" link.
See DEFINITIONS:SOURCE-LOCATION
See ABSOLUTE-SOURCE-LOCATION
system-page)) ¶definitions-index-page)) ¶definition) (page definitions-index-page)) ¶Returns all parse results that are sub-results of this parse result.
All parse results have the structure of (TYPE SOURCE . ARGS).
Thus you can simply destructure it and pass the arguments to this
function to retrieve its definitions.
See DEFINE-SUB-RESULTS
(eql :call)) args0) ¶(eql :macro)) args0) ¶(eql unwind-protect)) args0) ¶(eql throw)) args0) ¶(eql the)) args0) ¶(eql tagbody)) args0) ¶(eql symbol-macrolet)) args0) ¶(eql setq)) args0) ¶(eql return-from)) args0) ¶(eql progv)) args0) ¶(eql progn)) args0) ¶(eql multiple-value-prog1)) args0) ¶(eql multiple-value-call)) args0) ¶(eql macrolet)) args0) ¶(eql locally)) args0) ¶(eql load-time-value)) args0) ¶(eql let*)) args0) ¶(eql let)) args0) ¶(eql labels)) args0) ¶(eql if)) args0) ¶(eql go)) args0) ¶(eql sb-int:named-lambda)) args0) ¶(eql lambda)) args0) ¶(eql flet)) args0) ¶(eql eval-when)) args0) ¶(eql catch)) args0) ¶(eql block)) args0) ¶Returns a list of systems that are related to the given system.
By default this will find all ASDF systems whose name contains the
given system’s name as a prefix.
You may add a method specialising on a particular system to change
which subsystems are used for an inferred project.
See INFER-PROJECT
system)) ¶Accessor to the system the object is associated with.
See SYSTEM-PAGE
See NO-KNOWN-OUTPUT-DIRECTORY
no-known-output-directory)) ¶system-page)) ¶automatically generated reader method
system-page)) ¶system-page)) ¶automatically generated writer method
Returns the pathname to a Clip template suitable for the given system.
You may add a method specialising on a particular system to change
which template is used for an inferred project.
See INFER-PROJECT
system)) ¶Returns the arguments to CLIP:PROCESS that should be used for the page.
This should be a plistt containing the necessary data to compile the
template. Note that this generic function uses the APPEND method-
combination, meaning that you may add new keys by simply adding a new
method to this function. The method combination uses
:MOST-SPECIFIC-FIRST, and since plists short-circuit, you may also use
a method to override keys that less-specific methods may have set.
See TEMPLATED-PAGE
append.
:most-specific-first
simple-page)) ¶system-page)) ¶definitions-index-page)) ¶templated-page)) ¶Accessor to the title of a page.
The title should be a very short, unique identifier for the page
within the project. Pages that represent the same content but in
different languages should have the same titles. The title of a page
may be used as the name for a link to that page.
See PAGE
Walks the given CST in the environment.
Should return a parse result structure.
Parse results are lists of the following form:
PARSE-RESULT ::= (TYPE SOURCE . ARGS)
TYPE — The type of the form we’ve walked. Typically this
is a symbol of the form itself, like LAMBDA, or a
keyword if a generic variant is encountered like
for :CALLs and :MACROs.
SOURCE ::= (START . END)
ARGS — Additional arguments for the parse result,
including additional parse-results.
Generally see the overall concrete-syntax-tree system for explanations
on how to use this.
Note that you probably want to define a method on WALK-FORM instead,
as that is called automatically as appropriate for each CST:CONST-CST,
and WALK-ATOM is called for each CST:ATOM-CST.
See ENVIRONMENT
cons-cst) environment) ¶atom-cst) environment) ¶specialized-required-parameter) environment) ¶ordinary-key-parameter) environment) ¶ordinary-optional-parameter) environment) ¶simple-variable) environment) ¶specialized-lambda-list) environment) ¶macro-lambda-list) environment) ¶ordinary-lambda-list) environment) ¶Walks an atom.
If the atom is a symbol, it returns a parse result of a literal for keywords and booleans, or a variable for symbols. For everything else it returns a parse result for a literal.
Walks a form.
The form is identified by the car of the cons. The entirety of the form as a CST, including the operator, are passed along as well.
(eql apply)) (cst cons-cst) environment) ¶(eql funcall)) (cst cons-cst) environment) ¶(eql loop)) (cst cons-cst) environment) ¶(eql setf)) (cst cons-cst) environment) ¶(eql defmethod)) (cst cons-cst) environment) ¶(eql defclass)) (cst cons-cst) environment) ¶(eql make-instance)) (cst cons-cst) environment) ¶cons-cst) environment) ¶(eql unwind-protect)) (cst cons-cst) environment0) ¶(eql throw)) (cst cons-cst) environment0) ¶(eql the)) (cst cons-cst) environment0) ¶(eql tagbody)) (cst cons-cst) environment) ¶(eql symbol-macrolet)) (cst cons-cst) environment) ¶(eql setq)) (cst cons-cst) environment0) ¶(eql return-from)) (cst cons-cst) environment) ¶(eql quote)) (cst cons-cst) environment0) ¶(eql progv)) (cst cons-cst) environment) ¶(eql progn)) (cst cons-cst) environment0) ¶(eql multiple-value-prog1)) (cst cons-cst) environment0) ¶(eql multiple-value-call)) (cst cons-cst) environment0) ¶(eql macrolet)) (cst cons-cst) environment) ¶(eql locally)) (cst cons-cst) environment) ¶(eql load-time-value)) (cst cons-cst) environment0) ¶(eql let*)) (cst cons-cst) environment) ¶(eql let)) (cst cons-cst) environment) ¶(eql labels)) (cst cons-cst) environment) ¶(eql if)) (cst cons-cst) environment0) ¶(eql go)) (cst cons-cst) environment) ¶(eql sb-int:named-lambda)) (cst cons-cst) environment) ¶(eql lambda)) (cst cons-cst) environment) ¶(eql function)) (cst cons-cst) environment) ¶(eql flet)) (cst cons-cst) environment) ¶(eql eval-when)) (cst cons-cst) environment0) ¶(eql catch)) (cst cons-cst) environment0) ¶(eql block)) (cst cons-cst) environment) ¶Attempts to find a cross-reference URL for the given thing.
The following default cases are handled:
DEFINITIONS:DEFINITION — RESOLVE-XREF is called directly.
STRING — The string is parsed by PARSE-SYMBOL, and
if it represents a valid symbol, matching
definitions are attempted to be found via
FIND-DEFINITIONS-FOR-IDENTIFIER. The
definitions are ranked according to
PREFERRED-DEFINITION, and the first one
cross-reference via RESOLVE-XREF that can
be found is returned.
The optional TYPE argument constrains the cross references to be of the
given type of definition.
See RESOLVE-XREF
See PARSE-SYMBOL
See FIND-DEFINITIONS-FOR-IDENTIFIER
See PREFERRED-DEFINITION
simple-page) &key document output language) ¶client) in package symbol intern) ¶eclector.reader.
placeholder) stream) ¶Error signalled when no known output directory is available for a system.
See SYSTEM
See INFER-PROJECT
error.
A compiled page that is created by translating some input file.
In order to handle the translation, COMPILE-SOURCE is used.
The output of COMPILE-SOURCE may be a PLUMP:NODE, a STRING, or an
(unsigned-byte 8) vector. In the case of a PLUMP:NODE, the node is
first compressed using COMPACT if the :COMPACT argument to GENERATE
is non-NIL (default).
See INPUT-PAGE
See COMPILE-SOURCE
Superclass for pages that include a definitions index.
See PACKAGES
See FORMAT-DOCUMENTATION
See RESOLVE-SOURCE-LINK
See DEFINITION-WANTED-P
See DEFINITIONS
Container for environment information used during walking.
See PARENT
See NAMESPACES
See LOOKUP
See AUGMENT-ENVIRONMENT!
See AUGMENTED-ENVIRONMENT
(make-hash-table :test (quote eq))
This slot is read-only.
Superclass for pages that are generated using some kind of input.
See PAGE
See INPUT
Base class for all pages that can be generated as part of a project.
A page represents a single, well, page within the documentation for a
particular project. It should only produce a single output, which
is typically a file. A page should, if possible, only contain text in
a single language. This primary language is indicated by the page’s
LANGUAGE slot and defaults to "en" for English.
If the output is a pathname, the behaviour on existing output may be
specified through the :IF-EXISTS argument to GENERATE, by default set
to :ERROR.
See PROJECT
See TITLE
See LANGUAGE
See OUTPUT
See GENERATE
| Initarg | Value |
|---|---|
:output | nil |
:title | nil |
:project | (error project required.) |
:title
:en
:language
:output
:project
This class represents symbols that are not present in the host.
They are emitted in parsed code snippets in place of symbols that
cannot be read properly.
See PLACEHOLDER-NAME
See PLACEHOLDER-PACKAGE
See PLACEHOLDER-INTERN
| Initarg | Value |
|---|---|
:name | (error name required) |
:package | nil |
:intern | nil |
:name
This slot is read-only.
common-lisp.
:package
This slot is read-only.
common-lisp.
:intern
This slot is read-only.
Superclass for a documentation project.
A project encapsulates all documentation for a library or program.
Typically this is expressed by a number of PAGEs that will create the
expected documentation files when the project is GENERATEd.
The OUTPUT of a project represents the root directory of all output
data. It is used to figure out relative paths between pages and
resources.
See OUTPUT
See PAGE
See PAGES
See GENERATE
:output
A simple page to base documentation on.
Simple-pages are the preferred pages to use for inferred systems.
They provide a convenient all-in-one package for a definitions index
and a documentation body.
A single "document" makes up the main body of the page and should provide the primary documentation of the system or project. The document is transformed by COMPILE-SOURCE, which by default will automatically parse it from file and mark up code snippets within it.
If the OUTPUT pathname passed as initarg to this class is missing the
name and type, then the pathname is augmented using FILENAME of the
page.
See *DEFAULT-TEMPLATE*
See DOCUMENT
See IMAGES
See FILENAME
See SYSTEM-PAGE
See COMPILE-SOURCE
| Initarg | Value |
|---|---|
:document | nil |
:images | nil |
:document-package | nil |
:input | *default-template* |
:document-package
:document
:images
A simple project.
This class simply stores a list of page instances and generates them
when GENERATE is called on the project instance.
See PROJECT
See PAGES
| Initarg | Value |
|---|---|
:pages | nil |
:pages
A static page that simply copies its input to its output.
This is useful for static files such as images and other resources.
See INPUT-PAGE
Superclass for pages that represent and ASDF system.
This system will compute several properties automatically by using the
ASDF metadata: if the :PACKAGES are not given, they are computed from
calling PACKAGES on the system object. When a source link is resolved
and the project’s homepage resides on GitHub or GitLab, it will try to guess a
link to the GitHub/GitLab repository’s viewer of the source file.
See SYSTEM
See DEFINITIONS-INDEX-PAGE
nil
Superclass for pages that are templated using Clip.
The template that Clip is run on is the INPUT of the page. The
template arguments are computed using the TEMPLATE-DATA generic
function.
The output of the page is compressed using COMPACT if the :COMPACT
argument to GENERATE is non-NIL (default).
See INPUT-PAGE
See TEMPLATE-DATA
A type representing all possible values to be used with ENSURE-STREAM.
See ENSURE-STREAM
Like CL:CASE, but takes a test function.
TEST must be a function designator or a lambda expression.
See CL:CASE
Executes body for each file in the directory tree.
Evaluates RESULT last and returns its value.
See MAP-DIRECTORY-TREE
Ensures PLACE has a valid value.
This establishes a STORE-VALUE restart around BODY. If the restart is
called, the PLACE is set to the value the restart was called with and
the BODY is executed again.
Typically the BODY will be some kind of check to ensure the validity of the value stored in PLACE. In combination with this macro, that will ensure that the code only ever continues with a valid value in PLACE.
Compacts the given PLUMP:NODE by removing extraneous whitespace.
This will take care not to trim whitespace from <pre> tags, but will replace any duplicate whitespace with a single space anywhere else. Note that this will leave a single space between nodes, as it cannot determine whether the effects of the whitespace in that case are intended or not.
Makes sure the namespace of the given name exists in the environment.
See ENVIRONMENT
See NAMESPACES
Attempts to coerce the given designator to a stream object.
The following are handled:
STREAM — The designator is returned verbatim.
STRING/PATHNAME — OPEN is called on the designator using the
given keyword arguments as appropriate.
NULL — A string-output-stream is returned.
T — *STANDARD-OUTPUT* is returned.
See WITH-STREAM
See STREAM-DESIGNATOR
Ensures to return an ASDF:SYSTEM.
If the argument is not already an ASDF:SYSTEM, it is passed to
ASDF:FIND-SYSTEM, and errors if no system can be found.
See ASDF:SYSTEM
See ASDF:FIND-SYSTEM
Calls the given function for all files in the directory tree.
If MAX-DEPTH is given, it denotes the maximum number of directories into which it recurses. Specifically, if MAX-DEPTH is 0, only the files in the given directory are mapped to the function. Otherwise each directory is visited recursively with MAX-DEPTH reduced by one.
Accesses the namespace of the given name from the environment.
See NAMESPACES
See ENVIRONMENT
See LOOKUP
Parses a lisp symbol token, meaning it will read from string by properly interpreting backslashes and vertical bar escapes.
Parses a symbol from the given string identifier.
Explicit packages, keywords, and package-less symbols are handled.
Returns two values, the symbol’s name and its package as strings. If the symbol is a gensym, the returned package name is :GENSYM, rather than an actual package name string.
Returns T if PREFIX is a whole prefix of STRING.
Reads a value from *query-io*.
To be used with interactive restarts.
Continues reading from the stream until a valid lisp source form is encountered.
This skips both whitespace and comments.
Splits the given string by the given splitting character.
Returns the list of non-empty substrings. The split strings are not shared with the original string.
Attempts to turn the given string into one more suitable as a title.
Returns the hash-table of namespaces in the environment.
See ENVIRONMENT
See NAMESPACE
environment)) ¶automatically generated reader method
Returns the parent of the environment, if any.
See ENVIRONMENT
environment)) ¶automatically generated reader method
Returns a canonical keyword for the name of the ASDF:SYSTEM.
Our subclass of the eclector cst-client.
Uses the host lisp’s EVAL.
See ECLECTOR.CONCRETE-SYNTAX-TREE::CST-CLIENT
cst-client.
| Jump to: | (
A C D E F G I L M N O P R S T U W X |
|---|
| Jump to: | (
A C D E F G I L M N O P R S T U W X |
|---|
| Jump to: | *
D I L N O P S T |
|---|
| Jump to: | *
D I L N O P S T |
|---|
| Jump to: | C D E F I N P R S T W X |
|---|
| Jump to: | C D E F I N P R S T W X |
|---|