Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the hh-web Reference Manual, version 0.2, generated automatically by Declt version 3.0 "Montgomery Scott" on Sun May 15 04:57:11 2022 GMT+0.
• Introduction | What hh-web is all about | |
• Systems | The systems documentation | |
• Modules | The modules documentation | |
• Files | The files documentation | |
• Packages | The packages documentation | |
• Definitions | The symbols documentation | |
• Indexes | Concepts, functions, variables and data types |
#About HH-Web#
HH-Web is the beginnings of a web application framework written in Lisp designed to streamline development of modern web applications.
See the LICENSE file for the license covering all code within the HH-Web directory and any subdirectories.
Basically, it's the MIT license, so you are free to do what you want, provided you reproduce the original copyright.
##Platforms##
The primary platform for HH-Web development is SBCL x64 on Mac OS X Lion (latest SBCL rev tested is 1.0.57); other Common Lisp implementations that appear to work correctly are CCL 1.8 x86, LispWorks 6.01, and ABCL 1.0.1. HH-Web has also been tested with SBCL 1.0.57 x64 on Ubuntu 11.04.
Platforms with known issues include CCL x64 (problem with threads) and CMUCL (which does not like named-readtables).
##Features##
In its present form (as of June 2012), there are 4 principal features in HH-Web:
Composable widgets: HH-Web let's the developer write a web page using conventional Lisp s-expression syntax, complete with properly generated CSS & Javascript. More importantly, commonly used fragments of HTML/CSS/Javascript can be bundled as a tag (just like HTML tags such as p
, div
, h1
, etc.), and the corresponding HTML/CSS/Javascript for the expected fragment will be generated instead. Using custom tags means that most of the development of a new site involves identifying the common elements that make up the site's pages, creating custom tags (with parameters or "attributes", when necessary) as needed, and then authoring the pages as templates using both HTML tags and the site-specific custom tags.
Regex-based URL dispatching: Inspired by Django's (and Rails') use of regex dispatching, HH-Web implements a similar technique, but in Lisp. Most importantly, if the regex contains "variables" (e.g., named registers, in regex parlance), then symbols will be interned for those variables and exposed as parameters to the URL's handler. Thus, components of an URL's path will automatically be extracted and made available as arguments to the handling code.
Dynamic code reloading: HH-Web automatically monitors specific files for new URL dispatching rules, page template changes, and all taglibraries. Changes in the underlying code is by default automatically reflected the next time the page is refreshed in the browser. The intent is to provide the equivalent usability of other web authoring environments such as PHP or ASP: change the code for a page, and reflect that immediately in the browser.
Integrated caching: HH-Web's support for caching is evolving, but in its current form it permits marking caching guidelines for specific URLs. Specifically, caching causes HH-Web to preseve any generated content (from templates and tags, typically) in an in-memory cache for later use. If a request for a page in its map appear again, then HH-Web will serve the content from the cache, rather than invoking code to regenerate the content fresh.
##Getting Started##
As an aide to starting new projects that use HH-Web to structure web application development, you can load the HH-Web system into the REPL using Quicklisp (included as of 7/3/2012--thanks Zach!):
(ql:quickload :hh-web)
then execute the following expression:
(hh-web:make-skeleton :for :acme :in #p"~/lisp/")
Substitute your own project name for acme in the above expression. Note that the argument to the :for keyword must be a symbol or string, and the argument to the :in keyword must be a directory path (e.g., it must end in "/"), although that directory should not exist, make-skeleton
will not overwrite any files or directories that already present--it will raise an error instead. In the above example, the package for your new application will appear as a subdirectory of the one you provided, thus it will appear in ~/lisp/acme/
.
If you use Quicklisp and the "~/lisp/" directory is registered with ASDF as a source directory, then you can then run the following at your REPL to start your newly-created web application:
(ql:quickload :acme)
(acme:start-httpd-server)
Now just point your browser at http://localhost:8000, and you should see a boilerplate homepage.
You can stop your application at any time by running the following:
(acme:stop-httpd-server)
Additionally, the generated skeleton of a project also creates a single script called quickrun.lisp
that lets you load and run your site in one step. For example, with SBCL:
sbcl --load ~/lisp/acme/quickrun.lisp
Here's the directory structure created for your project:
/acme
|
+-- acme.asd # system declaration
+-- locales # directory containing files to support i18n and l10n
+-- logs.lisp # helpers for logging using log5
+-- package.lisp # package declaration
+-- quickrun.lisp # script for loading and running the site
+-- server.lisp # runs your site with hunchentoot
+-- taglibraries # directory for your tag libraries
+-- templates # directory for your templates
+-- templates.lisp # file for declaring which templates to use
+-- urls.lisp # file containing the regex rules for dispatching requests
To develop your site, edit the following files as needed, and refresh your browser to see changes take effect immediately:
The generated skeleton also demonstrates one mechanism for integrating Bootstrap and jQuery into a site, so that the resources of both libraries are always available. Note that the chosen method here may or may not be suitable for your scenario: the skeleton generates links to CDNs that host these libraries to ease other web sites.
For more information on how HH-Web works and how to make use of it for your application, see the documentation on the wiki.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The hh-web system |
0.2
hh-web.asd (file)
Modules are listed depth-first from the system components tree.
• The hh-web/l10n module | ||
• The hh-web/logs module | ||
• The hh-web/meta module |
Next: The hh-web/logs module, Previous: Modules, Up: Modules [Contents][Index]
utils.lisp (file)
hh-web (system)
l10n/
i18n.lisp (file)
Next: The hh-web/meta module, Previous: The hh-web/l10n module, Up: Modules [Contents][Index]
l10n (module)
hh-web (system)
logs/
Previous: The hh-web/logs module, Up: Modules [Contents][Index]
server.lisp (file)
hh-web (system)
meta/
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files |
Next: The hh-web/package․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
hh-web.asd
hh-web (system)
Next: The hh-web/utils․lisp file, Previous: The hh-web․asd file, Up: Lisp files [Contents][Index]
hh-web (system)
package.lisp
Next: The hh-web/l10n/i18n․lisp file, Previous: The hh-web/package․lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
hh-web (system)
utils.lisp
Next: The hh-web/logs/outputs․lisp file, Previous: The hh-web/utils․lisp file, Up: Lisp files [Contents][Index]
l10n (module)
l10n/i18n.lisp
Next: The hh-web/logs/categories․lisp file, Previous: The hh-web/l10n/i18n․lisp file, Up: Lisp files [Contents][Index]
logs (module)
logs/outputs.lisp
Next: The hh-web/logs/rotating․lisp file, Previous: The hh-web/logs/outputs․lisp file, Up: Lisp files [Contents][Index]
outputs.lisp (file)
logs (module)
logs/categories.lisp
Next: The hh-web/logs/misc․lisp file, Previous: The hh-web/logs/categories․lisp file, Up: Lisp files [Contents][Index]
categories.lisp (file)
logs (module)
logs/rotating.lisp
rotating-log-sender (class)
Next: The hh-web/logs/hunchentoot․lisp file, Previous: The hh-web/logs/rotating․lisp file, Up: Lisp files [Contents][Index]
rotating.lisp (file)
logs (module)
logs/misc.lisp
use-backtrace-logging (macro)
Next: The hh-web/useragents․lisp file, Previous: The hh-web/logs/misc․lisp file, Up: Lisp files [Contents][Index]
misc.lisp (file)
logs (module)
logs/hunchentoot.lisp
Next: The hh-web/tags․lisp file, Previous: The hh-web/logs/hunchentoot․lisp file, Up: Lisp files [Contents][Index]
logs (module)
hh-web (system)
useragents.lisp
Next: The hh-web/taglibraries․lisp file, Previous: The hh-web/useragents․lisp file, Up: Lisp files [Contents][Index]
useragents.lisp (file)
hh-web (system)
tags.lisp
Next: The hh-web/templates․lisp file, Previous: The hh-web/tags․lisp file, Up: Lisp files [Contents][Index]
tags.lisp (file)
hh-web (system)
taglibraries.lisp
Next: The hh-web/images․lisp file, Previous: The hh-web/taglibraries․lisp file, Up: Lisp files [Contents][Index]
taglibraries.lisp (file)
hh-web (system)
templates.lisp
Next: The hh-web/cookies․lisp file, Previous: The hh-web/templates․lisp file, Up: Lisp files [Contents][Index]
templates.lisp (file)
hh-web (system)
images.lisp
Next: The hh-web/services․lisp file, Previous: The hh-web/images․lisp file, Up: Lisp files [Contents][Index]
images.lisp (file)
hh-web (system)
cookies.lisp
Next: The hh-web/cache․lisp file, Previous: The hh-web/cookies․lisp file, Up: Lisp files [Contents][Index]
cookies.lisp (file)
hh-web (system)
services.lisp
Next: The hh-web/urls․lisp file, Previous: The hh-web/services․lisp file, Up: Lisp files [Contents][Index]
services.lisp (file)
hh-web (system)
cache.lisp
Next: The hh-web/documentation․lisp file, Previous: The hh-web/cache․lisp file, Up: Lisp files [Contents][Index]
cache.lisp (file)
hh-web (system)
urls.lisp
Next: The hh-web/server․lisp file, Previous: The hh-web/urls․lisp file, Up: Lisp files [Contents][Index]
urls.lisp (file)
hh-web (system)
documentation.lisp
Next: The hh-web/meta/localeservices․lisp file, Previous: The hh-web/documentation․lisp file, Up: Lisp files [Contents][Index]
documentation.lisp (file)
hh-web (system)
server.lisp
Next: The hh-web/meta/localehandlers․lisp file, Previous: The hh-web/server․lisp file, Up: Lisp files [Contents][Index]
meta (module)
meta/localeservices.lisp
Next: The hh-web/skeleton․lisp file, Previous: The hh-web/meta/localeservices․lisp file, Up: Lisp files [Contents][Index]
localeservices.lisp (file)
meta (module)
meta/localehandlers.lisp
locale-service (function)
Previous: The hh-web/meta/localehandlers․lisp file, Up: Lisp files [Contents][Index]
meta (module)
hh-web (system)
skeleton.lisp
make-skeleton (function)
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The hh-web-asd package | ||
• The hh-web package |
Next: The hh-web package, Previous: Packages, Up: Packages [Contents][Index]
package.lisp (file)
Previous: The hh-web-asd package, Up: Packages [Contents][Index]
package.lisp (file)
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions | ||
• Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported special variables | ||
• Exported macros | ||
• Exported functions | ||
• Exported generic functions | ||
• Exported classes |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
The current tag under construction (if any), within the scope of a tag’s body
useragents.lisp (file)
Default package containing localization information (locales)
Minimum time in seconds for which a template must remain stale (e.g. not expire, before reloading from its source
templates.lisp (file)
Default folder within a package that contains the package’s tag libraries
taglibraries.lisp (file)
The name of the folder within a package’s folder structure where template files are located
templates.lisp (file)
Current tag library to which new tag defintions will belong
A list of functions such that when each is called with 1 argument (a tag name), they return the tag source as a stream or string
taglibraries.lisp (file)
While reading a template, this is the current template object for whom a definition is being read
templates.lisp (file)
List of template providers, each of which will be called to resolve a template name to locate an appropriate template
templates.lisp (file)
The active tag in the scope of a tag method (e.g., while rendering); while rendering a custom tag, *this-tag* will not change within the same method, but *current-tag* changes within the body of each tag in the content
useragents.lisp (file)
useragents.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Should record literal string for reference within the i18n subsystem, and by default return the appropriate string for the current locale
Create a ssl server, using the provided initialization arguments for constructing the acceptor.
The acceptor class used internally inherits from hunchentoot’s easy-ssl-acceptor, so initialization arguments
valid for that class are also valid here as well. The initialization arguments need to have the following keyword
arguments with pathnames for values:
* :ssl-certificate-file
* :ssl-privatekey-file
You can also pass the keyword argument with a pathname as a value
* ssl-privatekey-password
In addition to initialization arguments, the following keywords are understood:
* folders : a list of pairs URL -> path mappings, where each points to a filesystem folder for static files
* packages : a list of of pairs of URL -> package mappings, where packages should have a www/ subfolder containing static files
* dispatchers: list of additional hunchentoot dispatchers to use, if the server cannot otherwise find a handler for a request
after attempting to locate a handler based on provided URL routes
server.lisp (file)
Create a web server, using the provided initialization arguments for constructing the acceptor.
The acceptor class used internally inherits from hunchentoot’s easy-acceptor, so initialization arguments
valid for that class are also valid here as well.
In addition to initialization arguments, the following keywords are understood:
* folders : a list of pairs URL -> path mappings, where each points to a filesystem folder for static files
* packages : a list of of pairs of URL -> package mappings, where packages should have a www/ subfolder containing static files
* dispatchers: list of additional hunchentoot dispatchers to use, if the server cannot otherwise find a handler for a request
after attempting to locate a handler based on provided URL routes
server.lisp (file)
cookies.lisp (file)
Defines an entity usable in HTML
Define a new tag renderable as HTML.
Defines a service with the specified name, optional documentation, optional args and keyword args
(typically extracted from the URL associated with the service), and a set of methods.
If present, args appear as the parameter lists of methods in client script
and are used to construct the path of the request. The intent is
to enable passing of args from the client through the URL
and also to have named registers from the pattern
registered for the service available as well
services.lisp (file)
services.lisp (file)
services.lisp (file)
templates.lisp (file)
templates.lisp (file)
useragents.lisp (file)
Macro to simplify writing out html to correct stream
Interpret the body as html markup, return multiple values, the first of which is an HTML string. The full list of return values is:
$(ul
(li "The intended title of the page containing this HTML fragment")
(li "Link elements that should appear in the head of the page containing this fragment")
(li "Style sheets required by the HTML fragment")
(li "Script libraries required by the HTML fragment")
(li "Sections of Javascript code required by the HTML fragment")
(li "Sections of Javascript code to be run on page initialization that are required by the HTML fragment")
)
Any of these values may be null (including the fragment itself). Care should be taken when nesting calls to this macro, as inline
expansion of $$ characters will occur in each invocation of it, and unexpected results may occur.
Captures calls to vecto to generate an image
images.lisp (file)
All following tag definitions will go into this named library
taglibraries.lisp (file)
Interpret the raw body as html markup, and return a complete HTML page. In combination with $(a {:href "_macro_html"} "html"), this macro weaves the output of calls to $(em "html") into a complete page, with styles, scripts, references to script libraries, a page title, etc., all arranged in the appropriate order.
Clear out list of dispatchers; useful to ensures that stale patterns do not survive reload
services.lisp (file)
cookies.lisp (file)
Execute body with the values of provided parameters in indicated variables. The parameter-list should be a list of variable/parameter combinations, where each combination in the list is of the form (variable parameter). The parameter name should be a string, the variable should be a symbol referenced in the body.
services.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
Find the tag-library (if possible), and import it into the
current package (e.g., found by looking at *package* in
dynamic environment
templates.lisp (file)
taglibraries.lisp (file)
templates.lisp (file)
cache.lisp (file)
Return a dispatcher suitable for use with Hunchentoot, dispatching URLs
cache.lisp (file)
taglibraries.lisp (file)
templates.lisp (file)
cache.lisp (file)
Create a dispatcher for all files inside a www subfolder of a package’s directory
images.lisp (file)
services.lisp (file)
services.lisp (file)
services.lisp (file)
services.lisp (file)
Refresh the list of templates, if necessary
templates.lisp (file)
Returns a symbol in the current package for storing the tag library provider registry expected by the package
templates.lisp (file)
Returns a symbol in the current package for storing the template provider registry expected by the package
templates.lisp (file)
Service for editing locales usable by the application
localehandlers.lisp (file)
Sends a standardized access log message to the access log with information about the current request and response.
hunchentoot.lisp (file)
Sends a formatted message to the file http message log. FORMAT and ARGS are as in FORMAT. LOG-LEVEL is a keyword denoting the log level or NIL in which case it is ignored.
hunchentoot.lisp (file)
Create a cache with the indicated root, and if populate is non-nil, preload the cache with all files underneath the root
cache.lisp (file)
Create a filesystem cache for the www subdirectory of a package
cache.lisp (file)
Generate a skeleton for a package in the indicated location;
skeleton.lisp (file)
If there is a _meta parameter present, then regard the request as a ’meta’ request by returning t; otherwise return nil
services.lisp (file)
Add the named tag library to the list of libraries used by the active tag library
taglibraries.lisp (file)
Next: Exported classes, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Obtain a cached item, regardless of whether the item is in the cache or must be loaded from the provider
cache.lisp (file)
Return some expression as an HTML string
server.lisp (file)
Return the name of the tag as a string used for rendering in html
tags.lisp (file)
(setf tag-name) (generic function)
The tag name is the string used in the start tag when rendering to HTML
Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
tags.lisp (file)
standard-object (class)
:definition
tag-definition (generic function)
(setf tag-definition) (generic function)
:attribute-map
(make-hash-table :test (function equal))
tag-attribute-map (generic function)
(setf tag-attribute-map) (generic function)
:body
body-of (generic function)
(setf body-of) (generic function)
A variation of stream sender that rotates logs based on a configurable interval. Log rotation happens just before a message is logged.
rotating.lisp (file)
stream-sender (class)
Interval in seconds between log rotations
:interval
(* 24 60 60)
log-interval (generic function)
(setf log-interval) (generic function)
(get-universal-time)
last-write (generic function)
(setf last-write) (generic function)
:max
10
maxlogs (generic function)
(setf maxlogs) (generic function)
i18n.lisp (file)
standard-object (class)
The string as it appeared in the development locale
:name
name (generic function)
(setf name) (generic function)
The locale in which this specific string has been localized
:locale
locale (generic function)
(setf locale) (generic function)
The localized representation of a string
:translation
localization (generic function)
(setf localization) (generic function)
Notes from / to localizers about a string
:notes
""
notes (generic function)
(setf notes) (generic function)
templates.lisp (file)
standard-object (class)
:path
template-path (generic function)
:provider
template-provider (generic function)
(setf template-provider) (generic function)
tag-libraries-used (generic function)
(setf tag-libraries-used) (generic function)
(local-time:now)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
:package
(make-package (gensym))
template-package (generic function)
(setf template-package) (generic function)
:args
template-args (generic function)
(setf template-args) (generic function)
:kwargs
template-keyword-args (generic function)
(setf template-keyword-args) (generic function)
:definition
definition-of (generic function)
(setf definition-of) (generic function)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal special variables | ||
• Internal macros | ||
• Internal functions | ||
• Internal generic functions | ||
• Internal conditions | ||
• Internal classes |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
All tag libraries
Provides default implementation for tag methods
The default folder for tag libraries
taglibraries.lisp (file)
The default folder for templates
templates.lisp (file)
Locale in which development occurs, and in which strings in code first appear before translation into other locales
Output stream for rendering html
Typically set to the URL in which the string occurs, but not always (and not always set implying no relevant context
Minimum time in seconds for which a cache entry is not stale (and thus can’t expire), but after which the item is stale and possible expired
cache.lisp (file)
Minimum time in seconds for which a tag library must remain stale (e.g. not expire) before reloading from its source
taglibraries.lisp (file)
Minimum time in seconds between checks for changes to URLs; lower times mean check for updates to defurls more often, higher times mean check more rarely
documentation.lisp (file)
documentation.lisp (file)
The default language of the page
A list of link tags that should appear in the head of the page
A list of strings, each representing script to be run when the document is ready (after load)
A list of strings, each pointing to a script library that the page referneces
A list of strings, each representing a script added to the page
A list of strings, each pointing to a styleseheet that the page references
A list of strings, each representing CSS added to the page
The title of the page as it should be presented to the user in the browser
Used for pretty printing HTML, with proper indentation for nested tags
Cache of template names to template objects
templates.lisp (file)
services.lisp (file)
When this parameter appears for a service, the service will perform other ’meta’ activities for the service. See handle-service-meta-request.
services.lisp (file)
Special parameter used in POST requests to indicate the actual desired
method (should be either ’DELETE’ or ’PUT’). Used by some browser-side
code as a substitute for situations where the browser will not allow Javascript
to send a native DELETE or PUT request.
services.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
utils.lisp (file)
Given the markup for a page, build a cond statement that will return the rendering appropriate to the current user agent
useragents.lisp (file)
Used to pull apart a method definition, which has the following structure. After the initial :method keyword, the structure below is a valid lambda list.
(:method method-name
&key
((:documentation documentation) nil)
((:http-method http-method) :get)
((:if test) nil)
((:cookies cookies) nil)
((:parameters parameters) nil)
)
services.lisp (file)
Each method handler should have the following form: (:method method-name &rest method-handler-body)
services.lisp (file)
Append some-object to the end of the list in some-place.
Modifies some-place.
taglibraries.lisp (file)
Write a string representation of content to the
location specified path relative to the skeleton’s base director
skeleton.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
Captures the context in which the string appears, if a relevant context is available
Borrowed from Arnesi (http://common-lisp.net/project/bese/arnesi.html)
utils.lisp (file)
If a request has any query parameters, it’s not cachable
Return a list of default attributes common to all tags
useragents.lisp (file)
Combine elements into a string, separating each element by token
utils.lisp (file)
documentation.lisp (file)
taglibraries.lisp (file)
templates.lisp (file)
Given the symbol for a tag definition, locate that definition in any available tag library
Safely a cached library, typically for reloading
taglibraries.lisp (file)
Safely a cached template, typically for reloading
templates.lisp (file)
utils.lisp (file)
Utility function for generating long strings of
random data, such as for nonces, salts, and session cookies
utils.lisp (file)
documentation.lisp (file)
skeleton.lisp (file)
Given a cached file, return the contents of the file in a hunchentoot reply
cache.lisp (file)
utils.lisp (file)
taglibraries.lisp (file)
Load the indicated template definition from the first provider that can
templates.lisp (file)
Refresh the list of URL dispatchers, if necessary
rotating.lisp (file)
rotating.lisp (file)
Useful for pre-processing specific expressions as directives inside a template; returns nil if the expression is *not* a directive–returns t if the expr should be regarded as a directive and discarded
templates.lisp (file)
services.lisp (file)
Helper for processing service parameter lists during script generation
services.lisp (file)
useragents.lisp (file)
Return a list containing only those elements from some list
for which a-test is true
utils.lisp (file)
Return T if target-string starts with search-string,
nil otherwise
utils.lisp (file)
Borrowed from Arnesi (http://common-lisp.net/project/bese/arnesi.html)
utils.lisp (file)
Break a token-string into a list, where each element is separated in the original token-string by token
utils.lisp (file)
Returns 3 values: a list of parameter name, a list of parameter values, and either t or nil to indicate that a match was successful
utils.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
Called at the point of tag definition to add the tag to the library
tags.lisp (file)
taglibraries.lisp (file)
Force an item into the cache for the indicated key, removing any item previously cached for that key
cache.lisp (file)
Return the key for the item (or request)
cache.lisp (file)
(setf cache-key) (generic function)
automatically generated reader method
urls.lisp (file)
automatically generated reader method
cache-key (generic function)
automatically generated writer method
urls.lisp (file)
automatically generated writer method
cache.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
Compute or determine the key to use for the particular cache and request
cache.lisp (file)
Return non-nil if item should be refreshed from provider, rather than reused from the cache
cache.lisp (file)
urls.lisp (file)
Return non-nil if item is not valid (for example, because of a failed authorization check
cache.lisp (file)
It’s invalid if the test fails, or it has parameters
urls.lisp (file)
If an item is not yet stale, then the cache does not check with the
provider to determine if the item is expired (intended as a means of throttling
checks by the provider, which may be expensive
cache.lisp (file)
automatically generated reader method
urls.lisp (file)
automatically generated writer method
urls.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
cookies.lisp (file)
cookies.lisp (file)
cookies.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
rotating.lisp (file)
A description of the string’s purpose and expected usage.
Likely this slot is unused in localized strings, but is
useful for strings in the development locale
i18n.lisp (file)
cache.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
cache.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
Expand the expression using the provided libraries
tags.lisp (file)
taglibraries.lisp (file)
Find an item in the cache with the indicated key, or null if there is no item cached for that key or if the cached item has expired
cache.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated reader method
taglibraries.lisp (file)
automatically generated writer method
taglibraries.lisp (file)
automatically generated reader method
skeleton.lisp (file)
automatically generated writer method
skeleton.lisp (file)
Return the full path of the indicated file
cache.lisp (file)
Obtain the file’s modified time
cache.lisp (file)
automatically generated reader method
cache.lisp (file)
automatically generated writer method
cache.lisp (file)
Return a string of client-side Javascript sufficient for calling all methods of the service
services.lisp (file)
localeservices.lisp (file)
Generate all the files necessary for a project using hh-web
skeleton.lisp (file)
Generate the files necessary for the indicated component and skeleton
skeleton.lisp (file)
If no such component exists for the skeleton, do nothing
Obtain cookie value from current hunchentoot:*request*
cookies.lisp (file)
Handle the service meta request with the named service, using the
meta argument (if non-nil) or the +meta-service-request-parameter+ to determine what to do.
Common meta service requests include (but are not limited to) the following values of
+meta-service-request-parameter+:
client - returns sufficient Javascript for invoking the service as an ordinary
function form javascript
help - returns an HTML page with a documentation string for the service
documentation - same as help
doc - same as help
docs - same as help
form - returns an HTML page with both the documentation string for the
service, but also a form suitable for entering parameters and then
invoking the service, as well as displaying (and changing?) values
of involved cookies before and after the invocation.
services.lisp (file)
Return the client script for the service
Default handling of service meta requests–
automatically generated reader method
skeleton.lisp (file)
automatically generated writer method
skeleton.lisp (file)
automatically generated reader method
rotating.lisp (file)
automatically generated writer method
rotating.lisp (file)
taglibraries.lisp (file)
Load an item with the indicated key into the cache
cache.lisp (file)
Load an item from the provider, given the indicated request
cache.lisp (file)
urls.lisp (file)
Load the tag library from the first provider that can provide it
taglibraries.lisp (file)
If the provider can provide a tag library with the indicated name, return the tag library; otherwise, return nil
taglibraries.lisp (file)
templates.lisp (file)
If the provider can provide a template with the indicated path, return the template; otherwise, return nil
templates.lisp (file)
Convert the argument to a pathname
skeleton.lisp (file)
Interval in seconds between log rotations
rotating.lisp (file)
Return true if it’s time to rotate the sender’s logs
rotating.lisp (file)
automatically generated reader method
rotating.lisp (file)
automatically generated writer method
rotating.lisp (file)
Required method for items in a cache, to determine whether it has become stale or expired
cache.lisp (file)
(setf modified-time-of) (generic function)
automatically generated reader method
urls.lisp (file)
automatically generated reader method
urls.lisp (file)
automatically generated reader method
automatically generated reader method
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated reader method
taglibraries.lisp (file)
modified-time-of (generic function)
automatically generated writer method
urls.lisp (file)
automatically generated writer method
urls.lisp (file)
automatically generated writer method
cache.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated writer method
taglibraries.lisp (file)
The string as it appeared in the development locale
i18n.lisp (file)
The string as it appeared in the development locale
i18n.lisp (file)
automatically generated reader method
i18n.lisp (file)
automatically generated writer method
i18n.lisp (file)
Notes from / to localizers about a string
i18n.lisp (file)
Notes from / to localizers about a string
i18n.lisp (file)
Return t if the provider considers the tag library expired, otherwise nil
taglibraries.lisp (file)
Return t if the provider considers the template expired, otherwise nil
templates.lisp (file)
Read in a tag library from a stream
taglibraries.lisp (file)
Read a template definition from a stream
templates.lisp (file)
rotating.lisp (file)
Render a tag’s attributes as string of name=value pairs
Render the body of a tag as html
Render just the content portion of the tag (no styles or scripts):
usually, the start tag, the rendered body, and the end tag. In tags
that have a custom html representation, this is usually the method overriden.
Render the end of a tag
Return a string representing script to run when a page
first loads. During rendering, scripts are accumulated by visiting each tag
in the page (depth, then breadth), and adding each unique script
(based on string comparison) to the end of a list. Consequently,
outer tags have their ready script run before inner tags.
Return a list of strings pointing to script libraries used by instances of this tag
Return the script that should be shared by all instances
of some-tag’s class within the same context (page, stylesheet, etc.)
Render the beginning of a tag, including its attributes (by calling render-attributes)
Return a list of strings pointing to stylesheets used by instances of this tag
Return a list of styles expected by instances of this tag
rotating.lisp (file)
Return a list of symbols identifying the arguments a service expects. All methods of a service share the same arguments.
services.lisp (file)
localeservices.lisp (file)
Return the documentation string provided with the service definition
services.lisp (file)
localeservices.lisp (file)
Return the argument list (derived from URL path component,typically) for a service
services.lisp (file)
Return the cookies touched by a service method
services.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
Return the documentation string provided with the method definition
services.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
Return the HTTP method expected for this service method
services.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
Return the parameter list for a service method
services.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
Return the test expected for this service method
services.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
localeservices.lisp (file)
Return as a list the symbolic names of methods supported by the service
services.lisp (file)
localeservices.lisp (file)
Set cookie value in current hunchentoot:*reply*
cookies.lisp (file)
Return the list of components of the skeleton, as a list of keywords
skeleton.lisp (file)
skeleton.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
Return the value of attribute on tag
tags.lisp (file)
(setf tag-attribute-value) (generic function)
Set the value of attribute on the tag
tags.lisp (file)
tag-attribute-value (generic function)
Return a list of attribute names for the tag
tags.lisp (file)
(setf tag-attributes) (generic function)
automatically generated reader method
tag-attributes (generic function)
automatically generated writer method
tags.lisp (file)
Return the macro for expanding a tag expression into a tag object
Return t (the default) if a tag expects to
have a tag body; nil otherwise. If no body, that implies
the tag treats the raw body as an initializer for the tag,
and that a custom html method will then use the tag’s
slots to render appropriate html.
tags.lisp (file)
(setf tag-has-body-p) (generic function)
automatically generated reader method
tag-has-body-p (generic function)
automatically generated writer method
tags.lisp (file)
Return t (the default) if a tag expects to
have an end tag rendered (e.g., </a>); nil otherwise. If nil,
then the tag’s rendering only includes the start tag and content
(if any). Examples of use is the <img> and <input> tags.
tags.lisp (file)
(setf tag-has-end-tag-p) (generic function)
automatically generated reader method
tag-has-end-tag-p (generic function)
automatically generated writer method
tags.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
A list of symbols identifying other libraries upon which this one depends
taglibraries.lisp (file)
Return the library with the indicated name
taglibraries.lisp (file)
Return if the library (or any of its dependent libraries) has epxired
taglibraries.lisp (file)
taglibraries.lisp (file)
taglibraries.lisp (file)
automatically generated reader method
taglibraries.lisp (file)
Return the name of the tag library in which the tag is defined
automatically generated reader method
taglibraries.lisp (file)
automatically generated writer method
taglibraries.lisp (file)
automatically generated reader method
taglibraries.lisp (file)
automatically generated writer method
taglibraries.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
taglibraries.lisp (file)
For some library, return the list of macro expansions for each tag in the library
taglibraries.lisp (file)
Gather all tag expansions for all libraries in the list
A list of symbols identifying tags defined by this library
taglibraries.lisp (file)
Return 2 values (nil if the value is not applicable):
the first is the tag initializer, the 2nd is the tag’s computed body.
Default behavior takes the first list starting ith +@ and uses the
cdr of that list as the arguments to a make-instance call for that
tag class. All other items in the list will be returned in the 2nd
value for the body of the tag
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
templates.lisp (file)
templates.lisp (file)
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
templates.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
Returns the base directory on a fileystem for templates served by the provider. Directory name should end in /.
templates.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
automatically generated reader method
templates.lisp (file)
automatically generated writer method
templates.lisp (file)
templates.lisp (file)
Return t if any of the known required tag libraries used in the template have expired; nil otherwise
templates.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
automatically generated reader method
server.lisp (file)
automatically generated writer method
server.lisp (file)
Next: Internal classes, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
taglibraries.lisp (file)
error (condition)
library-name (method)
:name
library-name (generic function)
templates.lisp (file)
error (condition)
template-path (method)
:path
template-path (generic function)
Previous: Internal conditions, Up: Internal definitions [Contents][Index]
templates.lisp (file)
folder-template-provider (class)
hh-web:*package-template-folder*
:system
system-of (generic function)
(setf system-of) (generic function)
cache.lisp (file)
standard-object (class)
(make-hash-table :test (quote equal))
entries (generic function)
(setf entries) (generic function)
:provider
cache-provider (generic function)
(setf cache-provider) (generic function)
t
cache-loading-enabled (generic function)
(setf cache-loading-enabled) (generic function)
cache.lisp (file)
standard-object (class)
Generalized type for providers serving templates from the filesystem
templates.lisp (file)
template-provider (class)
folder-template-provider (class)
taglibraries.lisp (file)
tag-library-provider (class)
:folder
folder-of (generic function)
(setf folder-of) (generic function)
templates.lisp (file)
file-based-template-provider (class)
asdf-system-provider (class)
:folder
folder-of (generic function)
(setf folder-of) (generic function)
:modified
(local-time:now)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
cache.lisp (file)
standard-object (class)
:path
cache-key (generic function)
(setf cache-key) (generic function)
:modified
modified-time-of (generic function)
(setf modified-time-of) (generic function)
:type
content-type (generic function)
(setf content-type) (generic function)
:content
content (generic function)
(setf content) (generic function)
cache.lisp (file)
standard-object (class)
:root
fs-root (generic function)
(setf fs-root) (generic function)
i18n.lisp (file)
standard-object (class)
:name
name (generic function)
(setf name) (generic function)
(make-hash-table :test (function equal))
strings (generic function)
(setf strings) (generic function)
i18n.lisp (file)
standard-object (class)
The string as it appeared in the development locale
:name
name (generic function)
(setf name) (generic function)
The contexts where the string appears; usually URLs (actually paths) to pages containing the string
contexts (generic function)
(setf contexts) (generic function)
A description of the string’s purpose and expected usage.
Likely this slot is unused in localized strings, but is
useful for strings in the development locale
:description
""
description (generic function)
(setf description) (generic function)
Notes from / to localizers about a string
:notes
""
notes (generic function)
(setf notes) (generic function)
A skeleton represents the starting point for a project based on hh-web
skeleton.lisp (file)
standard-object (class)
(satisfies cl-fad:directory-pathname-p)
:location
in-location (generic function)
(setf in-location) (generic function)
(or symbol string)
:package
for-package (generic function)
(setf for-package) (generic function)
server.lisp (file)
easy-ssl-acceptor (class)
:template-providers
template-provider-registry-of (generic function)
(setf template-provider-registry-of) (generic function)
:tag-library-providers
tag-library-provider-registry-of (generic function)
(setf tag-library-provider-registry-of) (generic function)
:urlcache
url-cache-of (generic function)
(setf url-cache-of) (generic function)
:dispatchers
dispatch-table-of (generic function)
(setf dispatch-table-of) (generic function)
Holds the details of a particular type of tag. All slots are lambdas (or funcallables) except for symbol, name, bases, and attributes
tags.lisp (file)
standard-object (class)
The tag symbol is the unique identifier for a tag definition
:symbol
tag-symbol (generic function)
(setf tag-symbol) (generic function)
The tag name is the string used in the start tag when rendering to HTML
:name
tag-name (generic function)
(setf tag-name) (generic function)
:bases
tag-bases (generic function)
(setf tag-bases) (generic function)
:attributes
tag-attributes (generic function)
(setf tag-attributes) (generic function)
:init
tag-init (generic function)
(setf tag-init) (generic function)
:has-body
tag-has-body-p (generic function)
(setf tag-has-body-p) (generic function)
:has-end-tag
tag-has-end-tag-p (generic function)
(setf tag-has-end-tag-p) (generic function)
:scripts
tag-scripts (generic function)
(setf tag-scripts) (generic function)
:ready-scripts
tag-ready-scripts (generic function)
(setf tag-ready-scripts) (generic function)
:script-libraries
tag-script-libraries (generic function)
(setf tag-script-libraries) (generic function)
:styles
tag-styles (generic function)
(setf tag-styles) (generic function)
:style-sheets
tag-style-sheets (generic function)
(setf tag-style-sheets) (generic function)
:content
tag-content (generic function)
(setf tag-content) (generic function)
taglibraries.lisp (file)
standard-object (class)
:name
tag-library-name (generic function)
:provider
tag-library-provider (generic function)
(setf tag-library-provider) (generic function)
(local-time:now)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
:package
tag-library-package (generic function)
(setf tag-library-package) (generic function)
A list of symbols identifying other libraries upon which this one depends
tag-libraries-used (generic function)
(setf tag-libraries-used) (generic function)
A list of symbols identifying tags defined by this library
(make-hash-table)
tag-library-tags (generic function)
(setf tag-library-tags) (generic function)
taglibraries.lisp (file)
standard-object (class)
folder-tag-library-provider (class)
provider-tag-library-expiredp (method)
templates.lisp (file)
standard-object (class)
file-based-template-provider (class)
provider-template-expiredp (method)
templates.lisp (file)
standard-object (class)
:providers
template-providers-of (generic function)
(setf template-providers-of) (generic function)
:modified
(local-time:universal-to-timestamp 0)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
Represents an cache entry containing the generated content for a specific URL
urls.lisp (file)
standard-object (class)
:path
cache-key (generic function)
(setf cache-key) (generic function)
:test
test (generic function)
(setf test) (generic function)
:modified
(local-time:now)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
:content
(make-hash-table)
content (generic function)
(setf content) (generic function)
:generator
generator (generic function)
(setf generator) (generic function)
List of symbols identifying categories to which the content belongs
:categories
categories (generic function)
(setf categories) (generic function)
handler (generic function)
(setf handler) (generic function)
:expiry
expiry (generic function)
(setf expiry) (generic function)
urls.lisp (file)
standard-object (class)
:package
package-of (generic function)
(setf package-of) (generic function)
patterns (generic function)
(setf patterns) (generic function)
:modified
(local-time:universal-to-timestamp 0)
modified-time-of (generic function)
(setf modified-time-of) (generic function)
server.lisp (file)
easy-acceptor (class)
:template-providers
template-provider-registry-of (generic function)
(setf template-provider-registry-of) (generic function)
:tag-library-providers
tag-library-provider-registry-of (generic function)
(setf tag-library-provider-registry-of) (generic function)
:urlcache
url-cache-of (generic function)
(setf url-cache-of) (generic function)
:dispatchers
dispatch-table-of (generic function)
(setf dispatch-table-of) (generic function)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index | ||
• Function index | ||
• Variable index | ||
• Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | F H L M |
---|
Jump to: | F H L M |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | (
+
_
A B C D E F G H I L M N P R S T U W |
---|