Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog. Podcast Helping communities build their own LTE networks. Podcast Making Agile work for data science. Featured on Meta.
New post summary designs on greatest hits now, everywhere else eventually. Related Hot Network Questions. Some people like bells and whistles and nicely organized to do lists, and journals and road maps to follow. As long as the items are getting done and action is being taken and ventures are progressing, what does it matter to you? I have the freedom and choice to decide what I find important in my journey without anyone like you jumping in and ridiculing it. If you don't see value in or want to use the templates then don't, that's your choice.
You assumed I was new here and didn't know the principles, and tried to dog on me asking if I've ever heard of paper. No, I'm not action faking. No, I'm not picking out a color for my Ferrari. Harbourmaster you can learn from anyone and help everyone. Harbourmaster dm Raoul Duke and talk. Apr 15, 10 5. All good. Not in need of any sauce, secret or otherwise. Have been deep in the entrepreneurial trenches for the last few years.
I'll assume that a PDF doc of this type doesn't exist from the forum at the moment and will just continue with good ol' fashion paper as per your advice or make my own template to use.
Gina H. Jul 7, 51 The Great Rat Race Escape! Pinned Pinned. Fastlane Marketplace. Jun 22, GlobalWealth. Nov 9, BulkPaintings. Jul 18, bibbysoka. This free book will teach you how to build a successful web design business.
Feb 19, Kung Fu Steve. Jul 15, Tjack Post reply. More complex tasks need the ttree program or custom programs using the Template module. However, there is one last tpage trick we can show you. This allows you to use it as Unix-style pipeline filter. For example, if the output of the mktemplate program is a Template Toolkit template, the following command can be used to pipe it into tpage to have it processed:.
Invoking tpage by itself, with no arguments and no piped input, starts it in interactive mode. In this case, tpage sits and waits for you to type in a source template.
This can be very useful for trying out small snippets of template syntax to see what they do. The first line invokes tpage from the command line. The rest of the example shows the output generated by tpage from processing the template.
The cat is sitting on the mat, and everything is working as expected. The ttree program offers many more features and options than tpage does.
The first major difference is that ttree works with entire directories of templates rather than with single files. The following example shows how you could invoke ttree to process all the templates in the templates directory containing the files cat and dog for the purpose of this example , and save the generated output in files of the same name, which are located in the output directory:.
The -s option defines the source directory for templates, and -d defines the destination directory for output files. This is a summary of the processing options, including the Source and Destination that we provided as the -s and -d command-line options.
The dog and cat files are listed as the two files that ttree found in the templates directory. Now that these templates have been processed, ttree will not process them again until they are modified or the corresponding output file is deleted. By looking at the file modification times of the source template and destination file, ttree can decide which templates have changed and which have not. It saves time by processing only those that have changed.
These - characters indicate that the template files were not processed this time, with the reason given in parentheses to the right. This can save a great deal of time when building large document systems using templates e. The -a option forces ttree to process all templates, regardless of their modification times:.
A second benefit of ttree is that it offers numerous options for changing its behavior. Adding a standard header and footer to each page template, for example, is as easy as setting the relevant option:. The number of options can be overwhelming at first, but in practice, only a few are used on a regular basis. To avoid having to always use the command line to specify options—something that can quickly become cumbersome and error prone, especially if you are using more than a few— ttree allows you to use configuration files to define all the options for a particular web site or other document system.
You can then invoke ttree , passing the name of the configuration file using the -f option:. Example shows a sample ttree configuration file. In the configuration file, the -s and -d options are represented by the src and dest options.
We also added a lib option -l on the command line , which tells ttree about an additional library directory where our header and footer templates are found. Setting up ttree is a little more involved than using tpage , but the effort quickly pays off in the time it saves you. We look at ttree in detail in Chapter 2 , showing everything from first-time use through writing and managing configuration files.
Both tpage and ttree use the Template Perl module to do the dirty work of processing templates. Chapter 7 goes into greater detail about what lurks beneath the hood of the Template Toolkit, but for now we cover just the basics. If you are already a Perl hacker experienced in using modules, the Template manpage gives you an executive summary to get you quickly up to speed.
Thanks to the tpage and ttree programs, you can build your entire web site or other template-based document system without ever having to write a line of Perl code. Also, certain features are accessible only through Perl for example, the ability to define a subroutine to return the value for a variable , so there is a good chance that sooner or later you will want or need those Perl-specific features.
Example shows a simple Perl program for processing the destruction. The first line defines the path to the Perl interpreter on your system. This is very much a Unix-specific convention. On a Windows machine, for example, this line is not relevant or required. It is good Perl style to include use strict; and use warnings; at the top of every program, or to invoke Perl with the -w switch instead of use warnings; for versions of Perl earlier than 5.
These two precautions will catch many common programming and typographical errors, and warn you about any questionable practices. Perl examples in this book may omit them for brevity, but you should always include them in any nontrivial chunk of code.
The process method processes the template and returns a true value to indicate success. If an error occurs, the process method returns false. In this case, we call the error method to find out what went wrong and report it as a fatal error using die. An error can be returned for a number of reasons, such as the file specified could not be found, had embedded directives containing illegal syntax that could not be parsed, or generated a runtime error while the template was being processed.
Now we can see how these are used in the underlying Perl implementation. Configuration options are passed to the new constructor method as a reference to a hash, as shown in Example These are provided as a reference to a list of the two directory paths. For this example, we are assuming that the destruction. The Template Toolkit provides numerous configuration options. These are described in detail in the Appendix. We describe the useful ones as we encounter them in later chapters.
Example shows an extract of an httpd. Apache::Template adopts the Apache convention of using StudlyCaps for the names of configuration options and also adds a unique TT2 prefix. The two options that follow are specific to the Apache::Template handler:. The first, TT2Params , provides a list of items that the handler should automatically extract from the Apache request and make available as template variables.
Any template can use the uri , env , params , and cookies variables to access the request URI, environment variables, request parameters, and cookies, respectively. The second directive, TT2Headers , indicates that Last-Modified and Content-Length headers should be automatically added to the response sent to the client. The final section uses the Apache Files directive to define the files that should be processed as templates:. With this configuration, the Apache server processes any files with a.
This is a convenient way of mixing static HTML pages with dynamic page templates in any directory that is currently accessible by the Apache web server. If you want to create a static page, use a. If you want to create a dynamic page from a template, with the appropriate headers and footer added automatically, simply give it a.
If you would rather not open up your entire web server to the Apache::Template module, you can instead use the Location directive. There are numerous other Apache configuration directives, all of which are described in the documentation provided with Apache. For a full discussion of the Apache::Template configuration, see the Appendix.
The Template Toolkit language is a presentation language rather than a general-purpose programming language. It provides the kind of features that you would expect to see in a regular programming language, including loops, conditional tests, and the ability to manipulate variable values. However, in this case they serve a slightly different purpose.
The Template Toolkit is designed for the task of generating content and presenting data, and it generally leaves more complex issues to a real programming language, namely, Perl. We have already seen the basics of what a template looks like—a mixture of tags known as directives and other fixed text.
The template processor interprets the directives and the remaining text is passed through unchanged. The TAGS directive takes either one or two arguments. The single-argument version expects the name of a predefined tag set.
If you give TAGS two arguments, they define the start and end tag markers that you want to use. In the rest of this book, we use the default tag style. We like it because it makes the directives stand out from the surrounding text, rather than making them blend in. We think it makes templates easier to read and write when you can more clearly distinguish one part from another. The variables that we have used so far have been scalar variables. A scalar variable stores a single piece of information—either a string or a number.
The value of a scalar variable is inserted in a template by using the variable name inside a directive like this:. In addition to scalar variables, the Template Toolkit also supports two complex data types for storing multiple values: the list and hash array also known as a hash.
A list is an ordered array of other variables, indexed numerically and starting at element 0. A hash is an unordered collection of other variables, which are indexed and accessible by a unique name or key. Perl programmers will already be familiar with these data structures. When you use the Template Toolkit from Perl you can easily define hash arrays and lists that are then passed as template variables to the process method.
Example shows a Perl program similar to Example , which defines a list of friends and a hash of terms as template variables. Example is the friends. This is the output generated by Example :. The Template Toolkit allows you to define lists and hash data structures inside templates, using syntax similar or identical if you prefer to the Perl equivalents shown earlier. This is inherently flexible, but not as efficient as it could be, especially in a persistent server environment where a template may be processed many times.
It is evaluated once at compile time and is stored in cached form as part of the compiled template subroutine. The downside is that you must code much closer to the metal. For example, in a PERL block you can call print to generate some output. The critical section of the generated subroutine for this example would then look something like:. The Template Toolkit supports fully functional, nested exception handling. Any errors that occur within that block will be caught and can be handled by one of the CATCH blocks defined.
Errors are raised as exceptions objects of the Template::Exception class which contain two fields: type and info. The exception type is used to indicate the kind of error that occurred.
The info field contains an error message indicating what actually went wrong. Within a catch block, the exception object is aliased to the error variable. You can access the type and info fields directly. Each CATCH block may be specified with a particular exception type denoting the kind of error that it should catch. A CATCH block specified without any type, as in the previous example, is a default handler which will catch any otherwise uncaught exceptions.
Remember that you can specify multiple directives within a single tag, each delimited by ' ; '. So the above example can be written more concisely as:. The other specific exception caught here is of the file type. The output generated would be:. Note that the DEFAULT option disabled by default allows you to specify a default file to be used any time a template file can't be found.
This will prevent file exceptions from ever being raised when a non-existent file is requested unless, of course, the DEFAULT file your specify doesn't exist. Errors encountered once the file has been found i. Uncaught exceptions i. If the error isn't caught at any level then processing will stop and the Template process method will return a false value to the caller.
The relevant Template::Exception object can be retrieved by calling the error method. We're using a variable to provide the name of the template we want to include, user. If an exception is uncaught then the FINAL block is processed before jumping to the enclosing block or returning to the caller. The output from the TRY block is left intact up to the point where an exception occurs. For example, this template:. Exception types are hierarchical, with each level being separated by the familiar dot operator.
A DBI. Similarly, an example. Note that the order in which CATCH handlers are defined is irrelevant; a more specific handler will always catch an exception in preference to a more generic or default one. In this example, a DBI. The first parameter is the exception type which doesn't need to be quoted but can be, it's the same as INCLUDE followed by the relevant error message which can be any regular value such as a quoted string, variable, etc. It's also possible to specify additional positional or named parameters to the THROW directive if you want to pass more than just a simple message back as the error info field.
In this case, the error info field will be a hash array containing the named arguments and an args item which contains a list of the positional arguments. Exceptions can also be thrown from Perl code which you've bound to template variables, or defined as a plugin or other extension.
To raise an exception, call die passing a reference to a Template::Exception object as the argument. This will then be caught by any enclosing TRY blocks from where the code was called. The info field can also be a reference to another object or data structure, if required.
You can also call die with a single string, as is common in much existing Perl code. This will automatically be converted to an exception of the ' undef ' type that's the literal string ' undef ', not the undefined value.
If you're writing a plugin, or some extension code that has the current Template::Context in scope you can safely skip this section if this means nothing to you then you can also raise an exception by calling the context throw method. If there is no enclosing template then the Template process method will return to the calling code with a true value.
The STOP directive can be used to indicate that the processor should stop gracefully without processing any more of the template document. This is a planned stop and the Template process method will return a true value to the caller.
This indicates that the template was processed successfully according to the directives within it. It is most commonly used to clear the output generated from a TRY block up to the point where the error occurred. The META directive allows simple metadata items to be defined within a template. These are evaluated when the template is parsed and as such may only contain simple values e.
The template variable contains a reference to the main template being processed. These metadata items may be retrieved as attributes of the template. The name and modtime metadata items are automatically defined for each template to contain its name and modification time in seconds since the epoch. The template reference is correctly defined when these templates are processed, allowing headers and footers to reference metadata items from the main template.
0コメント