Free template plugin translit ru software for linux

Template::Plugin::Translit::RU is a filter for converting cyrillic text into transliterated one and back.

SYNOPSIS

Use as filters.
[% USE Translit::RU translit detranslit %]
[% FILTER translit( koi ) %]
...
This text would stay unchanged because it is not cyrillic.
...
[% END %]
Use as object. First argument - text for conversion. Second optional argument - charset (koi is default).
[% USE plTranslit = Translit::RU %]
[% plTranslit.translit( without cyrillic text is useless ) %]
[% plTranslit.detranslit( kirilitca, win ) %]

Template::Plugin::Translit::RU is Template Toolkit filter which allows to convert cyrillic text into transliterated latin text. Currently two most popular charsets are supported - koi8-r and windows-1251. Also back conversion supported.

Template::Plugin::ASCIITable is a Perl module that allows you to use Text::ASCIITable in your templates.

SYNOPSIS

[% USE ASCIITable %]
blah
[% ASCIITable.cols(a, b, c);
ASCIITable.rows([1,2,3],[one,two,three]);
ASCIITable.draw() %]

A plugin object will be instantiated with the directive:

[% USE ASCIITable %]

You can pass a number of parameters to the constructor, for example:

[% USE ASCIITable(cols => [a,b,c], show=>rowline) %]

See "Parameters" for details.

To obtain the table, you invoke the draw method, to which you can pass the same parameters:

[% ASCIITable.draw(rows=>[[1,2,3],[one,two,three]]) %]

METHODS

new

This is the plugin construtor. You should never call it directly: use the USE directive.

draw

This method invokes Text::ASCIITable to obtain the textual representation of the table, and returns it.

You can pass various parameters to it, see "Parameters".

Template::Plugin::SSI is a plugin to use SSI in Template Toolkit (wrapper for CGI::SSI).

SYNOPSIS

[% USE SSI %]

# virtual include of the file /foo/bar.inc.html
[% SSI.include(virtual, /foo/bar.inc.html) %]

# file include of the file /foo/bar.inc.html
[% SSI.include(file, /var/www/html/foo/bar.inc.html) %]

# execute a command
[% SSI.exec(cmd, ls) %]

# execute a cgi script
[% SSI.exec(cgi, /cgi-bin/foo.cgi) %]

# set a config variable (sizefmt, timefmt, or errmsg)
[% SSI.config(timefmt, "%Y") %]

# echo a set or environment variable
# Environment Variable Examples:
# DOCUMENT_URI - the URI of this document
# DOCUMENT_NAME - the name of the current document
# DATE_GMT - the same as gmtime
# DATE_LOCAL - the same as localtime
# FLASTMOD - the last time this script was modified
[% SSI.echo(DATE_LOCAL) %]

# set a local variable ($name = Corey)
[% SSI.set(name, Corey) %]

# print when index.html was last modified
[% SSI.flastmod(file, index.html) %]

# print the file size of index.html
[% SSI.fsize(file, index.html) %]

A Template Toolkit Plugin that provides an easy way to include Apaches SSI within a template. (acts as a wrapper to CGI::SSI)

The plugin can be loaded via the familiar USE directive.

[% USE SSI %]

This creates a plugin object with the name of SSI.

Template::Plugin::Datum is a Perl module with TT2 plugin that converts international date format to German date format.

SYNOPSIS

[% USE Datum %]

von: [% 20030101 | datum %] -> 01.01.2003
bis: [% 2003-12-31 | datum %] -> 31.12.2003

Zeitstempel: [% 20031212143000 | datum %] -> 12.12.2003 14:30:00

This plugin converts international date format (year-month-day) to German date format (day.month.year).

Recognized formats are:

yyyy-mm-dd (2003-12-31)
yyyymmdd (20031231)
yyyymmddHHMMSS (20031231143000) date and time

Template::Plugin::XML is a XML plugin for the Template Toolkit.

SYNOPSIS

[% USE XML;
dom = XML.dom(foo.xml);
xpath = XML.xpath(bar.xml);
simple = XML.simple(baz.xml);
rss = XML.simple(news.rdf);
%]

[% USE XML(file=foo.xml);
dom = XML.dom
xpath = XML.xpath
# ...etc...
%]

[% USE XML(dir=/path/to/xml);
file = XML.file(foo.xml );
dom = file.dom
xpath = file.xpath
# ...etc...
%]

The Template-XML distribution provides a number of Template Toolkit plugin modules for working with XML.

