A reference to a hash array explicitly mapping internal variable names to external Perl modules. This can be used to override and/or augment the variable modules that the factory would normally be able to locate automatically.

my $variables = Template::TT3::Variables->new(
    variables => {
        foo => 'Some::Other::Variable::Foo',
        bar => 'Yet::Another::Variable::Bar'
    },
);

A reference to a list of module namespaces that the factory should search to locate variable modules. The default path is defined by the $PATH package variable.

my $variables = Template::TT3::Variables->new(
    variable_path => [
        'My::Variable', 'Template::TT3::Variable'
    ],
);

A reference to a hash array providing aliases for variable names.

my $variables = Template::TT3::Variables->new(
    variable_names => {
        FOO => 'foo',
        bar => 'foo',
    },
);

Locates and loads a variable module and returns the class name. This is created as an alias to the item() method in Badger::Factory .

Note that the method doesn't automatically create a new variable object as most factory modules do. TT uses this module to define constructor functions (via the constructors() method) which create objectm but not for creating instances of the variable objects directly.

Method for inspecting or modifying the variable type that the factory module manages. This is created as an alias to the items() method in Badger::Factory .

Returns a reference to a hash array containing constructor functions for the variables types specified as argument(s), along with any builtin() variable types.

    # default set of constructors
    my $ctors = Template::TT3::Variables->constructors;

    # customised set
    my $ctors = Template::TT3::Variables->constructors(
        undef => 'missing',                 # map data types
        text  => {                          # add virtual methods
            foo => sub { ... },             # to inbuilt data types
            bar => sub { ... },
        },
        'Wiz::Bang' => {                    # define custom object maps
            '*'   => 0,                     # don't call methods by default
            'foo' => 1,                     # do call foo() method
            'bar' => sub { ... },           # virtual method
        }
    );

This method loads all the builtin variable types and returns a reference to a hash array mapping their internal names (e.g. text, list, etc) to their external module names (e.g. Template::TT3::Variable::Text , Template::TT3::Variable::List , etc).

This replaces the default method inherited from the Badger::Factory base class. Instead of automatically creating an object when the variable() method is called, it instead returns the class name of the module implementing it.

This is the name of the item that the factory module returns. In this case it is defined as variable.

This defines the module search path for the factory. In this case it is defined as a list of the following values;

Template::TT3::Variable
Template::Variable
TemplateX::TT3::Variable
TemplateX::Variable