templates2ada(1) [debian man page]

TEMPLATES2ADA(1)					   Templates Parser User's Guide					  TEMPLATES2ADA(1)

NAME

       templates2ada - generate Ada sources from a templates file

SYNOPSIS

       templates2ada [options]

DESCRIPTION

       templates2ada  parses  all  the	template  files  in  a directory and then generates an output file from these, based on a template file (a
       default example of which is provided as /usr/share/doc/libtemplates-parser-dev/examples/templates.tads). The latter contains  in  fact  two
       examples,  depending on whether one Ada package should be generated per template, or whether a single package should be built.  In the for-
       mer case, if you are using the GNAT compiler, you should run `gnatchop' on the resulting file. Here is an example:

	    $ rm -f src/templates/*.ads
	    $ templates2ada -d resources/ -o src/templates/generated -r
	    $ cd src/templates; gnatchop -w -q generated
	    $ rm -f src/templates/generated

       One of the goals of templates2ada is to ensure that you are only setting tags that actually exist in the template  (and	thus  prevent,	as
       much as possibly, typos in the name of tags); also, when combined with other tools, to help ensure that all tags needed by the template are
       properly set.

       templates2ada also has special knowledge about HTTP constructs and will generate Ada constants for the HTTP parameters you might receive in
       return. Once more the goal is to help avoid typos in the Ada code.

       For instance, we will consider a simple template file, found in a local file `resources/block1.thtml'. This template contains the following
       simple html code:

	    <form>
	      <input name="PARAM1" value="@_TAG1_@" />
	      <input name="PARAM2" value="@_TAG2_@" />
	    </form>

       When you run templates2ada, the following Ada package will be generated. Note that this is only the default output of templates2ada,  which
       can be fully tailored to your needs.

	    package Templates.Block1 is
	      pragma Style_Checks (Off);
	      Template : constant string := "resources/block1.thtml";
	      Tag1 : constant String := "TAG1";
	      Tag2 : constant String := "TAG2";
	      package Http is
		Param1 : constant String := "PARAM1";
		Param2 : constant String := "PARAM2";
	      end Http;
	    end Templates.Block1;

OPTIONS

       -d dir Search for template files in dir.

       -h     Display a summary of options.

       -o file
	      Write the output to file.

       -e ext Process all files with extension ext that are in the input directory; consider these files as template files.

       -r     Recurse into subdirectories.

       -t file
	      Use  file  as  the  output  template  file.  The	templates  parser comes with an example for such a file, /usr/share/doc/templates-
	      parser/examples/templates.tads, that you can adapt to your own needs.

       -v     Verbose mode.  This will output a warning when an http parameter has a name made only of template parser	tags,  since  no  matching
	      entry can then be created for it in the output file.

SEE ALSO

       templatespp(1)

       The Template Parsers User's Guide in package libtemplates-parser-dev.

AUTHOR

       templates2ada was written by Pascal Obry <p.obry@wanadoo.fr> as part of the Ada Web Server.

       This manual page was written by Ludovic Brenta <lbrenta@debian.org> for Debian GNU/Linux.

GNU Ada Tools							    2008-05-04							  TEMPLATES2ADA(1)

Check Out this Related Man Page

Template::Provider::FromDATA(3pm)			User Contributed Perl Documentation			 Template::Provider::FromDATA(3pm)

NAME

       Template::Provider::FromDATA - Load templates from your __DATA__ section

SYNOPSIS

	   use Template;
	   use Template::Provider::FromDATA;

	   # Create the provider
	   my $provider = Template::Provider::FromDATA->new( {
	       CLASSES => __PACKAGE__
	   } );

	   # Add the provider to the config
	   my $template = Template->new( {
	       # ...
	       LOAD_TEMPLATES => [ $provider ]
	   } );

	   # Render a template
	   $template->process( 'mytemplate', { bar => 'Bar' } );

	   # ...and now the templates

	   __DATA__

	   __mytemplate__
	   Foo [% bar %]

	   __myothertemplate__
	   Baz, [% qux %]?

DESCRIPTION

       This module allows you to store your templates inline with your code in the "__DATA__" section. It will search any number of classes
       specified.

CAVEAT

       If you have two templates with the same name, this module will not understand the difference, it will simply return the first one found. If
       you wish, you can specify a fully qualified template name by prefixing the template with the module name (using "-" instead of "::" as a
       namespace separator), adding a "/" to separate the module name from the template name.

	   $template->process( 'My-Templates/mytemplate', { bar => 'Bar' } );

INSTALLATION

	   perl Makefile.PL
	   make
	   make test
	   make install

METHODS

   new( \%OPTIONS )
       Create a new instance of the provider. You can specify a list of classes to be searched for templates via the "CLASSES" option. By omitting
       this option it will search "main".

	   # defaults to 'main'
	   $provider = Template::Provider::FromDATA->new;

	   # look for templates in 'Foo'
	   $provider = Template::Provider::FromDATA->new( {
	       CLASSES => 'Foo'
	   } );

	   # look for templates in 'Foo::Bar' and 'Foo::Baz'
	   $provider = Template::Provider::FromDATA->new( {
	       CLASSES => [ 'Foo::Bar', 'Foo::Baz' ]
	   } );

       By default, template data is lazy-loaded as they it is  requested. If you wish to load up all template data upon initializtion, you can use
       the "PRELOAD" option.

	   $provider = Template::Provider::FromDATA->new( {
	       PRELOAD => 1
	   } );

   _init( \%OPTIONS )
       A subclassed method to handle the options passed to "new()".

   fetch( $name )
       This is a subclassed method that will load a template via "_fetch()" if a non-reference argument is passed.

   _load( $name )
       Loads the template via the "get_file()" sub and sets some cache information.

   get_file( $class, $template )
       This method searches through $class for a template named $template. Returns the contents on success, undef on failure.

       This function was mostly borrowed from Catalyst::Helper's "get_file" function.

ACCESSORS

   classes
       An arrayref of the class names containing our templates.

   cache
       A hashref of file and template data.

AUTHOR

       Brian Cassidy <bricas@cpan.org>

COPYRIGHT AND LICENSE

       Copyright 2005-2011 by Brian Cassidy

       This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

perl v5.14.2							    2011-12-07					 Template::Provider::FromDATA(3pm)

Linux and UNIX Man Pages

templates2ada(1) [debian man page]

Check Out this Related Man Page