The Template::Plugin::XML module is a front-end to the various other XML plugin modules. Through this you can access XML files and directories of XML files via the Template::Plugin::XML::File and Template::Plugin::XML::Directory modules (which subclass from the Template::Plugin::File and Template::Plugin::Directory modules respectively). You can then create a Document Object Model (DOM) from an XML file (Template::Plugin::XML::DOM), examine it using XPath queries (Template::Plugin::XML::XPath), turn it into a Perl data structure (Template::Plugin::XML::Simple) or parse it as an RSS (RDF Site Summary) file.

The basic XML plugins were distributed as part of the Template Toolkit until version 2.15 released in May 2006. At this time they were extracted into this separate Template-XML distribution and an alpha version of this Template::Plugin::XML front-end module was added.
The Template::Plugin::XML module is still in development and not guaranteed to work correctly yet. However, all the other XML plugins are more-or-less exactly as they were in TT version 2.14 and should work as normal.

For general information on the Template Toolkit see the documentation for the Template module or http://template-toolkit.org. For information on using plugins, see Template::Plugins and "USE" in Template::Manual::Directives. For further information on XML, see http://xml.com/.

Template::Plugin::HtmlToText is a plugin interface to HTML::FormatText.

SYNOPSIS

Quick summary of what the module does.

Perhaps a little code snippet.

[% USE HtmlToText %]

# use html2text FILTER to var myhtml or myhtmltext
[% myhtml FILTER html2text(leftmargin => 0, rightmargin => 50) %]
[% myhtmltext | html2text %]

# not to a var, but to html code
[% FILTER html2text %]
heavy
[% END %]
[%# output is "heavy", no %]

This plugin provides an interface to the HTML::FormatText module which format HTML as plaintext.

Template::Plugin::Java is a Perl module that can generate Java Classes from XML description files and templates.

SYNOPSIS

From an xml file such as:
< aBean >
< java: option1="value1" >
< option2 >value2< /option2 >
< /java: >
< foo >10< /foo >
< bar >String< /bar >
< container >
< baz >20< /baz >
< /container >
< /aBean >

Through the program "tjava":

tjava [options] [file.xml ...]

Via a template, such as:

[% USE Java %]
package $package;

public class $class {

[% FOREACH Java.variables %]
$type $name = $initializer;
[% END %]

//... etc
}

To generated Java source code in the appropriate directory as determined by the package of the .xml files directory, specified package option if any, and CLASSPATH.

OPTIONS

Any options may be given besides those listed, these are passed directly to the Templates being processed in the stash (the variable table at time of processing). They can be given in the < java: > ... < /java: > section of an XML file (in which case, dont use the -- dashes) as attributes or elements, or on the command line.

--template

Name of the template to process. No extension is assumed by default unlike in the previous version.

--package

Destination package to put the generated classes, otherwise will be determined from how the current directory relates to the CLASSPATH.

--class

Class name to use, otherwise will infer from the root tag of the XML file.

--templatePath

Colon separated path where the templates can be found, overrides the environment variable TEMPLATEPATH. This doesnt work right now, so use the TEMPLATEPATH environment variable.

--genContainers

If set to 0, classes for subcontainers will not be generated. This is generally not useful.

--containerTemplate

By default set to Container, this is the default template, as well as the template used for sub-containers.

--containerNamePrefix

By default, if generating class Foo that needs to have a sub container wrapped in tag < bar >, its name will be FooBar. This is safe and wont cause collisions with different classes having sub containers of the same name (until some sort of dependency checking code is introduced). To turn this off, set it to the empty string "".

--interface

Interface to add to list of implemented interfaces, can be supplied multiple times. Make sure you append any necessary code to implement any of these interfaces.

--append

Text to insert in the generated class body.

--appendFile

Will insert text read from the file specified into the generated class body. This option and the --append option are mutually exclusive.

--file[s]

The XML file(s) to parse. This is useful for when the Plugin is instantiated from a custom script, not via tjava or inside a template.

Any other option will be placed into the stash for the templates to use, making tjava very useful with your custom templates.

Anything thats not an option will be assumed to be a file.

Template::Plugin::JSON is a Perl module that adds a .json vmethod for all TT values.

SYNOPSIS

[% USE JSON %];

< script type="text/javascript" >

var foo = [% foo.json %];

< /script >

This plugin provides a .json vmethod to all value types when loaded.

With no argument it will try to load JSON::Syck and then JSON::Converter. If used as [% USE JSON("Syck") %] or [% USE JSON("Converter") %] it will load that specific plugin.
If no plugin could be loaded an exception is thrown. Check for errors from "process" in Template.