Specifically, the content, child and relation tags are defined here.
Also see:
publish::get_html_body
publish::get_mime_handler
publish::get_page_root
publish::get_publish_roots
publish::get_template_root
publish::handle_binary_file
publish::item_include_tag
publish::mkdirs
publish::proc_exists
publish::publish_revision
publish::schedule_status_sweep
publish::set_publish_status
publish::unpublish_item
publish::unschedule_status_sweep
publish::write_content
* indicates required
Public Methods:| publish::get_html_body | ||
Strip the {<body>} tags from the HTML, leaving just the body itself. Useful for including templates in each other.
|
| publish::get_mime_handler | ||
Return the name of a proc that should be used to render items with the given mime-type. The mime type handlers should all follow the naming conventionproc publish::handle::mime_prefix::mime_suffixIf the specific mime handler could not be found, get_mime_handler looks for a generic procedure with the nameproc publish::handle::mime_prefixIf the generic mime handler does not exist either, get_mime_handler returns { }
|
| publish::get_page_root |
Get the page root. All items will be published to the filesystem with their URLs relative to this root. The page root is controlled by the PageRoot parameter in CMS. A relative path is relative to {[ns_info} pageroot\] The default is {[ns_info} pageroot\]
|
| publish::get_publish_roots |
Get a list of all page roots to which files may be published. The publish roots are controlled by the PublishRoots parameter in CMS, which should be a space-separated list of all the roots. Relative paths are relative to publish::get_page_root. The default is {[list} {[publish::get_page_root]]}
|
| publish::get_template_root |
Get the template root. All templates are assumed to exist in the filesystem with their URLs relative to this root. The page root is controlled by the TemplateRoot parameter in CMS. The default is /web/yourserver/templates
|
| publish::handle_binary_file | ||||||||||||||
Helper procedure for writing handlers for binary files. It will write the blob of the item to the filesystem, but only if -embed is specified. Then, it will attempt to merge the image with its template.
|
| publish::item_include_tag | ||||
Create an include tag to include an item, in the forminclude src=/foo/bar/baz item_id=item_id param=value param=value ...
|
| publish::mkdirs | ||
Create all the directories neccessary to save the specified file
|
| publish::proc_exists | ||||
Determine if a procedure exists in the given namespace
|
| publish::publish_revision | ||||
Render a revision for an item and write it to the filesystem. The revision is always rendered with the -embed option turned on.
|
| publish::schedule_status_sweep | ||
Schedule a proc to keep track of the publish status. Resets the publish status to { expired} if the expiration date has passed. Publishes the item and sets the publish status to { live} if the current status is { ready} and the scheduled publication time has passed.
|
| publish::set_publish_status | ||||||||
Set the publish status of the item. If the status is live, publish the live revision of the item to the filesystem. Otherwise, unpublish the item from the filesystem.
|
| publish::unpublish_item | ||||||
Delete files which were created by publish_revision
|
| publish::unschedule_status_sweep |
Unschedule the proc which keeps track of the publish status.
|
| publish::write_content | ||||||||
Write the content (blob) of a revision into a binary file in the filesystem. The file will be published at the relative URL under each publish root listed under the PublishRoots parameter in the server's INI file (the value returnded by publish::get_page_root is used as the default). The file extension will be based on the revision's mime-type.
|
Private Methods:
| publish::delete_multiple_files | ||
Delete the specified URL from the filesystem, for all revisions
|
| publish::foreach_publish_path | ||||||
Execute some TCL code for each root path in the PublishRoots parameter
|
| publish::get_main_item_id |
Get the main item id from the top of the stack
|
| publish::get_main_revision_id |
Get the main item revision from the top of the stack
|
| publish::handle_item | ||||||||||||||
Render an item either by looking it up in the the temporary cache, or by using the appropriate mime handler. Once the item is rendered, it is stored in the temporary cache under a key which combines the item_id, any extra HTML parameters, and a flag which specifies whether the item was merged with its template.
|
| publish::html_args | ||
Concatenate a list of name-value pairs as returned by set_to_pairs into a list of { name=value} pairs
|
| publish::merge_with_template | ||||||
Merge the item with its template and return the resulting HTML. This proc is simlar to content::init
|
| publish::pop_id |
Pop the item_id and the revision_id off the top of the stack. Clear the temporary item cache if the stack becomes empty.
|
| publish::process_tag | ||||
Process a child or relation tag. This is a helper proc for the tags, which acts as a wrapper for render_subitem.
|
| publish::push_id | ||||
Push an item id on top of stack. This proc is used to store state between child, relation and content tags.
|
| publish::render_subitem | ||||||||||||||||
Render a child/related item and return the resulting HTML, stripping off the headers.
|
| publish::set_to_pairs | ||||
Convert an ns_set into a list of name-value pairs, in form {name value name value ...}
|
| publish::track_publish_status |
Scheduled proc which keeps the publish status updated
|
| publish::write_multiple_blobs | ||||||
Write the content of some revision to multiple publishing roots.
|
| publish::write_multiple_files | ||||
Write a relative URL to the multiple publishing roots.
|
Implements the content tag which renders the content of the current item. See the Developer Guide for more information.
|
Implements the relation tag which renders a related item. See the Developer Guide for more information.
|
* indicates required