=======================
Context and Environment
=======================

The two central objects in Jinja are the `Environment` and `Context`. Both
are designed to be subclassed by applications if they need to extend Jinja.

Environment
===========

The initialization parameters are already covered in the `Quickstart`_ thus
not repeated here.

But beside those configurable instance variables there are some functions used
in the template evaluation code you may want to override:

**def** `parse` *(source, filename)*:

    Parse the sourcecode and return the abstract syntax tree. This tree of
    nodes is used by the `translators`_ to convert the template into
    executable source- or bytecode.

**def** `lex` *(source, filename)*:

    Tokenize the given sourcecode and return a generator of tuples in the
    form ``(lineno, token, value)``. The filename is just used in the
    exceptions raised.
    
    **New in Jinja 1.1**

**def** `from_string` *(source)*:

    Load and parse a template source and translate it into eval-able Python
    code. This code is wrapped within a `Template` class that allows you to
    render it.

**def** `get_template` *(name)*:

    Load a template from a loader. If the template does not exist, you will
    get a `jinja.exceptions.TemplateNotFound` exception.

**def** `to_unicode` *(self, value)*:

    Called to convert variables to unicode. Per default this checks if the
    value is already unicode. If not it's converted to unicode using the
    charset defined on the environment.

    Also `None` is converted into an empty string per default.

**def** `get_translator` *(self, context)*:

    Return the translator used for i18n. A translator is an object that
    provides the two functions ``gettext(string)`` and
    ``ngettext(singular, plural, n)``. Both of those functions have to
    behave like the `ugettext` and `nugettext` functions described in the
    python `gettext documentation`_.

    If you don't provide a translator a default one is used to switch
    between singular and plural forms.

    Have a look at the `i18n`_ section for more information.

**def** `get_translations` *(self, name)*:

    Get the translations for the template `name`. Only works if a loader
    is present. See the `i18n`_ section for more details.

**def** `get_translations_for_string` *(self, string)*:

    Get the translations for the string `string`. This works also if no
    loader is present and can be used to lookup translation strings from
    templates that are loaded from dynamic resources like databases.

**def** `apply_filters` *(self, value, context, filters)*:

    Now this function is a bit tricky and you usually don't have to override
    it. It's used to apply filters on a value. The Jinja expression
    ``{{ foo|escape|replace('a', 'b') }}`` calls the function with the
    value of `foo` as first parameter, the current context as second and
    a list of filters as third. The list looks like this:

    .. sourcecode:: python

        [('escape', ()), ('replace', (u'a', u'b'))]

    As you can see the filter `escape` is called without arguments whereas
    `replace` is called with the two literal strings ``a`` and ``b``, both
    unicode. The filters for the names are stored on ``self.filters`` in a
    dict. Missing filters should raise a `FilterNotFound` exception.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.

**def** `perform_test` *(self, context, testname, args, value, invert)*:

    Like `apply_filters` you usually don't override this one. It's the
    callback function for tests (``foo is bar`` / ``foo is not bar``).

    The first parameter is the current contex, the second the name of
    the test to perform. the third a tuple of arguments, the fourth is
    the value to test. The last one is `True` if the test was performed
    with the `is not` operator, `False` if with the `is` operator.

    Missing tests should raise a `TestNotFound` exception.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.

**def** `get_attribute` *(self, obj, attribute)*:

    Get `attribute` from the object provided. The default implementation
    performs security tests.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.

**def** `get_attributes` *(self, obj, attributes)*:

    Get some attributes from the object. If `attributes` is an empty
    sequence the object itself is returned unchanged.

**def** `call_function` *(self, f, context, args, kwargs, dyn_args, dyn_kwargs)*:
    
    Call a function `f` with the arguments `args`, `kwargs`, `dyn_args` and
    `dyn_kwargs` where `args` is a tuple and `kwargs` a dict. If `dyn_args`
    is not `None` you have to add it to the arguments, if `dyn_kwargs` is
    not `None` you have to update the `kwargs` with it.

    The default implementation performs some security checks.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.

**def** `call_function_simple` *(self, f, context)*:

    Like `call_function` but without arguments.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.

**def** `finish_var` *(self, value, ctx)*:

    Postprocess a variable before it's sent to the template.

    **Warning** this is a Jinja internal method. The actual implementation
    and function signature might change.
    
.. admonition:: Note

    The Enviornment class is defined in `jinja.environment.Environment`
    but imported into the `jinja` package because it's often used.

