=head1 NAMEXAO::DO::Web::Page - core object of XAO::Web rendering system=head1 SYNOPSISOutside web environment:my $page=XAO::Objects->new(objname => 'Page');my $date=$page->expand(template => '<%Date%>');Inside XAO::Web template:<%Page path="/bits/some-path" ARG={<%SomeObject/f%>}%>=head1 DESCRIPTIONAs XAO::DO::Web::Page object (from now on just Page displayableobject) is the core object for XAO::Web web rendering engine wewill start with basics of how it works.The goal of XAO::Web rendering engine is to produce HTML data filethat can be understood by browser and displayed to a user. It willusually use database tables, templates and various displayable objectsto achieve that.Every time a page is requested in someone's web browser a XAO::Web handlergets executed, prepares site configuration, opens database connection,determines what would be start object and/or start path and does a lotof other useful things. If you have not read about it yet it is suggested todo so -- see L<XAO::Web::Intro> and L<XAO::Web>.Although XAO::Web handler can call arbitrary object with arbitrary argumentsto produce an HTML page we will assume the simplest scenario of callingPage object with just one argument -- path to an HTML file template forsimplicity (another way to pass some template to a Page object isto pass argument named "template" with the template text as thevalue). This is the default behavior of XAO::Web handler if youdo not override it in configuration.Let's say user asked for http://oursite.com/ and XAO::Web translatedthat into the call to Page's display method with "path" argument set to"/index.html". All template paths are treated relative to "templates"directory in site directory or to system-wide "templates" directory ifsite-specific template does not exist. Suppose templates/index.html filein our site's home directory contains the following:Hello, World!As there are no special symbols in that template Page's display methodwill return exactly that text without any changes (it will also cachepre-parsed template for re-use under mod_perl, but this is irrelevantfor now).Now let's move to a more complex example -- suppose we want some kind ofheader and footer around our text:<%Page path="/bits/header-template"%>Hello, World!<%Page path="/bits/footer-template"%>Now, Page's parser sees reference to other items in that template -these things, surrounded by <% %> signs. What it does is the following.First it checks if there is an argument given to original Page'sdisplay() method named 'Page' (case sensitive). In our case there is nosuch argument present.Then, as no such static argument is found, it attempts to load anobject named 'Page' and pass whatever arguments given to that object'sdisplay method.I<NOTE:> it is recommended to name staticarguments in all-lowercase (for standard parameters accepted by anobject) or all-uppercase (for parameters that are to be included intotemplate literally) letters to distinguish them from object names whereonly the first letter of every word is capitalized.In our case Page's parser will create yet another instance of Pagedisplayable object and pass argument "path" with value"/bits/header-template". That will include the content oftemplates/bits/header-template file into the output. So, if the contentof /bits/header-template file is:<HTML><BODY BGCOLOR="#FFFFFF">And the content of /bits/footer-template is:</BODY></HTML>Then the output produced by the original Page's display would be:<HTML><BODY BGCOLOR="#FFFFFF">Hello, World!</BODY></HTML>For the actual site you might opt to use specific objects for header andfooter (see L<XAO::DO::Web::Header> and L<XAO::DO::Web::Footer>):<%Header title="My first XAO::Web page"%>Hello, World!<%Footer%>Page's parser is not limited to only these simple cases, you can embedreferences to variables and objects almost everywhere. In the followingexample Utility object (see L<XAO::DO::Web::Utility>) is used tobuild complete link to a specific page:<A HREF="<%Utility mode="base-url"%>/somepage.html">blah blah blah</A>If current (configured or guessed) site URL is "http://demosite.com/"this template would be translated into:<A HREF="http://demosite.com/somepage.html">blah blah blah</A>Even more interesting is that you can use embedding to create argumentsfor embedded objects:<%Date gmtime={<%CgiParam param="shippingtime" default="0"%>}%>If your page was called with "shippingtime=984695182" argument in thequery then this code would expand to (in PST timezone):Thu Mar 15 14:26:22 2001As you probably noticed, in the above example argument value was incurly brackets instead of quotes. Here are the options for passingvalues for objects' arguments:=over=item 1You can surround value with double quotes: name="value". This isrecommended for short strings that do not include any " characters.=item 2You can surround value with matching curly brackets. Curly bracketsinside are allowed and counted so that these expansions would work:name={Some text with " symbols}name={MultipleLines}name={something <%Foo bar={test}%> alsdj}The interim brackets in the last example would be left untouched by theparser. Although this example won't work because of unmatched brackets:name={single { inside}See below for various ways to include special symbols inside ofarguments.=item 3Just like for HTML files if the value does not include any spaces orspecial symbols quotes can be left out:number=123But it is not recommended to use that method and it is not guaranteedthat this will remain legal in future versions. Kept mostly forcompatibility with already deployed code.=item 4To pass a string literally without performing any substitutions you canuse single quotes. For instance:<%FSuri="/Members/<%MEMBER_ID/f%>"mode="show-hash"fields="*"template='<%MEMBER_AGE/f%> -- <%MEMBER_STATUS/f%>'%>If double quotes were used in this example then the parser would try toexpand <%MEMBER_AGE%> and <%MEMBER_STATUS%> variables using the currentobject arguments which is not what is intended. Using single quotes itis possible to let FS object do the expansion and therefore insertdatabase values in this case.=item 5To pass multiple nested arguments literally or to include a single quoteinto the string matching pairs of {' and '} can be used:<%FSuri="/Members/<%MEMBER_ID/f%>"mode="show-hash"fields="*"template={'Member's age is <%MEMBER_AGE/f%>'}%>=back=head2 BINARY vs UNICODEBy default expanded templates and object arguments are bytes, notUnicode characters. This does not mean that they cannot be used inUnicode (or other encoding) web sites, but it does mean that objectsneed to convert arguments and expansion results into characters whereand as needed.Starting with version 1.48 it is possible to switch the engineinto returning perl characters from template expansion and forpassing characters in object arguments. This is achieved by setting/xao/page/character_mode configuration parameter to '1'.One exception allowing to retrieve byte data is when a template isexpanded with 'unparsed' qualifier. This is typically used to passbinary data such as images and spreadsheets to objects such asL<XAO::DO::Web::Mailer>.There is an important caveat for using 'unparsed' with binary data incharacter mode. A template like the one below wou pass perl charactersin 'data' argument when executing Process.<%Processdata={<%Pagepath='/binary/data.bin'unparsed%>}%>There is no way to mix byte and character processing mode. Pick onedepending on your needs. Character mode allows a more natural processingin Perl while byte mode allows more granular control over the data flow.=head2 EMBEDDING SPECIAL CHARACTERSSometimes it is necessary to include various special symbols intoargument values. This can be done in the same way you would embedspecial symbols into HTML tags arguments:=over=item *By using &tag; construction, where tag could be "quot", "lt", "gt" and"amp" for double quote, left angle bracket, right angle bracket andampersand respectfully.=item *By using &#NNN; construction where NNN is the decimal code for thecorresponding symbol. For example left curly bracket could be encoded as{ and right curly bracket as }. The above example should bere-written as follows to make it legal:name={single { inside}=back=head2 OUTPUT CONVERSIONAs the very final step in the processing of an embedded object orvariable the parser will check if it has any flags and convert itaccordingly. This can (and should) be used to safely pass specialcharacters into fields, HTML documents and so on.For instance, the following code might break if you do not use flags andvariable will contain a duoble quote character in it:<INPUT TYPE="TEXT" VALUE="<$VALUE$>">Correct way to write it would be (note /f after VALUE):<INPUT TYPE="TEXT" VALUE="<$VALUE/f$>">Generic format for specifying flags is:<%Object/x ...%> or <$VARIABLE/x$>Where 'x' could be one of:=over=item fConverts text for safe use in HTML elements attributes. Mnemonic forremembering - (f)ield.Will convert '123"234' into '123"234'.=item hConverts text for safe use in HTML text. Mnemonic - (H)TML.Will convert '123<BR>234' into '123<BR>234'.=item qConverts text for safe use in HTML query parameters. Mnemonic - (q)uery.Will convert '123 234' into '123%20234'.Example: <A HREF="test.html?name=<$VAR/q$>">Test '<$VAR/h$>'</A>=item sThe same as 'h' excepts that it translates empty string into' '. Suitable for inserting pieces of text into table cells.=item uThe same as 'q'. Mnemonic - (U)RL, as it can be used to convert text forinclusion into URLs.=backIt is a very good habit to use flags as much as possible and alwaysspecify a correct conversion. Leaving output untranslated may lead toanything from broken HTML to security violations.=head2 LEVELS OF PARSINGArguments can include as many level of embedding as you like, but youmust remember:=over=item 1That all embedded arguments are expanded from the deepestlevel up to the top before executing main object.=item 2That undefined references to either non-existing object or non-existingvariable produce a run-time error and the page is not shown.=item 3All embedded arguments are processed in the same arguments space thatthe template one level up from them.=backAs a test of how you understood everything above please attempt topredict what would be printed by the following example (after readingL<XAO::DO::Web::SetArg> or guessing its meaning). The answer isabout one page down, at the end of this chapter.<%SetArg name="V1" value="{}"%><%SetArg name="V2" value={""}%><%Page template={<%V1%><%V2%><%Page template={<%SetArg name="V2" value="[]" override%><%V2%>}%><%V2%><%V1%>}%>In most cases it is not recommended to make complex inline templatesthough. It is usually better to move a sub-template into a separate fileand include it by passing a 'path' parameter into Page. Usually it isalso more efficient because templates with known paths are cached inparsed state the first time they are used while inlined templates areparsed every time.It is usually a good idea to make templates as simple as possible and movemost of the logic inside of objects. To comment what you're doing invarious parts of template you can use normal HTML-style comments. Theyare removed from the output completely, so you can include any amountof text inside of comments -- it won't impact the size of final HTMLfile. Here is an example:<!-- Header section --><%Header title="demosite.com"%><%Page path="/bits/menu"%><!-- Main part --><%Page path="/bits/body"%><!-- Footer --><%Footer%>One exception is JavaScript code which is usually put into comments. Theparser will NOT remove comments if the opening comment is <!--//. Here is anexample of JavaScript code:<script type="text/javascript"><!--//function foo (){ alert("bar");}//--></script>=head2 CACHINGParsed templates are always cached either locally or using a configuredcache. The cache is keyed on 'path' or 'template' parameters value (twoidentical 'template's will only parse once). Parse cache can be disabledby giving a "xao.uncached" parameter. See parse() method descriptionfor details.The fully rendered content can also be cached if a couple of conditionsare met:=over=item */xao/page/render_cache_name in the config -- this should contain a name ofthe cache to be used for rendered page components.=item *The page is configured to be cacheable with either an entry inthe configuration under '/xao/page/render_cache_allow' or with a'xao.cacheable' parameter given (e.g. something like <%Page ...xao.cacheable%>).=item *There is no "/xao/page/render_cache_update" in the clipboard. This can be usedto force cache reload by checking some environmental variable early inthe flow and setting the clipboard to disable all render caches for thatone render. Cached content is not used, but is updated -- so subsequentcached calls with the same parameters will return new content.=item *There is no "/xao/page/render_cache_skip" in the clipboard. This can be used toskip cache altogether if it is known that pages rendered in this sessionare different from cached and the cache does not want to be contaminatedwith them.=backProperly used render cache can speed up pages significantly, but ifused incorrectly it can also introduce very hard to find issues in therendered content.Carefully consider what pages to tag with "cacheable" tag. Benchmarkingreports can be of great help for that.Entries in the config /xao/page/render_cache_allow may include additionalspecifications for what parameters are checked when rendered content iscached. By default, if the value is '1' or 'on' all of Page templateparameters are checked, but none of CGI or cookies. Values forparameters 'path' and 'template' are always checked, regardless of theconfiguration.The configuration can look like this:xao => {page => {render_cache_name => 'xao_page_render',render_cache_allow => {'p:/bits/complex-template' => 1,'p:/bits/complex-cgi' => {param => [ '*' ],cgi => [ 'cf*' ],},'p:/bits/complex-cookie' => {param => [ '*', '!session*' ],cookie => [ 'session' ],},},},}=head2 BENCHMARKINGBenchmarking can be started and stopped by using benchmark_start()and benchmark_stop() calls. The hash with current benchmarking data canbe retrieved with benchmark_stats() call.When benchmarking is started all rendered paths (and optionally alltemplates) are timed and are also analyzed for potential cacheability --if rendered content is repeatedly the same for some set of parameters.Custom execution paths spanning multiple templates can be tracked byusing benchmark_enter($tag) and benchmark_leave($tag) calls.The data is "static", not specific to a particular Page object.Benchmarking slows down processing. Do not use it in production.For an easy way to control benchmarking from templates use <%Benchmark%>object.=head2 NOTE FOR HARD-BOILED HACKERSIf you do not like something in the parser behavior you can definesite-specific Page object and refine or replace any methods of systemPage object. Your new object would then be used by all system andsite-specific objects B<for your site> and won't impact any other sitesinstalled on the same host. But this is mentioned here merely as atheoretical possibility, not as a good thing to do.=head2 TEST OUTPUTThe output of the test above would be:{}""[]""{}In fact first two SetArg's would add two empty lines in front becausethey have carriage returns after them, but this is only significant ifyour HTML code is space-sensitive.=head1 METHODSPublicly accessible methods of Page (and therefor of all objects derivedfrom Page unless overwritten) are:=over=cut###############################################################################packageXAO::DO::Web::Page;usewarnings;usestrict;useutf8;useEncode;useXAO::Cache;useXAO::Objects;useXAO::PageSupport;useXAO::Templates;useXAO::Utils;# Prototypes#subcache ($%);subcgi ($);subcheck_db ($);subdbh ($);subdisplay ($%);subexpand ($%);subfinaltextout ($%);subobject ($%);subodb ($);subparse ($%);subsiteconfig ($);subtextout ($%);subbenchmark_enabled ($);subbenchmark_enter ($$;$$$);subbenchmark_leave ($$;$$);subbenchmark_reset ($);subbenchmark_start ($;$);subbenchmark_stats ($;$);subbenchmark_stop ($);subpage_clipboard ($);sub_do_pass_args ($$$);###############################################################################subparams_digest ($$;$) {my($self,$args,$spec)=@_;# Dropping non-scalar values from params. They get in by calling# ::Action::data_... methods for example, and in other scenarios# too.#my$params={map{ref$args->{$_} ? () : ($_=>$args->{$_}) }keys%$args};# Template and path are always passed along#my$path=delete$params->{'path'};my$template=delete$params->{'template'};# Checking what is considered important for the digest, getting a# specification. It may come from outside in testing.#if(!$spec) {$spec=$args->{'xao.cacheable'};}if(!$spec&& !defined$args->{'template'} && (my$path=$args->{'path'})) {my$cache_allow=$self->{'cache_allow'};if($cache_allow) {$spec=$cache_allow->{'p:'.$path};}}# It may be a hash of instructions about what to keep and what to# drop for the key:## param => [ 'FOO*', '!FOO.BAR*' ],# cgi => [ 'fn', 'fv' ],# cookie => [ 'customer_id' ],## Default is to ignore cookies and CGI and hash all scalar# parameters.#my$cgis;my$cookies;my$protocol;if($spec&&ref($spec)) {while(my($spec_key,$spec_list)=each%$spec) {my$hash;my$target;if($spec_keyeq'param') {$hash=$params;$target=\$params;}elsif($spec_keyeq'cgi') {my$cgi=$self->cgi;$hash={map{$_=> [$cgi->param($_) ] }$cgi->param };$target=\$cgis;}elsif($spec_keyeq'cookie'||$spec_keyeq'cookies') {my$config=$self->siteconfig;$hash={map{$_=>$config->get_cookie($_,1) }$self->cgi->cookie() };$target=\$cookies;}elsif($spec_keyeq'proto'&&$spec_list) {$protocol=$self->is_secure ?'https':'http';next;}else{throw$self"- unsupported source '$spec_key' for '$args->{'path'}'";}$$target=$self->_do_pass_args($hash,$spec_list);}}# Converting to a canonical scalar and calculating a unique digest.#my$params_json=to_json([$path,$template,$params,$cgis,$cookies,$protocol],{utf8=> 1,canonical=> 1 });my$params_digest=sha1_hex($params_json);returnwantarray? ($params_digest,$params_json) :$params_digest;}###############################################################################sub_do_display ($@) {my$self=shift;my$cache_args=get_args(\@_);# We need to operate on this specific hash because it can get# modified during template processing.#my$args=$self->{'args'} || throw$self"- no 'args' in self";# Preparing to benchmark if requested#my$benchmark=$self->benchmark_enabled();# We need to bookmark buffer position to analyze content data# for cacheability later.#my$bookmark=$benchmark? XAO::PageSupport::bookmark() : 0;# When called from a cache retrieve we have a cache_key parameter.#my$from_cache_retrieve=$cache_args->{'cache_key'};if($from_cache_retrieve) {XAO::PageSupport::push();if($self->debug_check('render-cache-add')) {my($args_digest,$args_json)=$self->params_digest($args);dprint"RENDER_CACHE_ADD: $args_digest / $args_json";}}# Parsing template or getting already pre-parsed template when it is# available.## Also defining the tag for benchmarking. Normally it is only# defined for paths, but can also be defined for templates.#my$benchmark_tag;my$args_digest;my$args_json;my$parsed;if($benchmark) {$parsed=$self->parse($args,{cache_key_ref=> \$benchmark_tag});if($benchmark<2 &&$benchmark_tag&&substr($benchmark_tag,0,2) ne'p:') {$benchmark_tag=undef;}}else{$parsed=$self->parse($args);}# Starting the stopwatch if needed. We may not get a tag if this is# an inner pre-parsed template.## Calculating a 'run' key that uniquely identifies a specific set of# parameters. Used for two purposes: identifying cacheable pages# and benchmarking self-referencing recurrent templates.#if($benchmark_tag) {($args_digest,$args_json)=$self->params_digest($args);$self->benchmark_enter($benchmark_tag,$args_digest,$args_json,$self->can_cache_render($args) ? 1 : 0);}# Template processing itself. Pretty simple, huh? :)#foreachmy$item(@$parsed) {my$stop_after;my$itemflag;my$text;if(exists$item->{'text'}) {$text=$item->{'text'};}elsif(exists$item->{'varname'}) {my$varname=$item->{'varname'};$text=$args->{$varname};defined$text||throw$self"- undefined argument '$varname'";$itemflag=$item->{'flag'};}elsif(exists$item->{'objname'}) {my$objname=$item->{'objname'};$itemflag=$item->{'flag'};# First we're trying to substitute from arguments for old# style <%FUBAR%>#$text=$args->{$objname};# Executing object if not.#if(!defined$text) {my$obj=$self->object(objname=>$objname);# Preparing arguments. If argument includes object references -# they are expanded first.#my%objargs;my$ia=$item->{'args'};my$args_copy;my$page_obj;foreachmy$a(keys%$ia) {my$v=$ia->{$a};if(ref($v)) {if(@$v==1 &&exists($v->[0]->{'text'})) {$v=$v->[0]->{'text'};}else{if(!$args_copy) {$args_copy=merge_refs($args);delete$args_copy->{'path'};}if(!$page_obj) {$page_obj=$self->object(objname=>'Page');}$args_copy->{'template'}=$v;$v=$page_obj->expand($args_copy);}}# Decoding entities from arguments. Lt, gt, amp,# quot and &#DEC; are supported.#$v=~s/</</sg;$v=~s/>/>/sg;$v=~s/"/"/sg;$v=~s/&#(\d+);/chr($1)/sge;$v=~s/&/&/sg;$objargs{$a}=$v;}# Executing object. For speed optimisation we call object's# display method directly if we're not going to do anything# with the text anyway. This way we avoid push/pop and at# least two extra memcpy's.#if($itemflag&&$itemflagne't') {$text=$obj->expand(\%objargs);}else{$obj->display(\%objargs);}# Indicator that we do not need to parse or display anything# after that point.#$stop_after=$self->clipboard->get('_no_more_output');# Was it something like SetArg object? Merging changes in then.#if($self->{'merge_args'}) {@{$args}{keys%{$self->{'merge_args'}}}=values%{$self->{'merge_args'}};delete$self->{'merge_args'};}}}if(defined$text) {# When the text is from an external argument like \xe9# it might be stored in a platform encoding and not in# Unicode. Upgrading it.#utf8::upgrade($text)if$self->_character_mode && !$item->{'binary'};# Safety conversion - q for query, h - for html, s - for# nbsp'ced html, f - for tag fields, u - for URLs, t - for text# as is (default).#if($itemflag&&$itemflagne't') {if($itemflageq'h') {$text=XAO::Utils::t2ht($text);}elsif($itemflageq's') {$text=(defined$text&&length($text)) ? XAO::Utils::t2ht($text) :" ";}elsif($itemflageq'q') {$text=XAO::Utils::t2hq($text);}elsif($itemflageq'f') {$text=XAO::Utils::t2hf($text);}elsif($itemflageq'u') {$text=XAO::Utils::t2hq($text);}elsif($itemflageq'j') {$text=XAO::Utils::t2hj($text);}else{eprint"Unsupported translation flag '$itemflag', objname=",$item->{'objname'};}}# Sending out the text#$self->textout($text);}# Checking if this object required to stop processing#lastif$stop_after;}# We need to return the actual rendered content if this is called# from cache render.#my$content=undef;if($from_cache_retrieve) {$content=XAO::PageSupport::pop($self->_character_mode && !$args->{'unparsed'});}elsif($benchmark_tag) {$content=XAO::PageSupport::peek($bookmark,$self->_character_mode && !$args->{'unparsed'});}# When benchmarking we stop the timer and we also remember the# content for cacheability analysis.#if($benchmark_tag) {my$content_digest=sha1_hex($content);$self->benchmark_leave($benchmark_tag,$args_digest,$content_digest);}# This will be an undef if the call is not from cache. That is fine.#return$content;}###############################################################################sub_character_mode ($) {my$self=shift;return$self->{'character_mode'}ifexists$self->{'character_mode'};my$character_mode=$self->siteconfig->get('/xao/page/character_mode') ? 1 : 0;$self->{'character_mode'}=$character_mode;return$character_mode;}###############################################################################sub_render_cache ($) {my$self=$_[0];return$self->{'render_cache_obj'}ifexists$self->{'render_cache_obj'};my$cache_name=$self->siteconfig->get('/xao/page/render_cache_name') ||'';my$cache_obj;if($cache_name) {dprint"Using a cache '$cache_name' for rendered templates";$cache_obj=$self->cache(name=>$cache_name,coords=> ['cache_key'],retrieve=> \&_do_display,);}$self->{'render_cache_obj'}=$cache_obj;return$cache_obj;}################################################################################ In case of memcached this clears ALL caches, not just render!subrender_cache_clear ($) {my$self=$_[0];my$cache=$self->_render_cache;$cache->drop_allif$cache;}###############################################################################subcan_cache_render ($$) {my($self,$args)=@_;return0if$self->page_clipboard->{'render_cache_skip'};return1if$args->{'xao.cacheable'};my$path=!defined$args->{'template'} &&$args->{'path'};return0unless$path;my$cache_key='p:'.$path;my$cache_allow=$self->{'cache_allow'};if(!$cache_allow) {$cache_allow=$self->siteconfig->get('/xao/page/render_cache_allow');if($cache_allow) {$self->{'cache_allow'}=$cache_allow;}else{$cache_allow=$self->{'cache_allow'}={ };$self->siteconfig->put('/xao/page/render_cache_allow'=>$cache_allow);}}return$cache_allow->{$cache_key};}###############################################################################=item display (%)Displays given template to the current output buffer. The system usesbuffers to collect all text displayed by various objects in a ratheroptimal way using XAO::PageSupport (see L<XAO::PageSupport>)module. In XAO::Web handler the global buffer is initialized and after alldisplayable objects have worked their way it retrieves whatever wasaccumulated in that buffer and displays it.This way you do not have to think about where your output goes as longas you do not "print" anything by yourself - you should always calleither display() or textout() to print any piece of text.Display() accepts the following arguments:=over=item passPasses arguments from calling context into the template.The syntax allows to map parent arguments into new names,and/or to limit what is passed. Multiple semi-colon separated rules areallowed. Rules are processed from left to right.NEWNAME=OLDNAME - pass the value of OLDNAME as NEWNAMENEW*=OLD* - pass all old values starting with OLD as NEW*VAR;VAR.* - pass VAR and VAR.* under their own names*;!VAR* - pass everything except VAR*The default, when the value of 'pass' is 'on' or '1', is the same aspassing '*' -- meaning that all parent arguments are passed literallyunder their own names.There are exceptions, that are never passed from parent arguments:'pass', 'objname', 'path', and 'template'.Arguments given to display() override those inherited from the callerusing 'pass'.=item path => 'path/to/the/template'Gives Page a path to the template that should be processed anddisplayed.=item template => 'template text'Provides Page with the actual template text.=item unparsed => 1If set it does not parse template, just displays it literally.=backAny other argument given is passed into template unmodified as avariable. Remember that it is recommended to pass variables usingall-capital names for better visual recognition.Example:$obj->display(path => "/bits/left-menu", ITEM => "main");For security reasons it is also recommended to put all sub-templatesinto /bits/ directory under templates tree or into "bits" subdirectoryof some tree inside of templates (like /admin/bits/admin-menu). Suchtemplates cannot be displayed from XAO::Web handler by passing theirpath in URL.=cutsubdisplay ($%) {my$self=shift;my$args=$self->{'args'}=get_args(\@_);# Merging parent's args in if requested.#if($args->{'pass'}) {$args=$self->{'args'}=$self->pass_args($args->{'pass'},$args);}# Is this page cacheable? There is a distinction between page not# being cached with '/xao/page/render_cache_skip' and page being flushed in# cache with '/xao/page/render_cache_update'.#if($self->can_cache_render($args)) {if(my$cache=$self->_render_cache()) {# The key depends on all arguments.#my($cache_key,$params_json)=$self->params_digest($args);if($self->debug_check('render-cache-get')) {dprint"RENDER_CACHE_GET: $cache_key / $params_json";}# Building the content. Real arguments for displaying are in# $self->{'args'}.#my$content=$cache->get($self,{cache_key=>$cache_key,force_update=> ($self->page_clipboard->{'render_cache_update'} ||$args->{'xao.uncached'}),});$self->textout($content);return;}}# We get here if the page cannot be cached#$self->_do_display();}###############################################################################=item expand (%)Returns a string corresponding to the expanded template. Accepts exactlythe same arguments as display(). Here is an example:my $str=$obj->expand(template => '<%Date%>');=cutsubexpand ($%) {my$self=shift;my$args=get_args(\@_);# First it prepares a place in stack for new text (push) and after# display it calls pop to get back whatever was written. The sole# reason for all this is speed optimization - XAO::PageSupport is# implemented in C in quite optimal way.#XAO::PageSupport::push();# Not using Error's try{} -- it is too slow. Benchmarking showed# about 7% slowdown.#### my $args=get_args(\@_);### try {### $self->display($args);### }### otherwise {### my $e=shift;###### # Popping out the potential output of the failed### # template. Otherwise we are going to break the stack order.### #### XAO::PageSupport::pop();###### $e->throw();### };# Eval is faster, almost indistinguishable from the bare call on# benchmark results.#eval{$self->display($args);};if($@) {XAO::PageSupport::pop(0);if($@->can('throw')) {throw $@;}else{throw$self"- $@";}}# Text pages are converted into perl characters, otherwise returning# bytes.#my$chmode=$self->_character_mode &&!$args->{'unparsed'} &&!$self->siteconfig->force_byte_output;returnXAO::PageSupport::pop($chmode? 1 : 0);}###############################################################################=item parse ($%)Takes template from either 'path' or 'template' and parses it. If giventhe following template:Text <%Object a=A b="B" c={X<%C/f ca={CA}%>} d='D' e={'<$E$>'}%>It will return a reference to an array of the following structure:[ { text => 'Text ',},{ objname => 'Object',args => {a => [{ text => 'A',},],b => [{ text => 'B',},],c => [{ text => 'X',},{ objname => 'C',flag => 'f',args => {ca => [{ text => 'CA',},],},},],d => 'D',e => '<$E$>',},},]With "unparsed" parameter the content of the template is not analyzedand is returned as a single 'text' node.Templates are only parsed once, unless an "xao.uncached" parameter isset to true.Normally the parsed templates cache uses a local perl hash. Ifdesired a XAO::Cache based implementation can be used by setting/xao/page/parse_cache_name parameter in the site configuration to the desiredcache name (e.g. "xao_parse_cache").Statistics of various ways of calling:memcached-cache-path 1866/smemcached-cache-template 2407/sno-cache-path 5229/sno-cache-template 5572/smemory-cache-template 26699/smemory-cache-path 45253/slocal-cache-template 49681/slocal-cache-path 149806/sUnless the site has a huge number of templates there is really nocompelling reason to use anything but the default local cache. Theperformance of memcached is worse than no caching at all for example.The method always returns with a correct array or throws an error.=cutsubparse_retrieve ($@);my%parsed_cache;subparse ($%) {my$self=shift;my$args=get_args(\@_);my$unparsed=$args->{'unparsed'};my$uncached=$args->{'xao.uncached'};# Preparing a short key that uniquely identifies the template given# (by either a path or an inline text). Uniqueness is only needed# within the site context. Global scope uniqueness is dealt with by# cache implementations below.#my$path;my$cache_key;if(defined($args->{'template'})) {my$template=$args->{'template'};if(ref($template)) {return$template;# Pre-parsed as an argument of some upper class}my$tbytes=Encode::is_utf8($template) ? Encode::encode_utf8($template) :$template;if(length$tbytes< 80) {$cache_key=($unparsed?'T':'t').':'.$tbytes;}else{$cache_key=($unparsed?'H':'h').':'.sha1_hex($tbytes);}}else{$path=$args->{'path'} ||throw$self"- no 'path' and no 'template' given to a Page object";$cache_key=($unparsed?'P':'p').':'.$path;}# Remembering the key if needed. It is used for benchmark cache.#my$cache_key_ref=$args->{'cache_key_ref'};$$cache_key_ref=$cache_keyif$cache_key_ref;# Encoding also matters#$cache_key.=':'.$self->_character_mode;# With uncached we don't even try to use any caches.#my$parsed;if($uncached) {$parsed=$self->parse_retrieve($args);}# Caching either locally, or in a standard cache#else{# Setup, only executed once.#my$cache_name=$self->{'parse_cache_name'};if(!defined$cache_name) {$cache_name=$self->{'parse_cache_name'}=$self->siteconfig->get('/xao/page/parse_cache_name') ||'';}# A fast totally local implementation.## About two times faster than a memcached, but grows a template# cache per-process.#if(!$cache_name) {# Making it unique per site#my$sitename=$self->{'sitename'} || get_current_project_name() ||'';$cache_key=$sitename.':'.$cache_key;# Checking if we have parsed and cached this before#$parsed=$parsed_cache{$cache_key};return$parsedifdefined$parsed;# Reading and parsing.#$parsed=$self->parse_retrieve($args);# Caching the parsed template.#$parsed_cache{$cache_key}=$parsed;# Logging the size#if($self->debug_check('page-cache-size')) {$self->cache_show_size($cache_key);}}# More generic implementation that can be switched from local to# memcached to anything else#else{my$cache=$self->{'parse_cache_obj'};if(!$cache) {dprint"Using a named cache '$cache_name' for parsed templates";$cache=$self->{'parse_cache_obj'}=$self->siteconfig->cache(name=>$cache_name,coords=> ['cache_key'],retrieve=> \&parse_retrieve,);}$parsed=$cache->get($self,$args,{cache_key=>$cache_key,force_update=>$uncached,});}}return$parsed;}###############################################################################subparse_retrieve ($@) {my$self=shift;my$args=get_args(\@_);my$path=$args->{'path'};my$template=$args->{'template'};# Reading and parsing.#if($path&& !defined$template) {if($self->debug_check('show-read')) {dprint$self->objname."- read path='$path'";}$template=XAO::Templates::get(path=>$path);defined($template) ||throw$self"- no template found (path=$path)";}# An unparsed template is very simple. But it might include binary# data. We don't encode/decode it regardless of encoding settings.#if($args->{'unparsed'}) {return[ {text=>$template,binary=> 1 } ];}# Logging the template or path if requested.#if($self->debug_check('show-parse')) {if($path) {dprint$self->objname."- parsing path='$path'"}else{my$te=substr($template,0,20);$te=~s/\r/\\r/sg;$te=~s/\n/\\n/sg;$te=~s/\t/\\t/sg;$te.='...'iflength($template)>20;dprint$self->objname."- parsing template='$te'";}}# Parsing.#my$parsed;if($self->_character_mode) {# We might get a latin1 string like \xe9 that is meant to# be a Unicode, but is not. Unless all code is switched to# use 'unicode_strings' feature this can easily happen.## BUT! We can also get an already UTF-8 encoded byte string,# in which case upgrade would break it.## Using shameful black magic :(#if(!Encode::is_utf8($template)) {Encode::_utf8_on($template);# UTF-8 encoded bytes or plain ASCII#if(Encode::is_utf8($template,1)) {# No-op}else{Encode::_utf8_off($template);utf8::upgrade($template);}}$parsed=XAO::PageSupport::parse($template,1);}else{$parsed=XAO::PageSupport::parse($template,0);}# If a scalar is returned it is an indicator of an error.#ref$parsed||throw$self"- $parsed";return$parsed;}###############################################################################=item object (%)Creates a new displayable object correctly tied to the current one. Youshould always get a reference to a displayable object by calling thismethod, not by using XAO::Objects' new() method. Currently mostof the objects would work fine even if you do not, but this is notguaranteed.Possible arguments are (the same as for XAO::Objects' new method):=over=item objname => 'ObjectName'The name of an object you want to have an instance of. Default is'Page'. All objects are assumed to be in XAO::DO::Web namespace,prepending them with 'Web::' is optional.=item baseobj => 1If present then site specific object is ignored and system object isloaded.=backExample of getting Page object:sub display ($%) {my $self=shift;my $obj=$self->object;$obj->display(template => '<%Date%>');}Or even:$self->object->display(template => '<%Date%>');Getting FilloutForm object:sub display ($%) {my $self=shift;my $ff=$self->object(objname => 'FilloutForm');$ff->setup(...);...}Object() method always returns object reference or throws an exception- meaning that under normal circumstances you do not need to worryabout returned object correctness. If you get past the call to object()method then you have valid object reference on hands.=cutsubobject ($%) {my$self=shift;my$args=get_args(@_);my$objname=$args->{objname} ||'Page';$objname='Web::'.$objnameunlesssubstr($objname,0,5) eq'Web::';XAO::Objects->new(objname=>$objname,parent=>$self,);}###############################################################################=item textout ($)Displays a piece of text literally, without any changes.It used to be called as textout(text => "text") which is stillsupported for compatibility, but is not recommended any more. Call itwith single argument -- text to be displayed.Example:$obj->textout("Text to be displayed");This method is the only place where text is actually gets displayed. Youcan override it if you really need some other output strategy for youobject. Although it is not recommended to do so.=cutsubtextout ($%) {my$self=shift;returnunless@_;my$text;if(@_== 1) {$text=$_[0];}else{my%args=@_;$text=$args{'text'} //'';}if(Encode::is_utf8($text)) {XAO::PageSupport::addtext(Encode::encode_utf8($text));}else{XAO::PageSupport::addtext($text);}}###############################################################################=item finaltextout ($)Displays some text and stops processing templates on all levels. No moreobjects should be called in this session and no more text should beprinted.Used in Redirect object to break execution immediately for example.Accepts the same arguments as textout() method.=cutsubfinaltextout ($%) {my$self=shift;$self->textout(@_);$self->clipboard->put(_no_more_output=> 1);}###############################################################################=item dbh ()Returns current database handler or throws an error if it is notavailable.Example:sub display ($%)my $self=shift;my $dbh=$self->dbh;# if you got this far - you have valid DB handler on hands}=cutsubdbh ($) {my$self=shift;return$self->{dbh}if$self->{'dbh'};$self->{dbh}=$self->siteconfig->dbh;return$self->{dbh}if$self->{dbh};throw$self"- no database connection";}###############################################################################=item odb ()Returns current object database handler or throws an error if it is notavailable.Example:sub display ($%) {my $self=shift;my $odb=$self->odb;# ... if you got this far - you have valid DB handler on hands}=cutsubodb ($) {my$self=shift;return$self->{odb}if$self->{odb};$self->{odb}=$self->siteconfig->odb;return$self->{odb}if$self->{odb};throw$self"- requires object database connection";}###############################################################################=item cache (%)A shortcut that actually calls $self->siteconfig->cache. See thedescription of cache() in L<XAO::DO::Web::Config> for more details.=cutsubcache ($%) {my$self=shift;my$args=get_args(\@_);return$self->siteconfig->cache($args);}###############################################################################=item cgi ()Returns CGI object reference (see L<CGI>) or throws an error if it isnot available.=cutsubcgi ($) {my$self=shift;$self->siteconfig->cgi;}###############################################################################=item clipboard ()Returns clipboard object, which inherets XAO::SimpleHash methods. Usethis object to pass data between various objects that work together toproduce a page. Clipboard is cleaned before starting every new session.=cutsubclipboard ($) {my$self=shift;my$clipboard=$self->{'clipboard'};if(!$clipboard) {$clipboard=$self->{'clipboard'}=$self->siteconfig->clipboard;}return$clipboard;}###############################################################################=item siteconfig ()Returns site configuration reference. Be careful with your changes toconfiguration, try not to change configuration -- use clipboard to passdata between objects. See L<XAO::Projects> for more details.=cutsubsiteconfig ($) {my$self=shift;my$siteconfig=$self->{'siteconfig'};if(!$siteconfig) {$siteconfig=$self->{'siteconfig'}=$self->{'sitename'} ? get_project($self->{'sitename'}): get_current_project();}return$siteconfig;}###############################################################################=item base_url (%)Returns base_url for secure or normal connection. Depends on parameter"secure" if it is set, or current state if it is not.If 'active' parameter is set then will return active URL, not the baseone. In most practical cases active URL is the same as base URL exceptwhen your server is set up to answer for many domains. Base will stayat what is set in the site configuration and active will be the onetaken from the Host: header.Examples:# Returns secure url in secure mode and normal# url in normal mode.#my $url=$self->base_url;# Return secure url no matter what#my $url=$self->base_url(secure => 1);# Return normal url no matter what#my $url=$self->base_url(secure => 0);# Return secure equivalent of the current active URL#my $url=$self->base_url(secure => 1, active => 1);=cutsubbase_url ($;%) {my$self=shift;my$args=get_args(\@_);my$secure=$args->{secure};$secure=$self->is_secureunlessdefined$secure;my$active=$args->{active};my$url;if($secure) {$url=$active?$self->clipboard->get('active_url_secure'):$self->siteconfig->get('base_url_secure');}else{$url=$active?$self->clipboard->get('active_url'):$self->siteconfig->get('base_url');}return$url;}###############################################################################=item is_secure ()Returns 1 if the current the current connection is a secure one or0 otherwise. If there is a defined cgi() value then the result isdefined by its https() method; otherwise the default is taken from/xao/page/default_https configuration variable. The later is useful forscripts that don't have a CGI environment.=cutsubis_secure ($) {my$self=shift;my$cgi=$self->cgi;if($cgi) {return$cgi->https() ? 1 : 0;}else{return$self->siteconfig->get('/xao/page/default_https') ? 1 : 0;}}###############################################################################=item pageurl (%)Returns full URL of current page without parameters. Accepts the samearguments as base_url() method.=cutsubpageurl ($;%) {my$self=shift;my$pagedesc=$self->clipboard->get('pagedesc') ||throw$self"- no Web context, needs clipboard->'pagedesc'";my$url=$self->base_url(@_);# This works in both CGI and PSGI environments, but simply# requesting $cgi->url(-absolute => 1) does not work for PSGI# because it sets PATH_INFO and REQUEST_URI to the same value,# making them cancel each other.#my$uri=$self->cgi->request_uri();$uri=~ s/\?.*$//s;$uri=$self->cgi->unescape($uri);return$url.$uri;}###############################################################################sub_do_pass_args ($$$) {my($self,$pargs,$spec)=@_;my$hash={ };foreachmy$rule(@$spec) {$rule=~s/^\s*(.*?)\s*$/$1/;### dprint "...rule='$rule'";if($ruleeq'*') {$hash=merge_refs($pargs,$hash);}elsif($rule=~ /^([\w\.]+)\s*=\s*([\w\.]+)$/) {# VAR=FOO$hash->{$1}=$pargs->{$2};}elsif($rule=~ /^([\w\.]*)\*([\w\.]*)\s*=\s*([\w\.]*)\*([\w\.]*)$/) {# VAR*=FOO* or *VAR=*FOO or V*R=T*Z or *=X*Zmy($prnew,$sufnew,$prold,$sufold)=($1,$2,$3,$4);my$re=qr/^\Q$prold\E(.*)\Q$sufold\E$/;foreachmy$k(keys%$pargs) {nextunless$k=~$re;$hash->{$prnew.$1.$sufnew}=$pargs->{$k};}}elsif($rule=~ /^([\w\.]+)$/) {# VAR$hash->{$1}=$pargs->{$1};}elsif($rule=~ /^([\w\.]*)\*([\w\.]*)$/) {# VAR* or *VAR or VAR*FOOmy($pr,$suf)=($1,$2);my$re=qr/^\Q$pr\E(.*)\Q$suf\E$/;foreachmy$k(keys%$pargs) {nextunless$k=~$re;$hash->{$k}=$pargs->{$k};}}elsif($rule=~ /^!([\w\.]+)$/) {# !VARdelete$hash->{$1};}elsif($rule=~ /^!([\w\.]*)\*([\w\.]*)$/) {# !VAR* or !*VAR or !VAR*FOOmy($pr,$suf)=($1,$2);my$re=qr/^\Q$pr\E(.*)\Q$suf\E$/;my@todel;foreachmy$k(keys%$hash) {nextunless$k=~$re;push(@todel,$k);}delete@{$hash}{@todel};}elsif($ruleeq'!*') {$hash={};}elsif($ruleeq'') {# no-op}else{throw$self"- don't know how to pass for '$rule'";}}return$hash;}###############################################################################=item pass_args ($) {Helper method for supporting "pass" argument in web objects. Synopsis:$page->display($page->pass_args($args->{'pass'},$args),{path => $args->{'blah.path'},template => $args->{'blah.template'},FOO => 'bar',});If "pass" argument is not defined it will just return the original args,otherwise the following rules are supported:"on" or "1" - pass all arguments from parent object"VAR=FOO" - pass FOO from parent as VAR"VAR*=FOO*" - pass FOO* from parent renaming as VAR*"*=FOO*" - pass FOO* from parent stripping FOO"VAR" - pass only VAR from parent"VAR*" - pass only VAR* from parentMultiple pass specifications can be given with semi-colon delimiter.Several special tags are deleted from parent arguments: pass, path,template, and objname.=cutsubpass_args ($$;$) {my($self,$pass,$args)=@_;$args||={ };# The first argument is the content of 'pass', if it's not defined# we return unadulteraded arguments.#return$argsunless$pass;# If we don't have parent arguments then there is nothing to do.#my$pargs;if(!$self->{'parent'} || !($pargs=$self->{'parent'}->{'args'})) {return$args;}# Simplified (old) way of calling with just <%Page pass# template='xxx'%> would result in pass being 'on'.#if($passeq'on'||$passeq'1') {$pass='*';}# Building inherited hash.#my$hash=$self->_do_pass_args($pargs,[split(/;/,$pass)]);# Always deleting pass, path and template#delete@{$hash}{'pass','objname','path','template'};# This is it, merging with the arguments given to us and returning#returnmerge_refs($hash,$args);}###############################################################################subbenchmark_enabled ($) {my$self=shift;$self->clipboard->get('_page_benchmark_enabled') || 0;}###############################################################################sub_benchmark_hash ($) {my$self=shift;my$stats=$self->{'benchmark_stats'};if(!$stats) {$stats=$self->siteconfig->get('_page_benchmark_stats');if($stats) {$self->{'benchmark_stats'}=$stats;}else{$stats=$self->{'benchmark_stats'}={ };$self->siteconfig->put('_page_benchmark_stats'=>$stats);}}return$stats;}###############################################################################subbenchmark_tag_data ($$) {my($self,$tag,$key)=@_;$tag|| throw$self"- no 'tag'";$key||='-';ref$tag&& throw$self"- tag '$tag' is not a scalar";my$stats=$self->_benchmark_hash();my$tagdata=$stats->{$tag};if(!$tagdata) {$tagdata=$stats->{$tag}={count=> 0,total=> 0,last=> [ ],runs=> { },};}my$rundata=$tagdata->{'runs'};$rundata->{$key}||={ };$rundata=$rundata->{$key};returnwantarray? ($tagdata,$rundata,$key) :$tagdata;}###############################################################################=item benchmark_enter($;$$$)Start tracking the given tag execution time until benchmark_leave() iscalled on the same tag.An optional second argument can contain a unique key that identifies aspecific run for the tag (in case of recurrent tag execution). The thirdoptional argument is a description of this run.=cutsubbenchmark_enter ($$;$$$) {my($self,$tag,$key,$description,$cache_flag)=@_;my($tagdata,$rundata);($tagdata,$rundata,$key)=$self->benchmark_tag_data($tag,$key);if($rundata->{'started'}) {eprint"Benchmark for '$tag' (key '$key') not finished, discarding";}$description||='';$rundata->{'description'}=length$description> 100 ?substr($description,0,100) :$description;$rundata->{'cache_flag'}=$cache_flag? 1 : 0;$rundata->{'started'}=[ gettimeofday ];}###############################################################################=item benchmark_leave ($)Stop time tracking for the given tag and record tracking results in thehistory.=cutsubbenchmark_leave ($$;$$) {my($self,$tag,$key,$content_digest)=@_;my($tagdata,$rundata);($tagdata,$rundata,$key)=$self->benchmark_tag_data($tag,$key);### dprint to_json($tagdata);my$started=$rundata->{'started'};if(!$started) {eprint"Benchmark for '$tag' (key '$key') was not started";return;}my$taken=tv_interval($started);# For median calculation#my$last=$tagdata->{'last'};push(@$last,$taken);shift(@$last)ifscalar(@$last) > 50;++$tagdata->{'count'};++$rundata->{'count'};$tagdata->{'total'}+=$taken;$rundata->{'total'}+=$taken;# Remembering the content for cacheability analysis.#$content_digest||='-';++$rundata->{'content'}->{$content_digest};# Resetting for the next run#$rundata->{'started'}=undef;}###############################################################################=item benchmark_reset()Clear all benchmarking statistics accumulated so far.=cutsubbenchmark_reset ($) {my$self=shift;%{$self->_benchmark_hash()}=();}###############################################################################=item benchmark_start(;$)Start automatic system-wide page rendering benchmarking.By default only 'path' based rendering is benchmarked. If an optionalsingle argument is set to '2' then templates are also benchmarked (thismay demand a lot of extra memory!).=cutsubbenchmark_start ($;$) {my($self,$level)=@_;$self->clipboard->put('_page_benchmark_enabled'=> ($level|| 1));}###############################################################################=item benchmark_stop()Stop automatic system-wide rendering benchmarking.=cutsubbenchmark_stop ($) {my$self=shift;$self->clipboard->put('_page_benchmark_enabled'=> 0);}###############################################################################=item benchmark_statsReturn a hash with accumulated benchmark statistics.=cutsubbenchmark_stats ($;$) {my($self,$desired_tag)=@_;my$stats=$self->_benchmark_hash();my%analyzed;foreachmy$tag(keys%$stats) {my$d=$stats->{$tag};nextunless$d->{'count'};nextif$desired_tag&&$tagne$desired_tag;$d->{'average'}=$d->{'total'} /$d->{'count'};$d->{'median'}=$d->{'last'}->[scalar(@{$d->{'last'}})/2];# The page is cacheable if the content only depends on# parameters and not on clipboard, cookies, CGI, time, or other# environment.#$d->{'cacheable'}=scalar(grep{scalar(keys%{$d->{'runs'}->{$_}->{'content'}}) != 1}keys%{$d->{'runs'}}) ? 0 : 1;# Current cacheable flag, if it's shared across all runs#$d->{'cache_flag'}=scalar(grep{!$d->{'runs'}->{$_}->{'cache_flag'}}keys%{$d->{'runs'}}) ? 0 : 1;$analyzed{$tag}=$d;}### dprint to_json(\%analyzed,{ utf8 => 1, canonical => 1, pretty => 1 });return\%analyzed;}###############################################################################subcache_show_size ($$) {my($self,$path)=@_;eval{};if($@) {eprint"Devel::Size not available, disabling debug 'page-cache-size'";$self->debug_set('cache-size'=> 0);return;}my$size=Devel::Size::total_size(\%parsed_cache);eprint"Web::Page cache size ".sprintf('%.3f',$size/1024.0)." KB - ",$path;}###############################################################################subdebug_check ($$) {my($self,$type)=@_;# This is a speed up (makes the parsing more than twice faster when a# local parsing cache is also used).## 8 wallclock secs ( 8.78 usr + 0.01 sys = 8.79 CPU) @ 113765.64/s (n=1000000)# 19 wallclock secs (18.97 usr + 0.00 sys = 18.97 CPU) @ 52714.81/s (n=1000000)#### return $self->clipboard->get("debug/Web/Page/$type");my$debug_hash=$self->{'debug_hash'};if(!$debug_hash) {$debug_hash=$self->clipboard->get('/debug/Web/Page');if($debug_hash) {$self->{'debug_hash'}=$debug_hash;}else{$self->{'debug_hash'}=$debug_hash={ };$self->clipboard->put('/debug/Web/Page'=>$debug_hash);}}return$debug_hash->{$type};}###############################################################################subdebug_set ($%) {my$self=shift;my$args=get_args(\@_);foreachmy$type(keys%$args) {$self->clipboard->put("/debug/Web/Page/$type",$args->{$type} ? 1 : 0);}}###############################################################################subpage_clipboard ($) {my$self=shift;my$cb_hash=$self->{'page_clipboard'};if(!$cb_hash) {$cb_hash=$self->clipboard->get('/xao/page');if($cb_hash) {$self->{'page_clipboard'}=$cb_hash;}else{$self->{'page_clipboard'}=$cb_hash={ };$self->clipboard->put('/xao/page'=>$cb_hash);}}return$cb_hash;}###############################################################################1;__END__=back=head1 EXPORTSNothing.=head1 AUTHORCopyright (c) 2005 Andrew MaltsevCopyright (c) 2001-2004 Andrew Maltsev, XAO Inc.<am@ejelta.com> -- http://ejelta.com/xao/=head1 SEE ALSORecommended reading:L<XAO::Web>,L<XAO::Objects>,L<XAO::Projects>,L<XAO::Templates>.L<XAO::DO::Web::Benchmark>.=cut