Context
=======

Jinja wraps the variables passed to the template in a special class called a
context. This context supports variables on multiple layers and lazy (deferred)
objects. Often your application has a request object, database connection
object or something similar you want to access in filters, functions etc.

The default context object is defined in `jinja.datastructure`. If you want
to provide your own context object always subclass the default one. This
ensures that the class continues working after Jinja upgrades.

Beacause of that you can easily subclass a context to add additional variables
or to change the way it behaves.

**def** `pop` *(self)*:

    Pop the outermost layer and return it.

**def** `push` *(self, data=None)*:

    Push a dict to the stack or an empty layer.

    Has to return the pushed object.

**def** `to_dict` *(self)*:

    Flatten the context and convert it into a dict.

**def** `__getitem__` *(self, name)*:

    Resolve an item. Per default this also resolves `Deferred` objects.

**def** `__setitem__` *(self, name, value)*:

    Set an item in the outermost layer.

**def** `__delitem__` *(self, name)*:

    Delete an item in the outermost layer. Do not raise exceptions if
    the value does not exist.

**def** `__contains__` *(self, name)*:

    Return `True` if `name` exists in the context.

**attribute** `cache`:

    The cache is a dict which can be used by filters, test functions
    and global objects to cache data. It's also used by the environment
    to cache often used tests and filters.

**attribute** `translate_func`:

    This property is created on first access and returns a translation
    function used by the rendering process to translate strings with the
    translator defined on the environment.

.. admonition:: Note

    The context uses a stack of dicts internally to represent the
    layers of variables. It contains at least 3 levels available on
    the context with some attributes. Those are:

    `globals`:
        
        The reference to the global namespace of the environment.
        It's the lowest namespace on the stack and thus immutable

    `initial`:

        The initial namespace. Contains the values passed to the
        context in the render function. It also contains the resolved
        deferred values for bot the `initial` and the `globals`
        namespace.

    `current`:

        The reference to the current active namespace. When the
        context is initialized this automatically points to an
        empty namespace.

    The number of layers on the stack are theoretically unlimited.
    Some elements in the template language like loops, blocks,
    macros and others push and pop the layer on entering and leaving
    the section.

    This is done in order to keep the namespace clean.

    Note that since Jinja 1.1 the context object is a subclass of the
    `BaseContext`, a much simpler class that just implements a stack
    like namespace for python. If the `_speedups` extension was
    compiled for jinja the base class will be
    `jinja._speedups.BaseContext` otherwise `jinja._native.BaseContext`.

    Since you cannot reproduce completely the same semantics in python
    and the C API there are some things you should keep in mind:

    -   The `stack` attribute of the context maps to the real layers
        on the stack, thus you can modify the items but the list as
        such is meant to be read only.

    -   `globals`, `current` and `initial` are read only attributes that
        map to layers on the stack which you can of course modify.


Exceptions
==========

During parsing and evaluation Jinja raises a couple of Jinja specific
exceptions. All of those exceptions are defined in the `jinja.exceptions`
module and are subclasses of the `TemplateError` class defined there.

Here a list of exceptions that could occur:

`SecurityException`:

    An exception that is raised if the template tried to access something
    it should not access. In the default configuration this exception
    will get caught in the Jinja rendering process and silenced.

    If however the environment is configured to not silently fail it
    could happen that this exception reaches the application.

`FilterNotFound`:

    Raised if the template tried to apply a filter that does not exist.
    Since this exception is a subclass of `KeyError` too you can catch
    it this way too.

`FilterArgumentError`:

    Raised if the filter received an argument that it couldn't handle.
    It's a subclass of `TypeError` too so you can catch it this way too.

`TestNotFound`:

    Raised if the template tried to perform a test that does not exist.
    Since this exception is a subclass of `KeyError` too you can catch
    it this way too.

`TestArgumentError`:

    Raised if a test function received an argument that it couldn't handle.
    It's a subclass of `TypeError` too so you can catch it this way too.

`TemplateNotFound`:

    Raised if a template does not exist. Subclass of `IOError` too.

`TemplateSyntaxError`:

    Subclass of `SyntaxError` and used to indicate an syntax error.

`TemplateRuntimeError`:

    Generic runtime error exception which can occour at various places.


.. _i18n: i18n.txt
.. _translators: translators.txt
.. _Quickstart: devintro.txt
.. _gettext documentation: http://docs.python.org/lib/module-gettext.html
