|
+ +----------------------------------------------------------------------+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_twig.h"
+#include "ext/standard/php_var.h"
+#include "ext/standard/php_string.h"
+#include "ext/standard/php_smart_str.h"
+#include "ext/spl/spl_exceptions.h"
+
+#include "Zend/zend_object_handlers.h"
+#include "Zend/zend_interfaces.h"
+#include "Zend/zend_exceptions.h"
+
+#ifndef Z_ADDREF_P
+#define Z_ADDREF_P(pz) (pz)->refcount++
+#endif
+
+#define FREE_DTOR(z) \
+ zval_dtor(z); \
+ efree(z);
+
+#if PHP_VERSION_ID >= 50300
+ #define APPLY_TSRMLS_DC TSRMLS_DC
+ #define APPLY_TSRMLS_CC TSRMLS_CC
+ #define APPLY_TSRMLS_FETCH()
+#else
+ #define APPLY_TSRMLS_DC
+ #define APPLY_TSRMLS_CC
+ #define APPLY_TSRMLS_FETCH() TSRMLS_FETCH()
+#endif
+
+ZEND_BEGIN_ARG_INFO_EX(twig_template_get_attribute_args, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 6)
+ ZEND_ARG_INFO(0, template)
+ ZEND_ARG_INFO(0, object)
+ ZEND_ARG_INFO(0, item)
+ ZEND_ARG_INFO(0, arguments)
+ ZEND_ARG_INFO(0, type)
+ ZEND_ARG_INFO(0, isDefinedTest)
+ZEND_END_ARG_INFO()
+
+#ifndef PHP_FE_END
+#define PHP_FE_END { NULL, NULL, NULL, 0, 0 }
+#endif
+
+static const zend_function_entry twig_functions[] = {
+ PHP_FE(twig_template_get_attributes, twig_template_get_attribute_args)
+ PHP_FE_END
+};
+
+PHP_RSHUTDOWN_FUNCTION(twig)
+{
+#if ZEND_DEBUG
+ CG(unclean_shutdown) = 0; /* get rid of PHPUnit's exit() and report memleaks */
+#endif
+ return SUCCESS;
+}
+
+zend_module_entry twig_module_entry = {
+ STANDARD_MODULE_HEADER,
+ "twig",
+ twig_functions,
+ NULL,
+ NULL,
+ NULL,
+ PHP_RSHUTDOWN(twig),
+ NULL,
+ PHP_TWIG_VERSION,
+ STANDARD_MODULE_PROPERTIES
+};
+
+
+#ifdef COMPILE_DL_TWIG
+ZEND_GET_MODULE(twig)
+#endif
+
+static int TWIG_ARRAY_KEY_EXISTS(zval *array, zval *key)
+{
+ if (Z_TYPE_P(array) != IS_ARRAY) {
+ return 0;
+ }
+
+ switch (Z_TYPE_P(key)) {
+ case IS_NULL:
+ return zend_hash_exists(Z_ARRVAL_P(array), "", 1);
+
+ case IS_BOOL:
+ case IS_DOUBLE:
+ convert_to_long(key);
+ case IS_LONG:
+ return zend_hash_index_exists(Z_ARRVAL_P(array), Z_LVAL_P(key));
+
+ default:
+ convert_to_string(key);
+ return zend_symtable_exists(Z_ARRVAL_P(array), Z_STRVAL_P(key), Z_STRLEN_P(key) + 1);
+ }
+}
+
+static int TWIG_INSTANCE_OF(zval *object, zend_class_entry *interface TSRMLS_DC)
+{
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return 0;
+ }
+ return instanceof_function(Z_OBJCE_P(object), interface TSRMLS_CC);
+}
+
+static int TWIG_INSTANCE_OF_USERLAND(zval *object, char *interface TSRMLS_DC)
+{
+ zend_class_entry **pce;
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return 0;
+ }
+ if (zend_lookup_class(interface, strlen(interface), &pce TSRMLS_CC) == FAILURE) {
+ return 0;
+ }
+ return instanceof_function(Z_OBJCE_P(object), *pce TSRMLS_CC);
+}
+
+static zval *TWIG_GET_ARRAYOBJECT_ELEMENT(zval *object, zval *offset TSRMLS_DC)
+{
+ zend_class_entry *ce = Z_OBJCE_P(object);
+ zval *retval;
+
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ SEPARATE_ARG_IF_REF(offset);
+ zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
+
+ zval_ptr_dtor(&offset);
+
+ if (!retval) {
+ if (!EG(exception)) {
+ zend_error(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
+ }
+ return NULL;
+ }
+
+ return retval;
+ }
+ return NULL;
+}
+
+static int TWIG_ISSET_ARRAYOBJECT_ELEMENT(zval *object, zval *offset TSRMLS_DC)
+{
+ zend_class_entry *ce = Z_OBJCE_P(object);
+ zval *retval;
+
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ SEPARATE_ARG_IF_REF(offset);
+ zend_call_method_with_1_params(&object, ce, NULL, "offsetexists", &retval, offset);
+
+ zval_ptr_dtor(&offset);
+
+ if (!retval) {
+ if (!EG(exception)) {
+ zend_error(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
+ }
+ return 0;
+ }
+
+ return (retval && Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval));
+ }
+ return 0;
+}
+
+static char *TWIG_STRTOLOWER(const char *str, int str_len)
+{
+ char *item_dup;
+
+ item_dup = estrndup(str, str_len);
+ php_strtolower(item_dup, str_len);
+ return item_dup;
+}
+
+static zval *TWIG_CALL_USER_FUNC_ARRAY(zval *object, char *function, zval *arguments TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval ***args = NULL;
+ int arg_count = 0;
+ HashTable *table;
+ HashPosition pos;
+ int i = 0;
+ zval *retval_ptr;
+ zval *zfunction;
+
+ if (arguments) {
+ table = HASH_OF(arguments);
+ args = safe_emalloc(sizeof(zval **), table->nNumOfElements, 0);
+
+ zend_hash_internal_pointer_reset_ex(table, &pos);
+
+ while (zend_hash_get_current_data_ex(table, (void **)&args[i], &pos) == SUCCESS) {
+ i++;
+ zend_hash_move_forward_ex(table, &pos);
+ }
+ arg_count = table->nNumOfElements;
+ }
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, function, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = arg_count;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ ALLOC_INIT_ZVAL(retval_ptr);
+ ZVAL_BOOL(retval_ptr, 0);
+ }
+
+ if (args) {
+ efree(fci.params);
+ }
+ FREE_DTOR(zfunction);
+ return retval_ptr;
+}
+
+static int TWIG_CALL_BOOLEAN(zval *object, char *functionName TSRMLS_DC)
+{
+ zval *ret;
+ int res;
+
+ ret = TWIG_CALL_USER_FUNC_ARRAY(object, functionName, NULL TSRMLS_CC);
+ res = Z_LVAL_P(ret);
+ zval_ptr_dtor(&ret);
+ return res;
+}
+
+static zval *TWIG_GET_STATIC_PROPERTY(zval *class, char *prop_name TSRMLS_DC)
+{
+ zval **tmp_zval;
+ zend_class_entry *ce;
+
+ if (class == NULL || Z_TYPE_P(class) != IS_OBJECT) {
+ return NULL;
+ }
+
+ ce = zend_get_class_entry(class TSRMLS_CC);
+#if PHP_VERSION_ID >= 50400
+ tmp_zval = zend_std_get_static_property(ce, prop_name, strlen(prop_name), 0, NULL TSRMLS_CC);
+#else
+ tmp_zval = zend_std_get_static_property(ce, prop_name, strlen(prop_name), 0 TSRMLS_CC);
+#endif
+ return *tmp_zval;
+}
+
+static zval *TWIG_GET_ARRAY_ELEMENT_ZVAL(zval *class, zval *prop_name TSRMLS_DC)
+{
+ zval **tmp_zval;
+
+ if (class == NULL || Z_TYPE_P(class) != IS_ARRAY) {
+ if (class != NULL && Z_TYPE_P(class) == IS_OBJECT && TWIG_INSTANCE_OF(class, zend_ce_arrayaccess TSRMLS_CC)) {
+ // array access object
+ return TWIG_GET_ARRAYOBJECT_ELEMENT(class, prop_name TSRMLS_CC);
+ }
+ return NULL;
+ }
+
+ switch(Z_TYPE_P(prop_name)) {
+ case IS_NULL:
+ zend_hash_find(HASH_OF(class), "", 1, (void**) &tmp_zval);
+ return *tmp_zval;
+
+ case IS_BOOL:
+ case IS_DOUBLE:
+ convert_to_long(prop_name);
+ case IS_LONG:
+ zend_hash_index_find(HASH_OF(class), Z_LVAL_P(prop_name), (void **) &tmp_zval);
+ return *tmp_zval;
+
+ case IS_STRING:
+ zend_symtable_find(HASH_OF(class), Z_STRVAL_P(prop_name), Z_STRLEN_P(prop_name) + 1, (void**) &tmp_zval);
+ return *tmp_zval;
+ }
+
+ return NULL;
+}
+
+static zval *TWIG_GET_ARRAY_ELEMENT(zval *class, char *prop_name, int prop_name_length TSRMLS_DC)
+{
+ zval **tmp_zval;
+
+ if (class == NULL/* || Z_TYPE_P(class) != IS_ARRAY*/) {
+ return NULL;
+ }
+
+ if (class != NULL && Z_TYPE_P(class) == IS_OBJECT && TWIG_INSTANCE_OF(class, zend_ce_arrayaccess TSRMLS_CC)) {
+ // array access object
+ zval *tmp_name_zval;
+ zval *tmp_ret_zval;
+
+ ALLOC_INIT_ZVAL(tmp_name_zval);
+ ZVAL_STRING(tmp_name_zval, prop_name, 1);
+ tmp_ret_zval = TWIG_GET_ARRAYOBJECT_ELEMENT(class, tmp_name_zval TSRMLS_CC);
+ FREE_DTOR(tmp_name_zval);
+ return tmp_ret_zval;
+ }
+
+ if (zend_symtable_find(HASH_OF(class), prop_name, prop_name_length+1, (void**)&tmp_zval) == SUCCESS) {
+ return *tmp_zval;
+ }
+ return NULL;
+}
+
+static zval *TWIG_PROPERTY(zval *object, zval *propname TSRMLS_DC)
+{
+ zval *tmp = NULL;
+
+ if (Z_OBJ_HT_P(object)->read_property) {
+#if PHP_VERSION_ID >= 50400
+ tmp = Z_OBJ_HT_P(object)->read_property(object, propname, BP_VAR_IS, NULL TSRMLS_CC);
+#else
+ tmp = Z_OBJ_HT_P(object)->read_property(object, propname, BP_VAR_IS TSRMLS_CC);
+#endif
+ if (tmp == EG(uninitialized_zval_ptr)) {
+ ZVAL_NULL(tmp);
+ }
+ }
+ return tmp;
+}
+
+static int TWIG_HAS_PROPERTY(zval *object, zval *propname TSRMLS_DC)
+{
+ if (Z_OBJ_HT_P(object)->has_property) {
+#if PHP_VERSION_ID >= 50400
+ return Z_OBJ_HT_P(object)->has_property(object, propname, 0, NULL TSRMLS_CC);
+#else
+ return Z_OBJ_HT_P(object)->has_property(object, propname, 0 TSRMLS_CC);
+#endif
+ }
+ return 0;
+}
+
+static int TWIG_HAS_DYNAMIC_PROPERTY(zval *object, char *prop, int prop_len TSRMLS_DC)
+{
+ if (Z_OBJ_HT_P(object)->get_properties) {
+ return zend_hash_quick_exists(
+ Z_OBJ_HT_P(object)->get_properties(object TSRMLS_CC), // the properties hash
+ prop, // property name
+ prop_len + 1, // property length
+ zend_get_hash_value(prop, prop_len + 1) // hash value
+ );
+ }
+ return 0;
+}
+
+static zval *TWIG_PROPERTY_CHAR(zval *object, char *propname TSRMLS_DC)
+{
+ zval *tmp_name_zval, *tmp;
+
+ ALLOC_INIT_ZVAL(tmp_name_zval);
+ ZVAL_STRING(tmp_name_zval, propname, 1);
+ tmp = TWIG_PROPERTY(object, tmp_name_zval TSRMLS_CC);
+ FREE_DTOR(tmp_name_zval);
+ return tmp;
+}
+
+static zval *TWIG_CALL_S(zval *object, char *method, char *arg0 TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval **args[1];
+ zval *argument;
+ zval *zfunction;
+ zval *retval_ptr;
+
+ MAKE_STD_ZVAL(argument);
+ ZVAL_STRING(argument, arg0, 1);
+ args[0] = &argument;
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, method, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = 1;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ FREE_DTOR(zfunction);
+ zval_ptr_dtor(&argument);
+ return 0;
+ }
+ FREE_DTOR(zfunction);
+ zval_ptr_dtor(&argument);
+ return retval_ptr;
+}
+
+static int TWIG_CALL_SB(zval *object, char *method, char *arg0 TSRMLS_DC)
+{
+ zval *retval_ptr;
+ int success;
+
+ retval_ptr = TWIG_CALL_S(object, method, arg0 TSRMLS_CC);
+ success = (retval_ptr && (Z_TYPE_P(retval_ptr) == IS_BOOL) && Z_LVAL_P(retval_ptr));
+
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+
+ return success;
+}
+
+static int TWIG_CALL_ZZ(zval *object, char *method, zval *arg1, zval *arg2 TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval **args[2];
+ zval *zfunction;
+ zval *retval_ptr;
+ int success;
+
+ args[0] = &arg1;
+ args[1] = &arg2;
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, method, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = 2;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ FREE_DTOR(zfunction);
+ return 0;
+ }
+
+ FREE_DTOR(zfunction);
+
+ success = (retval_ptr && (Z_TYPE_P(retval_ptr) == IS_BOOL) && Z_LVAL_P(retval_ptr));
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+
+ return success;
+}
+
+#ifndef Z_SET_REFCOUNT_P
+# define Z_SET_REFCOUNT_P(pz, rc) pz->refcount = rc
+# define Z_UNSET_ISREF_P(pz) pz->is_ref = 0
+#endif
+
+static void TWIG_NEW(zval *object, char *class, zval *arg0, zval *arg1 TSRMLS_DC)
+{
+ zend_class_entry **pce;
+
+ if (zend_lookup_class(class, strlen(class), &pce TSRMLS_CC) == FAILURE) {
+ return;
+ }
+
+ Z_TYPE_P(object) = IS_OBJECT;
+ object_init_ex(object, *pce);
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_UNSET_ISREF_P(object);
+
+ TWIG_CALL_ZZ(object, "__construct", arg0, arg1 TSRMLS_CC);
+}
+
+static int twig_add_array_key_to_string(void *pDest APPLY_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ smart_str *buf;
+ char *joiner;
+ APPLY_TSRMLS_FETCH();
+
+ buf = va_arg(args, smart_str*);
+ joiner = va_arg(args, char*);
+
+ if (buf->len != 0) {
+ smart_str_appends(buf, joiner);
+ }
+
+ if (hash_key->nKeyLength == 0) {
+ smart_str_append_long(buf, (long) hash_key->h);
+ } else {
+ char *key, *tmp_str;
+ int key_len, tmp_len;
+ key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
+ tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
+
+ smart_str_appendl(buf, tmp_str, tmp_len);
+ efree(key);
+ efree(tmp_str);
+ }
+
+ return 0;
+}
+
+static char *TWIG_IMPLODE_ARRAY_KEYS(char *joiner, zval *array TSRMLS_DC)
+{
+ smart_str collector = { 0, 0, 0 };
+
+ smart_str_appendl(&collector, "", 0);
+ zend_hash_apply_with_arguments(HASH_OF(array) APPLY_TSRMLS_CC, twig_add_array_key_to_string, 2, &collector, joiner);
+ smart_str_0(&collector);
+
+ return collector.c;
+}
+
+static void TWIG_RUNTIME_ERROR(zval *template TSRMLS_DC, char *message, ...)
+{
+ char *buffer;
+ va_list args;
+ zend_class_entry **pce;
+ zval *ex;
+ zval *constructor;
+ zval *zmessage;
+ zval *lineno;
+ zval *filename_func;
+ zval *filename;
+ zval *constructor_args[3];
+ zval *constructor_retval;
+
+ if (zend_lookup_class("Twig_Error_Runtime", strlen("Twig_Error_Runtime"), &pce TSRMLS_CC) == FAILURE) {
+ return;
+ }
+
+ va_start(args, message);
+ vspprintf(&buffer, 0, message, args);
+ va_end(args);
+
+ MAKE_STD_ZVAL(ex);
+ object_init_ex(ex, *pce);
+
+ // Call Twig_Error constructor
+ MAKE_STD_ZVAL(constructor);
+ MAKE_STD_ZVAL(zmessage);
+ MAKE_STD_ZVAL(lineno);
+ MAKE_STD_ZVAL(filename);
+ MAKE_STD_ZVAL(filename_func);
+ MAKE_STD_ZVAL(constructor_retval);
+
+ ZVAL_STRINGL(constructor, "__construct", sizeof("__construct")-1, 1);
+ ZVAL_STRING(zmessage, buffer, 1);
+ ZVAL_LONG(lineno, -1);
+
+ // Get template filename
+ ZVAL_STRINGL(filename_func, "getTemplateName", sizeof("getTemplateName")-1, 1);
+ call_user_function(EG(function_table), &template, filename_func, filename, 0, 0 TSRMLS_CC);
+
+ constructor_args[0] = zmessage;
+ constructor_args[1] = lineno;
+ constructor_args[2] = filename;
+ call_user_function(EG(function_table), &ex, constructor, constructor_retval, 3, constructor_args TSRMLS_CC);
+
+ zval_ptr_dtor(&constructor_retval);
+ zval_ptr_dtor(&zmessage);
+ zval_ptr_dtor(&lineno);
+ zval_ptr_dtor(&filename);
+ FREE_DTOR(constructor);
+ FREE_DTOR(filename_func);
+ efree(buffer);
+
+ zend_throw_exception_object(ex TSRMLS_CC);
+}
+
+static char *TWIG_GET_CLASS_NAME(zval *object TSRMLS_DC)
+{
+ char *class_name;
+ zend_uint class_name_len;
+
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return "";
+ }
+#if PHP_API_VERSION >= 20100412
+ zend_get_object_classname(object, (const char **) &class_name, &class_name_len TSRMLS_CC);
+#else
+ zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
+#endif
+ return class_name;
+}
+
+static int twig_add_method_to_class(void *pDest APPLY_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zval *retval;
+ char *item;
+ size_t item_len;
+ zend_function *mptr = (zend_function *) pDest;
+ APPLY_TSRMLS_FETCH();
+
+ if (!(mptr->common.fn_flags & ZEND_ACC_PUBLIC)) {
+ return 0;
+ }
+
+ retval = va_arg(args, zval*);
+
+ item_len = strlen(mptr->common.function_name);
+ item = estrndup(mptr->common.function_name, item_len);
+ php_strtolower(item, item_len);
+
+ add_assoc_stringl_ex(retval, item, item_len+1, item, item_len, 0);
+
+ return 0;
+}
+
+static int twig_add_property_to_class(void *pDest APPLY_TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zend_class_entry *ce;
+ zval *retval;
+ char *class_name, *prop_name;
+ zend_property_info *pptr = (zend_property_info *) pDest;
+ APPLY_TSRMLS_FETCH();
+
+ if (!(pptr->flags & ZEND_ACC_PUBLIC) || (pptr->flags & ZEND_ACC_STATIC)) {
+ return 0;
+ }
+
+ ce = *va_arg(args, zend_class_entry**);
+ retval = va_arg(args, zval*);
+
+#if PHP_API_VERSION >= 20100412
+ zend_unmangle_property_name(pptr->name, pptr->name_length, (const char **) &class_name, (const char **) &prop_name);
+#else
+ zend_unmangle_property_name(pptr->name, pptr->name_length, &class_name, &prop_name);
+#endif
+
+ add_assoc_string(retval, prop_name, prop_name, 1);
+
+ return 0;
+}
+
+static void twig_add_class_to_cache(zval *cache, zval *object, char *class_name TSRMLS_DC)
+{
+ zval *class_info, *class_methods, *class_properties;
+ zend_class_entry *class_ce;
+
+ class_ce = zend_get_class_entry(object TSRMLS_CC);
+
+ ALLOC_INIT_ZVAL(class_info);
+ ALLOC_INIT_ZVAL(class_methods);
+ ALLOC_INIT_ZVAL(class_properties);
+ array_init(class_info);
+ array_init(class_methods);
+ array_init(class_properties);
+ // add all methods to self::cache[$class]['methods']
+ zend_hash_apply_with_arguments(&class_ce->function_table APPLY_TSRMLS_CC, twig_add_method_to_class, 1, class_methods);
+ zend_hash_apply_with_arguments(&class_ce->properties_info APPLY_TSRMLS_CC, twig_add_property_to_class, 2, &class_ce, class_properties);
+
+ add_assoc_zval(class_info, "methods", class_methods);
+ add_assoc_zval(class_info, "properties", class_properties);
+ add_assoc_zval(cache, class_name, class_info);
+}
+
+/* {{{ proto mixed twig_template_get_attributes(TwigTemplate template, mixed object, mixed item, array arguments, string type, boolean isDefinedTest, boolean ignoreStrictCheck)
+ A C implementation of TwigTemplate::getAttribute() */
+PHP_FUNCTION(twig_template_get_attributes)
+{
+ zval *template;
+ zval *object;
+ char *item;
+ int item_len;
+ zval *zitem, ztmpitem;
+ zval *arguments = NULL;
+ zval *ret = NULL;
+ char *type = NULL;
+ int type_len = 0;
+ zend_bool isDefinedTest = 0;
+ zend_bool ignoreStrictCheck = 0;
+ int free_ret = 0;
+ zval *tmp_self_cache;
+ char *class_name = NULL;
+ zval *tmp_class;
+ char *type_name;
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ozz|asbb", &template, &object, &zitem, &arguments, &type, &type_len, &isDefinedTest, &ignoreStrictCheck) == FAILURE) {
+ return;
+ }
+
+ // convert the item to a string
+ ztmpitem = *zitem;
+ zval_copy_ctor(&ztmpitem);
+ convert_to_string(&ztmpitem);
+ item_len = Z_STRLEN(ztmpitem);
+ item = estrndup(Z_STRVAL(ztmpitem), item_len);
+ zval_dtor(&ztmpitem);
+
+ if (!type) {
+ type = "any";
+ }
+
+/*
+ // array
+ if (Twig_Template::METHOD_CALL !== $type) {
+ $arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
+
+ if ((is_array($object) && array_key_exists($arrayItem, $object))
+ || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
+ ) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ return $object[$arrayItem];
+ }
+*/
+
+
+ if (strcmp("method", type) != 0) {
+ if ((TWIG_ARRAY_KEY_EXISTS(object, zitem))
+ || (TWIG_INSTANCE_OF(object, zend_ce_arrayaccess TSRMLS_CC) && TWIG_ISSET_ARRAYOBJECT_ELEMENT(object, zitem TSRMLS_CC))
+ ) {
+
+ if (isDefinedTest) {
+ efree(item);
+ RETURN_TRUE;
+ }
+
+ ret = TWIG_GET_ARRAY_ELEMENT_ZVAL(object, zitem TSRMLS_CC);
+
+ if (!ret) {
+ ret = &EG(uninitialized_zval);
+ }
+ RETVAL_ZVAL(ret, 1, 0);
+ if (free_ret) {
+ zval_ptr_dtor(&ret);
+ }
+ efree(item);
+ return;
+ }
+/*
+ if (Twig_Template::ARRAY_CALL === $type) {
+ if ($isDefinedTest) {
+ return false;
+ }
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+*/
+ if (strcmp("array", type) == 0 || Z_TYPE_P(object) != IS_OBJECT) {
+ if (isDefinedTest) {
+ efree(item);
+ RETURN_FALSE;
+ }
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ efree(item);
+ return;
+ }
+/*
+ if ($object instanceof ArrayAccess) {
+ $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist', $arrayItem, get_class($object));
+ } elseif (is_object($object)) {
+ $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface', $item, get_class($object));
+ } elseif (is_array($object)) {
+ if (empty($object)) {
+ $message = sprintf('Key "%s" does not exist as the array is empty', $arrayItem);
+ } else {
+ $message = sprintf('Key "%s" for array with keys "%s" does not exist', $arrayItem, implode(', ', array_keys($object)));
+ }
+ } elseif (Twig_Template::ARRAY_CALL === $type) {
+ if (null === $object) {
+ $message = sprintf('Impossible to access a key ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+ } elseif (null === $object) {
+ $message = sprintf('Impossible to access an attribute ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+ throw new Twig_Error_Runtime($message, -1, $this->getTemplateName());
+ }
+ }
+*/
+ if (TWIG_INSTANCE_OF(object, zend_ce_arrayaccess TSRMLS_CC)) {
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Key \"%s\" in object with ArrayAccess of class \"%s\" does not exist", item, TWIG_GET_CLASS_NAME(object TSRMLS_CC));
+ } else if (Z_TYPE_P(object) == IS_OBJECT) {
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Impossible to access a key \"%s\" on an object of class \"%s\" that does not implement ArrayAccess interface", item, TWIG_GET_CLASS_NAME(object TSRMLS_CC));
+ } else if (Z_TYPE_P(object) == IS_ARRAY) {
+ if (0 == zend_hash_num_elements(Z_ARRVAL_P(object))) {
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Key \"%s\" does not exist as the array is empty", item);
+ } else {
+ char *array_keys = TWIG_IMPLODE_ARRAY_KEYS(", ", object TSRMLS_CC);
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Key \"%s\" for array with keys \"%s\" does not exist", item, array_keys);
+ efree(array_keys);
+ }
+ } else {
+ char *type_name = zend_zval_type_name(object);
+ Z_ADDREF_P(object);
+ if (Z_TYPE_P(object) == IS_NULL) {
+ convert_to_string(object);
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC,
+ (strcmp("array", type) == 0)
+ ? "Impossible to access a key (\"%s\") on a %s variable"
+ : "Impossible to access an attribute (\"%s\") on a %s variable",
+ item, type_name);
+ } else {
+ convert_to_string(object);
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC,
+ (strcmp("array", type) == 0)
+ ? "Impossible to access a key (\"%s\") on a %s variable (\"%s\")"
+ : "Impossible to access an attribute (\"%s\") on a %s variable (\"%s\")",
+ item, type_name, Z_STRVAL_P(object));
+ }
+ zval_ptr_dtor(&object);
+ }
+ efree(item);
+ return;
+ }
+ }
+
+/*
+ if (!is_object($object)) {
+ if ($isDefinedTest) {
+ return false;
+ }
+*/
+
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ if (isDefinedTest) {
+ efree(item);
+ RETURN_FALSE;
+ }
+/*
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ if (null === $object) {
+ $message = sprintf('Impossible to invoke a method ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+
+ throw new Twig_Error_Runtime($message, -1, $this->getTemplateName());
+ }
+*/
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ efree(item);
+ return;
+ }
+
+ type_name = zend_zval_type_name(object);
+ Z_ADDREF_P(object);
+ if (Z_TYPE_P(object) == IS_NULL) {
+ convert_to_string_ex(&object);
+
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Impossible to invoke a method (\"%s\") on a %s variable", item, type_name);
+ } else {
+ convert_to_string_ex(&object);
+
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Impossible to invoke a method (\"%s\") on a %s variable (\"%s\")", item, type_name, Z_STRVAL_P(object));
+ }
+
+ zval_ptr_dtor(&object);
+ efree(item);
+ return;
+ }
+/*
+ $class = get_class($object);
+*/
+
+ class_name = TWIG_GET_CLASS_NAME(object TSRMLS_CC);
+ tmp_self_cache = TWIG_GET_STATIC_PROPERTY(template, "cache" TSRMLS_CC);
+ tmp_class = TWIG_GET_ARRAY_ELEMENT(tmp_self_cache, class_name, strlen(class_name) TSRMLS_CC);
+
+ if (!tmp_class) {
+ twig_add_class_to_cache(tmp_self_cache, object, class_name TSRMLS_CC);
+ tmp_class = TWIG_GET_ARRAY_ELEMENT(tmp_self_cache, class_name, strlen(class_name) TSRMLS_CC);
+ }
+ efree(class_name);
+
+/*
+ // object property
+ if (Twig_Template::METHOD_CALL !== $type) {
+ if (isset($object->$item) || array_key_exists((string) $item, $object)) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
+ }
+
+ return $object->$item;
+ }
+ }
+*/
+ if (strcmp("method", type) != 0) {
+ zval *tmp_properties, *tmp_item;
+
+ tmp_properties = TWIG_GET_ARRAY_ELEMENT(tmp_class, "properties", strlen("properties") TSRMLS_CC);
+ tmp_item = TWIG_GET_ARRAY_ELEMENT(tmp_properties, item, item_len TSRMLS_CC);
+
+ if (tmp_item || TWIG_HAS_PROPERTY(object, zitem TSRMLS_CC) || TWIG_HAS_DYNAMIC_PROPERTY(object, item, item_len TSRMLS_CC)) {
+ if (isDefinedTest) {
+ efree(item);
+ RETURN_TRUE;
+ }
+ if (TWIG_CALL_SB(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "hasExtension", "sandbox" TSRMLS_CC)) {
+ TWIG_CALL_ZZ(TWIG_CALL_S(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getExtension", "sandbox" TSRMLS_CC), "checkPropertyAllowed", object, zitem TSRMLS_CC);
+ }
+ if (EG(exception)) {
+ efree(item);
+ return;
+ }
+
+ ret = TWIG_PROPERTY(object, zitem TSRMLS_CC);
+ efree(item);
+ RETURN_ZVAL(ret, 1, 0);
+ }
+ }
+/*
+ // object method
+ if (!isset(self::$cache[$class]['methods'])) {
+ self::$cache[$class]['methods'] = array_change_key_case(array_flip(get_class_methods($object)));
+ }
+
+ $call = false;
+ $lcItem = strtolower($item);
+ if (isset(self::$cache[$class]['methods'][$lcItem])) {
+ $method = (string) $item;
+ } elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
+ $method = 'get'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
+ $method = 'is'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['__call'])) {
+ $method = (string) $item;
+ $call = true;
+*/
+ {
+ int call = 0;
+ char *lcItem = TWIG_STRTOLOWER(item, item_len);
+ int lcItem_length;
+ char *method = NULL;
+ char *tmp_method_name_get;
+ char *tmp_method_name_is;
+ zval *zmethod;
+ zval *tmp_methods;
+
+ lcItem_length = strlen(lcItem);
+ tmp_method_name_get = emalloc(4 + lcItem_length);
+ tmp_method_name_is = emalloc(3 + lcItem_length);
+
+ sprintf(tmp_method_name_get, "get%s", lcItem);
+ sprintf(tmp_method_name_is, "is%s", lcItem);
+
+ tmp_methods = TWIG_GET_ARRAY_ELEMENT(tmp_class, "methods", strlen("methods") TSRMLS_CC);
+
+ if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, lcItem, lcItem_length TSRMLS_CC)) {
+ method = item;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, tmp_method_name_get, lcItem_length + 3 TSRMLS_CC)) {
+ method = tmp_method_name_get;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, tmp_method_name_is, lcItem_length + 2 TSRMLS_CC)) {
+ method = tmp_method_name_is;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, "__call", 6 TSRMLS_CC)) {
+ method = item;
+ call = 1;
+/*
+ } else {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)), -1, $this->getTemplateName());
+ }
+
+ if ($isDefinedTest) {
+ return true;
+ }
+*/
+ } else {
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);
+
+ if (isDefinedTest) {
+ efree(item);
+ RETURN_FALSE;
+ }
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ efree(item);
+ return;
+ }
+ TWIG_RUNTIME_ERROR(template TSRMLS_CC, "Method \"%s\" for object \"%s\" does not exist", item, TWIG_GET_CLASS_NAME(object TSRMLS_CC));
+ efree(item);
+ return;
+ }
+
+ if (isDefinedTest) {
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);efree(item);
+ RETURN_TRUE;
+ }
+/*
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
+ }
+*/
+ MAKE_STD_ZVAL(zmethod);
+ ZVAL_STRING(zmethod, method, 1);
+ if (TWIG_CALL_SB(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "hasExtension", "sandbox" TSRMLS_CC)) {
+ TWIG_CALL_ZZ(TWIG_CALL_S(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getExtension", "sandbox" TSRMLS_CC), "checkMethodAllowed", object, zmethod TSRMLS_CC);
+ }
+ zval_ptr_dtor(&zmethod);
+ if (EG(exception)) {
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);efree(item);
+ return;
+ }
+/*
+ // Some objects throw exceptions when they have __call, and the method we try
+ // to call is not supported. If ignoreStrictCheck is true, we should return null.
+ try {
+ $ret = call_user_func_array(array($object, $method), $arguments);
+ } catch (BadMethodCallException $e) {
+ if ($call && ($ignoreStrictCheck || !$this->env->isStrictVariables())) {
+ return null;
+ }
+ throw $e;
+ }
+*/
+ ret = TWIG_CALL_USER_FUNC_ARRAY(object, method, arguments TSRMLS_CC);
+ if (EG(exception) && TWIG_INSTANCE_OF(EG(exception), spl_ce_BadMethodCallException TSRMLS_CC)) {
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);efree(item);
+ zend_clear_exception(TSRMLS_C);
+ return;
+ }
+ }
+ free_ret = 1;
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);
+ }
+/*
+ // useful when calling a template method from a template
+ // this is not supported but unfortunately heavily used in the Symfony profiler
+ if ($object instanceof Twig_TemplateInterface) {
+ return $ret === '' ? '' : new Twig_Markup($ret, $this->env->getCharset());
+ }
+
+ return $ret;
+*/
+ efree(item);
+ // ret can be null, if e.g. the called method throws an exception
+ if (ret) {
+ if (TWIG_INSTANCE_OF_USERLAND(object, "Twig_TemplateInterface" TSRMLS_CC)) {
+ if (Z_STRLEN_P(ret) != 0) {
+ zval *charset = TWIG_CALL_USER_FUNC_ARRAY(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getCharset", NULL TSRMLS_CC);
+ TWIG_NEW(return_value, "Twig_Markup", ret, charset TSRMLS_CC);
+ zval_ptr_dtor(&charset);
+ if (ret) {
+ zval_ptr_dtor(&ret);
+ }
+ return;
+ }
+ }
+
+ RETVAL_ZVAL(ret, 1, 0);
+ if (free_ret) {
+ zval_ptr_dtor(&ret);
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Autoloader.php b/vendor/twig/twig/lib/Twig/Autoloader.php
new file mode 100755
index 0000000..87f7415
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Autoloader.php
@@ -0,0 +1,48 @@
+
+ */
+class Twig_Autoloader
+{
+ /**
+ * Registers Twig_Autoloader as an SPL autoloader.
+ *
+ * @param bool $prepend Whether to prepend the autoloader or not.
+ */
+ public static function register($prepend = false)
+ {
+ if (PHP_VERSION_ID < 50300) {
+ spl_autoload_register(array(__CLASS__, 'autoload'));
+ } else {
+ spl_autoload_register(array(__CLASS__, 'autoload'), true, $prepend);
+ }
+ }
+
+ /**
+ * Handles autoloading of classes.
+ *
+ * @param string $class A class name.
+ */
+ public static function autoload($class)
+ {
+ if (0 !== strpos($class, 'Twig')) {
+ return;
+ }
+
+ if (is_file($file = dirname(__FILE__).'/../'.str_replace(array('_', "\0"), array('/', ''), $class).'.php')) {
+ require $file;
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Compiler.php b/vendor/twig/twig/lib/Twig/Compiler.php
new file mode 100755
index 0000000..2514c31
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Compiler.php
@@ -0,0 +1,278 @@
+
+ */
+class Twig_Compiler implements Twig_CompilerInterface
+{
+ protected $lastLine;
+ protected $source;
+ protected $indentation;
+ protected $env;
+ protected $debugInfo;
+ protected $sourceOffset;
+ protected $sourceLine;
+ protected $filename;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env The twig environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ $this->debugInfo = array();
+ }
+
+ public function getFilename()
+ {
+ return $this->filename;
+ }
+
+ /**
+ * Returns the environment instance related to this compiler.
+ *
+ * @return Twig_Environment The environment instance
+ */
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ /**
+ * Gets the current PHP code after compilation.
+ *
+ * @return string The PHP code
+ */
+ public function getSource()
+ {
+ return $this->source;
+ }
+
+ /**
+ * Compiles a node.
+ *
+ * @param Twig_NodeInterface $node The node to compile
+ * @param int $indentation The current indentation
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function compile(Twig_NodeInterface $node, $indentation = 0)
+ {
+ $this->lastLine = null;
+ $this->source = '';
+ $this->debugInfo = array();
+ $this->sourceOffset = 0;
+ // source code starts at 1 (as we then increment it when we encounter new lines)
+ $this->sourceLine = 1;
+ $this->indentation = $indentation;
+
+ if ($node instanceof Twig_Node_Module) {
+ $this->filename = $node->getAttribute('filename');
+ }
+
+ $node->compile($this);
+
+ return $this;
+ }
+
+ public function subcompile(Twig_NodeInterface $node, $raw = true)
+ {
+ if (false === $raw) {
+ $this->addIndentation();
+ }
+
+ $node->compile($this);
+
+ return $this;
+ }
+
+ /**
+ * Adds a raw string to the compiled code.
+ *
+ * @param string $string The string
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function raw($string)
+ {
+ $this->source .= $string;
+
+ return $this;
+ }
+
+ /**
+ * Writes a string to the compiled code by adding indentation.
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function write()
+ {
+ $strings = func_get_args();
+ foreach ($strings as $string) {
+ $this->addIndentation();
+ $this->source .= $string;
+ }
+
+ return $this;
+ }
+
+ /**
+ * Appends an indentation to the current PHP code after compilation.
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function addIndentation()
+ {
+ $this->source .= str_repeat(' ', $this->indentation * 4);
+
+ return $this;
+ }
+
+ /**
+ * Adds a quoted string to the compiled code.
+ *
+ * @param string $value The string
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function string($value)
+ {
+ $this->source .= sprintf('"%s"', addcslashes($value, "\0\t\"\$\\"));
+
+ return $this;
+ }
+
+ /**
+ * Returns a PHP representation of a given value.
+ *
+ * @param mixed $value The value to convert
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function repr($value)
+ {
+ if (is_int($value) || is_float($value)) {
+ if (false !== $locale = setlocale(LC_NUMERIC, 0)) {
+ setlocale(LC_NUMERIC, 'C');
+ }
+
+ $this->raw($value);
+
+ if (false !== $locale) {
+ setlocale(LC_NUMERIC, $locale);
+ }
+ } elseif (null === $value) {
+ $this->raw('null');
+ } elseif (is_bool($value)) {
+ $this->raw($value ? 'true' : 'false');
+ } elseif (is_array($value)) {
+ $this->raw('array(');
+ $first = true;
+ foreach ($value as $key => $v) {
+ if (!$first) {
+ $this->raw(', ');
+ }
+ $first = false;
+ $this->repr($key);
+ $this->raw(' => ');
+ $this->repr($v);
+ }
+ $this->raw(')');
+ } else {
+ $this->string($value);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds debugging information.
+ *
+ * @param Twig_NodeInterface $node The related twig node
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function addDebugInfo(Twig_NodeInterface $node)
+ {
+ if ($node->getLine() != $this->lastLine) {
+ $this->write(sprintf("// line %d\n", $node->getLine()));
+
+ // when mbstring.func_overload is set to 2
+ // mb_substr_count() replaces substr_count()
+ // but they have different signatures!
+ if (((int) ini_get('mbstring.func_overload')) & 2) {
+ // this is much slower than the "right" version
+ $this->sourceLine += mb_substr_count(mb_substr($this->source, $this->sourceOffset), "\n");
+ } else {
+ $this->sourceLine += substr_count($this->source, "\n", $this->sourceOffset);
+ }
+ $this->sourceOffset = strlen($this->source);
+ $this->debugInfo[$this->sourceLine] = $node->getLine();
+
+ $this->lastLine = $node->getLine();
+ }
+
+ return $this;
+ }
+
+ public function getDebugInfo()
+ {
+ ksort($this->debugInfo);
+
+ return $this->debugInfo;
+ }
+
+ /**
+ * Indents the generated code.
+ *
+ * @param int $step The number of indentation to add
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function indent($step = 1)
+ {
+ $this->indentation += $step;
+
+ return $this;
+ }
+
+ /**
+ * Outdents the generated code.
+ *
+ * @param int $step The number of indentation to remove
+ *
+ * @return Twig_Compiler The current compiler instance
+ *
+ * @throws LogicException When trying to outdent too much so the indentation would become negative
+ */
+ public function outdent($step = 1)
+ {
+ // can't outdent by more steps than the current indentation level
+ if ($this->indentation < $step) {
+ throw new LogicException('Unable to call outdent() as the indentation would become negative');
+ }
+
+ $this->indentation -= $step;
+
+ return $this;
+ }
+
+ public function getVarName()
+ {
+ return sprintf('__internal_%s', hash('sha256', uniqid(mt_rand(), true), false));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/CompilerInterface.php b/vendor/twig/twig/lib/Twig/CompilerInterface.php
new file mode 100755
index 0000000..272c767
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/CompilerInterface.php
@@ -0,0 +1,36 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_CompilerInterface
+{
+ /**
+ * Compiles a node.
+ *
+ * @param Twig_NodeInterface $node The node to compile
+ *
+ * @return Twig_CompilerInterface The current compiler instance
+ */
+ public function compile(Twig_NodeInterface $node);
+
+ /**
+ * Gets the current PHP code after compilation.
+ *
+ * @return string The PHP code
+ */
+ public function getSource();
+}
diff --git a/vendor/twig/twig/lib/Twig/Environment.php b/vendor/twig/twig/lib/Twig/Environment.php
new file mode 100755
index 0000000..f14e5d8
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Environment.php
@@ -0,0 +1,1292 @@
+
+ */
+class Twig_Environment
+{
+ const VERSION = '1.18.2';
+
+ protected $charset;
+ protected $loader;
+ protected $debug;
+ protected $autoReload;
+ protected $cache;
+ protected $lexer;
+ protected $parser;
+ protected $compiler;
+ protected $baseTemplateClass;
+ protected $extensions;
+ protected $parsers;
+ protected $visitors;
+ protected $filters;
+ protected $tests;
+ protected $functions;
+ protected $globals;
+ protected $runtimeInitialized;
+ protected $extensionInitialized;
+ protected $loadedTemplates;
+ protected $strictVariables;
+ protected $unaryOperators;
+ protected $binaryOperators;
+ protected $templateClassPrefix = '__TwigTemplate_';
+ protected $functionCallbacks;
+ protected $filterCallbacks;
+ protected $staging;
+
+ /**
+ * Constructor.
+ *
+ * Available options:
+ *
+ * * debug: When set to true, it automatically set "auto_reload" to true as
+ * well (default to false).
+ *
+ * * charset: The charset used by the templates (default to UTF-8).
+ *
+ * * base_template_class: The base template class to use for generated
+ * templates (default to Twig_Template).
+ *
+ * * cache: An absolute path where to store the compiled templates, or
+ * false to disable compilation cache (default).
+ *
+ * * auto_reload: Whether to reload the template if the original source changed.
+ * If you don't provide the auto_reload option, it will be
+ * determined automatically based on the debug value.
+ *
+ * * strict_variables: Whether to ignore invalid variables in templates
+ * (default to false).
+ *
+ * * autoescape: Whether to enable auto-escaping (default to html):
+ * * false: disable auto-escaping
+ * * true: equivalent to html
+ * * html, js: set the autoescaping to one of the supported strategies
+ * * filename: set the autoescaping strategy based on the template filename extension
+ * * PHP callback: a PHP callback that returns an escaping strategy based on the template "filename"
+ *
+ * * optimizations: A flag that indicates which optimizations to apply
+ * (default to -1 which means that all optimizations are enabled;
+ * set it to 0 to disable).
+ *
+ * @param Twig_LoaderInterface $loader A Twig_LoaderInterface instance
+ * @param array $options An array of options
+ */
+ public function __construct(Twig_LoaderInterface $loader = null, $options = array())
+ {
+ if (null !== $loader) {
+ $this->setLoader($loader);
+ }
+
+ $options = array_merge(array(
+ 'debug' => false,
+ 'charset' => 'UTF-8',
+ 'base_template_class' => 'Twig_Template',
+ 'strict_variables' => false,
+ 'autoescape' => 'html',
+ 'cache' => false,
+ 'auto_reload' => null,
+ 'optimizations' => -1,
+ ), $options);
+
+ $this->debug = (bool) $options['debug'];
+ $this->charset = strtoupper($options['charset']);
+ $this->baseTemplateClass = $options['base_template_class'];
+ $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
+ $this->strictVariables = (bool) $options['strict_variables'];
+ $this->runtimeInitialized = false;
+ $this->setCache($options['cache']);
+ $this->functionCallbacks = array();
+ $this->filterCallbacks = array();
+
+ $this->addExtension(new Twig_Extension_Core());
+ $this->addExtension(new Twig_Extension_Escaper($options['autoescape']));
+ $this->addExtension(new Twig_Extension_Optimizer($options['optimizations']));
+ $this->extensionInitialized = false;
+ $this->staging = new Twig_Extension_Staging();
+ }
+
+ /**
+ * Gets the base template class for compiled templates.
+ *
+ * @return string The base template class name
+ */
+ public function getBaseTemplateClass()
+ {
+ return $this->baseTemplateClass;
+ }
+
+ /**
+ * Sets the base template class for compiled templates.
+ *
+ * @param string $class The base template class name
+ */
+ public function setBaseTemplateClass($class)
+ {
+ $this->baseTemplateClass = $class;
+ }
+
+ /**
+ * Enables debugging mode.
+ */
+ public function enableDebug()
+ {
+ $this->debug = true;
+ }
+
+ /**
+ * Disables debugging mode.
+ */
+ public function disableDebug()
+ {
+ $this->debug = false;
+ }
+
+ /**
+ * Checks if debug mode is enabled.
+ *
+ * @return bool true if debug mode is enabled, false otherwise
+ */
+ public function isDebug()
+ {
+ return $this->debug;
+ }
+
+ /**
+ * Enables the auto_reload option.
+ */
+ public function enableAutoReload()
+ {
+ $this->autoReload = true;
+ }
+
+ /**
+ * Disables the auto_reload option.
+ */
+ public function disableAutoReload()
+ {
+ $this->autoReload = false;
+ }
+
+ /**
+ * Checks if the auto_reload option is enabled.
+ *
+ * @return bool true if auto_reload is enabled, false otherwise
+ */
+ public function isAutoReload()
+ {
+ return $this->autoReload;
+ }
+
+ /**
+ * Enables the strict_variables option.
+ */
+ public function enableStrictVariables()
+ {
+ $this->strictVariables = true;
+ }
+
+ /**
+ * Disables the strict_variables option.
+ */
+ public function disableStrictVariables()
+ {
+ $this->strictVariables = false;
+ }
+
+ /**
+ * Checks if the strict_variables option is enabled.
+ *
+ * @return bool true if strict_variables is enabled, false otherwise
+ */
+ public function isStrictVariables()
+ {
+ return $this->strictVariables;
+ }
+
+ /**
+ * Gets the cache directory or false if cache is disabled.
+ *
+ * @return string|false
+ */
+ public function getCache()
+ {
+ return $this->cache;
+ }
+
+ /**
+ * Sets the cache directory or false if cache is disabled.
+ *
+ * @param string|false $cache The absolute path to the compiled templates,
+ * or false to disable cache
+ */
+ public function setCache($cache)
+ {
+ $this->cache = $cache ? $cache : false;
+ }
+
+ /**
+ * Gets the cache filename for a given template.
+ *
+ * @param string $name The template name
+ *
+ * @return string|false The cache file name or false when caching is disabled
+ */
+ public function getCacheFilename($name)
+ {
+ if (false === $this->cache) {
+ return false;
+ }
+
+ $class = substr($this->getTemplateClass($name), strlen($this->templateClassPrefix));
+
+ return $this->getCache().'/'.$class[0].'/'.$class[1].'/'.$class.'.php';
+ }
+
+ /**
+ * Gets the template class associated with the given string.
+ *
+ * @param string $name The name for which to calculate the template class name
+ * @param int $index The index if it is an embedded template
+ *
+ * @return string The template class name
+ */
+ public function getTemplateClass($name, $index = null)
+ {
+ return $this->templateClassPrefix.hash('sha256', $this->getLoader()->getCacheKey($name)).(null === $index ? '' : '_'.$index);
+ }
+
+ /**
+ * Gets the template class prefix.
+ *
+ * @return string The template class prefix
+ */
+ public function getTemplateClassPrefix()
+ {
+ return $this->templateClassPrefix;
+ }
+
+ /**
+ * Renders a template.
+ *
+ * @param string $name The template name
+ * @param array $context An array of parameters to pass to the template
+ *
+ * @return string The rendered template
+ *
+ * @throws Twig_Error_Loader When the template cannot be found
+ * @throws Twig_Error_Syntax When an error occurred during compilation
+ * @throws Twig_Error_Runtime When an error occurred during rendering
+ */
+ public function render($name, array $context = array())
+ {
+ return $this->loadTemplate($name)->render($context);
+ }
+
+ /**
+ * Displays a template.
+ *
+ * @param string $name The template name
+ * @param array $context An array of parameters to pass to the template
+ *
+ * @throws Twig_Error_Loader When the template cannot be found
+ * @throws Twig_Error_Syntax When an error occurred during compilation
+ * @throws Twig_Error_Runtime When an error occurred during rendering
+ */
+ public function display($name, array $context = array())
+ {
+ $this->loadTemplate($name)->display($context);
+ }
+
+ /**
+ * Loads a template by name.
+ *
+ * @param string $name The template name
+ * @param int $index The index if it is an embedded template
+ *
+ * @return Twig_TemplateInterface A template instance representing the given template name
+ *
+ * @throws Twig_Error_Loader When the template cannot be found
+ * @throws Twig_Error_Syntax When an error occurred during compilation
+ */
+ public function loadTemplate($name, $index = null)
+ {
+ $cls = $this->getTemplateClass($name, $index);
+
+ if (isset($this->loadedTemplates[$cls])) {
+ return $this->loadedTemplates[$cls];
+ }
+
+ if (!class_exists($cls, false)) {
+ if (false === $cache = $this->getCacheFilename($name)) {
+ eval('?>'.$this->compileSource($this->getLoader()->getSource($name), $name));
+ } else {
+ if (!is_file($cache) || ($this->isAutoReload() && !$this->isTemplateFresh($name, filemtime($cache)))) {
+ $this->writeCacheFile($cache, $this->compileSource($this->getLoader()->getSource($name), $name));
+ }
+
+ require_once $cache;
+ }
+ }
+
+ if (!$this->runtimeInitialized) {
+ $this->initRuntime();
+ }
+
+ return $this->loadedTemplates[$cls] = new $cls($this);
+ }
+
+ /**
+ * Creates a template from source.
+ *
+ * This method should not be used as a generic way to load templates.
+ *
+ * @param string $template The template name
+ *
+ * @return Twig_Template A template instance representing the given template name
+ *
+ * @throws Twig_Error_Loader When the template cannot be found
+ * @throws Twig_Error_Syntax When an error occurred during compilation
+ */
+ public function createTemplate($template)
+ {
+ $name = sprintf('__string_template__%s', hash('sha256', uniqid(mt_rand(), true), false));
+
+ $loader = new Twig_Loader_Chain(array(
+ new Twig_Loader_Array(array($name => $template)),
+ $current = $this->getLoader(),
+ ));
+
+ $this->setLoader($loader);
+ try {
+ $template = $this->loadTemplate($name);
+ } catch (Exception $e) {
+ $this->setLoader($current);
+
+ throw $e;
+ }
+ $this->setLoader($current);
+
+ return $template;
+ }
+
+ /**
+ * Returns true if the template is still fresh.
+ *
+ * Besides checking the loader for freshness information,
+ * this method also checks if the enabled extensions have
+ * not changed.
+ *
+ * @param string $name The template name
+ * @param int $time The last modification time of the cached template
+ *
+ * @return bool true if the template is fresh, false otherwise
+ */
+ public function isTemplateFresh($name, $time)
+ {
+ foreach ($this->extensions as $extension) {
+ $r = new ReflectionObject($extension);
+ if (filemtime($r->getFileName()) > $time) {
+ return false;
+ }
+ }
+
+ return $this->getLoader()->isFresh($name, $time);
+ }
+
+ /**
+ * Tries to load a template consecutively from an array.
+ *
+ * Similar to loadTemplate() but it also accepts Twig_TemplateInterface instances and an array
+ * of templates where each is tried to be loaded.
+ *
+ * @param string|Twig_Template|array $names A template or an array of templates to try consecutively
+ *
+ * @return Twig_Template
+ *
+ * @throws Twig_Error_Loader When none of the templates can be found
+ * @throws Twig_Error_Syntax When an error occurred during compilation
+ */
+ public function resolveTemplate($names)
+ {
+ if (!is_array($names)) {
+ $names = array($names);
+ }
+
+ foreach ($names as $name) {
+ if ($name instanceof Twig_Template) {
+ return $name;
+ }
+
+ try {
+ return $this->loadTemplate($name);
+ } catch (Twig_Error_Loader $e) {
+ }
+ }
+
+ if (1 === count($names)) {
+ throw $e;
+ }
+
+ throw new Twig_Error_Loader(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
+ }
+
+ /**
+ * Clears the internal template cache.
+ */
+ public function clearTemplateCache()
+ {
+ $this->loadedTemplates = array();
+ }
+
+ /**
+ * Clears the template cache files on the filesystem.
+ */
+ public function clearCacheFiles()
+ {
+ if (false === $this->cache) {
+ return;
+ }
+
+ foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->cache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
+ if ($file->isFile()) {
+ @unlink($file->getPathname());
+ }
+ }
+ }
+
+ /**
+ * Gets the Lexer instance.
+ *
+ * @return Twig_LexerInterface A Twig_LexerInterface instance
+ */
+ public function getLexer()
+ {
+ if (null === $this->lexer) {
+ $this->lexer = new Twig_Lexer($this);
+ }
+
+ return $this->lexer;
+ }
+
+ /**
+ * Sets the Lexer instance.
+ *
+ * @param Twig_LexerInterface $lexer A Twig_LexerInterface instance
+ */
+ public function setLexer(Twig_LexerInterface $lexer)
+ {
+ $this->lexer = $lexer;
+ }
+
+ /**
+ * Tokenizes a source code.
+ *
+ * @param string $source The template source code
+ * @param string $name The template name
+ *
+ * @return Twig_TokenStream A Twig_TokenStream instance
+ *
+ * @throws Twig_Error_Syntax When the code is syntactically wrong
+ */
+ public function tokenize($source, $name = null)
+ {
+ return $this->getLexer()->tokenize($source, $name);
+ }
+
+ /**
+ * Gets the Parser instance.
+ *
+ * @return Twig_ParserInterface A Twig_ParserInterface instance
+ */
+ public function getParser()
+ {
+ if (null === $this->parser) {
+ $this->parser = new Twig_Parser($this);
+ }
+
+ return $this->parser;
+ }
+
+ /**
+ * Sets the Parser instance.
+ *
+ * @param Twig_ParserInterface $parser A Twig_ParserInterface instance
+ */
+ public function setParser(Twig_ParserInterface $parser)
+ {
+ $this->parser = $parser;
+ }
+
+ /**
+ * Converts a token stream to a node tree.
+ *
+ * @param Twig_TokenStream $stream A token stream instance
+ *
+ * @return Twig_Node_Module A node tree
+ *
+ * @throws Twig_Error_Syntax When the token stream is syntactically or semantically wrong
+ */
+ public function parse(Twig_TokenStream $stream)
+ {
+ return $this->getParser()->parse($stream);
+ }
+
+ /**
+ * Gets the Compiler instance.
+ *
+ * @return Twig_CompilerInterface A Twig_CompilerInterface instance
+ */
+ public function getCompiler()
+ {
+ if (null === $this->compiler) {
+ $this->compiler = new Twig_Compiler($this);
+ }
+
+ return $this->compiler;
+ }
+
+ /**
+ * Sets the Compiler instance.
+ *
+ * @param Twig_CompilerInterface $compiler A Twig_CompilerInterface instance
+ */
+ public function setCompiler(Twig_CompilerInterface $compiler)
+ {
+ $this->compiler = $compiler;
+ }
+
+ /**
+ * Compiles a node and returns the PHP code.
+ *
+ * @param Twig_NodeInterface $node A Twig_NodeInterface instance
+ *
+ * @return string The compiled PHP source code
+ */
+ public function compile(Twig_NodeInterface $node)
+ {
+ return $this->getCompiler()->compile($node)->getSource();
+ }
+
+ /**
+ * Compiles a template source code.
+ *
+ * @param string $source The template source code
+ * @param string $name The template name
+ *
+ * @return string The compiled PHP source code
+ *
+ * @throws Twig_Error_Syntax When there was an error during tokenizing, parsing or compiling
+ */
+ public function compileSource($source, $name = null)
+ {
+ try {
+ return $this->compile($this->parse($this->tokenize($source, $name)));
+ } catch (Twig_Error $e) {
+ $e->setTemplateFile($name);
+ throw $e;
+ } catch (Exception $e) {
+ throw new Twig_Error_Syntax(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $name, $e);
+ }
+ }
+
+ /**
+ * Sets the Loader instance.
+ *
+ * @param Twig_LoaderInterface $loader A Twig_LoaderInterface instance
+ */
+ public function setLoader(Twig_LoaderInterface $loader)
+ {
+ $this->loader = $loader;
+ }
+
+ /**
+ * Gets the Loader instance.
+ *
+ * @return Twig_LoaderInterface A Twig_LoaderInterface instance
+ */
+ public function getLoader()
+ {
+ if (null === $this->loader) {
+ throw new LogicException('You must set a loader first.');
+ }
+
+ return $this->loader;
+ }
+
+ /**
+ * Sets the default template charset.
+ *
+ * @param string $charset The default charset
+ */
+ public function setCharset($charset)
+ {
+ $this->charset = strtoupper($charset);
+ }
+
+ /**
+ * Gets the default template charset.
+ *
+ * @return string The default charset
+ */
+ public function getCharset()
+ {
+ return $this->charset;
+ }
+
+ /**
+ * Initializes the runtime environment.
+ */
+ public function initRuntime()
+ {
+ $this->runtimeInitialized = true;
+
+ foreach ($this->getExtensions() as $extension) {
+ $extension->initRuntime($this);
+ }
+ }
+
+ /**
+ * Returns true if the given extension is registered.
+ *
+ * @param string $name The extension name
+ *
+ * @return bool Whether the extension is registered or not
+ */
+ public function hasExtension($name)
+ {
+ return isset($this->extensions[$name]);
+ }
+
+ /**
+ * Gets an extension by name.
+ *
+ * @param string $name The extension name
+ *
+ * @return Twig_ExtensionInterface A Twig_ExtensionInterface instance
+ */
+ public function getExtension($name)
+ {
+ if (!isset($this->extensions[$name])) {
+ throw new Twig_Error_Runtime(sprintf('The "%s" extension is not enabled.', $name));
+ }
+
+ return $this->extensions[$name];
+ }
+
+ /**
+ * Registers an extension.
+ *
+ * @param Twig_ExtensionInterface $extension A Twig_ExtensionInterface instance
+ */
+ public function addExtension(Twig_ExtensionInterface $extension)
+ {
+ if ($this->extensionInitialized) {
+ throw new LogicException(sprintf('Unable to register extension "%s" as extensions have already been initialized.', $extension->getName()));
+ }
+
+ $this->extensions[$extension->getName()] = $extension;
+ }
+
+ /**
+ * Removes an extension by name.
+ *
+ * This method is deprecated and you should not use it.
+ *
+ * @param string $name The extension name
+ *
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+ public function removeExtension($name)
+ {
+ if ($this->extensionInitialized) {
+ throw new LogicException(sprintf('Unable to remove extension "%s" as extensions have already been initialized.', $name));
+ }
+
+ unset($this->extensions[$name]);
+ }
+
+ /**
+ * Registers an array of extensions.
+ *
+ * @param array $extensions An array of extensions
+ */
+ public function setExtensions(array $extensions)
+ {
+ foreach ($extensions as $extension) {
+ $this->addExtension($extension);
+ }
+ }
+
+ /**
+ * Returns all registered extensions.
+ *
+ * @return array An array of extensions
+ */
+ public function getExtensions()
+ {
+ return $this->extensions;
+ }
+
+ /**
+ * Registers a Token Parser.
+ *
+ * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
+ */
+ public function addTokenParser(Twig_TokenParserInterface $parser)
+ {
+ if ($this->extensionInitialized) {
+ throw new LogicException('Unable to add a token parser as extensions have already been initialized.');
+ }
+
+ $this->staging->addTokenParser($parser);
+ }
+
+ /**
+ * Gets the registered Token Parsers.
+ *
+ * @return Twig_TokenParserBrokerInterface A broker containing token parsers
+ */
+ public function getTokenParsers()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->parsers;
+ }
+
+ /**
+ * Gets registered tags.
+ *
+ * Be warned that this method cannot return tags defined by Twig_TokenParserBrokerInterface classes.
+ *
+ * @return Twig_TokenParserInterface[] An array of Twig_TokenParserInterface instances
+ */
+ public function getTags()
+ {
+ $tags = array();
+ foreach ($this->getTokenParsers()->getParsers() as $parser) {
+ if ($parser instanceof Twig_TokenParserInterface) {
+ $tags[$parser->getTag()] = $parser;
+ }
+ }
+
+ return $tags;
+ }
+
+ /**
+ * Registers a Node Visitor.
+ *
+ * @param Twig_NodeVisitorInterface $visitor A Twig_NodeVisitorInterface instance
+ */
+ public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ if ($this->extensionInitialized) {
+ throw new LogicException('Unable to add a node visitor as extensions have already been initialized.');
+ }
+
+ $this->staging->addNodeVisitor($visitor);
+ }
+
+ /**
+ * Gets the registered Node Visitors.
+ *
+ * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->visitors;
+ }
+
+ /**
+ * Registers a Filter.
+ *
+ * @param string|Twig_SimpleFilter $name The filter name or a Twig_SimpleFilter instance
+ * @param Twig_FilterInterface|Twig_SimpleFilter $filter A Twig_FilterInterface instance or a Twig_SimpleFilter instance
+ */
+ public function addFilter($name, $filter = null)
+ {
+ if (!$name instanceof Twig_SimpleFilter && !($filter instanceof Twig_SimpleFilter || $filter instanceof Twig_FilterInterface)) {
+ throw new LogicException('A filter must be an instance of Twig_FilterInterface or Twig_SimpleFilter');
+ }
+
+ if ($name instanceof Twig_SimpleFilter) {
+ $filter = $name;
+ $name = $filter->getName();
+ }
+
+ if ($this->extensionInitialized) {
+ throw new LogicException(sprintf('Unable to add filter "%s" as extensions have already been initialized.', $name));
+ }
+
+ $this->staging->addFilter($name, $filter);
+ }
+
+ /**
+ * Get a filter by name.
+ *
+ * Subclasses may override this method and load filters differently;
+ * so no list of filters is available.
+ *
+ * @param string $name The filter name
+ *
+ * @return Twig_Filter|false A Twig_Filter instance or false if the filter does not exist
+ */
+ public function getFilter($name)
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ if (isset($this->filters[$name])) {
+ return $this->filters[$name];
+ }
+
+ foreach ($this->filters as $pattern => $filter) {
+ $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
+
+ if ($count) {
+ if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
+ array_shift($matches);
+ $filter->setArguments($matches);
+
+ return $filter;
+ }
+ }
+ }
+
+ foreach ($this->filterCallbacks as $callback) {
+ if (false !== $filter = call_user_func($callback, $name)) {
+ return $filter;
+ }
+ }
+
+ return false;
+ }
+
+ public function registerUndefinedFilterCallback($callable)
+ {
+ $this->filterCallbacks[] = $callable;
+ }
+
+ /**
+ * Gets the registered Filters.
+ *
+ * Be warned that this method cannot return filters defined with registerUndefinedFunctionCallback.
+ *
+ * @return Twig_FilterInterface[] An array of Twig_FilterInterface instances
+ *
+ * @see registerUndefinedFilterCallback
+ */
+ public function getFilters()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->filters;
+ }
+
+ /**
+ * Registers a Test.
+ *
+ * @param string|Twig_SimpleTest $name The test name or a Twig_SimpleTest instance
+ * @param Twig_TestInterface|Twig_SimpleTest $test A Twig_TestInterface instance or a Twig_SimpleTest instance
+ */
+ public function addTest($name, $test = null)
+ {
+ if (!$name instanceof Twig_SimpleTest && !($test instanceof Twig_SimpleTest || $test instanceof Twig_TestInterface)) {
+ throw new LogicException('A test must be an instance of Twig_TestInterface or Twig_SimpleTest');
+ }
+
+ if ($name instanceof Twig_SimpleTest) {
+ $test = $name;
+ $name = $test->getName();
+ }
+
+ if ($this->extensionInitialized) {
+ throw new LogicException(sprintf('Unable to add test "%s" as extensions have already been initialized.', $name));
+ }
+
+ $this->staging->addTest($name, $test);
+ }
+
+ /**
+ * Gets the registered Tests.
+ *
+ * @return Twig_TestInterface[] An array of Twig_TestInterface instances
+ */
+ public function getTests()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->tests;
+ }
+
+ /**
+ * Gets a test by name.
+ *
+ * @param string $name The test name
+ *
+ * @return Twig_Test|false A Twig_Test instance or false if the test does not exist
+ */
+ public function getTest($name)
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ if (isset($this->tests[$name])) {
+ return $this->tests[$name];
+ }
+
+ return false;
+ }
+
+ /**
+ * Registers a Function.
+ *
+ * @param string|Twig_SimpleFunction $name The function name or a Twig_SimpleFunction instance
+ * @param Twig_FunctionInterface|Twig_SimpleFunction $function A Twig_FunctionInterface instance or a Twig_SimpleFunction instance
+ */
+ public function addFunction($name, $function = null)
+ {
+ if (!$name instanceof Twig_SimpleFunction && !($function instanceof Twig_SimpleFunction || $function instanceof Twig_FunctionInterface)) {
+ throw new LogicException('A function must be an instance of Twig_FunctionInterface or Twig_SimpleFunction');
+ }
+
+ if ($name instanceof Twig_SimpleFunction) {
+ $function = $name;
+ $name = $function->getName();
+ }
+
+ if ($this->extensionInitialized) {
+ throw new LogicException(sprintf('Unable to add function "%s" as extensions have already been initialized.', $name));
+ }
+
+ $this->staging->addFunction($name, $function);
+ }
+
+ /**
+ * Get a function by name.
+ *
+ * Subclasses may override this method and load functions differently;
+ * so no list of functions is available.
+ *
+ * @param string $name function name
+ *
+ * @return Twig_Function|false A Twig_Function instance or false if the function does not exist
+ */
+ public function getFunction($name)
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ if (isset($this->functions[$name])) {
+ return $this->functions[$name];
+ }
+
+ foreach ($this->functions as $pattern => $function) {
+ $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
+
+ if ($count) {
+ if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
+ array_shift($matches);
+ $function->setArguments($matches);
+
+ return $function;
+ }
+ }
+ }
+
+ foreach ($this->functionCallbacks as $callback) {
+ if (false !== $function = call_user_func($callback, $name)) {
+ return $function;
+ }
+ }
+
+ return false;
+ }
+
+ public function registerUndefinedFunctionCallback($callable)
+ {
+ $this->functionCallbacks[] = $callable;
+ }
+
+ /**
+ * Gets registered functions.
+ *
+ * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
+ *
+ * @return Twig_FunctionInterface[] An array of Twig_FunctionInterface instances
+ *
+ * @see registerUndefinedFunctionCallback
+ */
+ public function getFunctions()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->functions;
+ }
+
+ /**
+ * Registers a Global.
+ *
+ * New globals can be added before compiling or rendering a template;
+ * but after, you can only update existing globals.
+ *
+ * @param string $name The global name
+ * @param mixed $value The global value
+ */
+ public function addGlobal($name, $value)
+ {
+ if ($this->extensionInitialized || $this->runtimeInitialized) {
+ if (null === $this->globals) {
+ $this->globals = $this->initGlobals();
+ }
+
+ /* This condition must be uncommented in Twig 2.0
+ if (!array_key_exists($name, $this->globals)) {
+ throw new LogicException(sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
+ }
+ */
+ }
+
+ if ($this->extensionInitialized || $this->runtimeInitialized) {
+ // update the value
+ $this->globals[$name] = $value;
+ } else {
+ $this->staging->addGlobal($name, $value);
+ }
+ }
+
+ /**
+ * Gets the registered Globals.
+ *
+ * @return array An array of globals
+ */
+ public function getGlobals()
+ {
+ if (!$this->runtimeInitialized && !$this->extensionInitialized) {
+ return $this->initGlobals();
+ }
+
+ if (null === $this->globals) {
+ $this->globals = $this->initGlobals();
+ }
+
+ return $this->globals;
+ }
+
+ /**
+ * Merges a context with the defined globals.
+ *
+ * @param array $context An array representing the context
+ *
+ * @return array The context merged with the globals
+ */
+ public function mergeGlobals(array $context)
+ {
+ // we don't use array_merge as the context being generally
+ // bigger than globals, this code is faster.
+ foreach ($this->getGlobals() as $key => $value) {
+ if (!array_key_exists($key, $context)) {
+ $context[$key] = $value;
+ }
+ }
+
+ return $context;
+ }
+
+ /**
+ * Gets the registered unary Operators.
+ *
+ * @return array An array of unary operators
+ */
+ public function getUnaryOperators()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->unaryOperators;
+ }
+
+ /**
+ * Gets the registered binary Operators.
+ *
+ * @return array An array of binary operators
+ */
+ public function getBinaryOperators()
+ {
+ if (!$this->extensionInitialized) {
+ $this->initExtensions();
+ }
+
+ return $this->binaryOperators;
+ }
+
+ public function computeAlternatives($name, $items)
+ {
+ $alternatives = array();
+ foreach ($items as $item) {
+ $lev = levenshtein($name, $item);
+ if ($lev <= strlen($name) / 3 || false !== strpos($item, $name)) {
+ $alternatives[$item] = $lev;
+ }
+ }
+ asort($alternatives);
+
+ return array_keys($alternatives);
+ }
+
+ protected function initGlobals()
+ {
+ $globals = array();
+ foreach ($this->extensions as $extension) {
+ $extGlob = $extension->getGlobals();
+ if (!is_array($extGlob)) {
+ throw new UnexpectedValueException(sprintf('"%s::getGlobals()" must return an array of globals.', get_class($extension)));
+ }
+
+ $globals[] = $extGlob;
+ }
+
+ $globals[] = $this->staging->getGlobals();
+
+ return call_user_func_array('array_merge', $globals);
+ }
+
+ protected function initExtensions()
+ {
+ if ($this->extensionInitialized) {
+ return;
+ }
+
+ $this->extensionInitialized = true;
+ $this->parsers = new Twig_TokenParserBroker();
+ $this->filters = array();
+ $this->functions = array();
+ $this->tests = array();
+ $this->visitors = array();
+ $this->unaryOperators = array();
+ $this->binaryOperators = array();
+
+ foreach ($this->extensions as $extension) {
+ $this->initExtension($extension);
+ }
+ $this->initExtension($this->staging);
+ }
+
+ protected function initExtension(Twig_ExtensionInterface $extension)
+ {
+ // filters
+ foreach ($extension->getFilters() as $name => $filter) {
+ if ($name instanceof Twig_SimpleFilter) {
+ $filter = $name;
+ $name = $filter->getName();
+ } elseif ($filter instanceof Twig_SimpleFilter) {
+ $name = $filter->getName();
+ }
+
+ $this->filters[$name] = $filter;
+ }
+
+ // functions
+ foreach ($extension->getFunctions() as $name => $function) {
+ if ($name instanceof Twig_SimpleFunction) {
+ $function = $name;
+ $name = $function->getName();
+ } elseif ($function instanceof Twig_SimpleFunction) {
+ $name = $function->getName();
+ }
+
+ $this->functions[$name] = $function;
+ }
+
+ // tests
+ foreach ($extension->getTests() as $name => $test) {
+ if ($name instanceof Twig_SimpleTest) {
+ $test = $name;
+ $name = $test->getName();
+ } elseif ($test instanceof Twig_SimpleTest) {
+ $name = $test->getName();
+ }
+
+ $this->tests[$name] = $test;
+ }
+
+ // token parsers
+ foreach ($extension->getTokenParsers() as $parser) {
+ if ($parser instanceof Twig_TokenParserInterface) {
+ $this->parsers->addTokenParser($parser);
+ } elseif ($parser instanceof Twig_TokenParserBrokerInterface) {
+ $this->parsers->addTokenParserBroker($parser);
+ } else {
+ throw new LogicException('getTokenParsers() must return an array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances');
+ }
+ }
+
+ // node visitors
+ foreach ($extension->getNodeVisitors() as $visitor) {
+ $this->visitors[] = $visitor;
+ }
+
+ // operators
+ if ($operators = $extension->getOperators()) {
+ if (2 !== count($operators)) {
+ throw new InvalidArgumentException(sprintf('"%s::getOperators()" does not return a valid operators array.', get_class($extension)));
+ }
+
+ $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
+ $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
+ }
+ }
+
+ protected function writeCacheFile($file, $content)
+ {
+ $dir = dirname($file);
+ if (!is_dir($dir)) {
+ if (false === @mkdir($dir, 0777, true)) {
+ clearstatcache(false, $dir);
+ if (!is_dir($dir)) {
+ throw new RuntimeException(sprintf('Unable to create the cache directory (%s).', $dir));
+ }
+ }
+ } elseif (!is_writable($dir)) {
+ throw new RuntimeException(sprintf('Unable to write in the cache directory (%s).', $dir));
+ }
+
+ $tmpFile = tempnam($dir, basename($file));
+ if (false !== @file_put_contents($tmpFile, $content)) {
+ // rename does not work on Win32 before 5.2.6
+ if (@rename($tmpFile, $file) || (@copy($tmpFile, $file) && unlink($tmpFile))) {
+ @chmod($file, 0666 & ~umask());
+
+ return;
+ }
+ }
+
+ throw new RuntimeException(sprintf('Failed to write cache file "%s".', $file));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Error.php b/vendor/twig/twig/lib/Twig/Error.php
new file mode 100755
index 0000000..90650c5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Error.php
@@ -0,0 +1,250 @@
+
+ */
+class Twig_Error extends Exception
+{
+ protected $lineno;
+ protected $filename;
+ protected $rawMessage;
+ protected $previous;
+
+ /**
+ * Constructor.
+ *
+ * Set both the line number and the filename to false to
+ * disable automatic guessing of the original template name
+ * and line number.
+ *
+ * Set the line number to -1 to enable its automatic guessing.
+ * Set the filename to null to enable its automatic guessing.
+ *
+ * By default, automatic guessing is enabled.
+ *
+ * @param string $message The error message
+ * @param int $lineno The template line where the error occurred
+ * @param string $filename The template file name where the error occurred
+ * @param Exception $previous The previous exception
+ */
+ public function __construct($message, $lineno = -1, $filename = null, Exception $previous = null)
+ {
+ if (PHP_VERSION_ID < 50300) {
+ $this->previous = $previous;
+ parent::__construct('');
+ } else {
+ parent::__construct('', 0, $previous);
+ }
+
+ $this->lineno = $lineno;
+ $this->filename = $filename;
+
+ if (-1 === $this->lineno || null === $this->filename) {
+ $this->guessTemplateInfo();
+ }
+
+ $this->rawMessage = $message;
+
+ $this->updateRepr();
+ }
+
+ /**
+ * Gets the raw message.
+ *
+ * @return string The raw message
+ */
+ public function getRawMessage()
+ {
+ return $this->rawMessage;
+ }
+
+ /**
+ * Gets the filename where the error occurred.
+ *
+ * @return string The filename
+ */
+ public function getTemplateFile()
+ {
+ return $this->filename;
+ }
+
+ /**
+ * Sets the filename where the error occurred.
+ *
+ * @param string $filename The filename
+ */
+ public function setTemplateFile($filename)
+ {
+ $this->filename = $filename;
+
+ $this->updateRepr();
+ }
+
+ /**
+ * Gets the template line where the error occurred.
+ *
+ * @return int The template line
+ */
+ public function getTemplateLine()
+ {
+ return $this->lineno;
+ }
+
+ /**
+ * Sets the template line where the error occurred.
+ *
+ * @param int $lineno The template line
+ */
+ public function setTemplateLine($lineno)
+ {
+ $this->lineno = $lineno;
+
+ $this->updateRepr();
+ }
+
+ public function guess()
+ {
+ $this->guessTemplateInfo();
+ $this->updateRepr();
+ }
+
+ /**
+ * For PHP < 5.3.0, provides access to the getPrevious() method.
+ *
+ * @param string $method The method name
+ * @param array $arguments The parameters to be passed to the method
+ *
+ * @return Exception The previous exception or null
+ *
+ * @throws BadMethodCallException
+ */
+ public function __call($method, $arguments)
+ {
+ if ('getprevious' == strtolower($method)) {
+ return $this->previous;
+ }
+
+ throw new BadMethodCallException(sprintf('Method "Twig_Error::%s()" does not exist.', $method));
+ }
+
+ protected function updateRepr()
+ {
+ $this->message = $this->rawMessage;
+
+ $dot = false;
+ if ('.' === substr($this->message, -1)) {
+ $this->message = substr($this->message, 0, -1);
+ $dot = true;
+ }
+
+ if ($this->filename) {
+ if (is_string($this->filename) || (is_object($this->filename) && method_exists($this->filename, '__toString'))) {
+ $filename = sprintf('"%s"', $this->filename);
+ } else {
+ $filename = json_encode($this->filename);
+ }
+ $this->message .= sprintf(' in %s', $filename);
+ }
+
+ if ($this->lineno && $this->lineno >= 0) {
+ $this->message .= sprintf(' at line %d', $this->lineno);
+ }
+
+ if ($dot) {
+ $this->message .= '.';
+ }
+ }
+
+ protected function guessTemplateInfo()
+ {
+ $template = null;
+ $templateClass = null;
+
+ if (PHP_VERSION_ID >= 50306) {
+ $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS | DEBUG_BACKTRACE_PROVIDE_OBJECT);
+ } else {
+ $backtrace = debug_backtrace();
+ }
+
+ foreach ($backtrace as $trace) {
+ if (isset($trace['object']) && $trace['object'] instanceof Twig_Template && 'Twig_Template' !== get_class($trace['object'])) {
+ $currentClass = get_class($trace['object']);
+ $isEmbedContainer = 0 === strpos($templateClass, $currentClass);
+ if (null === $this->filename || ($this->filename == $trace['object']->getTemplateName() && !$isEmbedContainer)) {
+ $template = $trace['object'];
+ $templateClass = get_class($trace['object']);
+ }
+ }
+ }
+
+ // update template filename
+ if (null !== $template && null === $this->filename) {
+ $this->filename = $template->getTemplateName();
+ }
+
+ if (null === $template || $this->lineno > -1) {
+ return;
+ }
+
+ $r = new ReflectionObject($template);
+ $file = $r->getFileName();
+
+ // hhvm has a bug where eval'ed files comes out as the current directory
+ if (is_dir($file)) {
+ $file = '';
+ }
+
+ $exceptions = array($e = $this);
+ while (($e instanceof self || method_exists($e, 'getPrevious')) && $e = $e->getPrevious()) {
+ $exceptions[] = $e;
+ }
+
+ while ($e = array_pop($exceptions)) {
+ $traces = $e->getTrace();
+ array_unshift($traces, array('file' => $e->getFile(), 'line' => $e->getLine()));
+
+ while ($trace = array_shift($traces)) {
+ if (!isset($trace['file']) || !isset($trace['line']) || $file != $trace['file']) {
+ continue;
+ }
+
+ foreach ($template->getDebugInfo() as $codeLine => $templateLine) {
+ if ($codeLine <= $trace['line']) {
+ // update template line
+ $this->lineno = $templateLine;
+
+ return;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Error/Loader.php b/vendor/twig/twig/lib/Twig/Error/Loader.php
new file mode 100755
index 0000000..68efb57
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Error/Loader.php
@@ -0,0 +1,31 @@
+
+ */
+class Twig_Error_Loader extends Twig_Error
+{
+ public function __construct($message, $lineno = -1, $filename = null, Exception $previous = null)
+ {
+ parent::__construct($message, false, false, $previous);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Error/Runtime.php b/vendor/twig/twig/lib/Twig/Error/Runtime.php
new file mode 100755
index 0000000..8b6cedd
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Error/Runtime.php
@@ -0,0 +1,20 @@
+
+ */
+class Twig_Error_Runtime extends Twig_Error
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/Error/Syntax.php b/vendor/twig/twig/lib/Twig/Error/Syntax.php
new file mode 100755
index 0000000..0f5c579
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Error/Syntax.php
@@ -0,0 +1,20 @@
+
+ */
+class Twig_Error_Syntax extends Twig_Error
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/ExistsLoaderInterface.php b/vendor/twig/twig/lib/Twig/ExistsLoaderInterface.php
new file mode 100755
index 0000000..b168c3c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/ExistsLoaderInterface.php
@@ -0,0 +1,29 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_ExistsLoaderInterface
+{
+ /**
+ * Check if we have the source code of a template, given its name.
+ *
+ * @param string $name The name of the template to check if we can load
+ *
+ * @return bool If the template source code is handled by this loader or not
+ */
+ public function exists($name);
+}
diff --git a/vendor/twig/twig/lib/Twig/ExpressionParser.php b/vendor/twig/twig/lib/Twig/ExpressionParser.php
new file mode 100755
index 0000000..8fc8346
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/ExpressionParser.php
@@ -0,0 +1,619 @@
+
+ */
+class Twig_ExpressionParser
+{
+ const OPERATOR_LEFT = 1;
+ const OPERATOR_RIGHT = 2;
+
+ protected $parser;
+ protected $unaryOperators;
+ protected $binaryOperators;
+
+ public function __construct(Twig_Parser $parser, array $unaryOperators, array $binaryOperators)
+ {
+ $this->parser = $parser;
+ $this->unaryOperators = $unaryOperators;
+ $this->binaryOperators = $binaryOperators;
+ }
+
+ public function parseExpression($precedence = 0)
+ {
+ $expr = $this->getPrimary();
+ $token = $this->parser->getCurrentToken();
+ while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
+ $op = $this->binaryOperators[$token->getValue()];
+ $this->parser->getStream()->next();
+
+ if (isset($op['callable'])) {
+ $expr = call_user_func($op['callable'], $this->parser, $expr);
+ } else {
+ $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
+ $class = $op['class'];
+ $expr = new $class($expr, $expr1, $token->getLine());
+ }
+
+ $token = $this->parser->getCurrentToken();
+ }
+
+ if (0 === $precedence) {
+ return $this->parseConditionalExpression($expr);
+ }
+
+ return $expr;
+ }
+
+ protected function getPrimary()
+ {
+ $token = $this->parser->getCurrentToken();
+
+ if ($this->isUnary($token)) {
+ $operator = $this->unaryOperators[$token->getValue()];
+ $this->parser->getStream()->next();
+ $expr = $this->parseExpression($operator['precedence']);
+ $class = $operator['class'];
+
+ return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
+ } elseif ($token->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $this->parser->getStream()->next();
+ $expr = $this->parseExpression();
+ $this->parser->getStream()->expect(Twig_Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
+
+ return $this->parsePostfixExpression($expr);
+ }
+
+ return $this->parsePrimaryExpression();
+ }
+
+ protected function parseConditionalExpression($expr)
+ {
+ while ($this->parser->getStream()->nextIf(Twig_Token::PUNCTUATION_TYPE, '?')) {
+ if (!$this->parser->getStream()->nextIf(Twig_Token::PUNCTUATION_TYPE, ':')) {
+ $expr2 = $this->parseExpression();
+ if ($this->parser->getStream()->nextIf(Twig_Token::PUNCTUATION_TYPE, ':')) {
+ $expr3 = $this->parseExpression();
+ } else {
+ $expr3 = new Twig_Node_Expression_Constant('', $this->parser->getCurrentToken()->getLine());
+ }
+ } else {
+ $expr2 = $expr;
+ $expr3 = $this->parseExpression();
+ }
+
+ $expr = new Twig_Node_Expression_Conditional($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
+ }
+
+ return $expr;
+ }
+
+ protected function isUnary(Twig_Token $token)
+ {
+ return $token->test(Twig_Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->getValue()]);
+ }
+
+ protected function isBinary(Twig_Token $token)
+ {
+ return $token->test(Twig_Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->getValue()]);
+ }
+
+ public function parsePrimaryExpression()
+ {
+ $token = $this->parser->getCurrentToken();
+ switch ($token->getType()) {
+ case Twig_Token::NAME_TYPE:
+ $this->parser->getStream()->next();
+ switch ($token->getValue()) {
+ case 'true':
+ case 'TRUE':
+ $node = new Twig_Node_Expression_Constant(true, $token->getLine());
+ break;
+
+ case 'false':
+ case 'FALSE':
+ $node = new Twig_Node_Expression_Constant(false, $token->getLine());
+ break;
+
+ case 'none':
+ case 'NONE':
+ case 'null':
+ case 'NULL':
+ $node = new Twig_Node_Expression_Constant(null, $token->getLine());
+ break;
+
+ default:
+ if ('(' === $this->parser->getCurrentToken()->getValue()) {
+ $node = $this->getFunctionNode($token->getValue(), $token->getLine());
+ } else {
+ $node = new Twig_Node_Expression_Name($token->getValue(), $token->getLine());
+ }
+ }
+ break;
+
+ case Twig_Token::NUMBER_TYPE:
+ $this->parser->getStream()->next();
+ $node = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ break;
+
+ case Twig_Token::STRING_TYPE:
+ case Twig_Token::INTERPOLATION_START_TYPE:
+ $node = $this->parseStringExpression();
+ break;
+
+ case Twig_Token::OPERATOR_TYPE:
+ if (preg_match(Twig_Lexer::REGEX_NAME, $token->getValue(), $matches) && $matches[0] == $token->getValue()) {
+ // in this context, string operators are variable names
+ $this->parser->getStream()->next();
+ $node = new Twig_Node_Expression_Name($token->getValue(), $token->getLine());
+ break;
+ } elseif (isset($this->unaryOperators[$token->getValue()])) {
+ $class = $this->unaryOperators[$token->getValue()]['class'];
+
+ $ref = new ReflectionClass($class);
+ $negClass = 'Twig_Node_Expression_Unary_Neg';
+ $posClass = 'Twig_Node_Expression_Unary_Pos';
+ if (!(in_array($ref->getName(), array($negClass, $posClass)) || $ref->isSubclassOf($negClass) || $ref->isSubclassOf($posClass))) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected unary operator "%s"', $token->getValue()), $token->getLine(), $this->parser->getFilename());
+ }
+
+ $this->parser->getStream()->next();
+ $expr = $this->parsePrimaryExpression();
+
+ $node = new $class($expr, $token->getLine());
+ break;
+ }
+
+ default:
+ if ($token->test(Twig_Token::PUNCTUATION_TYPE, '[')) {
+ $node = $this->parseArrayExpression();
+ } elseif ($token->test(Twig_Token::PUNCTUATION_TYPE, '{')) {
+ $node = $this->parseHashExpression();
+ } else {
+ throw new Twig_Error_Syntax(sprintf('Unexpected token "%s" of value "%s"', Twig_Token::typeToEnglish($token->getType()), $token->getValue()), $token->getLine(), $this->parser->getFilename());
+ }
+ }
+
+ return $this->parsePostfixExpression($node);
+ }
+
+ public function parseStringExpression()
+ {
+ $stream = $this->parser->getStream();
+
+ $nodes = array();
+ // a string cannot be followed by another string in a single expression
+ $nextCanBeString = true;
+ while (true) {
+ if ($nextCanBeString && $token = $stream->nextIf(Twig_Token::STRING_TYPE)) {
+ $nodes[] = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ $nextCanBeString = false;
+ } elseif ($stream->nextIf(Twig_Token::INTERPOLATION_START_TYPE)) {
+ $nodes[] = $this->parseExpression();
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $nextCanBeString = true;
+ } else {
+ break;
+ }
+ }
+
+ $expr = array_shift($nodes);
+ foreach ($nodes as $node) {
+ $expr = new Twig_Node_Expression_Binary_Concat($expr, $node, $node->getLine());
+ }
+
+ return $expr;
+ }
+
+ public function parseArrayExpression()
+ {
+ $stream = $this->parser->getStream();
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
+
+ $node = new Twig_Node_Expression_Array(array(), $stream->getCurrent()->getLine());
+ $first = true;
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ if (!$first) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
+
+ // trailing ,?
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ break;
+ }
+ }
+ $first = false;
+
+ $node->addElement($this->parseExpression());
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
+
+ return $node;
+ }
+
+ public function parseHashExpression()
+ {
+ $stream = $this->parser->getStream();
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '{', 'A hash element was expected');
+
+ $node = new Twig_Node_Expression_Array(array(), $stream->getCurrent()->getLine());
+ $first = true;
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, '}')) {
+ if (!$first) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'A hash value must be followed by a comma');
+
+ // trailing ,?
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '}')) {
+ break;
+ }
+ }
+ $first = false;
+
+ // a hash key can be:
+ //
+ // * a number -- 12
+ // * a string -- 'a'
+ // * a name, which is equivalent to a string -- a
+ // * an expression, which must be enclosed in parentheses -- (1 + 2)
+ if (($token = $stream->nextIf(Twig_Token::STRING_TYPE)) || ($token = $stream->nextIf(Twig_Token::NAME_TYPE)) || $token = $stream->nextIf(Twig_Token::NUMBER_TYPE)) {
+ $key = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ } elseif ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $key = $this->parseExpression();
+ } else {
+ $current = $stream->getCurrent();
+
+ throw new Twig_Error_Syntax(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s"', Twig_Token::typeToEnglish($current->getType()), $current->getValue()), $current->getLine(), $this->parser->getFilename());
+ }
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ':', 'A hash key must be followed by a colon (:)');
+ $value = $this->parseExpression();
+
+ $node->addElement($value, $key);
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '}', 'An opened hash is not properly closed');
+
+ return $node;
+ }
+
+ public function parsePostfixExpression($node)
+ {
+ while (true) {
+ $token = $this->parser->getCurrentToken();
+ if ($token->getType() == Twig_Token::PUNCTUATION_TYPE) {
+ if ('.' == $token->getValue() || '[' == $token->getValue()) {
+ $node = $this->parseSubscriptExpression($node);
+ } elseif ('|' == $token->getValue()) {
+ $node = $this->parseFilterExpression($node);
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ return $node;
+ }
+
+ public function getFunctionNode($name, $line)
+ {
+ switch ($name) {
+ case 'parent':
+ $this->parseArguments();
+ if (!count($this->parser->getBlockStack())) {
+ throw new Twig_Error_Syntax('Calling "parent" outside a block is forbidden', $line, $this->parser->getFilename());
+ }
+
+ if (!$this->parser->getParent() && !$this->parser->hasTraits()) {
+ throw new Twig_Error_Syntax('Calling "parent" on a template that does not extend nor "use" another template is forbidden', $line, $this->parser->getFilename());
+ }
+
+ return new Twig_Node_Expression_Parent($this->parser->peekBlockStack(), $line);
+ case 'block':
+ return new Twig_Node_Expression_BlockReference($this->parseArguments()->getNode(0), false, $line);
+ case 'attribute':
+ $args = $this->parseArguments();
+ if (count($args) < 2) {
+ throw new Twig_Error_Syntax('The "attribute" function takes at least two arguments (the variable and the attributes)', $line, $this->parser->getFilename());
+ }
+
+ return new Twig_Node_Expression_GetAttr($args->getNode(0), $args->getNode(1), count($args) > 2 ? $args->getNode(2) : null, Twig_Template::ANY_CALL, $line);
+ default:
+ if (null !== $alias = $this->parser->getImportedSymbol('function', $name)) {
+ $arguments = new Twig_Node_Expression_Array(array(), $line);
+ foreach ($this->parseArguments() as $n) {
+ $arguments->addElement($n);
+ }
+
+ $node = new Twig_Node_Expression_MethodCall($alias['node'], $alias['name'], $arguments, $line);
+ $node->setAttribute('safe', true);
+
+ return $node;
+ }
+
+ $args = $this->parseArguments(true);
+ $class = $this->getFunctionNodeClass($name, $line);
+
+ return new $class($name, $args, $line);
+ }
+ }
+
+ public function parseSubscriptExpression($node)
+ {
+ $stream = $this->parser->getStream();
+ $token = $stream->next();
+ $lineno = $token->getLine();
+ $arguments = new Twig_Node_Expression_Array(array(), $lineno);
+ $type = Twig_Template::ANY_CALL;
+ if ($token->getValue() == '.') {
+ $token = $stream->next();
+ if (
+ $token->getType() == Twig_Token::NAME_TYPE
+ ||
+ $token->getType() == Twig_Token::NUMBER_TYPE
+ ||
+ ($token->getType() == Twig_Token::OPERATOR_TYPE && preg_match(Twig_Lexer::REGEX_NAME, $token->getValue()))
+ ) {
+ $arg = new Twig_Node_Expression_Constant($token->getValue(), $lineno);
+
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $type = Twig_TemplateInterface::METHOD_CALL;
+ foreach ($this->parseArguments() as $n) {
+ $arguments->addElement($n);
+ }
+ }
+ } else {
+ throw new Twig_Error_Syntax('Expected name or number', $lineno, $this->parser->getFilename());
+ }
+
+ if ($node instanceof Twig_Node_Expression_Name && null !== $this->parser->getImportedSymbol('template', $node->getAttribute('name'))) {
+ if (!$arg instanceof Twig_Node_Expression_Constant) {
+ throw new Twig_Error_Syntax(sprintf('Dynamic macro names are not supported (called on "%s")', $node->getAttribute('name')), $token->getLine(), $this->parser->getFilename());
+ }
+
+ $node = new Twig_Node_Expression_MethodCall($node, 'get'.$arg->getAttribute('value'), $arguments, $lineno);
+ $node->setAttribute('safe', true);
+
+ return $node;
+ }
+ } else {
+ $type = Twig_Template::ARRAY_CALL;
+
+ // slice?
+ $slice = false;
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ':')) {
+ $slice = true;
+ $arg = new Twig_Node_Expression_Constant(0, $token->getLine());
+ } else {
+ $arg = $this->parseExpression();
+ }
+
+ if ($stream->nextIf(Twig_Token::PUNCTUATION_TYPE, ':')) {
+ $slice = true;
+ }
+
+ if ($slice) {
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ $length = new Twig_Node_Expression_Constant(null, $token->getLine());
+ } else {
+ $length = $this->parseExpression();
+ }
+
+ $class = $this->getFilterNodeClass('slice', $token->getLine());
+ $arguments = new Twig_Node(array($arg, $length));
+ $filter = new $class($node, new Twig_Node_Expression_Constant('slice', $token->getLine()), $arguments, $token->getLine());
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']');
+
+ return $filter;
+ }
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']');
+ }
+
+ return new Twig_Node_Expression_GetAttr($node, $arg, $arguments, $type, $lineno);
+ }
+
+ public function parseFilterExpression($node)
+ {
+ $this->parser->getStream()->next();
+
+ return $this->parseFilterExpressionRaw($node);
+ }
+
+ public function parseFilterExpressionRaw($node, $tag = null)
+ {
+ while (true) {
+ $token = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE);
+
+ $name = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $arguments = new Twig_Node();
+ } else {
+ $arguments = $this->parseArguments(true);
+ }
+
+ $class = $this->getFilterNodeClass($name->getAttribute('value'), $token->getLine());
+
+ $node = new $class($node, $name, $arguments, $token->getLine(), $tag);
+
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, '|')) {
+ break;
+ }
+
+ $this->parser->getStream()->next();
+ }
+
+ return $node;
+ }
+
+ /**
+ * Parses arguments.
+ *
+ * @param bool $namedArguments Whether to allow named arguments or not
+ * @param bool $definition Whether we are parsing arguments for a function definition
+ *
+ * @return Twig_Node
+ *
+ * @throws Twig_Error_Syntax
+ */
+ public function parseArguments($namedArguments = false, $definition = false)
+ {
+ $args = array();
+ $stream = $this->parser->getStream();
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ')')) {
+ if (!empty($args)) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
+ }
+
+ if ($definition) {
+ $token = $stream->expect(Twig_Token::NAME_TYPE, null, 'An argument must be a name');
+ $value = new Twig_Node_Expression_Name($token->getValue(), $this->parser->getCurrentToken()->getLine());
+ } else {
+ $value = $this->parseExpression();
+ }
+
+ $name = null;
+ if ($namedArguments && $token = $stream->nextIf(Twig_Token::OPERATOR_TYPE, '=')) {
+ if (!$value instanceof Twig_Node_Expression_Name) {
+ throw new Twig_Error_Syntax(sprintf('A parameter name must be a string, "%s" given', get_class($value)), $token->getLine(), $this->parser->getFilename());
+ }
+ $name = $value->getAttribute('name');
+
+ if ($definition) {
+ $value = $this->parsePrimaryExpression();
+
+ if (!$this->checkConstantExpression($value)) {
+ throw new Twig_Error_Syntax(sprintf('A default value for an argument must be a constant (a boolean, a string, a number, or an array).'), $token->getLine(), $this->parser->getFilename());
+ }
+ } else {
+ $value = $this->parseExpression();
+ }
+ }
+
+ if ($definition) {
+ if (null === $name) {
+ $name = $value->getAttribute('name');
+ $value = new Twig_Node_Expression_Constant(null, $this->parser->getCurrentToken()->getLine());
+ }
+ $args[$name] = $value;
+ } else {
+ if (null === $name) {
+ $args[] = $value;
+ } else {
+ $args[$name] = $value;
+ }
+ }
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
+
+ return new Twig_Node($args);
+ }
+
+ public function parseAssignmentExpression()
+ {
+ $targets = array();
+ while (true) {
+ $token = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE, null, 'Only variables can be assigned to');
+ if (in_array($token->getValue(), array('true', 'false', 'none'))) {
+ throw new Twig_Error_Syntax(sprintf('You cannot assign a value to "%s"', $token->getValue()), $token->getLine(), $this->parser->getFilename());
+ }
+ $targets[] = new Twig_Node_Expression_AssignName($token->getValue(), $token->getLine());
+
+ if (!$this->parser->getStream()->nextIf(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ }
+
+ return new Twig_Node($targets);
+ }
+
+ public function parseMultitargetExpression()
+ {
+ $targets = array();
+ while (true) {
+ $targets[] = $this->parseExpression();
+ if (!$this->parser->getStream()->nextIf(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ }
+
+ return new Twig_Node($targets);
+ }
+
+ protected function getFunctionNodeClass($name, $line)
+ {
+ $env = $this->parser->getEnvironment();
+
+ if (false === $function = $env->getFunction($name)) {
+ $message = sprintf('The function "%s" does not exist', $name);
+ if ($alternatives = $env->computeAlternatives($name, array_keys($env->getFunctions()))) {
+ $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
+ }
+
+ throw new Twig_Error_Syntax($message, $line, $this->parser->getFilename());
+ }
+
+ if ($function instanceof Twig_SimpleFunction) {
+ return $function->getNodeClass();
+ }
+
+ return $function instanceof Twig_Function_Node ? $function->getClass() : 'Twig_Node_Expression_Function';
+ }
+
+ protected function getFilterNodeClass($name, $line)
+ {
+ $env = $this->parser->getEnvironment();
+
+ if (false === $filter = $env->getFilter($name)) {
+ $message = sprintf('The filter "%s" does not exist', $name);
+ if ($alternatives = $env->computeAlternatives($name, array_keys($env->getFilters()))) {
+ $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
+ }
+
+ throw new Twig_Error_Syntax($message, $line, $this->parser->getFilename());
+ }
+
+ if ($filter instanceof Twig_SimpleFilter) {
+ return $filter->getNodeClass();
+ }
+
+ return $filter instanceof Twig_Filter_Node ? $filter->getClass() : 'Twig_Node_Expression_Filter';
+ }
+
+ // checks that the node only contains "constant" elements
+ protected function checkConstantExpression(Twig_NodeInterface $node)
+ {
+ if (!($node instanceof Twig_Node_Expression_Constant || $node instanceof Twig_Node_Expression_Array
+ || $node instanceof Twig_Node_Expression_Unary_Neg || $node instanceof Twig_Node_Expression_Unary_Pos
+ )) {
+ return false;
+ }
+
+ foreach ($node as $n) {
+ if (!$this->checkConstantExpression($n)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension.php b/vendor/twig/twig/lib/Twig/Extension.php
new file mode 100755
index 0000000..5c8ad5c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension.php
@@ -0,0 +1,93 @@
+escapers[$strategy] = $callable;
+ }
+
+ /**
+ * Gets all defined escapers.
+ *
+ * @return array An array of escapers
+ */
+ public function getEscapers()
+ {
+ return $this->escapers;
+ }
+
+ /**
+ * Sets the default format to be used by the date filter.
+ *
+ * @param string $format The default date format string
+ * @param string $dateIntervalFormat The default date interval format string
+ */
+ public function setDateFormat($format = null, $dateIntervalFormat = null)
+ {
+ if (null !== $format) {
+ $this->dateFormats[0] = $format;
+ }
+
+ if (null !== $dateIntervalFormat) {
+ $this->dateFormats[1] = $dateIntervalFormat;
+ }
+ }
+
+ /**
+ * Gets the default format to be used by the date filter.
+ *
+ * @return array The default date format string and the default date interval format string
+ */
+ public function getDateFormat()
+ {
+ return $this->dateFormats;
+ }
+
+ /**
+ * Sets the default timezone to be used by the date filter.
+ *
+ * @param DateTimeZone|string $timezone The default timezone string or a DateTimeZone object
+ */
+ public function setTimezone($timezone)
+ {
+ $this->timezone = $timezone instanceof DateTimeZone ? $timezone : new DateTimeZone($timezone);
+ }
+
+ /**
+ * Gets the default timezone to be used by the date filter.
+ *
+ * @return DateTimeZone The default timezone currently in use
+ */
+ public function getTimezone()
+ {
+ if (null === $this->timezone) {
+ $this->timezone = new DateTimeZone(date_default_timezone_get());
+ }
+
+ return $this->timezone;
+ }
+
+ /**
+ * Sets the default format to be used by the number_format filter.
+ *
+ * @param int $decimal The number of decimal places to use.
+ * @param string $decimalPoint The character(s) to use for the decimal point.
+ * @param string $thousandSep The character(s) to use for the thousands separator.
+ */
+ public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
+ {
+ $this->numberFormat = array($decimal, $decimalPoint, $thousandSep);
+ }
+
+ /**
+ * Get the default format used by the number_format filter.
+ *
+ * @return array The arguments for number_format()
+ */
+ public function getNumberFormat()
+ {
+ return $this->numberFormat;
+ }
+
+ /**
+ * Returns the token parser instance to add to the existing list.
+ *
+ * @return Twig_TokenParser[] An array of Twig_TokenParser instances
+ */
+ public function getTokenParsers()
+ {
+ return array(
+ new Twig_TokenParser_For(),
+ new Twig_TokenParser_If(),
+ new Twig_TokenParser_Extends(),
+ new Twig_TokenParser_Include(),
+ new Twig_TokenParser_Block(),
+ new Twig_TokenParser_Use(),
+ new Twig_TokenParser_Filter(),
+ new Twig_TokenParser_Macro(),
+ new Twig_TokenParser_Import(),
+ new Twig_TokenParser_From(),
+ new Twig_TokenParser_Set(),
+ new Twig_TokenParser_Spaceless(),
+ new Twig_TokenParser_Flush(),
+ new Twig_TokenParser_Do(),
+ new Twig_TokenParser_Embed(),
+ );
+ }
+
+ /**
+ * Returns a list of filters to add to the existing list.
+ *
+ * @return array An array of filters
+ */
+ public function getFilters()
+ {
+ $filters = array(
+ // formatting filters
+ new Twig_SimpleFilter('date', 'twig_date_format_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('date_modify', 'twig_date_modify_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('format', 'sprintf'),
+ new Twig_SimpleFilter('replace', 'strtr'),
+ new Twig_SimpleFilter('number_format', 'twig_number_format_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('abs', 'abs'),
+ new Twig_SimpleFilter('round', 'twig_round'),
+
+ // encoding
+ new Twig_SimpleFilter('url_encode', 'twig_urlencode_filter'),
+ new Twig_SimpleFilter('json_encode', 'twig_jsonencode_filter'),
+ new Twig_SimpleFilter('convert_encoding', 'twig_convert_encoding'),
+
+ // string filters
+ new Twig_SimpleFilter('title', 'twig_title_string_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('capitalize', 'twig_capitalize_string_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('upper', 'strtoupper'),
+ new Twig_SimpleFilter('lower', 'strtolower'),
+ new Twig_SimpleFilter('striptags', 'strip_tags'),
+ new Twig_SimpleFilter('trim', 'trim'),
+ new Twig_SimpleFilter('nl2br', 'nl2br', array('pre_escape' => 'html', 'is_safe' => array('html'))),
+
+ // array helpers
+ new Twig_SimpleFilter('join', 'twig_join_filter'),
+ new Twig_SimpleFilter('split', 'twig_split_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('sort', 'twig_sort_filter'),
+ new Twig_SimpleFilter('merge', 'twig_array_merge'),
+ new Twig_SimpleFilter('batch', 'twig_array_batch'),
+
+ // string/array filters
+ new Twig_SimpleFilter('reverse', 'twig_reverse_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('length', 'twig_length_filter', array('needs_environment' => true)),
+ new Twig_SimpleFilter('slice', 'twig_slice', array('needs_environment' => true)),
+ new Twig_SimpleFilter('first', 'twig_first', array('needs_environment' => true)),
+ new Twig_SimpleFilter('last', 'twig_last', array('needs_environment' => true)),
+
+ // iteration and runtime
+ new Twig_SimpleFilter('default', '_twig_default_filter', array('node_class' => 'Twig_Node_Expression_Filter_Default')),
+ new Twig_SimpleFilter('keys', 'twig_get_array_keys_filter'),
+
+ // escaping
+ new Twig_SimpleFilter('escape', 'twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
+ new Twig_SimpleFilter('e', 'twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
+ );
+
+ if (function_exists('mb_get_info')) {
+ $filters[] = new Twig_SimpleFilter('upper', 'twig_upper_filter', array('needs_environment' => true));
+ $filters[] = new Twig_SimpleFilter('lower', 'twig_lower_filter', array('needs_environment' => true));
+ }
+
+ return $filters;
+ }
+
+ /**
+ * Returns a list of global functions to add to the existing list.
+ *
+ * @return array An array of global functions
+ */
+ public function getFunctions()
+ {
+ return array(
+ new Twig_SimpleFunction('max', 'max'),
+ new Twig_SimpleFunction('min', 'min'),
+ new Twig_SimpleFunction('range', 'range'),
+ new Twig_SimpleFunction('constant', 'twig_constant'),
+ new Twig_SimpleFunction('cycle', 'twig_cycle'),
+ new Twig_SimpleFunction('random', 'twig_random', array('needs_environment' => true)),
+ new Twig_SimpleFunction('date', 'twig_date_converter', array('needs_environment' => true)),
+ new Twig_SimpleFunction('include', 'twig_include', array('needs_environment' => true, 'needs_context' => true, 'is_safe' => array('all'))),
+ new Twig_SimpleFunction('source', 'twig_source', array('needs_environment' => true, 'is_safe' => array('all'))),
+ );
+ }
+
+ /**
+ * Returns a list of tests to add to the existing list.
+ *
+ * @return array An array of tests
+ */
+ public function getTests()
+ {
+ return array(
+ new Twig_SimpleTest('even', null, array('node_class' => 'Twig_Node_Expression_Test_Even')),
+ new Twig_SimpleTest('odd', null, array('node_class' => 'Twig_Node_Expression_Test_Odd')),
+ new Twig_SimpleTest('defined', null, array('node_class' => 'Twig_Node_Expression_Test_Defined')),
+ new Twig_SimpleTest('sameas', null, array('node_class' => 'Twig_Node_Expression_Test_Sameas')),
+ new Twig_SimpleTest('same as', null, array('node_class' => 'Twig_Node_Expression_Test_Sameas')),
+ new Twig_SimpleTest('none', null, array('node_class' => 'Twig_Node_Expression_Test_Null')),
+ new Twig_SimpleTest('null', null, array('node_class' => 'Twig_Node_Expression_Test_Null')),
+ new Twig_SimpleTest('divisibleby', null, array('node_class' => 'Twig_Node_Expression_Test_Divisibleby')),
+ new Twig_SimpleTest('divisible by', null, array('node_class' => 'Twig_Node_Expression_Test_Divisibleby')),
+ new Twig_SimpleTest('constant', null, array('node_class' => 'Twig_Node_Expression_Test_Constant')),
+ new Twig_SimpleTest('empty', 'twig_test_empty'),
+ new Twig_SimpleTest('iterable', 'twig_test_iterable'),
+ );
+ }
+
+ /**
+ * Returns a list of operators to add to the existing list.
+ *
+ * @return array An array of operators
+ */
+ public function getOperators()
+ {
+ return array(
+ array(
+ 'not' => array('precedence' => 50, 'class' => 'Twig_Node_Expression_Unary_Not'),
+ '-' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Neg'),
+ '+' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Pos'),
+ ),
+ array(
+ 'or' => array('precedence' => 10, 'class' => 'Twig_Node_Expression_Binary_Or', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'and' => array('precedence' => 15, 'class' => 'Twig_Node_Expression_Binary_And', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'b-or' => array('precedence' => 16, 'class' => 'Twig_Node_Expression_Binary_BitwiseOr', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'b-xor' => array('precedence' => 17, 'class' => 'Twig_Node_Expression_Binary_BitwiseXor', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'b-and' => array('precedence' => 18, 'class' => 'Twig_Node_Expression_Binary_BitwiseAnd', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '==' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Equal', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '!=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '<' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Less', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '>' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Greater', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '>=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_GreaterEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '<=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_LessEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'not in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotIn', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_In', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'matches' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Matches', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'starts with' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_StartsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'ends with' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_EndsWith', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '..' => array('precedence' => 25, 'class' => 'Twig_Node_Expression_Binary_Range', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '+' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Add', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '-' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Sub', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '~' => array('precedence' => 40, 'class' => 'Twig_Node_Expression_Binary_Concat', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '*' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mul', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '/' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Div', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '//' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_FloorDiv', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '%' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mod', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'is' => array('precedence' => 100, 'callable' => array($this, 'parseTestExpression'), 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'is not' => array('precedence' => 100, 'callable' => array($this, 'parseNotTestExpression'), 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '**' => array('precedence' => 200, 'class' => 'Twig_Node_Expression_Binary_Power', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT),
+ ),
+ );
+ }
+
+ public function parseNotTestExpression(Twig_Parser $parser, Twig_NodeInterface $node)
+ {
+ return new Twig_Node_Expression_Unary_Not($this->parseTestExpression($parser, $node), $parser->getCurrentToken()->getLine());
+ }
+
+ public function parseTestExpression(Twig_Parser $parser, Twig_NodeInterface $node)
+ {
+ $stream = $parser->getStream();
+ $name = $this->getTestName($parser, $node->getLine());
+ $class = $this->getTestNodeClass($parser, $name);
+ $arguments = null;
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $arguments = $parser->getExpressionParser()->parseArguments(true);
+ }
+
+ return new $class($node, $name, $arguments, $parser->getCurrentToken()->getLine());
+ }
+
+ protected function getTestName(Twig_Parser $parser, $line)
+ {
+ $stream = $parser->getStream();
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ $env = $parser->getEnvironment();
+ $testMap = $env->getTests();
+
+ if (isset($testMap[$name])) {
+ return $name;
+ }
+
+ if ($stream->test(Twig_Token::NAME_TYPE)) {
+ // try 2-words tests
+ $name = $name.' '.$parser->getCurrentToken()->getValue();
+
+ if (isset($testMap[$name])) {
+ $parser->getStream()->next();
+
+ return $name;
+ }
+ }
+
+ $message = sprintf('The test "%s" does not exist', $name);
+ if ($alternatives = $env->computeAlternatives($name, array_keys($testMap))) {
+ $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
+ }
+
+ throw new Twig_Error_Syntax($message, $line, $parser->getFilename());
+ }
+
+ protected function getTestNodeClass(Twig_Parser $parser, $name)
+ {
+ $env = $parser->getEnvironment();
+ $testMap = $env->getTests();
+
+ if ($testMap[$name] instanceof Twig_SimpleTest) {
+ return $testMap[$name]->getNodeClass();
+ }
+
+ return $testMap[$name] instanceof Twig_Test_Node ? $testMap[$name]->getClass() : 'Twig_Node_Expression_Test';
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'core';
+ }
+}
+
+/**
+ * Cycles over a value.
+ *
+ * @param ArrayAccess|array $values An array or an ArrayAccess instance
+ * @param int $position The cycle position
+ *
+ * @return string The next value in the cycle
+ */
+function twig_cycle($values, $position)
+{
+ if (!is_array($values) && !$values instanceof ArrayAccess) {
+ return $values;
+ }
+
+ return $values[$position % count($values)];
+}
+
+/**
+ * Returns a random value depending on the supplied parameter type:
+ * - a random item from a Traversable or array
+ * - a random character from a string
+ * - a random integer between 0 and the integer parameter
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param Traversable|array|int|string $values The values to pick a random item from
+ *
+ * @throws Twig_Error_Runtime When $values is an empty array (does not apply to an empty string which is returned as is).
+ *
+ * @return mixed A random value from the given sequence
+ */
+function twig_random(Twig_Environment $env, $values = null)
+{
+ if (null === $values) {
+ return mt_rand();
+ }
+
+ if (is_int($values) || is_float($values)) {
+ return $values < 0 ? mt_rand($values, 0) : mt_rand(0, $values);
+ }
+
+ if ($values instanceof Traversable) {
+ $values = iterator_to_array($values);
+ } elseif (is_string($values)) {
+ if ('' === $values) {
+ return '';
+ }
+ if (null !== $charset = $env->getCharset()) {
+ if ('UTF-8' != $charset) {
+ $values = twig_convert_encoding($values, 'UTF-8', $charset);
+ }
+
+ // unicode version of str_split()
+ // split at all positions, but not after the start and not before the end
+ $values = preg_split('/(? $value) {
+ $values[$i] = twig_convert_encoding($value, $charset, 'UTF-8');
+ }
+ }
+ } else {
+ return $values[mt_rand(0, strlen($values) - 1)];
+ }
+ }
+
+ if (!is_array($values)) {
+ return $values;
+ }
+
+ if (0 === count($values)) {
+ throw new Twig_Error_Runtime('The random function cannot pick from an empty array.');
+ }
+
+ return $values[array_rand($values, 1)];
+}
+
+/**
+ * Converts a date to the given format.
+ *
+ *
+ * {{ post.published_at|date("m/d/Y") }}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param DateTime|DateTimeInterface|DateInterval|string $date A date
+ * @param string|null $format The target format, null to use the default
+ * @param DateTimeZone|string|null|false $timezone The target timezone, null to use the default, false to leave unchanged
+ *
+ * @return string The formatted date
+ */
+function twig_date_format_filter(Twig_Environment $env, $date, $format = null, $timezone = null)
+{
+ if (null === $format) {
+ $formats = $env->getExtension('core')->getDateFormat();
+ $format = $date instanceof DateInterval ? $formats[1] : $formats[0];
+ }
+
+ if ($date instanceof DateInterval) {
+ return $date->format($format);
+ }
+
+ return twig_date_converter($env, $date, $timezone)->format($format);
+}
+
+/**
+ * Returns a new date object modified
+ *
+ *
+ * {{ post.published_at|date_modify("-1day")|date("m/d/Y") }}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param DateTime|string $date A date
+ * @param string $modifier A modifier string
+ *
+ * @return DateTime A new date object
+ */
+function twig_date_modify_filter(Twig_Environment $env, $date, $modifier)
+{
+ $date = twig_date_converter($env, $date, false);
+ $resultDate = $date->modify($modifier);
+
+ // This is a hack to ensure PHP 5.2 support and support for DateTimeImmutable
+ // DateTime::modify does not return the modified DateTime object < 5.3.0
+ // and DateTimeImmutable does not modify $date.
+ return null === $resultDate ? $date : $resultDate;
+}
+
+/**
+ * Converts an input to a DateTime instance.
+ *
+ *
+ * {% if date(user.created_at) < date('+2days') %}
+ * {# do something #}
+ * {% endif %}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param DateTime|DateTimeInterface|string|null $date A date
+ * @param DateTimeZone|string|null|false $timezone The target timezone, null to use the default, false to leave unchanged
+ *
+ * @return DateTime A DateTime instance
+ */
+function twig_date_converter(Twig_Environment $env, $date = null, $timezone = null)
+{
+ // determine the timezone
+ if (false !== $timezone) {
+ if (null === $timezone) {
+ $timezone = $env->getExtension('core')->getTimezone();
+ } elseif (!$timezone instanceof DateTimeZone) {
+ $timezone = new DateTimeZone($timezone);
+ }
+ }
+
+ // immutable dates
+ if ($date instanceof DateTimeImmutable) {
+ return false !== $timezone ? $date->setTimezone($timezone) : $date;
+ }
+
+ if ($date instanceof DateTime || $date instanceof DateTimeInterface) {
+ $date = clone $date;
+ if (false !== $timezone) {
+ $date->setTimezone($timezone);
+ }
+
+ return $date;
+ }
+
+ $asString = (string) $date;
+ if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
+ $date = '@'.$date;
+ }
+
+ $date = new DateTime($date, $env->getExtension('core')->getTimezone());
+ if (false !== $timezone) {
+ $date->setTimezone($timezone);
+ }
+
+ return $date;
+}
+
+/**
+ * Rounds a number.
+ *
+ * @param int|float $value The value to round
+ * @param int|float $precision The rounding precision
+ * @param string $method The method to use for rounding
+ *
+ * @return int|float The rounded number
+ */
+function twig_round($value, $precision = 0, $method = 'common')
+{
+ if ('common' == $method) {
+ return round($value, $precision);
+ }
+
+ if ('ceil' != $method && 'floor' != $method) {
+ throw new Twig_Error_Runtime('The round filter only supports the "common", "ceil", and "floor" methods.');
+ }
+
+ return $method($value * pow(10, $precision)) / pow(10, $precision);
+}
+
+/**
+ * Number format filter.
+ *
+ * All of the formatting options can be left null, in that case the defaults will
+ * be used. Supplying any of the parameters will override the defaults set in the
+ * environment object.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $number A float/int/string of the number to format
+ * @param int $decimal The number of decimal points to display.
+ * @param string $decimalPoint The character(s) to use for the decimal point.
+ * @param string $thousandSep The character(s) to use for the thousands separator.
+ *
+ * @return string The formatted number
+ */
+function twig_number_format_filter(Twig_Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
+{
+ $defaults = $env->getExtension('core')->getNumberFormat();
+ if (null === $decimal) {
+ $decimal = $defaults[0];
+ }
+
+ if (null === $decimalPoint) {
+ $decimalPoint = $defaults[1];
+ }
+
+ if (null === $thousandSep) {
+ $thousandSep = $defaults[2];
+ }
+
+ return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
+}
+
+/**
+ * URL encodes (RFC 3986) a string as a path segment or an array as a query string.
+ *
+ * @param string|array $url A URL or an array of query parameters
+ *
+ * @return string The URL encoded value
+ */
+function twig_urlencode_filter($url)
+{
+ if (is_array($url)) {
+ if (defined('PHP_QUERY_RFC3986')) {
+ return http_build_query($url, '', '&', PHP_QUERY_RFC3986);
+ }
+
+ return http_build_query($url, '', '&');
+ }
+
+ return rawurlencode($url);
+}
+
+if (PHP_VERSION_ID < 50300) {
+ /**
+ * JSON encodes a variable.
+ *
+ * @param mixed $value The value to encode.
+ * @param int $options Not used on PHP 5.2.x
+ *
+ * @return mixed The JSON encoded value
+ */
+ function twig_jsonencode_filter($value, $options = 0)
+ {
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ } elseif (is_array($value)) {
+ array_walk_recursive($value, '_twig_markup2string');
+ }
+
+ return json_encode($value);
+ }
+} else {
+ /**
+ * JSON encodes a variable.
+ *
+ * @param mixed $value The value to encode.
+ * @param int $options Bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT
+ *
+ * @return mixed The JSON encoded value
+ */
+ function twig_jsonencode_filter($value, $options = 0)
+ {
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ } elseif (is_array($value)) {
+ array_walk_recursive($value, '_twig_markup2string');
+ }
+
+ return json_encode($value, $options);
+ }
+}
+
+function _twig_markup2string(&$value)
+{
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ }
+}
+
+/**
+ * Merges an array with another one.
+ *
+ *
+ * {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
+ *
+ * {% set items = items|merge({ 'peugeot': 'car' }) %}
+ *
+ * {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
+ *
+ *
+ * @param array $arr1 An array
+ * @param array $arr2 An array
+ *
+ * @return array The merged array
+ */
+function twig_array_merge($arr1, $arr2)
+{
+ if (!is_array($arr1) || !is_array($arr2)) {
+ throw new Twig_Error_Runtime(sprintf('The merge filter only works with arrays or hashes; %s and %s given.', gettype($arr1), gettype($arr2)));
+ }
+
+ return array_merge($arr1, $arr2);
+}
+
+/**
+ * Slices a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $item A variable
+ * @param int $start Start of the slice
+ * @param int $length Size of the slice
+ * @param bool $preserveKeys Whether to preserve key or not (when the input is an array)
+ *
+ * @return mixed The sliced variable
+ */
+function twig_slice(Twig_Environment $env, $item, $start, $length = null, $preserveKeys = false)
+{
+ if ($item instanceof Traversable) {
+ if ($item instanceof IteratorAggregate) {
+ $item = $item->getIterator();
+ }
+
+ if ($start >= 0 && $length >= 0 && $item instanceof Iterator) {
+ try {
+ return iterator_to_array(new LimitIterator($item, $start, $length === null ? -1 : $length), $preserveKeys);
+ } catch (OutOfBoundsException $exception) {
+ return array();
+ }
+ }
+
+ $item = iterator_to_array($item, $preserveKeys);
+ }
+
+ if (is_array($item)) {
+ return array_slice($item, $start, $length, $preserveKeys);
+ }
+
+ $item = (string) $item;
+
+ if (function_exists('mb_get_info') && null !== $charset = $env->getCharset()) {
+ return (string) mb_substr($item, $start, null === $length ? mb_strlen($item, $charset) - $start : $length, $charset);
+ }
+
+ return (string) (null === $length ? substr($item, $start) : substr($item, $start, $length));
+}
+
+/**
+ * Returns the first element of the item.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $item A variable
+ *
+ * @return mixed The first element of the item
+ */
+function twig_first(Twig_Environment $env, $item)
+{
+ $elements = twig_slice($env, $item, 0, 1, false);
+
+ return is_string($elements) ? $elements : current($elements);
+}
+
+/**
+ * Returns the last element of the item.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $item A variable
+ *
+ * @return mixed The last element of the item
+ */
+function twig_last(Twig_Environment $env, $item)
+{
+ $elements = twig_slice($env, $item, -1, 1, false);
+
+ return is_string($elements) ? $elements : current($elements);
+}
+
+/**
+ * Joins the values to a string.
+ *
+ * The separator between elements is an empty string per default, you can define it with the optional parameter.
+ *
+ *
+ * {{ [1, 2, 3]|join('|') }}
+ * {# returns 1|2|3 #}
+ *
+ * {{ [1, 2, 3]|join }}
+ * {# returns 123 #}
+ *
+ *
+ * @param array $value An array
+ * @param string $glue The separator
+ *
+ * @return string The concatenated string
+ */
+function twig_join_filter($value, $glue = '')
+{
+ if ($value instanceof Traversable) {
+ $value = iterator_to_array($value, false);
+ }
+
+ return implode($glue, (array) $value);
+}
+
+/**
+ * Splits the string into an array.
+ *
+ *
+ * {{ "one,two,three"|split(',') }}
+ * {# returns [one, two, three] #}
+ *
+ * {{ "one,two,three,four,five"|split(',', 3) }}
+ * {# returns [one, two, "three,four,five"] #}
+ *
+ * {{ "123"|split('') }}
+ * {# returns [1, 2, 3] #}
+ *
+ * {{ "aabbcc"|split('', 2) }}
+ * {# returns [aa, bb, cc] #}
+ *
+ *
+ * @param string $value A string
+ * @param string $delimiter The delimiter
+ * @param int $limit The limit
+ *
+ * @return array The split string as an array
+ */
+function twig_split_filter(Twig_Environment $env, $value, $delimiter, $limit = null)
+{
+ if (!empty($delimiter)) {
+ return null === $limit ? explode($delimiter, $value) : explode($delimiter, $value, $limit);
+ }
+
+ if (!function_exists('mb_get_info') || null === $charset = $env->getCharset()) {
+ return str_split($value, null === $limit ? 1 : $limit);
+ }
+
+ if ($limit <= 1) {
+ return preg_split('/(?
+ * {% for key in array|keys %}
+ * {# ... #}
+ * {% endfor %}
+ *
+ *
+ * @param array $array An array
+ *
+ * @return array The keys
+ */
+function twig_get_array_keys_filter($array)
+{
+ if (is_object($array) && $array instanceof Traversable) {
+ return array_keys(iterator_to_array($array));
+ }
+
+ if (!is_array($array)) {
+ return array();
+ }
+
+ return array_keys($array);
+}
+
+/**
+ * Reverses a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param array|Traversable|string $item An array, a Traversable instance, or a string
+ * @param bool $preserveKeys Whether to preserve key or not
+ *
+ * @return mixed The reversed input
+ */
+function twig_reverse_filter(Twig_Environment $env, $item, $preserveKeys = false)
+{
+ if (is_object($item) && $item instanceof Traversable) {
+ return array_reverse(iterator_to_array($item), $preserveKeys);
+ }
+
+ if (is_array($item)) {
+ return array_reverse($item, $preserveKeys);
+ }
+
+ if (null !== $charset = $env->getCharset()) {
+ $string = (string) $item;
+
+ if ('UTF-8' != $charset) {
+ $item = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ preg_match_all('/./us', $item, $matches);
+
+ $string = implode('', array_reverse($matches[0]));
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+ }
+
+ return strrev((string) $item);
+}
+
+/**
+ * Sorts an array.
+ *
+ * @param array $array
+ *
+ * @return array
+ */
+function twig_sort_filter($array)
+{
+ asort($array);
+
+ return $array;
+}
+
+/* used internally */
+function twig_in_filter($value, $compare)
+{
+ if (is_array($compare)) {
+ return in_array($value, $compare, is_object($value) || is_resource($value));
+ } elseif (is_string($compare) && (is_string($value) || is_int($value) || is_float($value))) {
+ return '' === $value || false !== strpos($compare, (string) $value);
+ } elseif ($compare instanceof Traversable) {
+ return in_array($value, iterator_to_array($compare, false), is_object($value) || is_resource($value));
+ }
+
+ return false;
+}
+
+/**
+ * Escapes a string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string The value to be escaped
+ * @param string $strategy The escaping strategy
+ * @param string $charset The charset
+ * @param bool $autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
+ *
+ * @return string
+ */
+function twig_escape_filter(Twig_Environment $env, $string, $strategy = 'html', $charset = null, $autoescape = false)
+{
+ if ($autoescape && $string instanceof Twig_Markup) {
+ return $string;
+ }
+
+ if (!is_string($string)) {
+ if (is_object($string) && method_exists($string, '__toString')) {
+ $string = (string) $string;
+ } else {
+ return $string;
+ }
+ }
+
+ if (null === $charset) {
+ $charset = $env->getCharset();
+ }
+
+ switch ($strategy) {
+ case 'html':
+ // see http://php.net/htmlspecialchars
+
+ // Using a static variable to avoid initializing the array
+ // each time the function is called. Moving the declaration on the
+ // top of the function slow downs other escaping strategies.
+ static $htmlspecialcharsCharsets;
+
+ if (null === $htmlspecialcharsCharsets) {
+ if (defined('HHVM_VERSION')) {
+ $htmlspecialcharsCharsets = array('utf-8' => true, 'UTF-8' => true);
+ } else {
+ $htmlspecialcharsCharsets = array(
+ 'ISO-8859-1' => true, 'ISO8859-1' => true,
+ 'ISO-8859-15' => true, 'ISO8859-15' => true,
+ 'utf-8' => true, 'UTF-8' => true,
+ 'CP866' => true, 'IBM866' => true, '866' => true,
+ 'CP1251' => true, 'WINDOWS-1251' => true, 'WIN-1251' => true,
+ '1251' => true,
+ 'CP1252' => true, 'WINDOWS-1252' => true, '1252' => true,
+ 'KOI8-R' => true, 'KOI8-RU' => true, 'KOI8R' => true,
+ 'BIG5' => true, '950' => true,
+ 'GB2312' => true, '936' => true,
+ 'BIG5-HKSCS' => true,
+ 'SHIFT_JIS' => true, 'SJIS' => true, '932' => true,
+ 'EUC-JP' => true, 'EUCJP' => true,
+ 'ISO8859-5' => true, 'ISO-8859-5' => true, 'MACROMAN' => true,
+ );
+ }
+ }
+
+ if (isset($htmlspecialcharsCharsets[$charset])) {
+ return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
+ }
+
+ if (isset($htmlspecialcharsCharsets[strtoupper($charset)])) {
+ // cache the lowercase variant for future iterations
+ $htmlspecialcharsCharsets[$charset] = true;
+
+ return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
+ }
+
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
+
+ return twig_convert_encoding($string, $charset, 'UTF-8');
+
+ case 'js':
+ // escape all non-alphanumeric characters
+ // into their \xHH or \uHHHH representations
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ if (0 == strlen($string) ? false : (1 == preg_match('/^./su', $string) ? false : true)) {
+ throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
+ }
+
+ $string = preg_replace_callback('#[^a-zA-Z0-9,\._]#Su', '_twig_escape_js_callback', $string);
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+
+ case 'css':
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ if (0 == strlen($string) ? false : (1 == preg_match('/^./su', $string) ? false : true)) {
+ throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
+ }
+
+ $string = preg_replace_callback('#[^a-zA-Z0-9]#Su', '_twig_escape_css_callback', $string);
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+
+ case 'html_attr':
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ if (0 == strlen($string) ? false : (1 == preg_match('/^./su', $string) ? false : true)) {
+ throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
+ }
+
+ $string = preg_replace_callback('#[^a-zA-Z0-9,\.\-_]#Su', '_twig_escape_html_attr_callback', $string);
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+
+ case 'url':
+ if (PHP_VERSION_ID < 50300) {
+ return str_replace('%7E', '~', rawurlencode($string));
+ }
+
+ return rawurlencode($string);
+
+ default:
+ static $escapers;
+
+ if (null === $escapers) {
+ $escapers = $env->getExtension('core')->getEscapers();
+ }
+
+ if (isset($escapers[$strategy])) {
+ return call_user_func($escapers[$strategy], $env, $string, $charset);
+ }
+
+ $validStrategies = implode(', ', array_merge(array('html', 'js', 'url', 'css', 'html_attr'), array_keys($escapers)));
+
+ throw new Twig_Error_Runtime(sprintf('Invalid escaping strategy "%s" (valid ones: %s).', $strategy, $validStrategies));
+ }
+}
+
+/* used internally */
+function twig_escape_filter_is_safe(Twig_Node $filterArgs)
+{
+ foreach ($filterArgs as $arg) {
+ if ($arg instanceof Twig_Node_Expression_Constant) {
+ return array($arg->getAttribute('value'));
+ }
+
+ return array();
+ }
+
+ return array('html');
+}
+
+if (function_exists('mb_convert_encoding')) {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ return mb_convert_encoding($string, $to, $from);
+ }
+} elseif (function_exists('iconv')) {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ return iconv($from, $to, $string);
+ }
+} else {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ throw new Twig_Error_Runtime('No suitable convert encoding function (use UTF-8 as your encoding or install the iconv or mbstring extension).');
+ }
+}
+
+function _twig_escape_js_callback($matches)
+{
+ $char = $matches[0];
+
+ // \xHH
+ if (!isset($char[1])) {
+ return '\\x'.strtoupper(substr('00'.bin2hex($char), -2));
+ }
+
+ // \uHHHH
+ $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
+
+ return '\\u'.strtoupper(substr('0000'.bin2hex($char), -4));
+}
+
+function _twig_escape_css_callback($matches)
+{
+ $char = $matches[0];
+
+ // \xHH
+ if (!isset($char[1])) {
+ $hex = ltrim(strtoupper(bin2hex($char)), '0');
+ if (0 === strlen($hex)) {
+ $hex = '0';
+ }
+
+ return '\\'.$hex.' ';
+ }
+
+ // \uHHHH
+ $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
+
+ return '\\'.ltrim(strtoupper(bin2hex($char)), '0').' ';
+}
+
+/**
+ * This function is adapted from code coming from Zend Framework.
+ *
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license http://framework.zend.com/license/new-bsd New BSD License
+ */
+function _twig_escape_html_attr_callback($matches)
+{
+ /*
+ * While HTML supports far more named entities, the lowest common denominator
+ * has become HTML5's XML Serialisation which is restricted to the those named
+ * entities that XML supports. Using HTML entities would result in this error:
+ * XML Parsing Error: undefined entity
+ */
+ static $entityMap = array(
+ 34 => 'quot', /* quotation mark */
+ 38 => 'amp', /* ampersand */
+ 60 => 'lt', /* less-than sign */
+ 62 => 'gt', /* greater-than sign */
+ );
+
+ $chr = $matches[0];
+ $ord = ord($chr);
+
+ /**
+ * The following replaces characters undefined in HTML with the
+ * hex entity for the Unicode replacement character.
+ */
+ if (($ord <= 0x1f && $chr != "\t" && $chr != "\n" && $chr != "\r") || ($ord >= 0x7f && $ord <= 0x9f)) {
+ return '�';
+ }
+
+ /**
+ * Check if the current character to escape has a name entity we should
+ * replace it with while grabbing the hex value of the character.
+ */
+ if (strlen($chr) == 1) {
+ $hex = strtoupper(substr('00'.bin2hex($chr), -2));
+ } else {
+ $chr = twig_convert_encoding($chr, 'UTF-16BE', 'UTF-8');
+ $hex = strtoupper(substr('0000'.bin2hex($chr), -4));
+ }
+
+ $int = hexdec($hex);
+ if (array_key_exists($int, $entityMap)) {
+ return sprintf('&%s;', $entityMap[$int]);
+ }
+
+ /**
+ * Per OWASP recommendations, we'll use hex entities for any other
+ * characters where a named entity does not exist.
+ */
+ return sprintf('%s;', $hex);
+}
+
+// add multibyte extensions if possible
+if (function_exists('mb_get_info')) {
+ /**
+ * Returns the length of a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $thing A variable
+ *
+ * @return int The length of the value
+ */
+ function twig_length_filter(Twig_Environment $env, $thing)
+ {
+ return is_scalar($thing) ? mb_strlen($thing, $env->getCharset()) : count($thing);
+ }
+
+ /**
+ * Converts a string to uppercase.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The uppercased string
+ */
+ function twig_upper_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtoupper($string, $charset);
+ }
+
+ return strtoupper($string);
+ }
+
+ /**
+ * Converts a string to lowercase.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The lowercased string
+ */
+ function twig_lower_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtolower($string, $charset);
+ }
+
+ return strtolower($string);
+ }
+
+ /**
+ * Returns a titlecased string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The titlecased string
+ */
+ function twig_title_string_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_convert_case($string, MB_CASE_TITLE, $charset);
+ }
+
+ return ucwords(strtolower($string));
+ }
+
+ /**
+ * Returns a capitalized string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The capitalized string
+ */
+ function twig_capitalize_string_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).
+ mb_strtolower(mb_substr($string, 1, mb_strlen($string, $charset), $charset), $charset);
+ }
+
+ return ucfirst(strtolower($string));
+ }
+}
+// and byte fallback
+else {
+ /**
+ * Returns the length of a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $thing A variable
+ *
+ * @return int The length of the value
+ */
+ function twig_length_filter(Twig_Environment $env, $thing)
+ {
+ return is_scalar($thing) ? strlen($thing) : count($thing);
+ }
+
+ /**
+ * Returns a titlecased string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The titlecased string
+ */
+ function twig_title_string_filter(Twig_Environment $env, $string)
+ {
+ return ucwords(strtolower($string));
+ }
+
+ /**
+ * Returns a capitalized string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The capitalized string
+ */
+ function twig_capitalize_string_filter(Twig_Environment $env, $string)
+ {
+ return ucfirst(strtolower($string));
+ }
+}
+
+/* used internally */
+function twig_ensure_traversable($seq)
+{
+ if ($seq instanceof Traversable || is_array($seq)) {
+ return $seq;
+ }
+
+ return array();
+}
+
+/**
+ * Checks if a variable is empty.
+ *
+ *
+ * {# evaluates to true if the foo variable is null, false, or the empty string #}
+ * {% if foo is empty %}
+ * {# ... #}
+ * {% endif %}
+ *
+ *
+ * @param mixed $value A variable
+ *
+ * @return bool true if the value is empty, false otherwise
+ */
+function twig_test_empty($value)
+{
+ if ($value instanceof Countable) {
+ return 0 == count($value);
+ }
+
+ return '' === $value || false === $value || null === $value || array() === $value;
+}
+
+/**
+ * Checks if a variable is traversable.
+ *
+ *
+ * {# evaluates to true if the foo variable is an array or a traversable object #}
+ * {% if foo is traversable %}
+ * {# ... #}
+ * {% endif %}
+ *
+ *
+ * @param mixed $value A variable
+ *
+ * @return bool true if the value is traversable
+ */
+function twig_test_iterable($value)
+{
+ return $value instanceof Traversable || is_array($value);
+}
+
+/**
+ * Renders a template.
+ *
+ * @param Twig_Environment $env
+ * @param array $context
+ * @param string|array $template The template to render or an array of templates to try consecutively
+ * @param array $variables The variables to pass to the template
+ * @param bool $withContext
+ * @param bool $ignoreMissing Whether to ignore missing templates or not
+ * @param bool $sandboxed Whether to sandbox the template or not
+ *
+ * @return string The rendered template
+ */
+function twig_include(Twig_Environment $env, $context, $template, $variables = array(), $withContext = true, $ignoreMissing = false, $sandboxed = false)
+{
+ $alreadySandboxed = false;
+ $sandbox = null;
+ if ($withContext) {
+ $variables = array_merge($context, $variables);
+ }
+
+ if ($isSandboxed = $sandboxed && $env->hasExtension('sandbox')) {
+ $sandbox = $env->getExtension('sandbox');
+ if (!$alreadySandboxed = $sandbox->isSandboxed()) {
+ $sandbox->enableSandbox();
+ }
+ }
+
+ try {
+ return $env->resolveTemplate($template)->render($variables);
+ } catch (Twig_Error_Loader $e) {
+ if (!$ignoreMissing) {
+ throw $e;
+ }
+ }
+
+ if ($isSandboxed && !$alreadySandboxed) {
+ $sandbox->disableSandbox();
+ }
+}
+
+/**
+ * Returns a template content without rendering it.
+ *
+ * @param string $name The template name
+ *
+ * @return string The template source
+ */
+function twig_source(Twig_Environment $env, $name)
+{
+ return $env->getLoader()->getSource($name);
+}
+
+/**
+ * Provides the ability to get constants from instances as well as class/global constants.
+ *
+ * @param string $constant The name of the constant
+ * @param null|object $object The object to get the constant from
+ *
+ * @return string
+ */
+function twig_constant($constant, $object = null)
+{
+ if (null !== $object) {
+ $constant = get_class($object).'::'.$constant;
+ }
+
+ return constant($constant);
+}
+
+/**
+ * Batches item.
+ *
+ * @param array $items An array of items
+ * @param int $size The size of the batch
+ * @param mixed $fill A value used to fill missing items
+ *
+ * @return array
+ */
+function twig_array_batch($items, $size, $fill = null)
+{
+ if ($items instanceof Traversable) {
+ $items = iterator_to_array($items, false);
+ }
+
+ $size = ceil($size);
+
+ $result = array_chunk($items, $size, true);
+
+ if (null !== $fill) {
+ $last = count($result) - 1;
+ if ($fillCount = $size - count($result[$last])) {
+ $result[$last] = array_merge(
+ $result[$last],
+ array_fill(0, $fillCount, $fill)
+ );
+ }
+ }
+
+ return $result;
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Debug.php b/vendor/twig/twig/lib/Twig/Extension/Debug.php
new file mode 100755
index 0000000..e3a85bf
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Debug.php
@@ -0,0 +1,71 @@
+ $isDumpOutputHtmlSafe ? array('html') : array(), 'needs_context' => true, 'needs_environment' => true)),
+ );
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'debug';
+ }
+}
+
+function twig_var_dump(Twig_Environment $env, $context)
+{
+ if (!$env->isDebug()) {
+ return;
+ }
+
+ ob_start();
+
+ $count = func_num_args();
+ if (2 === $count) {
+ $vars = array();
+ foreach ($context as $key => $value) {
+ if (!$value instanceof Twig_Template) {
+ $vars[$key] = $value;
+ }
+ }
+
+ var_dump($vars);
+ } else {
+ for ($i = 2; $i < $count; $i++) {
+ var_dump(func_get_arg($i));
+ }
+ }
+
+ return ob_get_clean();
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Escaper.php b/vendor/twig/twig/lib/Twig/Extension/Escaper.php
new file mode 100755
index 0000000..cf2020e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Escaper.php
@@ -0,0 +1,113 @@
+setDefaultStrategy($defaultStrategy);
+ }
+
+ /**
+ * Returns the token parser instances to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
+ */
+ public function getTokenParsers()
+ {
+ return array(new Twig_TokenParser_AutoEscape());
+ }
+
+ /**
+ * Returns the node visitor instances to add to the existing list.
+ *
+ * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Escaper());
+ }
+
+ /**
+ * Returns a list of filters to add to the existing list.
+ *
+ * @return array An array of filters
+ */
+ public function getFilters()
+ {
+ return array(
+ new Twig_SimpleFilter('raw', 'twig_raw_filter', array('is_safe' => array('all'))),
+ );
+ }
+
+ /**
+ * Sets the default strategy to use when not defined by the user.
+ *
+ * The strategy can be a valid PHP callback that takes the template
+ * "filename" as an argument and returns the strategy to use.
+ *
+ * @param mixed $defaultStrategy An escaping strategy
+ */
+ public function setDefaultStrategy($defaultStrategy)
+ {
+ // for BC
+ if (true === $defaultStrategy) {
+ $defaultStrategy = 'html';
+ }
+
+ if ('filename' === $defaultStrategy) {
+ $defaultStrategy = array('Twig_FileExtensionEscapingStrategy', 'guess');
+ }
+
+ $this->defaultStrategy = $defaultStrategy;
+ }
+
+ /**
+ * Gets the default strategy to use when not defined by the user.
+ *
+ * @param string $filename The template "filename"
+ *
+ * @return string The default strategy to use for the template
+ */
+ public function getDefaultStrategy($filename)
+ {
+ // disable string callables to avoid calling a function named html or js,
+ // or any other upcoming escaping strategy
+ if (!is_string($this->defaultStrategy) && is_callable($this->defaultStrategy)) {
+ return call_user_func($this->defaultStrategy, $filename);
+ }
+
+ return $this->defaultStrategy;
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'escaper';
+ }
+}
+
+/**
+ * Marks a variable as being safe.
+ *
+ * @param string $string A PHP variable
+ *
+ * @return string
+ */
+function twig_raw_filter($string)
+{
+ return $string;
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Optimizer.php b/vendor/twig/twig/lib/Twig/Extension/Optimizer.php
new file mode 100755
index 0000000..013fcb6
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Optimizer.php
@@ -0,0 +1,35 @@
+optimizers = $optimizers;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Optimizer($this->optimizers));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getName()
+ {
+ return 'optimizer';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Profiler.php b/vendor/twig/twig/lib/Twig/Extension/Profiler.php
new file mode 100755
index 0000000..35e04a0
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Profiler.php
@@ -0,0 +1,52 @@
+actives = array($profile);
+ }
+
+ public function enter(Twig_Profiler_Profile $profile)
+ {
+ $this->actives[0]->addProfile($profile);
+ array_unshift($this->actives, $profile);
+ }
+
+ public function leave(Twig_Profiler_Profile $profile)
+ {
+ $profile->leave();
+ array_shift($this->actives);
+
+ if (1 === count($this->actives)) {
+ $this->actives[0]->leave();
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_Profiler_NodeVisitor_Profiler($this->getName()));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getName()
+ {
+ return 'profiler';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Sandbox.php b/vendor/twig/twig/lib/Twig/Extension/Sandbox.php
new file mode 100755
index 0000000..c58259c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Sandbox.php
@@ -0,0 +1,112 @@
+policy = $policy;
+ $this->sandboxedGlobally = $sandboxed;
+ }
+
+ /**
+ * Returns the token parser instances to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
+ */
+ public function getTokenParsers()
+ {
+ return array(new Twig_TokenParser_Sandbox());
+ }
+
+ /**
+ * Returns the node visitor instances to add to the existing list.
+ *
+ * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Sandbox());
+ }
+
+ public function enableSandbox()
+ {
+ $this->sandboxed = true;
+ }
+
+ public function disableSandbox()
+ {
+ $this->sandboxed = false;
+ }
+
+ public function isSandboxed()
+ {
+ return $this->sandboxedGlobally || $this->sandboxed;
+ }
+
+ public function isSandboxedGlobally()
+ {
+ return $this->sandboxedGlobally;
+ }
+
+ public function setSecurityPolicy(Twig_Sandbox_SecurityPolicyInterface $policy)
+ {
+ $this->policy = $policy;
+ }
+
+ public function getSecurityPolicy()
+ {
+ return $this->policy;
+ }
+
+ public function checkSecurity($tags, $filters, $functions)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkSecurity($tags, $filters, $functions);
+ }
+ }
+
+ public function checkMethodAllowed($obj, $method)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkMethodAllowed($obj, $method);
+ }
+ }
+
+ public function checkPropertyAllowed($obj, $method)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkPropertyAllowed($obj, $method);
+ }
+ }
+
+ public function ensureToStringAllowed($obj)
+ {
+ if ($this->isSandboxed() && is_object($obj)) {
+ $this->policy->checkMethodAllowed($obj, '__toString');
+ }
+
+ return $obj;
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'sandbox';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/Staging.php b/vendor/twig/twig/lib/Twig/Extension/Staging.php
new file mode 100755
index 0000000..8ab0f45
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/Staging.php
@@ -0,0 +1,113 @@
+
+ */
+class Twig_Extension_Staging extends Twig_Extension
+{
+ protected $functions = array();
+ protected $filters = array();
+ protected $visitors = array();
+ protected $tokenParsers = array();
+ protected $globals = array();
+ protected $tests = array();
+
+ public function addFunction($name, $function)
+ {
+ $this->functions[$name] = $function;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getFunctions()
+ {
+ return $this->functions;
+ }
+
+ public function addFilter($name, $filter)
+ {
+ $this->filters[$name] = $filter;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getFilters()
+ {
+ return $this->filters;
+ }
+
+ public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ $this->visitors[] = $visitor;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getNodeVisitors()
+ {
+ return $this->visitors;
+ }
+
+ public function addTokenParser(Twig_TokenParserInterface $parser)
+ {
+ $this->tokenParsers[] = $parser;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getTokenParsers()
+ {
+ return $this->tokenParsers;
+ }
+
+ public function addGlobal($name, $value)
+ {
+ $this->globals[$name] = $value;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getGlobals()
+ {
+ return $this->globals;
+ }
+
+ public function addTest($name, $test)
+ {
+ $this->tests[$name] = $test;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getTests()
+ {
+ return $this->tests;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getName()
+ {
+ return 'staging';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Extension/StringLoader.php b/vendor/twig/twig/lib/Twig/Extension/StringLoader.php
new file mode 100755
index 0000000..4e1a546
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Extension/StringLoader.php
@@ -0,0 +1,47 @@
+ true)),
+ );
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getName()
+ {
+ return 'string_loader';
+ }
+}
+
+/**
+ * Loads a template from a string.
+ *
+ *
+ * {{ include(template_from_string("Hello {{ name }}")) }}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $template A template as a string
+ *
+ * @return Twig_Template A Twig_Template instance
+ */
+function twig_template_from_string(Twig_Environment $env, $template)
+{
+ return $env->createTemplate($template);
+}
diff --git a/vendor/twig/twig/lib/Twig/ExtensionInterface.php b/vendor/twig/twig/lib/Twig/ExtensionInterface.php
new file mode 100755
index 0000000..49541b0
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/ExtensionInterface.php
@@ -0,0 +1,83 @@
+
+ */
+interface Twig_ExtensionInterface
+{
+ /**
+ * Initializes the runtime environment.
+ *
+ * This is where you can load some file that contains filter functions for instance.
+ *
+ * @param Twig_Environment $environment The current Twig_Environment instance
+ */
+ public function initRuntime(Twig_Environment $environment);
+
+ /**
+ * Returns the token parser instances to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
+ */
+ public function getTokenParsers();
+
+ /**
+ * Returns the node visitor instances to add to the existing list.
+ *
+ * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors();
+
+ /**
+ * Returns a list of filters to add to the existing list.
+ *
+ * @return array An array of filters
+ */
+ public function getFilters();
+
+ /**
+ * Returns a list of tests to add to the existing list.
+ *
+ * @return array An array of tests
+ */
+ public function getTests();
+
+ /**
+ * Returns a list of functions to add to the existing list.
+ *
+ * @return array An array of functions
+ */
+ public function getFunctions();
+
+ /**
+ * Returns a list of operators to add to the existing list.
+ *
+ * @return array An array of operators
+ */
+ public function getOperators();
+
+ /**
+ * Returns a list of global variables to add to the existing list.
+ *
+ * @return array An array of global variables
+ */
+ public function getGlobals();
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName();
+}
diff --git a/vendor/twig/twig/lib/Twig/FileExtensionEscapingStrategy.php b/vendor/twig/twig/lib/Twig/FileExtensionEscapingStrategy.php
new file mode 100755
index 0000000..b1ace7d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/FileExtensionEscapingStrategy.php
@@ -0,0 +1,49 @@
+
+ */
+class Twig_FileExtensionEscapingStrategy
+{
+ /**
+ * Guesses the best autoescaping strategy based on the file name.
+ *
+ * @param string $filename The template file name
+ *
+ * @return string The escaping strategy name to use
+ */
+ public static function guess($filename)
+ {
+ if (!preg_match('{\.(js|css|txt)(?:\.[^/\\\\]+)?$}', $filename, $match)) {
+ return 'html';
+ }
+
+ switch ($match[1]) {
+ case 'js':
+ return 'js';
+
+ case 'css':
+ return 'css';
+
+ case 'txt':
+ return false;
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Filter.php b/vendor/twig/twig/lib/Twig/Filter.php
new file mode 100755
index 0000000..5cfbb66
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Filter.php
@@ -0,0 +1,81 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+abstract class Twig_Filter implements Twig_FilterInterface, Twig_FilterCallableInterface
+{
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct(array $options = array())
+ {
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ 'pre_escape' => null,
+ 'preserves_safety' => null,
+ 'callable' => null,
+ ), $options);
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $filterArgs)
+ {
+ if (isset($this->options['is_safe'])) {
+ return $this->options['is_safe'];
+ }
+
+ if (isset($this->options['is_safe_callback'])) {
+ return call_user_func($this->options['is_safe_callback'], $filterArgs);
+ }
+ }
+
+ public function getPreservesSafety()
+ {
+ return $this->options['preserves_safety'];
+ }
+
+ public function getPreEscape()
+ {
+ return $this->options['pre_escape'];
+ }
+
+ public function getCallable()
+ {
+ return $this->options['callable'];
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Filter/Function.php b/vendor/twig/twig/lib/Twig/Filter/Function.php
new file mode 100755
index 0000000..ad374a5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Filter/Function.php
@@ -0,0 +1,37 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Filter_Function extends Twig_Filter
+{
+ protected $function;
+
+ public function __construct($function, array $options = array())
+ {
+ $options['callable'] = $function;
+
+ parent::__construct($options);
+
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Filter/Method.php b/vendor/twig/twig/lib/Twig/Filter/Method.php
new file mode 100755
index 0000000..63c8c3b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Filter/Method.php
@@ -0,0 +1,39 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Filter_Method extends Twig_Filter
+{
+ protected $extension;
+ protected $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method, array $options = array())
+ {
+ $options['callable'] = array($extension, $method);
+
+ parent::__construct($options);
+
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Filter/Node.php b/vendor/twig/twig/lib/Twig/Filter/Node.php
new file mode 100755
index 0000000..8744c5e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Filter/Node.php
@@ -0,0 +1,39 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Filter_Node extends Twig_Filter
+{
+ protected $class;
+
+ public function __construct($class, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/FilterCallableInterface.php b/vendor/twig/twig/lib/Twig/FilterCallableInterface.php
new file mode 100755
index 0000000..145534d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/FilterCallableInterface.php
@@ -0,0 +1,23 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_FilterCallableInterface
+{
+ public function getCallable();
+}
diff --git a/vendor/twig/twig/lib/Twig/FilterInterface.php b/vendor/twig/twig/lib/Twig/FilterInterface.php
new file mode 100755
index 0000000..5319ecc
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/FilterInterface.php
@@ -0,0 +1,42 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_FilterInterface
+{
+ /**
+ * Compiles a filter.
+ *
+ * @return string The PHP code for the filter
+ */
+ public function compile();
+
+ public function needsEnvironment();
+
+ public function needsContext();
+
+ public function getSafe(Twig_Node $filterArgs);
+
+ public function getPreservesSafety();
+
+ public function getPreEscape();
+
+ public function setArguments($arguments);
+
+ public function getArguments();
+}
diff --git a/vendor/twig/twig/lib/Twig/Function.php b/vendor/twig/twig/lib/Twig/Function.php
new file mode 100755
index 0000000..b5ffb2b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Function.php
@@ -0,0 +1,71 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+abstract class Twig_Function implements Twig_FunctionInterface, Twig_FunctionCallableInterface
+{
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct(array $options = array())
+ {
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ 'callable' => null,
+ ), $options);
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $functionArgs)
+ {
+ if (isset($this->options['is_safe'])) {
+ return $this->options['is_safe'];
+ }
+
+ if (isset($this->options['is_safe_callback'])) {
+ return call_user_func($this->options['is_safe_callback'], $functionArgs);
+ }
+
+ return array();
+ }
+
+ public function getCallable()
+ {
+ return $this->options['callable'];
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Function/Function.php b/vendor/twig/twig/lib/Twig/Function/Function.php
new file mode 100755
index 0000000..d1e1b96
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Function/Function.php
@@ -0,0 +1,38 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Function_Function extends Twig_Function
+{
+ protected $function;
+
+ public function __construct($function, array $options = array())
+ {
+ $options['callable'] = $function;
+
+ parent::__construct($options);
+
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Function/Method.php b/vendor/twig/twig/lib/Twig/Function/Method.php
new file mode 100755
index 0000000..67039a9
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Function/Method.php
@@ -0,0 +1,40 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Function_Method extends Twig_Function
+{
+ protected $extension;
+ protected $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method, array $options = array())
+ {
+ $options['callable'] = array($extension, $method);
+
+ parent::__construct($options);
+
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Function/Node.php b/vendor/twig/twig/lib/Twig/Function/Node.php
new file mode 100755
index 0000000..06a0d0d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Function/Node.php
@@ -0,0 +1,39 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Function_Node extends Twig_Function
+{
+ protected $class;
+
+ public function __construct($class, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/FunctionCallableInterface.php b/vendor/twig/twig/lib/Twig/FunctionCallableInterface.php
new file mode 100755
index 0000000..0aab4f5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/FunctionCallableInterface.php
@@ -0,0 +1,23 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_FunctionCallableInterface
+{
+ public function getCallable();
+}
diff --git a/vendor/twig/twig/lib/Twig/FunctionInterface.php b/vendor/twig/twig/lib/Twig/FunctionInterface.php
new file mode 100755
index 0000000..67f4f89
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/FunctionInterface.php
@@ -0,0 +1,39 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_FunctionInterface
+{
+ /**
+ * Compiles a function.
+ *
+ * @return string The PHP code for the function
+ */
+ public function compile();
+
+ public function needsEnvironment();
+
+ public function needsContext();
+
+ public function getSafe(Twig_Node $filterArgs);
+
+ public function setArguments($arguments);
+
+ public function getArguments();
+}
diff --git a/vendor/twig/twig/lib/Twig/Lexer.php b/vendor/twig/twig/lib/Twig/Lexer.php
new file mode 100755
index 0000000..19380b5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Lexer.php
@@ -0,0 +1,407 @@
+
+ */
+class Twig_Lexer implements Twig_LexerInterface
+{
+ protected $tokens;
+ protected $code;
+ protected $cursor;
+ protected $lineno;
+ protected $end;
+ protected $state;
+ protected $states;
+ protected $brackets;
+ protected $env;
+ protected $filename;
+ protected $options;
+ protected $regexes;
+ protected $position;
+ protected $positions;
+ protected $currentVarBlockLine;
+
+ const STATE_DATA = 0;
+ const STATE_BLOCK = 1;
+ const STATE_VAR = 2;
+ const STATE_STRING = 3;
+ const STATE_INTERPOLATION = 4;
+
+ const REGEX_NAME = '/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A';
+ const REGEX_NUMBER = '/[0-9]+(?:\.[0-9]+)?/A';
+ const REGEX_STRING = '/"([^#"\\\\]*(?:\\\\.[^#"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As';
+ const REGEX_DQ_STRING_DELIM = '/"/A';
+ const REGEX_DQ_STRING_PART = '/[^#"\\\\]*(?:(?:\\\\.|#(?!\{))[^#"\\\\]*)*/As';
+ const PUNCTUATION = '()[]{}?:.,|';
+
+ public function __construct(Twig_Environment $env, array $options = array())
+ {
+ $this->env = $env;
+
+ $this->options = array_merge(array(
+ 'tag_comment' => array('{#', '#}'),
+ 'tag_block' => array('{%', '%}'),
+ 'tag_variable' => array('{{', '}}'),
+ 'whitespace_trim' => '-',
+ 'interpolation' => array('#{', '}'),
+ ), $options);
+
+ $this->regexes = array(
+ 'lex_var' => '/\s*'.preg_quote($this->options['whitespace_trim'].$this->options['tag_variable'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_variable'][1], '/').'/A',
+ 'lex_block' => '/\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')\n?/A',
+ 'lex_raw_data' => '/('.preg_quote($this->options['tag_block'][0].$this->options['whitespace_trim'], '/').'|'.preg_quote($this->options['tag_block'][0], '/').')\s*(?:end%s)\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/s',
+ 'operator' => $this->getOperatorRegex(),
+ 'lex_comment' => '/(?:'.preg_quote($this->options['whitespace_trim'], '/').preg_quote($this->options['tag_comment'][1], '/').'\s*|'.preg_quote($this->options['tag_comment'][1], '/').')\n?/s',
+ 'lex_block_raw' => '/\s*(raw|verbatim)\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/As',
+ 'lex_block_line' => '/\s*line\s+(\d+)\s*'.preg_quote($this->options['tag_block'][1], '/').'/As',
+ 'lex_tokens_start' => '/('.preg_quote($this->options['tag_variable'][0], '/').'|'.preg_quote($this->options['tag_block'][0], '/').'|'.preg_quote($this->options['tag_comment'][0], '/').')('.preg_quote($this->options['whitespace_trim'], '/').')?/s',
+ 'interpolation_start' => '/'.preg_quote($this->options['interpolation'][0], '/').'\s*/A',
+ 'interpolation_end' => '/\s*'.preg_quote($this->options['interpolation'][1], '/').'/A',
+ );
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function tokenize($code, $filename = null)
+ {
+ if (function_exists('mb_internal_encoding') && ((int) ini_get('mbstring.func_overload')) & 2) {
+ $mbEncoding = mb_internal_encoding();
+ mb_internal_encoding('ASCII');
+ } else {
+ $mbEncoding = null;
+ }
+
+ $this->code = str_replace(array("\r\n", "\r"), "\n", $code);
+ $this->filename = $filename;
+ $this->cursor = 0;
+ $this->lineno = 1;
+ $this->end = strlen($this->code);
+ $this->tokens = array();
+ $this->state = self::STATE_DATA;
+ $this->states = array();
+ $this->brackets = array();
+ $this->position = -1;
+
+ // find all token starts in one go
+ preg_match_all($this->regexes['lex_tokens_start'], $this->code, $matches, PREG_OFFSET_CAPTURE);
+ $this->positions = $matches;
+
+ while ($this->cursor < $this->end) {
+ // dispatch to the lexing functions depending
+ // on the current state
+ switch ($this->state) {
+ case self::STATE_DATA:
+ $this->lexData();
+ break;
+
+ case self::STATE_BLOCK:
+ $this->lexBlock();
+ break;
+
+ case self::STATE_VAR:
+ $this->lexVar();
+ break;
+
+ case self::STATE_STRING:
+ $this->lexString();
+ break;
+
+ case self::STATE_INTERPOLATION:
+ $this->lexInterpolation();
+ break;
+ }
+ }
+
+ $this->pushToken(Twig_Token::EOF_TYPE);
+
+ if (!empty($this->brackets)) {
+ list($expect, $lineno) = array_pop($this->brackets);
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+
+ if ($mbEncoding) {
+ mb_internal_encoding($mbEncoding);
+ }
+
+ return new Twig_TokenStream($this->tokens, $this->filename);
+ }
+
+ protected function lexData()
+ {
+ // if no matches are left we return the rest of the template as simple text token
+ if ($this->position == count($this->positions[0]) - 1) {
+ $this->pushToken(Twig_Token::TEXT_TYPE, substr($this->code, $this->cursor));
+ $this->cursor = $this->end;
+
+ return;
+ }
+
+ // Find the first token after the current cursor
+ $position = $this->positions[0][++$this->position];
+ while ($position[1] < $this->cursor) {
+ if ($this->position == count($this->positions[0]) - 1) {
+ return;
+ }
+ $position = $this->positions[0][++$this->position];
+ }
+
+ // push the template text first
+ $text = $textContent = substr($this->code, $this->cursor, $position[1] - $this->cursor);
+ if (isset($this->positions[2][$this->position][0])) {
+ $text = rtrim($text);
+ }
+ $this->pushToken(Twig_Token::TEXT_TYPE, $text);
+ $this->moveCursor($textContent.$position[0]);
+
+ switch ($this->positions[1][$this->position][0]) {
+ case $this->options['tag_comment'][0]:
+ $this->lexComment();
+ break;
+
+ case $this->options['tag_block'][0]:
+ // raw data?
+ if (preg_match($this->regexes['lex_block_raw'], $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+ $this->lexRawData($match[1]);
+ // {% line \d+ %}
+ } elseif (preg_match($this->regexes['lex_block_line'], $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+ $this->lineno = (int) $match[1];
+ } else {
+ $this->pushToken(Twig_Token::BLOCK_START_TYPE);
+ $this->pushState(self::STATE_BLOCK);
+ $this->currentVarBlockLine = $this->lineno;
+ }
+ break;
+
+ case $this->options['tag_variable'][0]:
+ $this->pushToken(Twig_Token::VAR_START_TYPE);
+ $this->pushState(self::STATE_VAR);
+ $this->currentVarBlockLine = $this->lineno;
+ break;
+ }
+ }
+
+ protected function lexBlock()
+ {
+ if (empty($this->brackets) && preg_match($this->regexes['lex_block'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::BLOCK_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function lexVar()
+ {
+ if (empty($this->brackets) && preg_match($this->regexes['lex_var'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::VAR_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function lexExpression()
+ {
+ // whitespace
+ if (preg_match('/\s+/A', $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+
+ if ($this->cursor >= $this->end) {
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $this->state === self::STATE_BLOCK ? 'block' : 'variable'), $this->currentVarBlockLine, $this->filename);
+ }
+ }
+
+ // operators
+ if (preg_match($this->regexes['operator'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::OPERATOR_TYPE, preg_replace('/\s+/', ' ', $match[0]));
+ $this->moveCursor($match[0]);
+ }
+ // names
+ elseif (preg_match(self::REGEX_NAME, $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::NAME_TYPE, $match[0]);
+ $this->moveCursor($match[0]);
+ }
+ // numbers
+ elseif (preg_match(self::REGEX_NUMBER, $this->code, $match, null, $this->cursor)) {
+ $number = (float) $match[0]; // floats
+ if (ctype_digit($match[0]) && $number <= PHP_INT_MAX) {
+ $number = (int) $match[0]; // integers lower than the maximum
+ }
+ $this->pushToken(Twig_Token::NUMBER_TYPE, $number);
+ $this->moveCursor($match[0]);
+ }
+ // punctuation
+ elseif (false !== strpos(self::PUNCTUATION, $this->code[$this->cursor])) {
+ // opening bracket
+ if (false !== strpos('([{', $this->code[$this->cursor])) {
+ $this->brackets[] = array($this->code[$this->cursor], $this->lineno);
+ }
+ // closing bracket
+ elseif (false !== strpos(')]}', $this->code[$this->cursor])) {
+ if (empty($this->brackets)) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected "%s"', $this->code[$this->cursor]), $this->lineno, $this->filename);
+ }
+
+ list($expect, $lineno) = array_pop($this->brackets);
+ if ($this->code[$this->cursor] != strtr($expect, '([{', ')]}')) {
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+ }
+
+ $this->pushToken(Twig_Token::PUNCTUATION_TYPE, $this->code[$this->cursor]);
+ ++$this->cursor;
+ }
+ // strings
+ elseif (preg_match(self::REGEX_STRING, $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes(substr($match[0], 1, -1)));
+ $this->moveCursor($match[0]);
+ }
+ // opening double quoted string
+ elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
+ $this->brackets[] = array('"', $this->lineno);
+ $this->pushState(self::STATE_STRING);
+ $this->moveCursor($match[0]);
+ }
+ // unlexable
+ else {
+ throw new Twig_Error_Syntax(sprintf('Unexpected character "%s"', $this->code[$this->cursor]), $this->lineno, $this->filename);
+ }
+ }
+
+ protected function lexRawData($tag)
+ {
+ if (!preg_match(str_replace('%s', $tag, $this->regexes['lex_raw_data']), $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected end of file: Unclosed "%s" block', $tag), $this->lineno, $this->filename);
+ }
+
+ $text = substr($this->code, $this->cursor, $match[0][1] - $this->cursor);
+ $this->moveCursor($text.$match[0][0]);
+
+ if (false !== strpos($match[1][0], $this->options['whitespace_trim'])) {
+ $text = rtrim($text);
+ }
+
+ $this->pushToken(Twig_Token::TEXT_TYPE, $text);
+ }
+
+ protected function lexComment()
+ {
+ if (!preg_match($this->regexes['lex_comment'], $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
+ throw new Twig_Error_Syntax('Unclosed comment', $this->lineno, $this->filename);
+ }
+
+ $this->moveCursor(substr($this->code, $this->cursor, $match[0][1] - $this->cursor).$match[0][0]);
+ }
+
+ protected function lexString()
+ {
+ if (preg_match($this->regexes['interpolation_start'], $this->code, $match, null, $this->cursor)) {
+ $this->brackets[] = array($this->options['interpolation'][0], $this->lineno);
+ $this->pushToken(Twig_Token::INTERPOLATION_START_TYPE);
+ $this->moveCursor($match[0]);
+ $this->pushState(self::STATE_INTERPOLATION);
+ } elseif (preg_match(self::REGEX_DQ_STRING_PART, $this->code, $match, null, $this->cursor) && strlen($match[0]) > 0) {
+ $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes($match[0]));
+ $this->moveCursor($match[0]);
+ } elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
+ list($expect, $lineno) = array_pop($this->brackets);
+ if ($this->code[$this->cursor] != '"') {
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+
+ $this->popState();
+ ++$this->cursor;
+ }
+ }
+
+ protected function lexInterpolation()
+ {
+ $bracket = end($this->brackets);
+ if ($this->options['interpolation'][0] === $bracket[0] && preg_match($this->regexes['interpolation_end'], $this->code, $match, null, $this->cursor)) {
+ array_pop($this->brackets);
+ $this->pushToken(Twig_Token::INTERPOLATION_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function pushToken($type, $value = '')
+ {
+ // do not push empty text tokens
+ if (Twig_Token::TEXT_TYPE === $type && '' === $value) {
+ return;
+ }
+
+ $this->tokens[] = new Twig_Token($type, $value, $this->lineno);
+ }
+
+ protected function moveCursor($text)
+ {
+ $this->cursor += strlen($text);
+ $this->lineno += substr_count($text, "\n");
+ }
+
+ protected function getOperatorRegex()
+ {
+ $operators = array_merge(
+ array('='),
+ array_keys($this->env->getUnaryOperators()),
+ array_keys($this->env->getBinaryOperators())
+ );
+
+ $operators = array_combine($operators, array_map('strlen', $operators));
+ arsort($operators);
+
+ $regex = array();
+ foreach ($operators as $operator => $length) {
+ // an operator that ends with a character must be followed by
+ // a whitespace or a parenthesis
+ if (ctype_alpha($operator[$length - 1])) {
+ $r = preg_quote($operator, '/').'(?=[\s()])';
+ } else {
+ $r = preg_quote($operator, '/');
+ }
+
+ // an operator with a space can be any amount of whitespaces
+ $r = preg_replace('/\s+/', '\s+', $r);
+
+ $regex[] = $r;
+ }
+
+ return '/'.implode('|', $regex).'/A';
+ }
+
+ protected function pushState($state)
+ {
+ $this->states[] = $this->state;
+ $this->state = $state;
+ }
+
+ protected function popState()
+ {
+ if (0 === count($this->states)) {
+ throw new Exception('Cannot pop state without a previous state');
+ }
+
+ $this->state = array_pop($this->states);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/LexerInterface.php b/vendor/twig/twig/lib/Twig/LexerInterface.php
new file mode 100755
index 0000000..24a9478
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/LexerInterface.php
@@ -0,0 +1,32 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_LexerInterface
+{
+ /**
+ * Tokenizes a source code.
+ *
+ * @param string $code The source code
+ * @param string $filename A unique identifier for the source code
+ *
+ * @return Twig_TokenStream A token stream instance
+ *
+ * @throws Twig_Error_Syntax When the code is syntactically wrong
+ */
+ public function tokenize($code, $filename = null);
+}
diff --git a/vendor/twig/twig/lib/Twig/Loader/Array.php b/vendor/twig/twig/lib/Twig/Loader/Array.php
new file mode 100755
index 0000000..436edd8
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Loader/Array.php
@@ -0,0 +1,97 @@
+
+ */
+class Twig_Loader_Array implements Twig_LoaderInterface, Twig_ExistsLoaderInterface
+{
+ protected $templates = array();
+
+ /**
+ * Constructor.
+ *
+ * @param array $templates An array of templates (keys are the names, and values are the source code)
+ *
+ * @see Twig_Loader
+ */
+ public function __construct(array $templates)
+ {
+ $this->templates = $templates;
+ }
+
+ /**
+ * Adds or overrides a template.
+ *
+ * @param string $name The template name
+ * @param string $template The template source
+ */
+ public function setTemplate($name, $template)
+ {
+ $this->templates[(string) $name] = $template;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSource($name)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return $this->templates[$name];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function exists($name)
+ {
+ return isset($this->templates[(string) $name]);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCacheKey($name)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return $this->templates[$name];
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isFresh($name, $time)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return true;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Loader/Chain.php b/vendor/twig/twig/lib/Twig/Loader/Chain.php
new file mode 100755
index 0000000..7919eda
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Loader/Chain.php
@@ -0,0 +1,138 @@
+
+ */
+class Twig_Loader_Chain implements Twig_LoaderInterface, Twig_ExistsLoaderInterface
+{
+ private $hasSourceCache = array();
+ protected $loaders = array();
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_LoaderInterface[] $loaders An array of loader instances
+ */
+ public function __construct(array $loaders = array())
+ {
+ foreach ($loaders as $loader) {
+ $this->addLoader($loader);
+ }
+ }
+
+ /**
+ * Adds a loader instance.
+ *
+ * @param Twig_LoaderInterface $loader A Loader instance
+ */
+ public function addLoader(Twig_LoaderInterface $loader)
+ {
+ $this->loaders[] = $loader;
+ $this->hasSourceCache = array();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSource($name)
+ {
+ $exceptions = array();
+ foreach ($this->loaders as $loader) {
+ if ($loader instanceof Twig_ExistsLoaderInterface && !$loader->exists($name)) {
+ continue;
+ }
+
+ try {
+ return $loader->getSource($name);
+ } catch (Twig_Error_Loader $e) {
+ $exceptions[] = $e->getMessage();
+ }
+ }
+
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined (%s).', $name, implode(', ', $exceptions)));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function exists($name)
+ {
+ $name = (string) $name;
+
+ if (isset($this->hasSourceCache[$name])) {
+ return $this->hasSourceCache[$name];
+ }
+
+ foreach ($this->loaders as $loader) {
+ if ($loader instanceof Twig_ExistsLoaderInterface) {
+ if ($loader->exists($name)) {
+ return $this->hasSourceCache[$name] = true;
+ }
+
+ continue;
+ }
+
+ try {
+ $loader->getSource($name);
+
+ return $this->hasSourceCache[$name] = true;
+ } catch (Twig_Error_Loader $e) {
+ }
+ }
+
+ return $this->hasSourceCache[$name] = false;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCacheKey($name)
+ {
+ $exceptions = array();
+ foreach ($this->loaders as $loader) {
+ if ($loader instanceof Twig_ExistsLoaderInterface && !$loader->exists($name)) {
+ continue;
+ }
+
+ try {
+ return $loader->getCacheKey($name);
+ } catch (Twig_Error_Loader $e) {
+ $exceptions[] = get_class($loader).': '.$e->getMessage();
+ }
+ }
+
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined (%s).', $name, implode(' ', $exceptions)));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isFresh($name, $time)
+ {
+ $exceptions = array();
+ foreach ($this->loaders as $loader) {
+ if ($loader instanceof Twig_ExistsLoaderInterface && !$loader->exists($name)) {
+ continue;
+ }
+
+ try {
+ return $loader->isFresh($name, $time);
+ } catch (Twig_Error_Loader $e) {
+ $exceptions[] = get_class($loader).': '.$e->getMessage();
+ }
+ }
+
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined (%s).', $name, implode(' ', $exceptions)));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Loader/Filesystem.php b/vendor/twig/twig/lib/Twig/Loader/Filesystem.php
new file mode 100755
index 0000000..818a461
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Loader/Filesystem.php
@@ -0,0 +1,240 @@
+
+ */
+class Twig_Loader_Filesystem implements Twig_LoaderInterface, Twig_ExistsLoaderInterface
+{
+ /** Identifier of the main namespace. */
+ const MAIN_NAMESPACE = '__main__';
+
+ protected $paths = array();
+ protected $cache = array();
+
+ /**
+ * Constructor.
+ *
+ * @param string|array $paths A path or an array of paths where to look for templates
+ */
+ public function __construct($paths = array())
+ {
+ if ($paths) {
+ $this->setPaths($paths);
+ }
+ }
+
+ /**
+ * Returns the paths to the templates.
+ *
+ * @param string $namespace A path namespace
+ *
+ * @return array The array of paths where to look for templates
+ */
+ public function getPaths($namespace = self::MAIN_NAMESPACE)
+ {
+ return isset($this->paths[$namespace]) ? $this->paths[$namespace] : array();
+ }
+
+ /**
+ * Returns the path namespaces.
+ *
+ * The main namespace is always defined.
+ *
+ * @return array The array of defined namespaces
+ */
+ public function getNamespaces()
+ {
+ return array_keys($this->paths);
+ }
+
+ /**
+ * Sets the paths where templates are stored.
+ *
+ * @param string|array $paths A path or an array of paths where to look for templates
+ * @param string $namespace A path namespace
+ */
+ public function setPaths($paths, $namespace = self::MAIN_NAMESPACE)
+ {
+ if (!is_array($paths)) {
+ $paths = array($paths);
+ }
+
+ $this->paths[$namespace] = array();
+ foreach ($paths as $path) {
+ $this->addPath($path, $namespace);
+ }
+ }
+
+ /**
+ * Adds a path where templates are stored.
+ *
+ * @param string $path A path where to look for templates
+ * @param string $namespace A path name
+ *
+ * @throws Twig_Error_Loader
+ */
+ public function addPath($path, $namespace = self::MAIN_NAMESPACE)
+ {
+ // invalidate the cache
+ $this->cache = array();
+
+ if (!is_dir($path)) {
+ throw new Twig_Error_Loader(sprintf('The "%s" directory does not exist.', $path));
+ }
+
+ $this->paths[$namespace][] = rtrim($path, '/\\');
+ }
+
+ /**
+ * Prepends a path where templates are stored.
+ *
+ * @param string $path A path where to look for templates
+ * @param string $namespace A path name
+ *
+ * @throws Twig_Error_Loader
+ */
+ public function prependPath($path, $namespace = self::MAIN_NAMESPACE)
+ {
+ // invalidate the cache
+ $this->cache = array();
+
+ if (!is_dir($path)) {
+ throw new Twig_Error_Loader(sprintf('The "%s" directory does not exist.', $path));
+ }
+
+ $path = rtrim($path, '/\\');
+
+ if (!isset($this->paths[$namespace])) {
+ $this->paths[$namespace][] = $path;
+ } else {
+ array_unshift($this->paths[$namespace], $path);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSource($name)
+ {
+ return file_get_contents($this->findTemplate($name));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCacheKey($name)
+ {
+ return $this->findTemplate($name);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function exists($name)
+ {
+ $name = $this->normalizeName($name);
+
+ if (isset($this->cache[$name])) {
+ return true;
+ }
+
+ try {
+ $this->findTemplate($name);
+
+ return true;
+ } catch (Twig_Error_Loader $exception) {
+ return false;
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isFresh($name, $time)
+ {
+ return filemtime($this->findTemplate($name)) <= $time;
+ }
+
+ protected function findTemplate($name)
+ {
+ $name = $this->normalizeName($name);
+
+ if (isset($this->cache[$name])) {
+ return $this->cache[$name];
+ }
+
+ $this->validateName($name);
+
+ list($namespace, $shortname) = $this->parseName($name);
+
+ if (!isset($this->paths[$namespace])) {
+ throw new Twig_Error_Loader(sprintf('There are no registered paths for namespace "%s".', $namespace));
+ }
+
+ foreach ($this->paths[$namespace] as $path) {
+ if (is_file($path.'/'.$shortname)) {
+ if (false !== $realpath = realpath($path.'/'.$shortname)) {
+ return $this->cache[$name] = $realpath;
+ }
+
+ return $this->cache[$name] = $path.'/'.$shortname;
+ }
+ }
+
+ throw new Twig_Error_Loader(sprintf('Unable to find template "%s" (looked into: %s).', $name, implode(', ', $this->paths[$namespace])));
+ }
+
+ protected function parseName($name, $default = self::MAIN_NAMESPACE)
+ {
+ if (isset($name[0]) && '@' == $name[0]) {
+ if (false === $pos = strpos($name, '/')) {
+ throw new Twig_Error_Loader(sprintf('Malformed namespaced template name "%s" (expecting "@namespace/template_name").', $name));
+ }
+
+ $namespace = substr($name, 1, $pos - 1);
+ $shortname = substr($name, $pos + 1);
+
+ return array($namespace, $shortname);
+ }
+
+ return array($default, $name);
+ }
+
+ protected function normalizeName($name)
+ {
+ return preg_replace('#/{2,}#', '/', strtr((string) $name, '\\', '/'));
+ }
+
+ protected function validateName($name)
+ {
+ if (false !== strpos($name, "\0")) {
+ throw new Twig_Error_Loader('A template name cannot contain NUL bytes.');
+ }
+
+ $name = ltrim($name, '/');
+ $parts = explode('/', $name);
+ $level = 0;
+ foreach ($parts as $part) {
+ if ('..' === $part) {
+ --$level;
+ } elseif ('.' !== $part) {
+ ++$level;
+ }
+
+ if ($level < 0) {
+ throw new Twig_Error_Loader(sprintf('Looks like you try to load a template outside configured directories (%s).', $name));
+ }
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Loader/String.php b/vendor/twig/twig/lib/Twig/Loader/String.php
new file mode 100755
index 0000000..63d6890
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Loader/String.php
@@ -0,0 +1,59 @@
+
+ */
+class Twig_Loader_String implements Twig_LoaderInterface, Twig_ExistsLoaderInterface
+{
+ /**
+ * {@inheritdoc}
+ */
+ public function getSource($name)
+ {
+ return $name;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function exists($name)
+ {
+ return true;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getCacheKey($name)
+ {
+ return $name;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isFresh($name, $time)
+ {
+ return true;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/LoaderInterface.php b/vendor/twig/twig/lib/Twig/LoaderInterface.php
new file mode 100755
index 0000000..9cd45e2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/LoaderInterface.php
@@ -0,0 +1,53 @@
+
+ */
+interface Twig_LoaderInterface
+{
+ /**
+ * Gets the source code of a template, given its name.
+ *
+ * @param string $name The name of the template to load
+ *
+ * @return string The template source code
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ public function getSource($name);
+
+ /**
+ * Gets the cache key to use for the cache for a given template name.
+ *
+ * @param string $name The name of the template to load
+ *
+ * @return string The cache key
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ public function getCacheKey($name);
+
+ /**
+ * Returns true if the template is still fresh.
+ *
+ * @param string $name The template name
+ * @param int $time Timestamp of the last modification time of the
+ * cached template
+ *
+ * @return bool true if the template is fresh, false otherwise
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ public function isFresh($name, $time);
+}
diff --git a/vendor/twig/twig/lib/Twig/Markup.php b/vendor/twig/twig/lib/Twig/Markup.php
new file mode 100755
index 0000000..69871fc
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Markup.php
@@ -0,0 +1,37 @@
+
+ */
+class Twig_Markup implements Countable
+{
+ protected $content;
+ protected $charset;
+
+ public function __construct($content, $charset)
+ {
+ $this->content = (string) $content;
+ $this->charset = $charset;
+ }
+
+ public function __toString()
+ {
+ return $this->content;
+ }
+
+ public function count()
+ {
+ return function_exists('mb_get_info') ? mb_strlen($this->content, $this->charset) : strlen($this->content);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node.php b/vendor/twig/twig/lib/Twig/Node.php
new file mode 100755
index 0000000..1c78e7b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node.php
@@ -0,0 +1,229 @@
+
+ */
+class Twig_Node implements Twig_NodeInterface
+{
+ protected $nodes;
+ protected $attributes;
+ protected $lineno;
+ protected $tag;
+
+ /**
+ * Constructor.
+ *
+ * The nodes are automatically made available as properties ($this->node).
+ * The attributes are automatically made available as array items ($this['name']).
+ *
+ * @param array $nodes An array of named nodes
+ * @param array $attributes An array of attributes (should not be nodes)
+ * @param int $lineno The line number
+ * @param string $tag The tag name associated with the Node
+ */
+ public function __construct(array $nodes = array(), array $attributes = array(), $lineno = 0, $tag = null)
+ {
+ $this->nodes = $nodes;
+ $this->attributes = $attributes;
+ $this->lineno = $lineno;
+ $this->tag = $tag;
+ }
+
+ public function __toString()
+ {
+ $attributes = array();
+ foreach ($this->attributes as $name => $value) {
+ $attributes[] = sprintf('%s: %s', $name, str_replace("\n", '', var_export($value, true)));
+ }
+
+ $repr = array(get_class($this).'('.implode(', ', $attributes));
+
+ if (count($this->nodes)) {
+ foreach ($this->nodes as $name => $node) {
+ $len = strlen($name) + 4;
+ $noderepr = array();
+ foreach (explode("\n", (string) $node) as $line) {
+ $noderepr[] = str_repeat(' ', $len).$line;
+ }
+
+ $repr[] = sprintf(' %s: %s', $name, ltrim(implode("\n", $noderepr)));
+ }
+
+ $repr[] = ')';
+ } else {
+ $repr[0] .= ')';
+ }
+
+ return implode("\n", $repr);
+ }
+
+ /**
+ * @deprecated since 1.16.1 (to be removed in 2.0)
+ */
+ public function toXml($asDom = false)
+ {
+ $dom = new DOMDocument('1.0', 'UTF-8');
+ $dom->formatOutput = true;
+ $dom->appendChild($xml = $dom->createElement('twig'));
+
+ $xml->appendChild($node = $dom->createElement('node'));
+ $node->setAttribute('class', get_class($this));
+
+ foreach ($this->attributes as $name => $value) {
+ $node->appendChild($attribute = $dom->createElement('attribute'));
+ $attribute->setAttribute('name', $name);
+ $attribute->appendChild($dom->createTextNode($value));
+ }
+
+ foreach ($this->nodes as $name => $n) {
+ if (null === $n) {
+ continue;
+ }
+
+ $child = $n->toXml(true)->getElementsByTagName('node')->item(0);
+ $child = $dom->importNode($child, true);
+ $child->setAttribute('name', $name);
+
+ $node->appendChild($child);
+ }
+
+ return $asDom ? $dom : $dom->saveXml();
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ foreach ($this->nodes as $node) {
+ $node->compile($compiler);
+ }
+ }
+
+ public function getLine()
+ {
+ return $this->lineno;
+ }
+
+ public function getNodeTag()
+ {
+ return $this->tag;
+ }
+
+ /**
+ * Returns true if the attribute is defined.
+ *
+ * @param string $name The attribute name
+ *
+ * @return bool true if the attribute is defined, false otherwise
+ */
+ public function hasAttribute($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ /**
+ * Gets an attribute value by name.
+ *
+ * @param string $name
+ *
+ * @return mixed
+ */
+ public function getAttribute($name)
+ {
+ if (!array_key_exists($name, $this->attributes)) {
+ throw new LogicException(sprintf('Attribute "%s" does not exist for Node "%s".', $name, get_class($this)));
+ }
+
+ return $this->attributes[$name];
+ }
+
+ /**
+ * Sets an attribute by name to a value.
+ *
+ * @param string $name
+ * @param mixed $value
+ */
+ public function setAttribute($name, $value)
+ {
+ $this->attributes[$name] = $value;
+ }
+
+ /**
+ * Removes an attribute by name.
+ *
+ * @param string $name
+ */
+ public function removeAttribute($name)
+ {
+ unset($this->attributes[$name]);
+ }
+
+ /**
+ * Returns true if the node with the given name exists.
+ *
+ * @param string $name
+ *
+ * @return bool
+ */
+ public function hasNode($name)
+ {
+ return array_key_exists($name, $this->nodes);
+ }
+
+ /**
+ * Gets a node by name.
+ *
+ * @param string $name
+ *
+ * @return Twig_Node
+ */
+ public function getNode($name)
+ {
+ if (!array_key_exists($name, $this->nodes)) {
+ throw new LogicException(sprintf('Node "%s" does not exist for Node "%s".', $name, get_class($this)));
+ }
+
+ return $this->nodes[$name];
+ }
+
+ /**
+ * Sets a node.
+ *
+ * @param string $name
+ * @param Twig_Node $node
+ */
+ public function setNode($name, $node = null)
+ {
+ $this->nodes[$name] = $node;
+ }
+
+ /**
+ * Removes a node by name.
+ *
+ * @param string $name
+ */
+ public function removeNode($name)
+ {
+ unset($this->nodes[$name]);
+ }
+
+ public function count()
+ {
+ return count($this->nodes);
+ }
+
+ public function getIterator()
+ {
+ return new ArrayIterator($this->nodes);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/AutoEscape.php b/vendor/twig/twig/lib/Twig/Node/AutoEscape.php
new file mode 100755
index 0000000..fcabf90
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/AutoEscape.php
@@ -0,0 +1,39 @@
+
+ */
+class Twig_Node_AutoEscape extends Twig_Node
+{
+ public function __construct($value, Twig_NodeInterface $body, $lineno, $tag = 'autoescape')
+ {
+ parent::__construct(array('body' => $body), array('value' => $value), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('body'));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Block.php b/vendor/twig/twig/lib/Twig/Node/Block.php
new file mode 100755
index 0000000..989e4a0
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Block.php
@@ -0,0 +1,44 @@
+
+ */
+class Twig_Node_Block extends Twig_Node
+{
+ public function __construct($name, Twig_NodeInterface $body, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("public function block_%s(\$context, array \$blocks = array())\n", $this->getAttribute('name')), "{\n")
+ ->indent()
+ ;
+
+ $compiler
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/BlockReference.php b/vendor/twig/twig/lib/Twig/Node/BlockReference.php
new file mode 100755
index 0000000..a05ea04
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/BlockReference.php
@@ -0,0 +1,37 @@
+
+ */
+class Twig_Node_BlockReference extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("\$this->displayBlock('%s', \$context, \$blocks);\n", $this->getAttribute('name')))
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Body.php b/vendor/twig/twig/lib/Twig/Node/Body.php
new file mode 100755
index 0000000..3ffb134
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Body.php
@@ -0,0 +1,19 @@
+
+ */
+class Twig_Node_Body extends Twig_Node
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/CheckSecurity.php b/vendor/twig/twig/lib/Twig/Node/CheckSecurity.php
new file mode 100755
index 0000000..3040b76
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/CheckSecurity.php
@@ -0,0 +1,78 @@
+
+ */
+class Twig_Node_CheckSecurity extends Twig_Node
+{
+ protected $usedFilters;
+ protected $usedTags;
+ protected $usedFunctions;
+
+ public function __construct(array $usedFilters, array $usedTags, array $usedFunctions)
+ {
+ $this->usedFilters = $usedFilters;
+ $this->usedTags = $usedTags;
+ $this->usedFunctions = $usedFunctions;
+
+ parent::__construct();
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $tags = $filters = $functions = array();
+ foreach (array('tags', 'filters', 'functions') as $type) {
+ foreach ($this->{'used'.ucfirst($type)} as $name => $node) {
+ if ($node instanceof Twig_Node) {
+ ${$type}[$name] = $node->getLine();
+ } else {
+ ${$type}[$node] = null;
+ }
+ }
+ }
+
+ $compiler
+ ->write("\$tags = ")->repr(array_filter($tags))->raw(";\n")
+ ->write("\$filters = ")->repr(array_filter($filters))->raw(";\n")
+ ->write("\$functions = ")->repr(array_filter($functions))->raw(";\n\n")
+ ->write("try {\n")
+ ->indent()
+ ->write("\$this->env->getExtension('sandbox')->checkSecurity(\n")
+ ->indent()
+ ->write(!$tags ? "array(),\n" : "array('".implode("', '", array_keys($tags))."'),\n")
+ ->write(!$filters ? "array(),\n" : "array('".implode("', '", array_keys($filters))."'),\n")
+ ->write(!$functions ? "array()\n" : "array('".implode("', '", array_keys($functions))."')\n")
+ ->outdent()
+ ->write(");\n")
+ ->outdent()
+ ->write("} catch (Twig_Sandbox_SecurityError \$e) {\n")
+ ->indent()
+ ->write("\$e->setTemplateFile(\$this->getTemplateName());\n\n")
+ ->write("if (\$e instanceof Twig_Sandbox_SecurityNotAllowedTagError && isset(\$tags[\$e->getTagName()])) {\n")
+ ->indent()
+ ->write("\$e->setTemplateLine(\$tags[\$e->getTagName()]);\n")
+ ->outdent()
+ ->write("} elseif (\$e instanceof Twig_Sandbox_SecurityNotAllowedFilterError && isset(\$filters[\$e->getFilterName()])) {\n")
+ ->indent()
+ ->write("\$e->setTemplateLine(\$filters[\$e->getFilterName()]);\n")
+ ->outdent()
+ ->write("} elseif (\$e instanceof Twig_Sandbox_SecurityNotAllowedFunctionError && isset(\$functions[\$e->getFunctionName()])) {\n")
+ ->indent()
+ ->write("\$e->setTemplateLine(\$functions[\$e->getFunctionName()]);\n")
+ ->outdent()
+ ->write("}\n\n")
+ ->write("throw \$e;\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Do.php b/vendor/twig/twig/lib/Twig/Node/Do.php
new file mode 100755
index 0000000..9981bc1
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Do.php
@@ -0,0 +1,38 @@
+
+ */
+class Twig_Node_Do extends Twig_Node
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('')
+ ->subcompile($this->getNode('expr'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Embed.php b/vendor/twig/twig/lib/Twig/Node/Embed.php
new file mode 100755
index 0000000..c54d2cc
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Embed.php
@@ -0,0 +1,42 @@
+
+ */
+class Twig_Node_Embed extends Twig_Node_Include
+{
+ // we don't inject the module to avoid node visitors to traverse it twice (as it will be already visited in the main module)
+ public function __construct($filename, $index, Twig_Node_Expression $variables = null, $only = false, $ignoreMissing = false, $lineno, $tag = null)
+ {
+ parent::__construct(new Twig_Node_Expression_Constant('not_used', $lineno), $variables, $only, $ignoreMissing, $lineno, $tag);
+
+ $this->setAttribute('filename', $filename);
+ $this->setAttribute('index', $index);
+ }
+
+ protected function addGetTemplate(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("\$this->loadTemplate(")
+ ->string($this->getAttribute('filename'))
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($this->getLine())
+ ->raw(', ')
+ ->string($this->getAttribute('index'))
+ ->raw(")")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression.php b/vendor/twig/twig/lib/Twig/Node/Expression.php
new file mode 100755
index 0000000..a7382e7
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression.php
@@ -0,0 +1,20 @@
+
+ */
+abstract class Twig_Node_Expression extends Twig_Node
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Array.php b/vendor/twig/twig/lib/Twig/Node/Expression/Array.php
new file mode 100755
index 0000000..6cf7ca1
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Array.php
@@ -0,0 +1,86 @@
+index = -1;
+ foreach ($this->getKeyValuePairs() as $pair) {
+ if ($pair['key'] instanceof Twig_Node_Expression_Constant && ctype_digit((string) $pair['key']->getAttribute('value')) && $pair['key']->getAttribute('value') > $this->index) {
+ $this->index = $pair['key']->getAttribute('value');
+ }
+ }
+ }
+
+ public function getKeyValuePairs()
+ {
+ $pairs = array();
+
+ foreach (array_chunk($this->nodes, 2) as $pair) {
+ $pairs[] = array(
+ 'key' => $pair[0],
+ 'value' => $pair[1],
+ );
+ }
+
+ return $pairs;
+ }
+
+ public function hasElement(Twig_Node_Expression $key)
+ {
+ foreach ($this->getKeyValuePairs() as $pair) {
+ // we compare the string representation of the keys
+ // to avoid comparing the line numbers which are not relevant here.
+ if ((string) $key == (string) $pair['key']) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public function addElement(Twig_Node_Expression $value, Twig_Node_Expression $key = null)
+ {
+ if (null === $key) {
+ $key = new Twig_Node_Expression_Constant(++$this->index, $value->getLine());
+ }
+
+ array_push($this->nodes, $key, $value);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw('array(');
+ $first = true;
+ foreach ($this->getKeyValuePairs() as $pair) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $first = false;
+
+ $compiler
+ ->subcompile($pair['key'])
+ ->raw(' => ')
+ ->subcompile($pair['value'])
+ ;
+ }
+ $compiler->raw(')');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/AssignName.php b/vendor/twig/twig/lib/Twig/Node/Expression/AssignName.php
new file mode 100755
index 0000000..4d5dbdb
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/AssignName.php
@@ -0,0 +1,28 @@
+raw('$context[')
+ ->string($this->getAttribute('name'))
+ ->raw(']')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary.php
new file mode 100755
index 0000000..5c383d1
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary.php
@@ -0,0 +1,40 @@
+ $left, 'right' => $right), array(), $lineno);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('left'))
+ ->raw(' ')
+ ;
+ $this->operator($compiler);
+ $compiler
+ ->raw(' ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ abstract public function operator(Twig_Compiler $compiler);
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Add.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Add.php
new file mode 100755
index 0000000..0ef8e11
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Add.php
@@ -0,0 +1,18 @@
+raw('+');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/And.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/And.php
new file mode 100755
index 0000000..d5752eb
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/And.php
@@ -0,0 +1,18 @@
+raw('&&');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php
new file mode 100755
index 0000000..9a46d84
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php
@@ -0,0 +1,18 @@
+raw('&');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php
new file mode 100755
index 0000000..058a20b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php
@@ -0,0 +1,18 @@
+raw('|');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php
new file mode 100755
index 0000000..f4da73d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php
@@ -0,0 +1,18 @@
+raw('^');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Concat.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Concat.php
new file mode 100755
index 0000000..f9a6462
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Concat.php
@@ -0,0 +1,18 @@
+raw('.');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Div.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Div.php
new file mode 100755
index 0000000..e0797a6
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Div.php
@@ -0,0 +1,18 @@
+raw('/');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/EndsWith.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/EndsWith.php
new file mode 100755
index 0000000..93b3b96
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/EndsWith.php
@@ -0,0 +1,30 @@
+getVarName();
+ $right = $compiler->getVarName();
+ $compiler
+ ->raw(sprintf('(is_string($%s = ', $left))
+ ->subcompile($this->getNode('left'))
+ ->raw(sprintf(') && is_string($%s = ', $right))
+ ->subcompile($this->getNode('right'))
+ ->raw(sprintf(') && (\'\' === $%2$s || $%2$s === substr($%1$s, -strlen($%2$s))))', $left, $right))
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Equal.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Equal.php
new file mode 100755
index 0000000..7b1236d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Equal.php
@@ -0,0 +1,17 @@
+raw('==');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php
new file mode 100755
index 0000000..d3518b5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php
@@ -0,0 +1,29 @@
+raw('intval(floor(');
+ parent::compile($compiler);
+ $compiler->raw('))');
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('/');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Greater.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Greater.php
new file mode 100755
index 0000000..a110bd9
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Greater.php
@@ -0,0 +1,17 @@
+raw('>');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php
new file mode 100755
index 0000000..3754fed
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php
@@ -0,0 +1,17 @@
+raw('>=');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/In.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/In.php
new file mode 100755
index 0000000..1d485b6
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/In.php
@@ -0,0 +1,33 @@
+raw('twig_in_filter(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('in');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Less.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Less.php
new file mode 100755
index 0000000..45fd300
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Less.php
@@ -0,0 +1,17 @@
+raw('<');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/LessEqual.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/LessEqual.php
new file mode 100755
index 0000000..e38e257
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/LessEqual.php
@@ -0,0 +1,17 @@
+raw('<=');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Matches.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Matches.php
new file mode 100755
index 0000000..93bb292
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Matches.php
@@ -0,0 +1,28 @@
+raw('preg_match(')
+ ->subcompile($this->getNode('right'))
+ ->raw(', ')
+ ->subcompile($this->getNode('left'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mod.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mod.php
new file mode 100755
index 0000000..9924114
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mod.php
@@ -0,0 +1,18 @@
+raw('%');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mul.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mul.php
new file mode 100755
index 0000000..c91529c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Mul.php
@@ -0,0 +1,18 @@
+raw('*');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotEqual.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotEqual.php
new file mode 100755
index 0000000..26867ba
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotEqual.php
@@ -0,0 +1,17 @@
+raw('!=');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotIn.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotIn.php
new file mode 100755
index 0000000..8f215f1
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/NotIn.php
@@ -0,0 +1,33 @@
+raw('!twig_in_filter(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('not in');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Or.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Or.php
new file mode 100755
index 0000000..adba49c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Or.php
@@ -0,0 +1,18 @@
+raw('||');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Power.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Power.php
new file mode 100755
index 0000000..6cd3a21
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Power.php
@@ -0,0 +1,33 @@
+raw('pow(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('**');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Range.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Range.php
new file mode 100755
index 0000000..fc102fe
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Range.php
@@ -0,0 +1,33 @@
+raw('range(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('..');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/StartsWith.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/StartsWith.php
new file mode 100755
index 0000000..d2e30d6
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/StartsWith.php
@@ -0,0 +1,30 @@
+getVarName();
+ $right = $compiler->getVarName();
+ $compiler
+ ->raw(sprintf('(is_string($%s = ', $left))
+ ->subcompile($this->getNode('left'))
+ ->raw(sprintf(') && is_string($%s = ', $right))
+ ->subcompile($this->getNode('right'))
+ ->raw(sprintf(') && (\'\' === $%2$s || 0 === strpos($%1$s, $%2$s)))', $left, $right))
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Sub.php b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Sub.php
new file mode 100755
index 0000000..d446399
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Binary/Sub.php
@@ -0,0 +1,18 @@
+raw('-');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/BlockReference.php b/vendor/twig/twig/lib/Twig/Node/Expression/BlockReference.php
new file mode 100755
index 0000000..4ddb2cf
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/BlockReference.php
@@ -0,0 +1,51 @@
+
+ */
+class Twig_Node_Expression_BlockReference extends Twig_Node_Expression
+{
+ public function __construct(Twig_NodeInterface $name, $asString = false, $lineno, $tag = null)
+ {
+ parent::__construct(array('name' => $name), array('as_string' => $asString, 'output' => false), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('as_string')) {
+ $compiler->raw('(string) ');
+ }
+
+ if ($this->getAttribute('output')) {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$this->displayBlock(")
+ ->subcompile($this->getNode('name'))
+ ->raw(", \$context, \$blocks);\n")
+ ;
+ } else {
+ $compiler
+ ->raw("\$this->renderBlock(")
+ ->subcompile($this->getNode('name'))
+ ->raw(", \$context, \$blocks)")
+ ;
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Call.php b/vendor/twig/twig/lib/Twig/Node/Expression/Call.php
new file mode 100755
index 0000000..998160b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Call.php
@@ -0,0 +1,210 @@
+hasAttribute('callable') && $callable = $this->getAttribute('callable')) {
+ if (is_string($callable)) {
+ $compiler->raw($callable);
+ } elseif (is_array($callable) && $callable[0] instanceof Twig_ExtensionInterface) {
+ $compiler->raw(sprintf('$this->env->getExtension(\'%s\')->%s', $callable[0]->getName(), $callable[1]));
+ } else {
+ $type = ucfirst($this->getAttribute('type'));
+ $compiler->raw(sprintf('call_user_func_array($this->env->get%s(\'%s\')->getCallable(), array', $type, $this->getAttribute('name')));
+ $closingParenthesis = true;
+ }
+ } else {
+ $compiler->raw($this->getAttribute('thing')->compile());
+ }
+
+ $this->compileArguments($compiler);
+
+ if ($closingParenthesis) {
+ $compiler->raw(')');
+ }
+ }
+
+ protected function compileArguments(Twig_Compiler $compiler)
+ {
+ $compiler->raw('(');
+
+ $first = true;
+
+ if ($this->hasAttribute('needs_environment') && $this->getAttribute('needs_environment')) {
+ $compiler->raw('$this->env');
+ $first = false;
+ }
+
+ if ($this->hasAttribute('needs_context') && $this->getAttribute('needs_context')) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $compiler->raw('$context');
+ $first = false;
+ }
+
+ if ($this->hasAttribute('arguments')) {
+ foreach ($this->getAttribute('arguments') as $argument) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $compiler->string($argument);
+ $first = false;
+ }
+ }
+
+ if ($this->hasNode('node')) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $compiler->subcompile($this->getNode('node'));
+ $first = false;
+ }
+
+ if ($this->hasNode('arguments') && null !== $this->getNode('arguments')) {
+ $callable = $this->hasAttribute('callable') ? $this->getAttribute('callable') : null;
+
+ $arguments = $this->getArguments($callable, $this->getNode('arguments'));
+
+ foreach ($arguments as $node) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $compiler->subcompile($node);
+ $first = false;
+ }
+ }
+
+ $compiler->raw(')');
+ }
+
+ protected function getArguments($callable, $arguments)
+ {
+ $callType = $this->getAttribute('type');
+ $callName = $this->getAttribute('name');
+
+ $parameters = array();
+ $named = false;
+ foreach ($arguments as $name => $node) {
+ if (!is_int($name)) {
+ $named = true;
+ $name = $this->normalizeName($name);
+ } elseif ($named) {
+ throw new Twig_Error_Syntax(sprintf('Positional arguments cannot be used after named arguments for %s "%s".', $callType, $callName));
+ }
+
+ $parameters[$name] = $node;
+ }
+
+ if (!$named) {
+ return $parameters;
+ }
+
+ if (!$callable) {
+ throw new LogicException(sprintf('Named arguments are not supported for %s "%s".', $callType, $callName));
+ }
+
+ // manage named arguments
+ if (is_array($callable)) {
+ $r = new ReflectionMethod($callable[0], $callable[1]);
+ } elseif (is_object($callable) && !$callable instanceof Closure) {
+ $r = new ReflectionObject($callable);
+ $r = $r->getMethod('__invoke');
+ } elseif (is_string($callable) && false !== strpos($callable, '::')) {
+ $r = new ReflectionMethod($callable);
+ } else {
+ $r = new ReflectionFunction($callable);
+ }
+
+ $definition = $r->getParameters();
+ if ($this->hasNode('node')) {
+ array_shift($definition);
+ }
+ if ($this->hasAttribute('needs_environment') && $this->getAttribute('needs_environment')) {
+ array_shift($definition);
+ }
+ if ($this->hasAttribute('needs_context') && $this->getAttribute('needs_context')) {
+ array_shift($definition);
+ }
+ if ($this->hasAttribute('arguments') && null !== $this->getAttribute('arguments')) {
+ foreach ($this->getAttribute('arguments') as $argument) {
+ array_shift($definition);
+ }
+ }
+
+ $arguments = array();
+ $names = array();
+ $missingArguments = array();
+ $optionalArguments = array();
+ $pos = 0;
+ foreach ($definition as $param) {
+ $names[] = $name = $this->normalizeName($param->name);
+
+ if (array_key_exists($name, $parameters)) {
+ if (array_key_exists($pos, $parameters)) {
+ throw new Twig_Error_Syntax(sprintf('Argument "%s" is defined twice for %s "%s".', $name, $callType, $callName));
+ }
+
+ if (!empty($missingArguments)) {
+ throw new Twig_Error_Syntax(sprintf(
+ 'Argument "%s" could not be assigned for %s "%s(%s)" because it is mapped to an internal PHP function which cannot determine default value for optional argument%s "%s".',
+ $name, $callType, $callName, implode(', ', $names), count($missingArguments) > 1 ? 's' : '', implode('", "', $missingArguments))
+ );
+ }
+
+ $arguments = array_merge($arguments, $optionalArguments);
+ $arguments[] = $parameters[$name];
+ unset($parameters[$name]);
+ $optionalArguments = array();
+ } elseif (array_key_exists($pos, $parameters)) {
+ $arguments = array_merge($arguments, $optionalArguments);
+ $arguments[] = $parameters[$pos];
+ unset($parameters[$pos]);
+ $optionalArguments = array();
+ ++$pos;
+ } elseif ($param->isDefaultValueAvailable()) {
+ $optionalArguments[] = new Twig_Node_Expression_Constant($param->getDefaultValue(), -1);
+ } elseif ($param->isOptional()) {
+ if (empty($parameters)) {
+ break;
+ } else {
+ $missingArguments[] = $name;
+ }
+ } else {
+ throw new Twig_Error_Syntax(sprintf('Value for argument "%s" is required for %s "%s".', $name, $callType, $callName));
+ }
+ }
+
+ if (!empty($parameters)) {
+ $unknownParameter = null;
+ foreach ($parameters as $parameter) {
+ if ($parameter instanceof Twig_Node) {
+ $unknownParameter = $parameter;
+ break;
+ }
+ }
+
+ throw new Twig_Error_Syntax(sprintf(
+ 'Unknown argument%s "%s" for %s "%s(%s)".',
+ count($parameters) > 1 ? 's' : '', implode('", "', array_keys($parameters)), $callType, $callName, implode(', ', $names)
+ ), $unknownParameter ? $unknownParameter->getLine() : -1);
+ }
+
+ return $arguments;
+ }
+
+ protected function normalizeName($name)
+ {
+ return strtolower(preg_replace(array('/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'), array('\\1_\\2', '\\1_\\2'), $name));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Conditional.php b/vendor/twig/twig/lib/Twig/Node/Expression/Conditional.php
new file mode 100755
index 0000000..edcb1e2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Conditional.php
@@ -0,0 +1,31 @@
+ $expr1, 'expr2' => $expr2, 'expr3' => $expr3), array(), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('((')
+ ->subcompile($this->getNode('expr1'))
+ ->raw(') ? (')
+ ->subcompile($this->getNode('expr2'))
+ ->raw(') : (')
+ ->subcompile($this->getNode('expr3'))
+ ->raw('))')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Constant.php b/vendor/twig/twig/lib/Twig/Node/Expression/Constant.php
new file mode 100755
index 0000000..a91dc69
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Constant.php
@@ -0,0 +1,23 @@
+ $value), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->repr($this->getAttribute('value'));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/ExtensionReference.php b/vendor/twig/twig/lib/Twig/Node/Expression/ExtensionReference.php
new file mode 100755
index 0000000..db06abb
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/ExtensionReference.php
@@ -0,0 +1,33 @@
+
+ */
+class Twig_Node_Expression_ExtensionReference extends Twig_Node_Expression
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw(sprintf("\$this->env->getExtension('%s')", $this->getAttribute('name')));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Filter.php b/vendor/twig/twig/lib/Twig/Node/Expression/Filter.php
new file mode 100755
index 0000000..207b062
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Filter.php
@@ -0,0 +1,36 @@
+ $node, 'filter' => $filterName, 'arguments' => $arguments), array(), $lineno, $tag);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getNode('filter')->getAttribute('value');
+ $filter = $compiler->getEnvironment()->getFilter($name);
+
+ $this->setAttribute('name', $name);
+ $this->setAttribute('type', 'filter');
+ $this->setAttribute('thing', $filter);
+ $this->setAttribute('needs_environment', $filter->needsEnvironment());
+ $this->setAttribute('needs_context', $filter->needsContext());
+ $this->setAttribute('arguments', $filter->getArguments());
+ if ($filter instanceof Twig_FilterCallableInterface || $filter instanceof Twig_SimpleFilter) {
+ $this->setAttribute('callable', $filter->getCallable());
+ }
+
+ $this->compileCallable($compiler);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Filter/Default.php b/vendor/twig/twig/lib/Twig/Node/Expression/Filter/Default.php
new file mode 100755
index 0000000..1827c88
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Filter/Default.php
@@ -0,0 +1,43 @@
+
+ * {{ var.foo|default('foo item on var is not defined') }}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Filter_Default extends Twig_Node_Expression_Filter
+{
+ public function __construct(Twig_NodeInterface $node, Twig_Node_Expression_Constant $filterName, Twig_NodeInterface $arguments, $lineno, $tag = null)
+ {
+ $default = new Twig_Node_Expression_Filter($node, new Twig_Node_Expression_Constant('default', $node->getLine()), $arguments, $node->getLine());
+
+ if ('default' === $filterName->getAttribute('value') && ($node instanceof Twig_Node_Expression_Name || $node instanceof Twig_Node_Expression_GetAttr)) {
+ $test = new Twig_Node_Expression_Test_Defined(clone $node, 'defined', new Twig_Node(), $node->getLine());
+ $false = count($arguments) ? $arguments->getNode(0) : new Twig_Node_Expression_Constant('', $node->getLine());
+
+ $node = new Twig_Node_Expression_Conditional($test, $default, $false, $node->getLine());
+ } else {
+ $node = $default;
+ }
+
+ parent::__construct($node, $filterName, $arguments, $lineno, $tag);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('node'));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Function.php b/vendor/twig/twig/lib/Twig/Node/Expression/Function.php
new file mode 100755
index 0000000..3e1f6b5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Function.php
@@ -0,0 +1,35 @@
+ $arguments), array('name' => $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+ $function = $compiler->getEnvironment()->getFunction($name);
+
+ $this->setAttribute('name', $name);
+ $this->setAttribute('type', 'function');
+ $this->setAttribute('thing', $function);
+ $this->setAttribute('needs_environment', $function->needsEnvironment());
+ $this->setAttribute('needs_context', $function->needsContext());
+ $this->setAttribute('arguments', $function->getArguments());
+ if ($function instanceof Twig_FunctionCallableInterface || $function instanceof Twig_SimpleFunction) {
+ $this->setAttribute('callable', $function->getCallable());
+ }
+
+ $this->compileCallable($compiler);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/GetAttr.php b/vendor/twig/twig/lib/Twig/Node/Expression/GetAttr.php
new file mode 100755
index 0000000..6ce6111
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/GetAttr.php
@@ -0,0 +1,63 @@
+ $node, 'attribute' => $attribute, 'arguments' => $arguments), array('type' => $type, 'is_defined_test' => false, 'ignore_strict_check' => false, 'disable_c_ext' => false), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ if (function_exists('twig_template_get_attributes') && !$this->getAttribute('disable_c_ext')) {
+ $compiler->raw('twig_template_get_attributes($this, ');
+ } else {
+ $compiler->raw('$this->getAttribute(');
+ }
+
+ if ($this->getAttribute('ignore_strict_check')) {
+ $this->getNode('node')->setAttribute('ignore_strict_check', true);
+ }
+
+ $compiler->subcompile($this->getNode('node'));
+
+ $compiler->raw(', ')->subcompile($this->getNode('attribute'));
+
+ // only generate optional arguments when needed (to make generated code more readable)
+ $needFourth = $this->getAttribute('ignore_strict_check');
+ $needThird = $needFourth || $this->getAttribute('is_defined_test');
+ $needSecond = $needThird || Twig_Template::ANY_CALL !== $this->getAttribute('type');
+ $needFirst = $needSecond || null !== $this->getNode('arguments');
+
+ if ($needFirst) {
+ if (null !== $this->getNode('arguments')) {
+ $compiler->raw(', ')->subcompile($this->getNode('arguments'));
+ } else {
+ $compiler->raw(', array()');
+ }
+ }
+
+ if ($needSecond) {
+ $compiler->raw(', ')->repr($this->getAttribute('type'));
+ }
+
+ if ($needThird) {
+ $compiler->raw(', ')->repr($this->getAttribute('is_defined_test'));
+ }
+
+ if ($needFourth) {
+ $compiler->raw(', ')->repr($this->getAttribute('ignore_strict_check'));
+ }
+
+ $compiler->raw(')');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/MethodCall.php b/vendor/twig/twig/lib/Twig/Node/Expression/MethodCall.php
new file mode 100755
index 0000000..620b02b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/MethodCall.php
@@ -0,0 +1,41 @@
+ $node, 'arguments' => $arguments), array('method' => $method, 'safe' => false), $lineno);
+
+ if ($node instanceof Twig_Node_Expression_Name) {
+ $node->setAttribute('always_defined', true);
+ }
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->subcompile($this->getNode('node'))
+ ->raw('->')
+ ->raw($this->getAttribute('method'))
+ ->raw('(')
+ ;
+ $first = true;
+ foreach ($this->getNode('arguments')->getKeyValuePairs() as $pair) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $first = false;
+
+ $compiler->subcompile($pair['value']);
+ }
+ $compiler->raw(')');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Name.php b/vendor/twig/twig/lib/Twig/Node/Expression/Name.php
new file mode 100755
index 0000000..0bfcdbc
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Name.php
@@ -0,0 +1,90 @@
+ '$this',
+ '_context' => '$context',
+ '_charset' => '$this->env->getCharset()',
+ );
+
+ public function __construct($name, $lineno)
+ {
+ parent::__construct(array(), array('name' => $name, 'is_defined_test' => false, 'ignore_strict_check' => false, 'always_defined' => false), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+
+ $compiler->addDebugInfo($this);
+
+ if ($this->getAttribute('is_defined_test')) {
+ if ($this->isSpecial()) {
+ $compiler->repr(true);
+ } else {
+ $compiler->raw('array_key_exists(')->repr($name)->raw(', $context)');
+ }
+ } elseif ($this->isSpecial()) {
+ $compiler->raw($this->specialVars[$name]);
+ } elseif ($this->getAttribute('always_defined')) {
+ $compiler
+ ->raw('$context[')
+ ->string($name)
+ ->raw(']')
+ ;
+ } else {
+ // remove the non-PHP 5.4 version when PHP 5.3 support is dropped
+ // as the non-optimized version is just a workaround for slow ternary operator
+ // when the context has a lot of variables
+ if (PHP_VERSION_ID >= 50400) {
+ // PHP 5.4 ternary operator performance was optimized
+ $compiler
+ ->raw('(isset($context[')
+ ->string($name)
+ ->raw(']) ? $context[')
+ ->string($name)
+ ->raw('] : ')
+ ;
+
+ if ($this->getAttribute('ignore_strict_check') || !$compiler->getEnvironment()->isStrictVariables()) {
+ $compiler->raw('null)');
+ } else {
+ $compiler->raw('$this->getContext($context, ')->string($name)->raw('))');
+ }
+ } else {
+ $compiler
+ ->raw('$this->getContext($context, ')
+ ->string($name)
+ ;
+
+ if ($this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', true');
+ }
+
+ $compiler
+ ->raw(')')
+ ;
+ }
+ }
+ }
+
+ public function isSpecial()
+ {
+ return isset($this->specialVars[$this->getAttribute('name')]);
+ }
+
+ public function isSimple()
+ {
+ return !$this->isSpecial() && !$this->getAttribute('is_defined_test');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Parent.php b/vendor/twig/twig/lib/Twig/Node/Expression/Parent.php
new file mode 100755
index 0000000..a22ce03
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Parent.php
@@ -0,0 +1,47 @@
+
+ */
+class Twig_Node_Expression_Parent extends Twig_Node_Expression
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('output' => false, 'name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('output')) {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$this->displayParentBlock(")
+ ->string($this->getAttribute('name'))
+ ->raw(", \$context, \$blocks);\n")
+ ;
+ } else {
+ $compiler
+ ->raw("\$this->renderParentBlock(")
+ ->string($this->getAttribute('name'))
+ ->raw(", \$context, \$blocks)")
+ ;
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/TempName.php b/vendor/twig/twig/lib/Twig/Node/Expression/TempName.php
new file mode 100755
index 0000000..e6b058e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/TempName.php
@@ -0,0 +1,26 @@
+ $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('$_')
+ ->raw($this->getAttribute('name'))
+ ->raw('_')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test.php
new file mode 100755
index 0000000..639f501
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test.php
@@ -0,0 +1,32 @@
+ $node, 'arguments' => $arguments), array('name' => $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+ $test = $compiler->getEnvironment()->getTest($name);
+
+ $this->setAttribute('name', $name);
+ $this->setAttribute('type', 'test');
+ $this->setAttribute('thing', $test);
+ if ($test instanceof Twig_TestCallableInterface || $test instanceof Twig_SimpleTest) {
+ $this->setAttribute('callable', $test->getCallable());
+ }
+
+ $this->compileCallable($compiler);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Constant.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Constant.php
new file mode 100755
index 0000000..de55f5f
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Constant.php
@@ -0,0 +1,46 @@
+
+ * {% if post.status is constant('Post::PUBLISHED') %}
+ * the status attribute is exactly the same as Post::PUBLISHED
+ * {% endif %}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Constant extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' === constant(')
+ ;
+
+ if ($this->getNode('arguments')->hasNode(1)) {
+ $compiler
+ ->raw('get_class(')
+ ->subcompile($this->getNode('arguments')->getNode(1))
+ ->raw(')."::".')
+ ;
+ }
+
+ $compiler
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw('))')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Defined.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Defined.php
new file mode 100755
index 0000000..247b2e2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Defined.php
@@ -0,0 +1,54 @@
+
+ * {# defined works with variable names and variable attributes #}
+ * {% if foo is defined %}
+ * {# ... #}
+ * {% endif %}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Defined extends Twig_Node_Expression_Test
+{
+ public function __construct(Twig_NodeInterface $node, $name, Twig_NodeInterface $arguments = null, $lineno)
+ {
+ parent::__construct($node, $name, $arguments, $lineno);
+
+ if ($node instanceof Twig_Node_Expression_Name) {
+ $node->setAttribute('is_defined_test', true);
+ } elseif ($node instanceof Twig_Node_Expression_GetAttr) {
+ $node->setAttribute('is_defined_test', true);
+
+ $this->changeIgnoreStrictCheck($node);
+ } else {
+ throw new Twig_Error_Syntax('The "defined" test only works with simple variables', $this->getLine());
+ }
+ }
+
+ protected function changeIgnoreStrictCheck(Twig_Node_Expression_GetAttr $node)
+ {
+ $node->setAttribute('ignore_strict_check', true);
+
+ if ($node->getNode('node') instanceof Twig_Node_Expression_GetAttr) {
+ $this->changeIgnoreStrictCheck($node->getNode('node'));
+ }
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('node'));
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Divisibleby.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Divisibleby.php
new file mode 100755
index 0000000..d5bed23
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Divisibleby.php
@@ -0,0 +1,33 @@
+
+ * {% if loop.index is divisible by(3) %}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Divisibleby extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(0 == ')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % ')
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Even.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Even.php
new file mode 100755
index 0000000..d7853e8
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Even.php
@@ -0,0 +1,32 @@
+
+ * {{ var is even }}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Even extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % 2 == 0')
+ ->raw(')')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Null.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Null.php
new file mode 100755
index 0000000..1c83825
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Null.php
@@ -0,0 +1,31 @@
+
+ * {{ var is none }}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Null extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(null === ')
+ ->subcompile($this->getNode('node'))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Odd.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Odd.php
new file mode 100755
index 0000000..421c19e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Odd.php
@@ -0,0 +1,32 @@
+
+ * {{ var is odd }}
+ *
+ *
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Odd extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % 2 == 1')
+ ->raw(')')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Test/Sameas.php b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Sameas.php
new file mode 100755
index 0000000..b48905e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Test/Sameas.php
@@ -0,0 +1,29 @@
+
+ */
+class Twig_Node_Expression_Test_Sameas extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' === ')
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Unary.php b/vendor/twig/twig/lib/Twig/Node/Expression/Unary.php
new file mode 100755
index 0000000..1cf54c3
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Unary.php
@@ -0,0 +1,27 @@
+ $node), array(), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw(' ');
+ $this->operator($compiler);
+ $compiler->subcompile($this->getNode('node'));
+ }
+
+ abstract public function operator(Twig_Compiler $compiler);
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Neg.php b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Neg.php
new file mode 100755
index 0000000..2a3937e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Neg.php
@@ -0,0 +1,18 @@
+raw('-');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Not.php b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Not.php
new file mode 100755
index 0000000..f94073c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Not.php
@@ -0,0 +1,18 @@
+raw('!');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Pos.php b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Pos.php
new file mode 100755
index 0000000..04edb52
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Expression/Unary/Pos.php
@@ -0,0 +1,18 @@
+raw('+');
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Flush.php b/vendor/twig/twig/lib/Twig/Node/Flush.php
new file mode 100755
index 0000000..20d6aab
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Flush.php
@@ -0,0 +1,36 @@
+
+ */
+class Twig_Node_Flush extends Twig_Node
+{
+ public function __construct($lineno, $tag)
+ {
+ parent::__construct(array(), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("flush();\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/For.php b/vendor/twig/twig/lib/Twig/Node/For.php
new file mode 100755
index 0000000..c54a23c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/For.php
@@ -0,0 +1,112 @@
+
+ */
+class Twig_Node_For extends Twig_Node
+{
+ protected $loop;
+
+ public function __construct(Twig_Node_Expression_AssignName $keyTarget, Twig_Node_Expression_AssignName $valueTarget, Twig_Node_Expression $seq, Twig_Node_Expression $ifexpr = null, Twig_NodeInterface $body, Twig_NodeInterface $else = null, $lineno, $tag = null)
+ {
+ $body = new Twig_Node(array($body, $this->loop = new Twig_Node_ForLoop($lineno, $tag)));
+
+ if (null !== $ifexpr) {
+ $body = new Twig_Node_If(new Twig_Node(array($ifexpr, $body)), null, $lineno, $tag);
+ }
+
+ parent::__construct(array('key_target' => $keyTarget, 'value_target' => $valueTarget, 'seq' => $seq, 'body' => $body, 'else' => $else), array('with_loop' => true, 'ifexpr' => null !== $ifexpr), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ // the (array) cast bypasses a PHP 5.2.6 bug
+ ->write("\$context['_parent'] = (array) \$context;\n")
+ ->write("\$context['_seq'] = twig_ensure_traversable(")
+ ->subcompile($this->getNode('seq'))
+ ->raw(");\n")
+ ;
+
+ if (null !== $this->getNode('else')) {
+ $compiler->write("\$context['_iterated'] = false;\n");
+ }
+
+ if ($this->getAttribute('with_loop')) {
+ $compiler
+ ->write("\$context['loop'] = array(\n")
+ ->write(" 'parent' => \$context['_parent'],\n")
+ ->write(" 'index0' => 0,\n")
+ ->write(" 'index' => 1,\n")
+ ->write(" 'first' => true,\n")
+ ->write(");\n")
+ ;
+
+ if (!$this->getAttribute('ifexpr')) {
+ $compiler
+ ->write("if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {\n")
+ ->indent()
+ ->write("\$length = count(\$context['_seq']);\n")
+ ->write("\$context['loop']['revindex0'] = \$length - 1;\n")
+ ->write("\$context['loop']['revindex'] = \$length;\n")
+ ->write("\$context['loop']['length'] = \$length;\n")
+ ->write("\$context['loop']['last'] = 1 === \$length;\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+
+ $this->loop->setAttribute('else', null !== $this->getNode('else'));
+ $this->loop->setAttribute('with_loop', $this->getAttribute('with_loop'));
+ $this->loop->setAttribute('ifexpr', $this->getAttribute('ifexpr'));
+
+ $compiler
+ ->write("foreach (\$context['_seq'] as ")
+ ->subcompile($this->getNode('key_target'))
+ ->raw(" => ")
+ ->subcompile($this->getNode('value_target'))
+ ->raw(") {\n")
+ ->indent()
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("}\n")
+ ;
+
+ if (null !== $this->getNode('else')) {
+ $compiler
+ ->write("if (!\$context['_iterated']) {\n")
+ ->indent()
+ ->subcompile($this->getNode('else'))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ $compiler->write("\$_parent = \$context['_parent'];\n");
+
+ // remove some "private" loop variables (needed for nested loops)
+ $compiler->write('unset($context[\'_seq\'], $context[\'_iterated\'], $context[\''.$this->getNode('key_target')->getAttribute('name').'\'], $context[\''.$this->getNode('value_target')->getAttribute('name').'\'], $context[\'_parent\'], $context[\'loop\']);'."\n");
+
+ // keep the values set in the inner context for variables defined in the outer context
+ $compiler->write("\$context = array_intersect_key(\$context, \$_parent) + \$_parent;\n");
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/ForLoop.php b/vendor/twig/twig/lib/Twig/Node/ForLoop.php
new file mode 100755
index 0000000..d330283
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/ForLoop.php
@@ -0,0 +1,55 @@
+
+ */
+class Twig_Node_ForLoop extends Twig_Node
+{
+ public function __construct($lineno, $tag = null)
+ {
+ parent::__construct(array(), array('with_loop' => false, 'ifexpr' => false, 'else' => false), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('else')) {
+ $compiler->write("\$context['_iterated'] = true;\n");
+ }
+
+ if ($this->getAttribute('with_loop')) {
+ $compiler
+ ->write("++\$context['loop']['index0'];\n")
+ ->write("++\$context['loop']['index'];\n")
+ ->write("\$context['loop']['first'] = false;\n")
+ ;
+
+ if (!$this->getAttribute('ifexpr')) {
+ $compiler
+ ->write("if (isset(\$context['loop']['length'])) {\n")
+ ->indent()
+ ->write("--\$context['loop']['revindex0'];\n")
+ ->write("--\$context['loop']['revindex'];\n")
+ ->write("\$context['loop']['last'] = 0 === \$context['loop']['revindex0'];\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/If.php b/vendor/twig/twig/lib/Twig/Node/If.php
new file mode 100755
index 0000000..980274e
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/If.php
@@ -0,0 +1,66 @@
+
+ */
+class Twig_Node_If extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $tests, Twig_NodeInterface $else = null, $lineno, $tag = null)
+ {
+ parent::__construct(array('tests' => $tests, 'else' => $else), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+ for ($i = 0, $count = count($this->getNode('tests')); $i < $count; $i += 2) {
+ if ($i > 0) {
+ $compiler
+ ->outdent()
+ ->write("} elseif (")
+ ;
+ } else {
+ $compiler
+ ->write('if (')
+ ;
+ }
+
+ $compiler
+ ->subcompile($this->getNode('tests')->getNode($i))
+ ->raw(") {\n")
+ ->indent()
+ ->subcompile($this->getNode('tests')->getNode($i + 1))
+ ;
+ }
+
+ if ($this->hasNode('else') && null !== $this->getNode('else')) {
+ $compiler
+ ->outdent()
+ ->write("} else {\n")
+ ->indent()
+ ->subcompile($this->getNode('else'))
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write("}\n");
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Import.php b/vendor/twig/twig/lib/Twig/Node/Import.php
new file mode 100755
index 0000000..5e4aa11
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Import.php
@@ -0,0 +1,54 @@
+
+ */
+class Twig_Node_Import extends Twig_Node
+{
+ public function __construct(Twig_Node_Expression $expr, Twig_Node_Expression $var, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr, 'var' => $var), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('')
+ ->subcompile($this->getNode('var'))
+ ->raw(' = ')
+ ;
+
+ if ($this->getNode('expr') instanceof Twig_Node_Expression_Name && '_self' === $this->getNode('expr')->getAttribute('name')) {
+ $compiler->raw("\$this");
+ } else {
+ $compiler
+ ->raw('$this->loadTemplate(')
+ ->subcompile($this->getNode('expr'))
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($this->getLine())
+ ->raw(")")
+ ;
+ }
+
+ $compiler->raw(";\n");
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Include.php b/vendor/twig/twig/lib/Twig/Node/Include.php
new file mode 100755
index 0000000..46b0685
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Include.php
@@ -0,0 +1,88 @@
+
+ */
+class Twig_Node_Include extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct(Twig_Node_Expression $expr, Twig_Node_Expression $variables = null, $only = false, $ignoreMissing = false, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr, 'variables' => $variables), array('only' => (bool) $only, 'ignore_missing' => (bool) $ignoreMissing), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+
+ if ($this->getAttribute('ignore_missing')) {
+ $compiler
+ ->write("try {\n")
+ ->indent()
+ ;
+ }
+
+ $this->addGetTemplate($compiler);
+
+ $compiler->raw('->display(');
+
+ $this->addTemplateArguments($compiler);
+
+ $compiler->raw(");\n");
+
+ if ($this->getAttribute('ignore_missing')) {
+ $compiler
+ ->outdent()
+ ->write("} catch (Twig_Error_Loader \$e) {\n")
+ ->indent()
+ ->write("// ignore missing template\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+ }
+
+ protected function addGetTemplate(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("\$this->loadTemplate(")
+ ->subcompile($this->getNode('expr'))
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($this->getLine())
+ ->raw(")")
+ ;
+ }
+
+ protected function addTemplateArguments(Twig_Compiler $compiler)
+ {
+ if (null === $this->getNode('variables')) {
+ $compiler->raw(false === $this->getAttribute('only') ? '$context' : 'array()');
+ } elseif (false === $this->getAttribute('only')) {
+ $compiler
+ ->raw('array_merge($context, ')
+ ->subcompile($this->getNode('variables'))
+ ->raw(')')
+ ;
+ } else {
+ $compiler->subcompile($this->getNode('variables'));
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Macro.php b/vendor/twig/twig/lib/Twig/Node/Macro.php
new file mode 100755
index 0000000..ab7e8d2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Macro.php
@@ -0,0 +1,96 @@
+
+ */
+class Twig_Node_Macro extends Twig_Node
+{
+ public function __construct($name, Twig_NodeInterface $body, Twig_NodeInterface $arguments, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body, 'arguments' => $arguments), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("public function get%s(", $this->getAttribute('name')))
+ ;
+
+ $count = count($this->getNode('arguments'));
+ $pos = 0;
+ foreach ($this->getNode('arguments') as $name => $default) {
+ $compiler
+ ->raw('$__'.$name.'__ = ')
+ ->subcompile($default)
+ ;
+
+ if (++$pos < $count) {
+ $compiler->raw(', ');
+ }
+ }
+
+ $compiler
+ ->raw(")\n")
+ ->write("{\n")
+ ->indent()
+ ;
+
+ if (!count($this->getNode('arguments'))) {
+ $compiler->write("\$context = \$this->env->getGlobals();\n\n");
+ } else {
+ $compiler
+ ->write("\$context = \$this->env->mergeGlobals(array(\n")
+ ->indent()
+ ;
+
+ foreach ($this->getNode('arguments') as $name => $default) {
+ $compiler
+ ->write('')
+ ->string($name)
+ ->raw(' => $__'.$name.'__')
+ ->raw(",\n")
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write("));\n\n")
+ ;
+ }
+
+ $compiler
+ ->write("\$blocks = array();\n\n")
+ ->write("ob_start();\n")
+ ->write("try {\n")
+ ->indent()
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("} catch (Exception \$e) {\n")
+ ->indent()
+ ->write("ob_end_clean();\n\n")
+ ->write("throw \$e;\n")
+ ->outdent()
+ ->write("}\n\n")
+ ->write("return ('' === \$tmp = ob_get_clean()) ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset());\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Module.php b/vendor/twig/twig/lib/Twig/Node/Module.php
new file mode 100755
index 0000000..7802263
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Module.php
@@ -0,0 +1,423 @@
+
+ */
+class Twig_Node_Module extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, Twig_Node_Expression $parent = null, Twig_NodeInterface $blocks, Twig_NodeInterface $macros, Twig_NodeInterface $traits, $embeddedTemplates, $filename)
+ {
+ // embedded templates are set as attributes so that they are only visited once by the visitors
+ parent::__construct(array(
+ 'parent' => $parent,
+ 'body' => $body,
+ 'blocks' => $blocks,
+ 'macros' => $macros,
+ 'traits' => $traits,
+ 'display_start' => new Twig_Node(),
+ 'display_end' => new Twig_Node(),
+ 'constructor_start' => new Twig_Node(),
+ 'constructor_end' => new Twig_Node(),
+ 'class_end' => new Twig_Node(),
+ ), array(
+ 'filename' => $filename,
+ 'index' => null,
+ 'embedded_templates' => $embeddedTemplates,
+ ), 1);
+ }
+
+ public function setIndex($index)
+ {
+ $this->setAttribute('index', $index);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $this->compileTemplate($compiler);
+
+ foreach ($this->getAttribute('embedded_templates') as $template) {
+ $compiler->subcompile($template);
+ }
+ }
+
+ protected function compileTemplate(Twig_Compiler $compiler)
+ {
+ if (!$this->getAttribute('index')) {
+ $compiler->write('compileClassHeader($compiler);
+
+ if (
+ count($this->getNode('blocks'))
+ || count($this->getNode('traits'))
+ || null === $this->getNode('parent')
+ || $this->getNode('parent') instanceof Twig_Node_Expression_Constant
+ || count($this->getNode('constructor_start'))
+ || count($this->getNode('constructor_end'))
+ ) {
+ $this->compileConstructor($compiler);
+ }
+
+ $this->compileGetParent($compiler);
+
+ $this->compileDisplay($compiler);
+
+ $compiler->subcompile($this->getNode('blocks'));
+
+ $this->compileMacros($compiler);
+
+ $this->compileGetTemplateName($compiler);
+
+ $this->compileIsTraitable($compiler);
+
+ $this->compileDebugInfo($compiler);
+
+ $this->compileClassFooter($compiler);
+ }
+
+ protected function compileGetParent(Twig_Compiler $compiler)
+ {
+ if (null === $parent = $this->getNode('parent')) {
+ return;
+ }
+
+ $compiler
+ ->write("protected function doGetParent(array \$context)\n", "{\n")
+ ->indent()
+ ->addDebugInfo($parent)
+ ->write("return ")
+ ;
+
+ if ($parent instanceof Twig_Node_Expression_Constant) {
+ $compiler->subcompile($parent);
+ } else {
+ $compiler
+ ->raw("\$this->loadTemplate(")
+ ->subcompile($parent)
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($this->getNode('parent')->getLine())
+ ->raw(")")
+ ;
+ }
+
+ $compiler
+ ->raw(";\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileClassHeader(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("\n\n")
+ // if the filename contains */, add a blank to avoid a PHP parse error
+ ->write("/* ".str_replace('*/', '* /', $this->getAttribute('filename'))." */\n")
+ ->write('class '.$compiler->getEnvironment()->getTemplateClass($this->getAttribute('filename'), $this->getAttribute('index')))
+ ->raw(sprintf(" extends %s\n", $compiler->getEnvironment()->getBaseTemplateClass()))
+ ->write("{\n")
+ ->indent()
+ ;
+ }
+
+ protected function compileConstructor(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function __construct(Twig_Environment \$env)\n", "{\n")
+ ->indent()
+ ->subcompile($this->getNode('constructor_start'))
+ ->write("parent::__construct(\$env);\n\n")
+ ;
+
+ // parent
+ if (null === $parent = $this->getNode('parent')) {
+ $compiler->write("\$this->parent = false;\n\n");
+ } elseif ($parent instanceof Twig_Node_Expression_Constant) {
+ $compiler
+ ->addDebugInfo($parent)
+ ->write("\$this->parent = \$this->loadTemplate(")
+ ->subcompile($parent)
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($this->getNode('parent')->getLine())
+ ->raw(");\n")
+ ;
+ }
+
+ $countTraits = count($this->getNode('traits'));
+ if ($countTraits) {
+ // traits
+ foreach ($this->getNode('traits') as $i => $trait) {
+ $this->compileLoadTemplate($compiler, $trait->getNode('template'), sprintf('$_trait_%s', $i));
+
+ $compiler
+ ->addDebugInfo($trait->getNode('template'))
+ ->write(sprintf("if (!\$_trait_%s->isTraitable()) {\n", $i))
+ ->indent()
+ ->write("throw new Twig_Error_Runtime('Template \"'.")
+ ->subcompile($trait->getNode('template'))
+ ->raw(".'\" cannot be used as a trait.');\n")
+ ->outdent()
+ ->write("}\n")
+ ->write(sprintf("\$_trait_%s_blocks = \$_trait_%s->getBlocks();\n\n", $i, $i))
+ ;
+
+ foreach ($trait->getNode('targets') as $key => $value) {
+ $compiler
+ ->write(sprintf("if (!isset(\$_trait_%s_blocks[", $i))
+ ->string($key)
+ ->raw("])) {\n")
+ ->indent()
+ ->write("throw new Twig_Error_Runtime(sprintf('Block ")
+ ->string($key)
+ ->raw(" is not defined in trait ")
+ ->subcompile($trait->getNode('template'))
+ ->raw(".'));\n")
+ ->outdent()
+ ->write("}\n\n")
+
+ ->write(sprintf("\$_trait_%s_blocks[", $i))
+ ->subcompile($value)
+ ->raw(sprintf("] = \$_trait_%s_blocks[", $i))
+ ->string($key)
+ ->raw(sprintf("]; unset(\$_trait_%s_blocks[", $i))
+ ->string($key)
+ ->raw("]);\n\n")
+ ;
+ }
+ }
+
+ if ($countTraits > 1) {
+ $compiler
+ ->write("\$this->traits = array_merge(\n")
+ ->indent()
+ ;
+
+ for ($i = 0; $i < $countTraits; $i++) {
+ $compiler
+ ->write(sprintf("\$_trait_%s_blocks".($i == $countTraits - 1 ? '' : ',')."\n", $i))
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write(");\n\n")
+ ;
+ } else {
+ $compiler
+ ->write("\$this->traits = \$_trait_0_blocks;\n\n")
+ ;
+ }
+
+ $compiler
+ ->write("\$this->blocks = array_merge(\n")
+ ->indent()
+ ->write("\$this->traits,\n")
+ ->write("array(\n")
+ ;
+ } else {
+ $compiler
+ ->write("\$this->blocks = array(\n")
+ ;
+ }
+
+ // blocks
+ $compiler
+ ->indent()
+ ;
+
+ foreach ($this->getNode('blocks') as $name => $node) {
+ $compiler
+ ->write(sprintf("'%s' => array(\$this, 'block_%s'),\n", $name, $name))
+ ;
+ }
+
+ if ($countTraits) {
+ $compiler
+ ->outdent()
+ ->write(")\n")
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write(");\n")
+ ->outdent()
+ ->subcompile($this->getNode('constructor_end'))
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileDisplay(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("protected function doDisplay(array \$context, array \$blocks = array())\n", "{\n")
+ ->indent()
+ ->subcompile($this->getNode('display_start'))
+ ->subcompile($this->getNode('body'))
+ ;
+
+ if (null !== $parent = $this->getNode('parent')) {
+ $compiler->addDebugInfo($parent);
+ if ($parent instanceof Twig_Node_Expression_Constant) {
+ $compiler->write("\$this->parent");
+ } else {
+ $compiler->write("\$this->getParent(\$context)");
+ }
+ $compiler->raw("->display(\$context, array_merge(\$this->blocks, \$blocks));\n");
+ }
+
+ $compiler
+ ->subcompile($this->getNode('display_end'))
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileClassFooter(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->subcompile($this->getNode('class_end'))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ protected function compileMacros(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('macros'));
+ }
+
+ protected function compileGetTemplateName(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function getTemplateName()\n", "{\n")
+ ->indent()
+ ->write('return ')
+ ->repr($this->getAttribute('filename'))
+ ->raw(";\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileIsTraitable(Twig_Compiler $compiler)
+ {
+ // A template can be used as a trait if:
+ // * it has no parent
+ // * it has no macros
+ // * it has no body
+ //
+ // Put another way, a template can be used as a trait if it
+ // only contains blocks and use statements.
+ $traitable = null === $this->getNode('parent') && 0 === count($this->getNode('macros'));
+ if ($traitable) {
+ if ($this->getNode('body') instanceof Twig_Node_Body) {
+ $nodes = $this->getNode('body')->getNode(0);
+ } else {
+ $nodes = $this->getNode('body');
+ }
+
+ if (!count($nodes)) {
+ $nodes = new Twig_Node(array($nodes));
+ }
+
+ foreach ($nodes as $node) {
+ if (!count($node)) {
+ continue;
+ }
+
+ if ($node instanceof Twig_Node_Text && ctype_space($node->getAttribute('data'))) {
+ continue;
+ }
+
+ if ($node instanceof Twig_Node_BlockReference) {
+ continue;
+ }
+
+ $traitable = false;
+ break;
+ }
+ }
+
+ if ($traitable) {
+ return;
+ }
+
+ $compiler
+ ->write("public function isTraitable()\n", "{\n")
+ ->indent()
+ ->write(sprintf("return %s;\n", $traitable ? 'true' : 'false'))
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileDebugInfo(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function getDebugInfo()\n", "{\n")
+ ->indent()
+ ->write(sprintf("return %s;\n", str_replace("\n", '', var_export(array_reverse($compiler->getDebugInfo(), true), true))))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ protected function compileLoadTemplate(Twig_Compiler $compiler, $node, $var)
+ {
+ if ($node instanceof Twig_Node_Expression_Constant) {
+ $compiler
+ ->write(sprintf("%s = \$this->loadTemplate(", $var))
+ ->subcompile($node)
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($node->getLine())
+ ->raw(");\n")
+ ;
+ } else {
+ $compiler
+ ->write(sprintf("%s = ", $var))
+ ->subcompile($node)
+ ->raw(";\n")
+ ->write(sprintf("if (!%s", $var))
+ ->raw(" instanceof Twig_Template) {\n")
+ ->indent()
+ ->write(sprintf("%s = \$this->loadTemplate(%s")
+ ->raw(', ')
+ ->repr($compiler->getFilename())
+ ->raw(', ')
+ ->repr($node->getLine())
+ ->raw(");\n", $var, $var))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Print.php b/vendor/twig/twig/lib/Twig/Node/Print.php
new file mode 100755
index 0000000..4263536
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Print.php
@@ -0,0 +1,39 @@
+
+ */
+class Twig_Node_Print extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo ')
+ ->subcompile($this->getNode('expr'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Sandbox.php b/vendor/twig/twig/lib/Twig/Node/Sandbox.php
new file mode 100755
index 0000000..8ca772b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Sandbox.php
@@ -0,0 +1,47 @@
+
+ */
+class Twig_Node_Sandbox extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$sandbox = \$this->env->getExtension('sandbox');\n")
+ ->write("if (!\$alreadySandboxed = \$sandbox->isSandboxed()) {\n")
+ ->indent()
+ ->write("\$sandbox->enableSandbox();\n")
+ ->outdent()
+ ->write("}\n")
+ ->subcompile($this->getNode('body'))
+ ->write("if (!\$alreadySandboxed) {\n")
+ ->indent()
+ ->write("\$sandbox->disableSandbox();\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/SandboxedPrint.php b/vendor/twig/twig/lib/Twig/Node/SandboxedPrint.php
new file mode 100755
index 0000000..823e7ac
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/SandboxedPrint.php
@@ -0,0 +1,61 @@
+
+ */
+class Twig_Node_SandboxedPrint extends Twig_Node_Print
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct($expr, $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo $this->env->getExtension(\'sandbox\')->ensureToStringAllowed(')
+ ->subcompile($this->getNode('expr'))
+ ->raw(");\n")
+ ;
+ }
+
+ /**
+ * Removes node filters.
+ *
+ * This is mostly needed when another visitor adds filters (like the escaper one).
+ *
+ * @param Twig_Node $node A Node
+ *
+ * @return Twig_Node
+ */
+ protected function removeNodeFilter($node)
+ {
+ if ($node instanceof Twig_Node_Expression_Filter) {
+ return $this->removeNodeFilter($node->getNode('node'));
+ }
+
+ return $node;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Set.php b/vendor/twig/twig/lib/Twig/Node/Set.php
new file mode 100755
index 0000000..407d147
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Set.php
@@ -0,0 +1,101 @@
+
+ */
+class Twig_Node_Set extends Twig_Node
+{
+ public function __construct($capture, Twig_NodeInterface $names, Twig_NodeInterface $values, $lineno, $tag = null)
+ {
+ parent::__construct(array('names' => $names, 'values' => $values), array('capture' => $capture, 'safe' => false), $lineno, $tag);
+
+ /*
+ * Optimizes the node when capture is used for a large block of text.
+ *
+ * {% set foo %}foo{% endset %} is compiled to $context['foo'] = new Twig_Markup("foo");
+ */
+ if ($this->getAttribute('capture')) {
+ $this->setAttribute('safe', true);
+
+ $values = $this->getNode('values');
+ if ($values instanceof Twig_Node_Text) {
+ $this->setNode('values', new Twig_Node_Expression_Constant($values->getAttribute('data'), $values->getLine()));
+ $this->setAttribute('capture', false);
+ }
+ }
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+
+ if (count($this->getNode('names')) > 1) {
+ $compiler->write('list(');
+ foreach ($this->getNode('names') as $idx => $node) {
+ if ($idx) {
+ $compiler->raw(', ');
+ }
+
+ $compiler->subcompile($node);
+ }
+ $compiler->raw(')');
+ } else {
+ if ($this->getAttribute('capture')) {
+ $compiler
+ ->write("ob_start();\n")
+ ->subcompile($this->getNode('values'))
+ ;
+ }
+
+ $compiler->subcompile($this->getNode('names'), false);
+
+ if ($this->getAttribute('capture')) {
+ $compiler->raw(" = ('' === \$tmp = ob_get_clean()) ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset())");
+ }
+ }
+
+ if (!$this->getAttribute('capture')) {
+ $compiler->raw(' = ');
+
+ if (count($this->getNode('names')) > 1) {
+ $compiler->write('array(');
+ foreach ($this->getNode('values') as $idx => $value) {
+ if ($idx) {
+ $compiler->raw(', ');
+ }
+
+ $compiler->subcompile($value);
+ }
+ $compiler->raw(')');
+ } else {
+ if ($this->getAttribute('safe')) {
+ $compiler
+ ->raw("('' === \$tmp = ")
+ ->subcompile($this->getNode('values'))
+ ->raw(") ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset())")
+ ;
+ } else {
+ $compiler->subcompile($this->getNode('values'));
+ }
+ }
+ }
+
+ $compiler->raw(";\n");
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/SetTemp.php b/vendor/twig/twig/lib/Twig/Node/SetTemp.php
new file mode 100755
index 0000000..3bdd1cb
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/SetTemp.php
@@ -0,0 +1,35 @@
+ $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+ $compiler
+ ->addDebugInfo($this)
+ ->write('if (isset($context[')
+ ->string($name)
+ ->raw('])) { $_')
+ ->raw($name)
+ ->raw('_ = $context[')
+ ->repr($name)
+ ->raw(']; } else { $_')
+ ->raw($name)
+ ->raw("_ = null; }\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Spaceless.php b/vendor/twig/twig/lib/Twig/Node/Spaceless.php
new file mode 100755
index 0000000..1478c59
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Spaceless.php
@@ -0,0 +1,40 @@
+
+ */
+class Twig_Node_Spaceless extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, $lineno, $tag = 'spaceless')
+ {
+ parent::__construct(array('body' => $body), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("ob_start();\n")
+ ->subcompile($this->getNode('body'))
+ ->write("echo trim(preg_replace('/>\s+', '><', ob_get_clean()));\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Node/Text.php b/vendor/twig/twig/lib/Twig/Node/Text.php
new file mode 100755
index 0000000..6863604
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Node/Text.php
@@ -0,0 +1,39 @@
+
+ */
+class Twig_Node_Text extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct($data, $lineno)
+ {
+ parent::__construct(array(), array('data' => $data), $lineno);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo ')
+ ->string($this->getAttribute('data'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeInterface.php b/vendor/twig/twig/lib/Twig/NodeInterface.php
new file mode 100755
index 0000000..8077349
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeInterface.php
@@ -0,0 +1,31 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_NodeInterface extends Countable, IteratorAggregate
+{
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler $compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler);
+
+ public function getLine();
+
+ public function getNodeTag();
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeOutputInterface.php b/vendor/twig/twig/lib/Twig/NodeOutputInterface.php
new file mode 100755
index 0000000..22172c0
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeOutputInterface.php
@@ -0,0 +1,19 @@
+
+ */
+interface Twig_NodeOutputInterface
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeTraverser.php b/vendor/twig/twig/lib/Twig/NodeTraverser.php
new file mode 100755
index 0000000..6024e65
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeTraverser.php
@@ -0,0 +1,90 @@
+
+ */
+class Twig_NodeTraverser
+{
+ protected $env;
+ protected $visitors;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param Twig_NodeVisitorInterface[] $visitors An array of Twig_NodeVisitorInterface instances
+ */
+ public function __construct(Twig_Environment $env, array $visitors = array())
+ {
+ $this->env = $env;
+ $this->visitors = array();
+ foreach ($visitors as $visitor) {
+ $this->addVisitor($visitor);
+ }
+ }
+
+ /**
+ * Adds a visitor.
+ *
+ * @param Twig_NodeVisitorInterface $visitor A Twig_NodeVisitorInterface instance
+ */
+ public function addVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ if (!isset($this->visitors[$visitor->getPriority()])) {
+ $this->visitors[$visitor->getPriority()] = array();
+ }
+
+ $this->visitors[$visitor->getPriority()][] = $visitor;
+ }
+
+ /**
+ * Traverses a node and calls the registered visitors.
+ *
+ * @param Twig_NodeInterface $node A Twig_NodeInterface instance
+ *
+ * @return Twig_NodeInterface
+ */
+ public function traverse(Twig_NodeInterface $node)
+ {
+ ksort($this->visitors);
+ foreach ($this->visitors as $visitors) {
+ foreach ($visitors as $visitor) {
+ $node = $this->traverseForVisitor($visitor, $node);
+ }
+ }
+
+ return $node;
+ }
+
+ protected function traverseForVisitor(Twig_NodeVisitorInterface $visitor, Twig_NodeInterface $node = null)
+ {
+ if (null === $node) {
+ return;
+ }
+
+ $node = $visitor->enterNode($node, $this->env);
+
+ foreach ($node as $k => $n) {
+ if (false !== $n = $this->traverseForVisitor($visitor, $n)) {
+ $node->setNode($k, $n);
+ } else {
+ $node->removeNode($k);
+ }
+ }
+
+ return $visitor->leaveNode($node, $this->env);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeVisitor/Escaper.php b/vendor/twig/twig/lib/Twig/NodeVisitor/Escaper.php
new file mode 100755
index 0000000..cc4b3d7
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeVisitor/Escaper.php
@@ -0,0 +1,167 @@
+
+ */
+class Twig_NodeVisitor_Escaper implements Twig_NodeVisitorInterface
+{
+ protected $statusStack = array();
+ protected $blocks = array();
+ protected $safeAnalysis;
+ protected $traverser;
+ protected $defaultStrategy = false;
+ protected $safeVars = array();
+
+ public function __construct()
+ {
+ $this->safeAnalysis = new Twig_NodeVisitor_SafeAnalysis();
+ }
+
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ if ($env->hasExtension('escaper') && $defaultStrategy = $env->getExtension('escaper')->getDefaultStrategy($node->getAttribute('filename'))) {
+ $this->defaultStrategy = $defaultStrategy;
+ }
+ $this->safeVars = array();
+ } elseif ($node instanceof Twig_Node_AutoEscape) {
+ $this->statusStack[] = $node->getAttribute('value');
+ } elseif ($node instanceof Twig_Node_Block) {
+ $this->statusStack[] = isset($this->blocks[$node->getAttribute('name')]) ? $this->blocks[$node->getAttribute('name')] : $this->needEscaping($env);
+ } elseif ($node instanceof Twig_Node_Import) {
+ $this->safeVars[] = $node->getNode('var')->getAttribute('name');
+ }
+
+ return $node;
+ }
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $this->defaultStrategy = false;
+ $this->safeVars = array();
+ } elseif ($node instanceof Twig_Node_Expression_Filter) {
+ return $this->preEscapeFilterNode($node, $env);
+ } elseif ($node instanceof Twig_Node_Print) {
+ return $this->escapePrintNode($node, $env, $this->needEscaping($env));
+ }
+
+ if ($node instanceof Twig_Node_AutoEscape || $node instanceof Twig_Node_Block) {
+ array_pop($this->statusStack);
+ } elseif ($node instanceof Twig_Node_BlockReference) {
+ $this->blocks[$node->getAttribute('name')] = $this->needEscaping($env);
+ }
+
+ return $node;
+ }
+
+ protected function escapePrintNode(Twig_Node_Print $node, Twig_Environment $env, $type)
+ {
+ if (false === $type) {
+ return $node;
+ }
+
+ $expression = $node->getNode('expr');
+
+ if ($this->isSafeFor($type, $expression, $env)) {
+ return $node;
+ }
+
+ $class = get_class($node);
+
+ return new $class(
+ $this->getEscaperFilter($type, $expression),
+ $node->getLine()
+ );
+ }
+
+ protected function preEscapeFilterNode(Twig_Node_Expression_Filter $filter, Twig_Environment $env)
+ {
+ $name = $filter->getNode('filter')->getAttribute('value');
+
+ $type = $env->getFilter($name)->getPreEscape();
+ if (null === $type) {
+ return $filter;
+ }
+
+ $node = $filter->getNode('node');
+ if ($this->isSafeFor($type, $node, $env)) {
+ return $filter;
+ }
+
+ $filter->setNode('node', $this->getEscaperFilter($type, $node));
+
+ return $filter;
+ }
+
+ protected function isSafeFor($type, Twig_NodeInterface $expression, $env)
+ {
+ $safe = $this->safeAnalysis->getSafe($expression);
+
+ if (null === $safe) {
+ if (null === $this->traverser) {
+ $this->traverser = new Twig_NodeTraverser($env, array($this->safeAnalysis));
+ }
+
+ $this->safeAnalysis->setSafeVars($this->safeVars);
+
+ $this->traverser->traverse($expression);
+ $safe = $this->safeAnalysis->getSafe($expression);
+ }
+
+ return in_array($type, $safe) || in_array('all', $safe);
+ }
+
+ protected function needEscaping(Twig_Environment $env)
+ {
+ if (count($this->statusStack)) {
+ return $this->statusStack[count($this->statusStack) - 1];
+ }
+
+ return $this->defaultStrategy ? $this->defaultStrategy : false;
+ }
+
+ protected function getEscaperFilter($type, Twig_NodeInterface $node)
+ {
+ $line = $node->getLine();
+ $name = new Twig_Node_Expression_Constant('escape', $line);
+ $args = new Twig_Node(array(new Twig_Node_Expression_Constant((string) $type, $line), new Twig_Node_Expression_Constant(null, $line), new Twig_Node_Expression_Constant(true, $line)));
+
+ return new Twig_Node_Expression_Filter($node, $name, $args, $line);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeVisitor/Optimizer.php b/vendor/twig/twig/lib/Twig/NodeVisitor/Optimizer.php
new file mode 100755
index 0000000..b206e9a
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeVisitor/Optimizer.php
@@ -0,0 +1,271 @@
+
+ */
+class Twig_NodeVisitor_Optimizer implements Twig_NodeVisitorInterface
+{
+ const OPTIMIZE_ALL = -1;
+ const OPTIMIZE_NONE = 0;
+ const OPTIMIZE_FOR = 2;
+ const OPTIMIZE_RAW_FILTER = 4;
+ const OPTIMIZE_VAR_ACCESS = 8;
+
+ protected $loops = array();
+ protected $loopsTargets = array();
+ protected $optimizers;
+ protected $prependedNodes = array();
+ protected $inABody = false;
+
+ /**
+ * Constructor.
+ *
+ * @param int $optimizers The optimizer mode
+ */
+ public function __construct($optimizers = -1)
+ {
+ if (!is_int($optimizers) || $optimizers > (self::OPTIMIZE_FOR | self::OPTIMIZE_RAW_FILTER | self::OPTIMIZE_VAR_ACCESS)) {
+ throw new InvalidArgumentException(sprintf('Optimizer mode "%s" is not valid.', $optimizers));
+ }
+
+ $this->optimizers = $optimizers;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if (self::OPTIMIZE_FOR === (self::OPTIMIZE_FOR & $this->optimizers)) {
+ $this->enterOptimizeFor($node, $env);
+ }
+
+ if (PHP_VERSION_ID < 50400 && self::OPTIMIZE_VAR_ACCESS === (self::OPTIMIZE_VAR_ACCESS & $this->optimizers) && !$env->isStrictVariables() && !$env->hasExtension('sandbox')) {
+ if ($this->inABody) {
+ if (!$node instanceof Twig_Node_Expression) {
+ if (get_class($node) !== 'Twig_Node') {
+ array_unshift($this->prependedNodes, array());
+ }
+ } else {
+ $node = $this->optimizeVariables($node, $env);
+ }
+ } elseif ($node instanceof Twig_Node_Body) {
+ $this->inABody = true;
+ }
+ }
+
+ return $node;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ $expression = $node instanceof Twig_Node_Expression;
+
+ if (self::OPTIMIZE_FOR === (self::OPTIMIZE_FOR & $this->optimizers)) {
+ $this->leaveOptimizeFor($node, $env);
+ }
+
+ if (self::OPTIMIZE_RAW_FILTER === (self::OPTIMIZE_RAW_FILTER & $this->optimizers)) {
+ $node = $this->optimizeRawFilter($node, $env);
+ }
+
+ $node = $this->optimizePrintNode($node, $env);
+
+ if (self::OPTIMIZE_VAR_ACCESS === (self::OPTIMIZE_VAR_ACCESS & $this->optimizers) && !$env->isStrictVariables() && !$env->hasExtension('sandbox')) {
+ if ($node instanceof Twig_Node_Body) {
+ $this->inABody = false;
+ } elseif ($this->inABody) {
+ if (!$expression && get_class($node) !== 'Twig_Node' && $prependedNodes = array_shift($this->prependedNodes)) {
+ $nodes = array();
+ foreach (array_unique($prependedNodes) as $name) {
+ $nodes[] = new Twig_Node_SetTemp($name, $node->getLine());
+ }
+
+ $nodes[] = $node;
+ $node = new Twig_Node($nodes);
+ }
+ }
+ }
+
+ return $node;
+ }
+
+ protected function optimizeVariables(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ('Twig_Node_Expression_Name' === get_class($node) && $node->isSimple()) {
+ $this->prependedNodes[0][] = $node->getAttribute('name');
+
+ return new Twig_Node_Expression_TempName($node->getAttribute('name'), $node->getLine());
+ }
+
+ return $node;
+ }
+
+ /**
+ * Optimizes print nodes.
+ *
+ * It replaces:
+ *
+ * * "echo $this->render(Parent)Block()" with "$this->display(Parent)Block()"
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ *
+ * @return Twig_NodeInterface
+ */
+ protected function optimizePrintNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if (!$node instanceof Twig_Node_Print) {
+ return $node;
+ }
+
+ if (
+ $node->getNode('expr') instanceof Twig_Node_Expression_BlockReference ||
+ $node->getNode('expr') instanceof Twig_Node_Expression_Parent
+ ) {
+ $node->getNode('expr')->setAttribute('output', true);
+
+ return $node->getNode('expr');
+ }
+
+ return $node;
+ }
+
+ /**
+ * Removes "raw" filters.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ *
+ * @return Twig_NodeInterface
+ */
+ protected function optimizeRawFilter(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Expression_Filter && 'raw' == $node->getNode('filter')->getAttribute('value')) {
+ return $node->getNode('node');
+ }
+
+ return $node;
+ }
+
+ /**
+ * Optimizes "for" tag by removing the "loop" variable creation whenever possible.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function enterOptimizeFor(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_For) {
+ // disable the loop variable by default
+ $node->setAttribute('with_loop', false);
+ array_unshift($this->loops, $node);
+ array_unshift($this->loopsTargets, $node->getNode('value_target')->getAttribute('name'));
+ array_unshift($this->loopsTargets, $node->getNode('key_target')->getAttribute('name'));
+ } elseif (!$this->loops) {
+ // we are outside a loop
+ return;
+ }
+
+ // when do we need to add the loop variable back?
+
+ // the loop variable is referenced for the current loop
+ elseif ($node instanceof Twig_Node_Expression_Name && 'loop' === $node->getAttribute('name')) {
+ $node->setAttribute('always_defined', true);
+ $this->addLoopToCurrent();
+ }
+
+ // optimize access to loop targets
+ elseif ($node instanceof Twig_Node_Expression_Name && in_array($node->getAttribute('name'), $this->loopsTargets)) {
+ $node->setAttribute('always_defined', true);
+ }
+
+ // block reference
+ elseif ($node instanceof Twig_Node_BlockReference || $node instanceof Twig_Node_Expression_BlockReference) {
+ $this->addLoopToCurrent();
+ }
+
+ // include without the only attribute
+ elseif ($node instanceof Twig_Node_Include && !$node->getAttribute('only')) {
+ $this->addLoopToAll();
+ }
+
+ // include function without the with_context=false parameter
+ elseif ($node instanceof Twig_Node_Expression_Function
+ && 'include' === $node->getAttribute('name')
+ && (!$node->getNode('arguments')->hasNode('with_context')
+ || false !== $node->getNode('arguments')->getNode('with_context')->getAttribute('value')
+ )
+ ) {
+ $this->addLoopToAll();
+ }
+
+ // the loop variable is referenced via an attribute
+ elseif ($node instanceof Twig_Node_Expression_GetAttr
+ && (!$node->getNode('attribute') instanceof Twig_Node_Expression_Constant
+ || 'parent' === $node->getNode('attribute')->getAttribute('value')
+ )
+ && (true === $this->loops[0]->getAttribute('with_loop')
+ || ($node->getNode('node') instanceof Twig_Node_Expression_Name
+ && 'loop' === $node->getNode('node')->getAttribute('name')
+ )
+ )
+ ) {
+ $this->addLoopToAll();
+ }
+ }
+
+ /**
+ * Optimizes "for" tag by removing the "loop" variable creation whenever possible.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function leaveOptimizeFor(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_For) {
+ array_shift($this->loops);
+ array_shift($this->loopsTargets);
+ array_shift($this->loopsTargets);
+ }
+ }
+
+ protected function addLoopToCurrent()
+ {
+ $this->loops[0]->setAttribute('with_loop', true);
+ }
+
+ protected function addLoopToAll()
+ {
+ foreach ($this->loops as $loop) {
+ $loop->setAttribute('with_loop', true);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 255;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeVisitor/SafeAnalysis.php b/vendor/twig/twig/lib/Twig/NodeVisitor/SafeAnalysis.php
new file mode 100755
index 0000000..a5d06de
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeVisitor/SafeAnalysis.php
@@ -0,0 +1,139 @@
+safeVars = $safeVars;
+ }
+
+ public function getSafe(Twig_NodeInterface $node)
+ {
+ $hash = spl_object_hash($node);
+ if (!isset($this->data[$hash])) {
+ return;
+ }
+
+ foreach ($this->data[$hash] as $bucket) {
+ if ($bucket['key'] !== $node) {
+ continue;
+ }
+
+ if (in_array('html_attr', $bucket['value'])) {
+ $bucket['value'][] = 'html';
+ }
+
+ return $bucket['value'];
+ }
+ }
+
+ protected function setSafe(Twig_NodeInterface $node, array $safe)
+ {
+ $hash = spl_object_hash($node);
+ if (isset($this->data[$hash])) {
+ foreach ($this->data[$hash] as &$bucket) {
+ if ($bucket['key'] === $node) {
+ $bucket['value'] = $safe;
+
+ return;
+ }
+ }
+ }
+ $this->data[$hash][] = array(
+ 'key' => $node,
+ 'value' => $safe,
+ );
+ }
+
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Expression_Constant) {
+ // constants are marked safe for all
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_BlockReference) {
+ // blocks are safe by definition
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_Parent) {
+ // parent block is safe by definition
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_Conditional) {
+ // intersect safeness of both operands
+ $safe = $this->intersectSafe($this->getSafe($node->getNode('expr2')), $this->getSafe($node->getNode('expr3')));
+ $this->setSafe($node, $safe);
+ } elseif ($node instanceof Twig_Node_Expression_Filter) {
+ // filter expression is safe when the filter is safe
+ $name = $node->getNode('filter')->getAttribute('value');
+ $args = $node->getNode('arguments');
+ if (false !== $filter = $env->getFilter($name)) {
+ $safe = $filter->getSafe($args);
+ if (null === $safe) {
+ $safe = $this->intersectSafe($this->getSafe($node->getNode('node')), $filter->getPreservesSafety());
+ }
+ $this->setSafe($node, $safe);
+ } else {
+ $this->setSafe($node, array());
+ }
+ } elseif ($node instanceof Twig_Node_Expression_Function) {
+ // function expression is safe when the function is safe
+ $name = $node->getAttribute('name');
+ $args = $node->getNode('arguments');
+ $function = $env->getFunction($name);
+ if (false !== $function) {
+ $this->setSafe($node, $function->getSafe($args));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } elseif ($node instanceof Twig_Node_Expression_MethodCall) {
+ if ($node->getAttribute('safe')) {
+ $this->setSafe($node, array('all'));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } elseif ($node instanceof Twig_Node_Expression_GetAttr && $node->getNode('node') instanceof Twig_Node_Expression_Name) {
+ $name = $node->getNode('node')->getAttribute('name');
+ // attributes on template instances are safe
+ if ('_self' == $name || in_array($name, $this->safeVars)) {
+ $this->setSafe($node, array('all'));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } else {
+ $this->setSafe($node, array());
+ }
+
+ return $node;
+ }
+
+ protected function intersectSafe(array $a = null, array $b = null)
+ {
+ if (null === $a || null === $b) {
+ return array();
+ }
+
+ if (in_array('all', $a)) {
+ return $b;
+ }
+
+ if (in_array('all', $b)) {
+ return $a;
+ }
+
+ return array_intersect($a, $b);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeVisitor/Sandbox.php b/vendor/twig/twig/lib/Twig/NodeVisitor/Sandbox.php
new file mode 100755
index 0000000..5467f81
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeVisitor/Sandbox.php
@@ -0,0 +1,92 @@
+
+ */
+class Twig_NodeVisitor_Sandbox implements Twig_NodeVisitorInterface
+{
+ protected $inAModule = false;
+ protected $tags;
+ protected $filters;
+ protected $functions;
+
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $this->inAModule = true;
+ $this->tags = array();
+ $this->filters = array();
+ $this->functions = array();
+
+ return $node;
+ } elseif ($this->inAModule) {
+ // look for tags
+ if ($node->getNodeTag() && !isset($this->tags[$node->getNodeTag()])) {
+ $this->tags[$node->getNodeTag()] = $node;
+ }
+
+ // look for filters
+ if ($node instanceof Twig_Node_Expression_Filter && !isset($this->filters[$node->getNode('filter')->getAttribute('value')])) {
+ $this->filters[$node->getNode('filter')->getAttribute('value')] = $node;
+ }
+
+ // look for functions
+ if ($node instanceof Twig_Node_Expression_Function && !isset($this->functions[$node->getAttribute('name')])) {
+ $this->functions[$node->getAttribute('name')] = $node;
+ }
+
+ // wrap print to check __toString() calls
+ if ($node instanceof Twig_Node_Print) {
+ return new Twig_Node_SandboxedPrint($node->getNode('expr'), $node->getLine(), $node->getNodeTag());
+ }
+ }
+
+ return $node;
+ }
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $this->inAModule = false;
+
+ $node->setNode('display_start', new Twig_Node(array(new Twig_Node_CheckSecurity($this->filters, $this->tags, $this->functions), $node->getNode('display_start'))));
+ }
+
+ return $node;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/NodeVisitorInterface.php b/vendor/twig/twig/lib/Twig/NodeVisitorInterface.php
new file mode 100755
index 0000000..f276163
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/NodeVisitorInterface.php
@@ -0,0 +1,47 @@
+
+ */
+interface Twig_NodeVisitorInterface
+{
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env);
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface|false The modified node or false if the node must be removed
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env);
+
+ /**
+ * Returns the priority for this visitor.
+ *
+ * Priority should be between -10 and 10 (0 is the default).
+ *
+ * @return int The priority level
+ */
+ public function getPriority();
+}
diff --git a/vendor/twig/twig/lib/Twig/Parser.php b/vendor/twig/twig/lib/Twig/Parser.php
new file mode 100755
index 0000000..549ce2b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Parser.php
@@ -0,0 +1,390 @@
+
+ */
+class Twig_Parser implements Twig_ParserInterface
+{
+ protected $stack = array();
+ protected $stream;
+ protected $parent;
+ protected $handlers;
+ protected $visitors;
+ protected $expressionParser;
+ protected $blocks;
+ protected $blockStack;
+ protected $macros;
+ protected $env;
+ protected $reservedMacroNames;
+ protected $importedSymbols;
+ protected $traits;
+ protected $embeddedTemplates = array();
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ }
+
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ public function getVarName()
+ {
+ return sprintf('__internal_%s', hash('sha256', uniqid(mt_rand(), true), false));
+ }
+
+ public function getFilename()
+ {
+ return $this->stream->getFilename();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function parse(Twig_TokenStream $stream, $test = null, $dropNeedle = false)
+ {
+ // push all variables into the stack to keep the current state of the parser
+ $vars = get_object_vars($this);
+ unset($vars['stack'], $vars['env'], $vars['handlers'], $vars['visitors'], $vars['expressionParser']);
+ $this->stack[] = $vars;
+
+ // tag handlers
+ if (null === $this->handlers) {
+ $this->handlers = $this->env->getTokenParsers();
+ $this->handlers->setParser($this);
+ }
+
+ // node visitors
+ if (null === $this->visitors) {
+ $this->visitors = $this->env->getNodeVisitors();
+ }
+
+ if (null === $this->expressionParser) {
+ $this->expressionParser = new Twig_ExpressionParser($this, $this->env->getUnaryOperators(), $this->env->getBinaryOperators());
+ }
+
+ $this->stream = $stream;
+ $this->parent = null;
+ $this->blocks = array();
+ $this->macros = array();
+ $this->traits = array();
+ $this->blockStack = array();
+ $this->importedSymbols = array(array());
+ $this->embeddedTemplates = array();
+
+ try {
+ $body = $this->subparse($test, $dropNeedle);
+
+ if (null !== $this->parent) {
+ if (null === $body = $this->filterBodyNodes($body)) {
+ $body = new Twig_Node();
+ }
+ }
+ } catch (Twig_Error_Syntax $e) {
+ if (!$e->getTemplateFile()) {
+ $e->setTemplateFile($this->getFilename());
+ }
+
+ if (!$e->getTemplateLine()) {
+ $e->setTemplateLine($this->stream->getCurrent()->getLine());
+ }
+
+ throw $e;
+ }
+
+ $node = new Twig_Node_Module(new Twig_Node_Body(array($body)), $this->parent, new Twig_Node($this->blocks), new Twig_Node($this->macros), new Twig_Node($this->traits), $this->embeddedTemplates, $this->getFilename());
+
+ $traverser = new Twig_NodeTraverser($this->env, $this->visitors);
+
+ $node = $traverser->traverse($node);
+
+ // restore previous stack so previous parse() call can resume working
+ foreach (array_pop($this->stack) as $key => $val) {
+ $this->$key = $val;
+ }
+
+ return $node;
+ }
+
+ public function subparse($test, $dropNeedle = false)
+ {
+ $lineno = $this->getCurrentToken()->getLine();
+ $rv = array();
+ while (!$this->stream->isEOF()) {
+ switch ($this->getCurrentToken()->getType()) {
+ case Twig_Token::TEXT_TYPE:
+ $token = $this->stream->next();
+ $rv[] = new Twig_Node_Text($token->getValue(), $token->getLine());
+ break;
+
+ case Twig_Token::VAR_START_TYPE:
+ $token = $this->stream->next();
+ $expr = $this->expressionParser->parseExpression();
+ $this->stream->expect(Twig_Token::VAR_END_TYPE);
+ $rv[] = new Twig_Node_Print($expr, $token->getLine());
+ break;
+
+ case Twig_Token::BLOCK_START_TYPE:
+ $this->stream->next();
+ $token = $this->getCurrentToken();
+
+ if ($token->getType() !== Twig_Token::NAME_TYPE) {
+ throw new Twig_Error_Syntax('A block must start with a tag name', $token->getLine(), $this->getFilename());
+ }
+
+ if (null !== $test && call_user_func($test, $token)) {
+ if ($dropNeedle) {
+ $this->stream->next();
+ }
+
+ if (1 === count($rv)) {
+ return $rv[0];
+ }
+
+ return new Twig_Node($rv, array(), $lineno);
+ }
+
+ $subparser = $this->handlers->getTokenParser($token->getValue());
+ if (null === $subparser) {
+ if (null !== $test) {
+ $error = sprintf('Unexpected tag name "%s"', $token->getValue());
+ if (is_array($test) && isset($test[0]) && $test[0] instanceof Twig_TokenParserInterface) {
+ $error .= sprintf(' (expecting closing tag for the "%s" tag defined near line %s)', $test[0]->getTag(), $lineno);
+ }
+
+ throw new Twig_Error_Syntax($error, $token->getLine(), $this->getFilename());
+ }
+
+ $message = sprintf('Unknown tag name "%s"', $token->getValue());
+ if ($alternatives = $this->env->computeAlternatives($token->getValue(), array_keys($this->env->getTags()))) {
+ $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
+ }
+
+ throw new Twig_Error_Syntax($message, $token->getLine(), $this->getFilename());
+ }
+
+ $this->stream->next();
+
+ $node = $subparser->parse($token);
+ if (null !== $node) {
+ $rv[] = $node;
+ }
+ break;
+
+ default:
+ throw new Twig_Error_Syntax('Lexer or parser ended up in unsupported state.', 0, $this->getFilename());
+ }
+ }
+
+ if (1 === count($rv)) {
+ return $rv[0];
+ }
+
+ return new Twig_Node($rv, array(), $lineno);
+ }
+
+ public function addHandler($name, $class)
+ {
+ $this->handlers[$name] = $class;
+ }
+
+ public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ $this->visitors[] = $visitor;
+ }
+
+ public function getBlockStack()
+ {
+ return $this->blockStack;
+ }
+
+ public function peekBlockStack()
+ {
+ return $this->blockStack[count($this->blockStack) - 1];
+ }
+
+ public function popBlockStack()
+ {
+ array_pop($this->blockStack);
+ }
+
+ public function pushBlockStack($name)
+ {
+ $this->blockStack[] = $name;
+ }
+
+ public function hasBlock($name)
+ {
+ return isset($this->blocks[$name]);
+ }
+
+ public function getBlock($name)
+ {
+ return $this->blocks[$name];
+ }
+
+ public function setBlock($name, Twig_Node_Block $value)
+ {
+ $this->blocks[$name] = new Twig_Node_Body(array($value), array(), $value->getLine());
+ }
+
+ public function hasMacro($name)
+ {
+ return isset($this->macros[$name]);
+ }
+
+ public function setMacro($name, Twig_Node_Macro $node)
+ {
+ if (null === $this->reservedMacroNames) {
+ $this->reservedMacroNames = array();
+ $r = new ReflectionClass($this->env->getBaseTemplateClass());
+ foreach ($r->getMethods() as $method) {
+ $this->reservedMacroNames[] = $method->getName();
+ }
+ }
+
+ if (in_array($name, $this->reservedMacroNames)) {
+ throw new Twig_Error_Syntax(sprintf('"%s" cannot be used as a macro name as it is a reserved keyword', $name), $node->getLine(), $this->getFilename());
+ }
+
+ $this->macros[$name] = $node;
+ }
+
+ public function addTrait($trait)
+ {
+ $this->traits[] = $trait;
+ }
+
+ public function hasTraits()
+ {
+ return count($this->traits) > 0;
+ }
+
+ public function embedTemplate(Twig_Node_Module $template)
+ {
+ $template->setIndex(mt_rand());
+
+ $this->embeddedTemplates[] = $template;
+ }
+
+ public function addImportedSymbol($type, $alias, $name = null, Twig_Node_Expression $node = null)
+ {
+ $this->importedSymbols[0][$type][$alias] = array('name' => $name, 'node' => $node);
+ }
+
+ public function getImportedSymbol($type, $alias)
+ {
+ foreach ($this->importedSymbols as $functions) {
+ if (isset($functions[$type][$alias])) {
+ return $functions[$type][$alias];
+ }
+ }
+ }
+
+ public function isMainScope()
+ {
+ return 1 === count($this->importedSymbols);
+ }
+
+ public function pushLocalScope()
+ {
+ array_unshift($this->importedSymbols, array());
+ }
+
+ public function popLocalScope()
+ {
+ array_shift($this->importedSymbols);
+ }
+
+ /**
+ * Gets the expression parser.
+ *
+ * @return Twig_ExpressionParser The expression parser
+ */
+ public function getExpressionParser()
+ {
+ return $this->expressionParser;
+ }
+
+ public function getParent()
+ {
+ return $this->parent;
+ }
+
+ public function setParent($parent)
+ {
+ $this->parent = $parent;
+ }
+
+ /**
+ * Gets the token stream.
+ *
+ * @return Twig_TokenStream The token stream
+ */
+ public function getStream()
+ {
+ return $this->stream;
+ }
+
+ /**
+ * Gets the current token.
+ *
+ * @return Twig_Token The current token
+ */
+ public function getCurrentToken()
+ {
+ return $this->stream->getCurrent();
+ }
+
+ protected function filterBodyNodes(Twig_NodeInterface $node)
+ {
+ // check that the body does not contain non-empty output nodes
+ if (
+ ($node instanceof Twig_Node_Text && !ctype_space($node->getAttribute('data')))
+ ||
+ (!$node instanceof Twig_Node_Text && !$node instanceof Twig_Node_BlockReference && $node instanceof Twig_NodeOutputInterface)
+ ) {
+ if (false !== strpos((string) $node, chr(0xEF).chr(0xBB).chr(0xBF))) {
+ throw new Twig_Error_Syntax('A template that extends another one cannot have a body but a byte order mark (BOM) has been detected; it must be removed.', $node->getLine(), $this->getFilename());
+ }
+
+ throw new Twig_Error_Syntax('A template that extends another one cannot have a body.', $node->getLine(), $this->getFilename());
+ }
+
+ // bypass "set" nodes as they "capture" the output
+ if ($node instanceof Twig_Node_Set) {
+ return $node;
+ }
+
+ if ($node instanceof Twig_NodeOutputInterface) {
+ return;
+ }
+
+ foreach ($node as $k => $n) {
+ if (null !== $n && null === $this->filterBodyNodes($n)) {
+ $node->removeNode($k);
+ }
+ }
+
+ return $node;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/ParserInterface.php b/vendor/twig/twig/lib/Twig/ParserInterface.php
new file mode 100755
index 0000000..8e7cc0a
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/ParserInterface.php
@@ -0,0 +1,31 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_ParserInterface
+{
+ /**
+ * Converts a token stream to a node tree.
+ *
+ * @param Twig_TokenStream $stream A token stream instance
+ *
+ * @return Twig_Node_Module A node tree
+ *
+ * @throws Twig_Error_Syntax When the token stream is syntactically or semantically wrong
+ */
+ public function parse(Twig_TokenStream $stream);
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Dumper/Blackfire.php b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Blackfire.php
new file mode 100755
index 0000000..b82747a
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Blackfire.php
@@ -0,0 +1,68 @@
+
+ */
+class Twig_Profiler_Dumper_Blackfire
+{
+ public function dump(Twig_Profiler_Profile $profile)
+ {
+ $data = array();
+ $this->dumpProfile('main()', $profile, $data);
+ $this->dumpChildren('main()', $profile, $data);
+
+ $start = microtime(true);
+ $str = << $values) {
+ $str .= "{$name}//{$values['ct']} {$values['wt']} {$values['mu']} {$values['pmu']}\n";
+ }
+
+ return $str;
+ }
+
+ private function dumpChildren($parent, Twig_Profiler_Profile $profile, &$data)
+ {
+ foreach ($profile as $p) {
+ if ($p->isTemplate()) {
+ $name = $p->getTemplate();
+ } else {
+ $name = sprintf('%s::%s(%s)', $p->getTemplate(), $p->getType(), $p->getName());
+ }
+ $this->dumpProfile(sprintf('%s==>%s', $parent, $name), $p, $data);
+ $this->dumpChildren($name, $p, $data);
+ }
+ }
+
+ private function dumpProfile($edge, Twig_Profiler_Profile $profile, &$data)
+ {
+ if (isset($data[$edge])) {
+ $data[$edge]['ct'] += 1;
+ $data[$edge]['wt'] += floor($profile->getDuration() * 1000000);
+ $data[$edge]['mu'] += $profile->getMemoryUsage();
+ $data[$edge]['pmu'] += $profile->getPeakMemoryUsage();
+ } else {
+ $data[$edge] = array(
+ 'ct' => 1,
+ 'wt' => floor($profile->getDuration() * 1000000),
+ 'mu' => $profile->getMemoryUsage(),
+ 'pmu' => $profile->getPeakMemoryUsage(),
+ );
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Dumper/Html.php b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Html.php
new file mode 100755
index 0000000..c898520
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Html.php
@@ -0,0 +1,43 @@
+
+ */
+class Twig_Profiler_Dumper_Html extends Twig_Profiler_Dumper_Text
+{
+ static private $colors = array(
+ 'block' => '#dfd',
+ 'macro' => '#ddf',
+ 'template' => '#ffd',
+ 'big' => '#d44',
+ );
+
+ public function dump(Twig_Profiler_Profile $profile)
+ {
+ return ''.parent::dump($profile).' ';
+ }
+
+ protected function formatTemplate(Twig_Profiler_Profile $profile, $prefix)
+ {
+ return sprintf('%s└ %s ', $prefix, self::$colors['template'], $profile->getTemplate());
+ }
+
+ protected function formatNonTemplate(Twig_Profiler_Profile $profile, $prefix)
+ {
+ return sprintf('%s└ %s::%s(%s )', $prefix, $profile->getTemplate(), $profile->getType(), isset(self::$colors[$profile->getType()]) ? self::$colors[$profile->getType()] : 'auto', $profile->getName());
+ }
+
+ protected function formatTime(Twig_Profiler_Profile $profile, $percent)
+ {
+ return sprintf('%.2fms/%.0f%% ', $percent > 20 ? self::$colors['big'] : 'auto', $profile->getDuration() * 1000, $percent);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Dumper/Text.php b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Text.php
new file mode 100755
index 0000000..998e210
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Dumper/Text.php
@@ -0,0 +1,68 @@
+
+ */
+class Twig_Profiler_Dumper_Text
+{
+ private $root;
+
+ public function dump(Twig_Profiler_Profile $profile)
+ {
+ return $this->dumpProfile($profile);
+ }
+
+ protected function formatTemplate(Twig_Profiler_Profile $profile, $prefix)
+ {
+ return sprintf('%s└ %s', $prefix, $profile->getTemplate());
+ }
+
+ protected function formatNonTemplate(Twig_Profiler_Profile $profile, $prefix)
+ {
+ return sprintf('%s└ %s::%s(%s)', $prefix, $profile->getTemplate(), $profile->getType(), $profile->getName());
+ }
+
+ protected function formatTime(Twig_Profiler_Profile $profile, $percent)
+ {
+ return sprintf('%.2fms/%.0f%%', $profile->getDuration() * 1000, $percent);
+ }
+
+ private function dumpProfile(Twig_Profiler_Profile $profile, $prefix = '', $sibling = false)
+ {
+ if ($profile->isRoot()) {
+ $this->root = $profile->getDuration();
+ $start = $profile->getName();
+ } else {
+ if ($profile->isTemplate()) {
+ $start = $this->formatTemplate($profile, $prefix);
+ } else {
+ $start = $this->formatNonTemplate($profile, $prefix);
+ }
+ $prefix .= $sibling ? '│ ' : ' ';
+ }
+
+ $percent = $this->root ? $profile->getDuration() / $this->root * 100 : 0;
+
+ if ($profile->getDuration() * 1000 < 1) {
+ $str = $start."\n";
+ } else {
+ $str = sprintf("%s %s\n", $start, $this->formatTime($profile, $percent));
+ }
+
+ $nCount = count($profile->getProfiles());
+ foreach ($profile as $i => $p) {
+ $str .= $this->dumpProfile($p, $prefix, $i + 1 !== $nCount);
+ }
+
+ return $str;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Node/EnterProfile.php b/vendor/twig/twig/lib/Twig/Profiler/Node/EnterProfile.php
new file mode 100755
index 0000000..11c1114
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Node/EnterProfile.php
@@ -0,0 +1,40 @@
+
+ */
+class Twig_Profiler_Node_EnterProfile extends Twig_Node
+{
+ public function __construct($extensionName, $type, $name, $varName)
+ {
+ parent::__construct(array(), array('extension_name' => $extensionName, 'name' => $name, 'type' => $type, 'var_name' => $varName));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write(sprintf("\$%s = \$this->env->getExtension(", $this->getAttribute('var_name')))
+ ->repr($this->getAttribute('extension_name'))
+ ->raw(");\n")
+ ->write(sprintf("\$%s->enter(\$%s = new Twig_Profiler_Profile(\$this->getTemplateName(), ", $this->getAttribute('var_name'), $this->getAttribute('var_name').'_prof'))
+ ->repr($this->getAttribute('type'))
+ ->raw(", ")
+ ->repr($this->getAttribute('name'))
+ ->raw("));\n\n")
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Node/LeaveProfile.php b/vendor/twig/twig/lib/Twig/Profiler/Node/LeaveProfile.php
new file mode 100755
index 0000000..88074c2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Node/LeaveProfile.php
@@ -0,0 +1,34 @@
+
+ */
+class Twig_Profiler_Node_LeaveProfile extends Twig_Node
+{
+ public function __construct($varName)
+ {
+ parent::__construct(array(), array('var_name' => $varName));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("\n")
+ ->write(sprintf("\$%s->leave(\$%s);\n\n", $this->getAttribute('var_name'), $this->getAttribute('var_name').'_prof'))
+ ;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/NodeVisitor/Profiler.php b/vendor/twig/twig/lib/Twig/Profiler/NodeVisitor/Profiler.php
new file mode 100755
index 0000000..58beb0a
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/NodeVisitor/Profiler.php
@@ -0,0 +1,72 @@
+
+ */
+class Twig_Profiler_NodeVisitor_Profiler implements Twig_NodeVisitorInterface
+{
+ private $extensionName;
+
+ public function __construct($extensionName)
+ {
+ $this->extensionName = $extensionName;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $varName = $this->getVarName();
+ $node->setNode('display_start', new Twig_Node(array(new Twig_Profiler_Node_EnterProfile($this->extensionName, Twig_Profiler_Profile::TEMPLATE, $node->getAttribute('filename'), $varName), $node->getNode('display_start'))));
+ $node->setNode('display_end', new Twig_Node(array(new Twig_Profiler_Node_LeaveProfile($varName), $node->getNode('display_end'))));
+ } elseif ($node instanceof Twig_Node_Block) {
+ $varName = $this->getVarName();
+ $node->setNode('body', new Twig_Node_Body(array(
+ new Twig_Profiler_Node_EnterProfile($this->extensionName, Twig_Profiler_Profile::BLOCK, $node->getAttribute('name'), $varName),
+ $node->getNode('body'),
+ new Twig_Profiler_Node_LeaveProfile($varName),
+ )));
+ } elseif ($node instanceof Twig_Node_Macro) {
+ $varName = $this->getVarName();
+ $node->setNode('body', new Twig_Node_Body(array(
+ new Twig_Profiler_Node_EnterProfile($this->extensionName, Twig_Profiler_Profile::MACRO, $node->getAttribute('name'), $varName),
+ $node->getNode('body'),
+ new Twig_Profiler_Node_LeaveProfile($varName),
+ )));
+ }
+
+ return $node;
+ }
+
+ private function getVarName()
+ {
+ return sprintf('__internal_%s', hash('sha256', uniqid(mt_rand(), true), false));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Profiler/Profile.php b/vendor/twig/twig/lib/Twig/Profiler/Profile.php
new file mode 100755
index 0000000..fe48a4d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Profiler/Profile.php
@@ -0,0 +1,150 @@
+
+ */
+class Twig_Profiler_Profile implements IteratorAggregate, Serializable
+{
+ const ROOT = 'ROOT';
+ const BLOCK = 'block';
+ const TEMPLATE = 'template';
+ const MACRO = 'macro';
+
+ private $template;
+ private $name;
+ private $type;
+ private $starts = array();
+ private $ends = array();
+ private $profiles = array();
+
+ public function __construct($template = 'main', $type = Twig_Profiler_Profile::ROOT, $name = 'main')
+ {
+ $this->template = $template;
+ $this->type = $type;
+ $this->name = 0 === strpos($name, '__internal_') ? 'INTERNAL' : $name;
+ $this->enter();
+ }
+
+ public function getTemplate()
+ {
+ return $this->template;
+ }
+
+ public function getType()
+ {
+ return $this->type;
+ }
+
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ public function isRoot()
+ {
+ return self::ROOT === $this->type;
+ }
+
+ public function isTemplate()
+ {
+ return self::TEMPLATE === $this->type;
+ }
+
+ public function isBlock()
+ {
+ return self::BLOCK === $this->type;
+ }
+
+ public function isMacro()
+ {
+ return self::MACRO === $this->type;
+ }
+
+ public function getProfiles()
+ {
+ return $this->profiles;
+ }
+
+ public function addProfile(Twig_Profiler_Profile $profile)
+ {
+ $this->profiles[] = $profile;
+ }
+
+ /**
+ * Returns the duration in microseconds.
+ *
+ * @return int
+ */
+ public function getDuration()
+ {
+ return isset($this->ends['wt']) && isset($this->starts['wt']) ? $this->ends['wt'] - $this->starts['wt'] : 0;
+ }
+
+ /**
+ * Returns the memory usage in bytes.
+ *
+ * @return int
+ */
+ public function getMemoryUsage()
+ {
+ return isset($this->ends['mu']) && isset($this->starts['mu']) ? $this->ends['mu'] - $this->starts['mu'] : 0;
+ }
+
+ /**
+ * Returns the peak memory usage in bytes.
+ *
+ * @return int
+ */
+ public function getPeakMemoryUsage()
+ {
+ return isset($this->ends['pmu']) && isset($this->starts['pmu']) ? $this->ends['pmu'] - $this->starts['pmu'] : 0;
+ }
+
+ /**
+ * Starts the profiling.
+ */
+ public function enter()
+ {
+ $this->starts = array(
+ 'wt' => microtime(true),
+ 'mu' => memory_get_usage(),
+ 'pmu' => memory_get_peak_usage(),
+ );
+ }
+
+ /**
+ * Stops the profiling.
+ */
+ public function leave()
+ {
+ $this->ends = array(
+ 'wt' => microtime(true),
+ 'mu' => memory_get_usage(),
+ 'pmu' => memory_get_peak_usage(),
+ );
+ }
+
+ public function getIterator()
+ {
+ return new ArrayIterator($this->profiles);
+ }
+
+ public function serialize()
+ {
+ return serialize(array($this->template, $this->name, $this->type, $this->starts, $this->ends, $this->profiles));
+ }
+
+ public function unserialize($data)
+ {
+ list($this->template, $this->name, $this->type, $this->starts, $this->ends, $this->profiles) = unserialize($data);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityError.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityError.php
new file mode 100755
index 0000000..015bfae
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityError.php
@@ -0,0 +1,19 @@
+
+ */
+class Twig_Sandbox_SecurityError extends Twig_Error
+{
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFilterError.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFilterError.php
new file mode 100755
index 0000000..99faba9
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFilterError.php
@@ -0,0 +1,31 @@
+
+ */
+class Twig_Sandbox_SecurityNotAllowedFilterError extends Twig_Sandbox_SecurityError
+{
+ private $filterName;
+
+ public function __construct($message, $functionName, $lineno = -1, $filename = null, Exception $previous = null)
+ {
+ parent::__construct($message, $lineno, $filename, $previous);
+ $this->filterName = $functionName;
+ }
+
+ public function getFilterName()
+ {
+ return $this->filterName;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFunctionError.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFunctionError.php
new file mode 100755
index 0000000..05cf488
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedFunctionError.php
@@ -0,0 +1,31 @@
+
+ */
+class Twig_Sandbox_SecurityNotAllowedFunctionError extends Twig_Sandbox_SecurityError
+{
+ private $functionName;
+
+ public function __construct($message, $functionName, $lineno = -1, $filename = null, Exception $previous = null)
+ {
+ parent::__construct($message, $lineno, $filename, $previous);
+ $this->functionName = $functionName;
+ }
+
+ public function getFunctionName()
+ {
+ return $this->functionName;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedTagError.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedTagError.php
new file mode 100755
index 0000000..b3bb5e8
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityNotAllowedTagError.php
@@ -0,0 +1,31 @@
+
+ */
+class Twig_Sandbox_SecurityNotAllowedTagError extends Twig_Sandbox_SecurityError
+{
+ private $tagName;
+
+ public function __construct($message, $tagName, $lineno = -1, $filename = null, Exception $previous = null)
+ {
+ parent::__construct($message, $lineno, $filename, $previous);
+ $this->tagName = $tagName;
+ }
+
+ public function getTagName()
+ {
+ return $this->tagName;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicy.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicy.php
new file mode 100755
index 0000000..c4dd03d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicy.php
@@ -0,0 +1,119 @@
+
+ */
+class Twig_Sandbox_SecurityPolicy implements Twig_Sandbox_SecurityPolicyInterface
+{
+ protected $allowedTags;
+ protected $allowedFilters;
+ protected $allowedMethods;
+ protected $allowedProperties;
+ protected $allowedFunctions;
+
+ public function __construct(array $allowedTags = array(), array $allowedFilters = array(), array $allowedMethods = array(), array $allowedProperties = array(), array $allowedFunctions = array())
+ {
+ $this->allowedTags = $allowedTags;
+ $this->allowedFilters = $allowedFilters;
+ $this->setAllowedMethods($allowedMethods);
+ $this->allowedProperties = $allowedProperties;
+ $this->allowedFunctions = $allowedFunctions;
+ }
+
+ public function setAllowedTags(array $tags)
+ {
+ $this->allowedTags = $tags;
+ }
+
+ public function setAllowedFilters(array $filters)
+ {
+ $this->allowedFilters = $filters;
+ }
+
+ public function setAllowedMethods(array $methods)
+ {
+ $this->allowedMethods = array();
+ foreach ($methods as $class => $m) {
+ $this->allowedMethods[$class] = array_map('strtolower', is_array($m) ? $m : array($m));
+ }
+ }
+
+ public function setAllowedProperties(array $properties)
+ {
+ $this->allowedProperties = $properties;
+ }
+
+ public function setAllowedFunctions(array $functions)
+ {
+ $this->allowedFunctions = $functions;
+ }
+
+ public function checkSecurity($tags, $filters, $functions)
+ {
+ foreach ($tags as $tag) {
+ if (!in_array($tag, $this->allowedTags)) {
+ throw new Twig_Sandbox_SecurityNotAllowedTagError(sprintf('Tag "%s" is not allowed.', $tag), $tag);
+ }
+ }
+
+ foreach ($filters as $filter) {
+ if (!in_array($filter, $this->allowedFilters)) {
+ throw new Twig_Sandbox_SecurityNotAllowedFilterError(sprintf('Filter "%s" is not allowed.', $filter), $filter);
+ }
+ }
+
+ foreach ($functions as $function) {
+ if (!in_array($function, $this->allowedFunctions)) {
+ throw new Twig_Sandbox_SecurityNotAllowedFunctionError(sprintf('Function "%s" is not allowed.', $function), $function);
+ }
+ }
+ }
+
+ public function checkMethodAllowed($obj, $method)
+ {
+ if ($obj instanceof Twig_TemplateInterface || $obj instanceof Twig_Markup) {
+ return true;
+ }
+
+ $allowed = false;
+ $method = strtolower($method);
+ foreach ($this->allowedMethods as $class => $methods) {
+ if ($obj instanceof $class) {
+ $allowed = in_array($method, $methods);
+
+ break;
+ }
+ }
+
+ if (!$allowed) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Calling "%s" method on a "%s" object is not allowed.', $method, get_class($obj)));
+ }
+ }
+
+ public function checkPropertyAllowed($obj, $property)
+ {
+ $allowed = false;
+ foreach ($this->allowedProperties as $class => $properties) {
+ if ($obj instanceof $class) {
+ $allowed = in_array($property, is_array($properties) ? $properties : array($properties));
+
+ break;
+ }
+ }
+
+ if (!$allowed) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Calling "%s" property on a "%s" object is not allowed.', $property, get_class($obj)));
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php b/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php
new file mode 100755
index 0000000..6ab48e3
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php
@@ -0,0 +1,24 @@
+
+ */
+interface Twig_Sandbox_SecurityPolicyInterface
+{
+ public function checkSecurity($tags, $filters, $functions);
+
+ public function checkMethodAllowed($obj, $method);
+
+ public function checkPropertyAllowed($obj, $method);
+}
diff --git a/vendor/twig/twig/lib/Twig/SimpleFilter.php b/vendor/twig/twig/lib/Twig/SimpleFilter.php
new file mode 100755
index 0000000..d35c563
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/SimpleFilter.php
@@ -0,0 +1,94 @@
+
+ */
+class Twig_SimpleFilter
+{
+ protected $name;
+ protected $callable;
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct($name, $callable, array $options = array())
+ {
+ $this->name = $name;
+ $this->callable = $callable;
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ 'is_safe' => null,
+ 'is_safe_callback' => null,
+ 'pre_escape' => null,
+ 'preserves_safety' => null,
+ 'node_class' => 'Twig_Node_Expression_Filter',
+ ), $options);
+ }
+
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ public function getCallable()
+ {
+ return $this->callable;
+ }
+
+ public function getNodeClass()
+ {
+ return $this->options['node_class'];
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $filterArgs)
+ {
+ if (null !== $this->options['is_safe']) {
+ return $this->options['is_safe'];
+ }
+
+ if (null !== $this->options['is_safe_callback']) {
+ return call_user_func($this->options['is_safe_callback'], $filterArgs);
+ }
+ }
+
+ public function getPreservesSafety()
+ {
+ return $this->options['preserves_safety'];
+ }
+
+ public function getPreEscape()
+ {
+ return $this->options['pre_escape'];
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/SimpleFunction.php b/vendor/twig/twig/lib/Twig/SimpleFunction.php
new file mode 100755
index 0000000..8ef6aca
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/SimpleFunction.php
@@ -0,0 +1,84 @@
+
+ */
+class Twig_SimpleFunction
+{
+ protected $name;
+ protected $callable;
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct($name, $callable, array $options = array())
+ {
+ $this->name = $name;
+ $this->callable = $callable;
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ 'is_safe' => null,
+ 'is_safe_callback' => null,
+ 'node_class' => 'Twig_Node_Expression_Function',
+ ), $options);
+ }
+
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ public function getCallable()
+ {
+ return $this->callable;
+ }
+
+ public function getNodeClass()
+ {
+ return $this->options['node_class'];
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $functionArgs)
+ {
+ if (null !== $this->options['is_safe']) {
+ return $this->options['is_safe'];
+ }
+
+ if (null !== $this->options['is_safe_callback']) {
+ return call_user_func($this->options['is_safe_callback'], $functionArgs);
+ }
+
+ return array();
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/SimpleTest.php b/vendor/twig/twig/lib/Twig/SimpleTest.php
new file mode 100755
index 0000000..225459c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/SimpleTest.php
@@ -0,0 +1,46 @@
+
+ */
+class Twig_SimpleTest
+{
+ protected $name;
+ protected $callable;
+ protected $options;
+
+ public function __construct($name, $callable, array $options = array())
+ {
+ $this->name = $name;
+ $this->callable = $callable;
+ $this->options = array_merge(array(
+ 'node_class' => 'Twig_Node_Expression_Test',
+ ), $options);
+ }
+
+ public function getName()
+ {
+ return $this->name;
+ }
+
+ public function getCallable()
+ {
+ return $this->callable;
+ }
+
+ public function getNodeClass()
+ {
+ return $this->options['node_class'];
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Template.php b/vendor/twig/twig/lib/Twig/Template.php
new file mode 100755
index 0000000..0878d16
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Template.php
@@ -0,0 +1,536 @@
+
+ */
+abstract class Twig_Template implements Twig_TemplateInterface
+{
+ protected static $cache = array();
+
+ protected $parent;
+ protected $parents = array();
+ protected $env;
+ protected $blocks;
+ protected $traits;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ $this->blocks = array();
+ $this->traits = array();
+ }
+
+ /**
+ * Returns the template name.
+ *
+ * @return string The template name
+ */
+ abstract public function getTemplateName();
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ /**
+ * Returns the parent template.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param array $context
+ *
+ * @return Twig_TemplateInterface|false The parent template or false if there is no parent
+ */
+ public function getParent(array $context)
+ {
+ if (null !== $this->parent) {
+ return $this->parent;
+ }
+
+ try {
+ $parent = $this->doGetParent($context);
+
+ if (false === $parent) {
+ return false;
+ }
+
+ if ($parent instanceof self) {
+ return $this->parents[$parent->getTemplateName()] = $parent;
+ }
+
+ if (!isset($this->parents[$parent])) {
+ $this->parents[$parent] = $this->loadTemplate($parent);
+ }
+ } catch (Twig_Error_Loader $e) {
+ $e->setTemplateFile(null);
+ $e->guess();
+
+ throw $e;
+ }
+
+ return $this->parents[$parent];
+ }
+
+ protected function doGetParent(array $context)
+ {
+ return false;
+ }
+
+ public function isTraitable()
+ {
+ return true;
+ }
+
+ /**
+ * Displays a parent block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to display from the parent
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ */
+ public function displayParentBlock($name, array $context, array $blocks = array())
+ {
+ $name = (string) $name;
+
+ if (isset($this->traits[$name])) {
+ $this->traits[$name][0]->displayBlock($name, $context, $blocks, false);
+ } elseif (false !== $parent = $this->getParent($context)) {
+ $parent->displayBlock($name, $context, $blocks, false);
+ } else {
+ throw new Twig_Error_Runtime(sprintf('The template has no parent and no traits defining the "%s" block', $name), -1, $this->getTemplateName());
+ }
+ }
+
+ /**
+ * Displays a block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to display
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ * @param bool $useBlocks Whether to use the current set of blocks
+ */
+ public function displayBlock($name, array $context, array $blocks = array(), $useBlocks = true)
+ {
+ $name = (string) $name;
+
+ if ($useBlocks && isset($blocks[$name])) {
+ $template = $blocks[$name][0];
+ $block = $blocks[$name][1];
+ } elseif (isset($this->blocks[$name])) {
+ $template = $this->blocks[$name][0];
+ $block = $this->blocks[$name][1];
+ } else {
+ $template = null;
+ $block = null;
+ }
+
+ if (null !== $template) {
+ try {
+ $template->$block($context, $blocks);
+ } catch (Twig_Error $e) {
+ throw $e;
+ } catch (Exception $e) {
+ throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $template->getTemplateName(), $e);
+ }
+ } elseif (false !== $parent = $this->getParent($context)) {
+ $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks), false);
+ }
+ }
+
+ /**
+ * Renders a parent block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to render from the parent
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ *
+ * @return string The rendered block
+ */
+ public function renderParentBlock($name, array $context, array $blocks = array())
+ {
+ ob_start();
+ $this->displayParentBlock($name, $context, $blocks);
+
+ return ob_get_clean();
+ }
+
+ /**
+ * Renders a block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to render
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ * @param bool $useBlocks Whether to use the current set of blocks
+ *
+ * @return string The rendered block
+ */
+ public function renderBlock($name, array $context, array $blocks = array(), $useBlocks = true)
+ {
+ ob_start();
+ $this->displayBlock($name, $context, $blocks, $useBlocks);
+
+ return ob_get_clean();
+ }
+
+ /**
+ * Returns whether a block exists or not.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * This method does only return blocks defined in the current template
+ * or defined in "used" traits.
+ *
+ * It does not return blocks from parent templates as the parent
+ * template name can be dynamic, which is only known based on the
+ * current context.
+ *
+ * @param string $name The block name
+ *
+ * @return bool true if the block exists, false otherwise
+ */
+ public function hasBlock($name)
+ {
+ return isset($this->blocks[(string) $name]);
+ }
+
+ /**
+ * Returns all block names.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @return array An array of block names
+ *
+ * @see hasBlock
+ */
+ public function getBlockNames()
+ {
+ return array_keys($this->blocks);
+ }
+
+ protected function loadTemplate($template, $templateName = null, $line = null, $index = null)
+ {
+ try {
+ if (is_array($template)) {
+ return $this->env->resolveTemplate($template);
+ }
+
+ if ($template instanceof self) {
+ return $template;
+ }
+
+ return $this->env->loadTemplate($template, $index);
+ } catch (Twig_Error $e) {
+ if (!$e->getTemplateFile()) {
+ $e->setTemplateFile($templateName ? $templateName : $this->getTemplateName());
+ }
+
+ if ($e->getTemplateLine()) {
+ throw $e;
+ }
+
+ if (!$line) {
+ $e->guess();
+ } else {
+ $e->setTemplateLine($line);
+ }
+
+ throw $e;
+ }
+ }
+
+ /**
+ * Returns all blocks.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @return array An array of blocks
+ *
+ * @see hasBlock
+ */
+ public function getBlocks()
+ {
+ return $this->blocks;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function display(array $context, array $blocks = array())
+ {
+ $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function render(array $context)
+ {
+ $level = ob_get_level();
+ ob_start();
+ try {
+ $this->display($context);
+ } catch (Exception $e) {
+ while (ob_get_level() > $level) {
+ ob_end_clean();
+ }
+
+ throw $e;
+ }
+
+ return ob_get_clean();
+ }
+
+ protected function displayWithErrorHandling(array $context, array $blocks = array())
+ {
+ try {
+ $this->doDisplay($context, $blocks);
+ } catch (Twig_Error $e) {
+ if (!$e->getTemplateFile()) {
+ $e->setTemplateFile($this->getTemplateName());
+ }
+
+ // this is mostly useful for Twig_Error_Loader exceptions
+ // see Twig_Error_Loader
+ if (false === $e->getTemplateLine()) {
+ $e->setTemplateLine(-1);
+ $e->guess();
+ }
+
+ throw $e;
+ } catch (Exception $e) {
+ throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $this->getTemplateName(), $e);
+ }
+ }
+
+ /**
+ * Auto-generated method to display the template with the given context.
+ *
+ * @param array $context An array of parameters to pass to the template
+ * @param array $blocks An array of blocks to pass to the template
+ */
+ abstract protected function doDisplay(array $context, array $blocks = array());
+
+ /**
+ * Returns a variable from the context.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * This method should not be overridden in a sub-class as this is an
+ * implementation detail that has been introduced to optimize variable
+ * access for versions of PHP before 5.4. This is not a way to override
+ * the way to get a variable value.
+ *
+ * @param array $context The context
+ * @param string $item The variable to return from the context
+ * @param bool $ignoreStrictCheck Whether to ignore the strict variable check or not
+ *
+ * @return mixed The content of the context variable
+ *
+ * @throws Twig_Error_Runtime if the variable does not exist and Twig is running in strict mode
+ */
+ final protected function getContext($context, $item, $ignoreStrictCheck = false)
+ {
+ if (!array_key_exists($item, $context)) {
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Variable "%s" does not exist', $item), -1, $this->getTemplateName());
+ }
+
+ return $context[$item];
+ }
+
+ /**
+ * Returns the attribute value for a given array/object.
+ *
+ * @param mixed $object The object or array from where to get the item
+ * @param mixed $item The item to get from the array or object
+ * @param array $arguments An array of arguments to pass if the item is an object method
+ * @param string $type The type of attribute (@see Twig_Template constants)
+ * @param bool $isDefinedTest Whether this is only a defined check
+ * @param bool $ignoreStrictCheck Whether to ignore the strict attribute check or not
+ *
+ * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
+ *
+ * @throws Twig_Error_Runtime if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
+ */
+ protected function getAttribute($object, $item, array $arguments = array(), $type = self::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
+ {
+ // array
+ if (self::METHOD_CALL !== $type) {
+ $arrayItem = is_bool($item) || is_float($item) ? (int) $item : $item;
+
+ if ((is_array($object) && array_key_exists($arrayItem, $object))
+ || ($object instanceof ArrayAccess && isset($object[$arrayItem]))
+ ) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ return $object[$arrayItem];
+ }
+
+ if (self::ARRAY_CALL === $type || !is_object($object)) {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return;
+ }
+
+ if ($object instanceof ArrayAccess) {
+ $message = sprintf('Key "%s" in object with ArrayAccess of class "%s" does not exist', $arrayItem, get_class($object));
+ } elseif (is_object($object)) {
+ $message = sprintf('Impossible to access a key "%s" on an object of class "%s" that does not implement ArrayAccess interface', $item, get_class($object));
+ } elseif (is_array($object)) {
+ if (empty($object)) {
+ $message = sprintf('Key "%s" does not exist as the array is empty', $arrayItem);
+ } else {
+ $message = sprintf('Key "%s" for array with keys "%s" does not exist', $arrayItem, implode(', ', array_keys($object)));
+ }
+ } elseif (self::ARRAY_CALL === $type) {
+ if (null === $object) {
+ $message = sprintf('Impossible to access a key ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to access a key ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+ } elseif (null === $object) {
+ $message = sprintf('Impossible to access an attribute ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to access an attribute ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+
+ throw new Twig_Error_Runtime($message, -1, $this->getTemplateName());
+ }
+ }
+
+ if (!is_object($object)) {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return;
+ }
+
+ if (null === $object) {
+ $message = sprintf('Impossible to invoke a method ("%s") on a null variable', $item);
+ } else {
+ $message = sprintf('Impossible to invoke a method ("%s") on a %s variable ("%s")', $item, gettype($object), $object);
+ }
+
+ throw new Twig_Error_Runtime($message, -1, $this->getTemplateName());
+ }
+
+ // object property
+ if (self::METHOD_CALL !== $type) {
+ if (isset($object->$item) || array_key_exists((string) $item, $object)) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
+ }
+
+ return $object->$item;
+ }
+ }
+
+ $class = get_class($object);
+
+ // object method
+ if (!isset(self::$cache[$class]['methods'])) {
+ self::$cache[$class]['methods'] = array_change_key_case(array_flip(get_class_methods($object)));
+ }
+
+ $call = false;
+ $lcItem = strtolower($item);
+ if (isset(self::$cache[$class]['methods'][$lcItem])) {
+ $method = (string) $item;
+ } elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
+ $method = 'get'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
+ $method = 'is'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['__call'])) {
+ $method = (string) $item;
+ $call = true;
+ } else {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)), -1, $this->getTemplateName());
+ }
+
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
+ }
+
+ // Some objects throw exceptions when they have __call, and the method we try
+ // to call is not supported. If ignoreStrictCheck is true, we should return null.
+ try {
+ $ret = call_user_func_array(array($object, $method), $arguments);
+ } catch (BadMethodCallException $e) {
+ if ($call && ($ignoreStrictCheck || !$this->env->isStrictVariables())) {
+ return;
+ }
+ throw $e;
+ }
+
+ // useful when calling a template method from a template
+ // this is not supported but unfortunately heavily used in the Symfony profiler
+ if ($object instanceof Twig_TemplateInterface) {
+ return $ret === '' ? '' : new Twig_Markup($ret, $this->env->getCharset());
+ }
+
+ return $ret;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TemplateInterface.php b/vendor/twig/twig/lib/Twig/TemplateInterface.php
new file mode 100755
index 0000000..d178832
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TemplateInterface.php
@@ -0,0 +1,48 @@
+
+ *
+ * @deprecated since 1.12 (to be removed in 3.0)
+ */
+interface Twig_TemplateInterface
+{
+ const ANY_CALL = 'any';
+ const ARRAY_CALL = 'array';
+ const METHOD_CALL = 'method';
+
+ /**
+ * Renders the template with the given context and returns it as string.
+ *
+ * @param array $context An array of parameters to pass to the template
+ *
+ * @return string The rendered template
+ */
+ public function render(array $context);
+
+ /**
+ * Displays the template with the given context.
+ *
+ * @param array $context An array of parameters to pass to the template
+ * @param array $blocks An array of blocks to pass to the template
+ */
+ public function display(array $context, array $blocks = array());
+
+ /**
+ * Returns the bound environment for this template.
+ *
+ * @return Twig_Environment The current environment
+ */
+ public function getEnvironment();
+}
diff --git a/vendor/twig/twig/lib/Twig/Test.php b/vendor/twig/twig/lib/Twig/Test.php
new file mode 100755
index 0000000..3baff88
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test.php
@@ -0,0 +1,34 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+abstract class Twig_Test implements Twig_TestInterface, Twig_TestCallableInterface
+{
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct(array $options = array())
+ {
+ $this->options = array_merge(array(
+ 'callable' => null,
+ ), $options);
+ }
+
+ public function getCallable()
+ {
+ return $this->options['callable'];
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Test/Function.php b/vendor/twig/twig/lib/Twig/Test/Function.php
new file mode 100755
index 0000000..4be6b9b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test/Function.php
@@ -0,0 +1,35 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Test_Function extends Twig_Test
+{
+ protected $function;
+
+ public function __construct($function, array $options = array())
+ {
+ $options['callable'] = $function;
+
+ parent::__construct($options);
+
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Test/IntegrationTestCase.php b/vendor/twig/twig/lib/Twig/Test/IntegrationTestCase.php
new file mode 100755
index 0000000..b8bceb8
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test/IntegrationTestCase.php
@@ -0,0 +1,154 @@
+
+ * @author Karma Dordrak
+ */
+abstract class Twig_Test_IntegrationTestCase extends PHPUnit_Framework_TestCase
+{
+ abstract protected function getExtensions();
+ abstract protected function getFixturesDir();
+
+ /**
+ * @dataProvider getTests
+ */
+ public function testIntegration($file, $message, $condition, $templates, $exception, $outputs)
+ {
+ $this->doIntegrationTest($file, $message, $condition, $templates, $exception, $outputs);
+ }
+
+ public function getTests()
+ {
+ $fixturesDir = realpath($this->getFixturesDir());
+ $tests = array();
+
+ foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($fixturesDir), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
+ if (!preg_match('/\.test$/', $file)) {
+ continue;
+ }
+
+ $test = file_get_contents($file->getRealpath());
+
+ if (preg_match('/
+ --TEST--\s*(.*?)\s*(?:--CONDITION--\s*(.*))?\s*((?:--TEMPLATE(?:\(.*?\))?--(?:.*?))+)\s*(?:--DATA--\s*(.*))?\s*--EXCEPTION--\s*(.*)/sx', $test, $match)) {
+ $message = $match[1];
+ $condition = $match[2];
+ $templates = $this->parseTemplates($match[3]);
+ $exception = $match[5];
+ $outputs = array(array(null, $match[4], null, ''));
+ } elseif (preg_match('/--TEST--\s*(.*?)\s*(?:--CONDITION--\s*(.*))?\s*((?:--TEMPLATE(?:\(.*?\))?--(?:.*?))+)--DATA--.*?--EXPECT--.*/s', $test, $match)) {
+ $message = $match[1];
+ $condition = $match[2];
+ $templates = $this->parseTemplates($match[3]);
+ $exception = false;
+ preg_match_all('/--DATA--(.*?)(?:--CONFIG--(.*?))?--EXPECT--(.*?)(?=\-\-DATA\-\-|$)/s', $test, $outputs, PREG_SET_ORDER);
+ } else {
+ throw new InvalidArgumentException(sprintf('Test "%s" is not valid.', str_replace($fixturesDir.'/', '', $file)));
+ }
+
+ $tests[] = array(str_replace($fixturesDir.'/', '', $file), $message, $condition, $templates, $exception, $outputs);
+ }
+
+ return $tests;
+ }
+
+ protected function doIntegrationTest($file, $message, $condition, $templates, $exception, $outputs)
+ {
+ if ($condition) {
+ eval('$ret = '.$condition.';');
+ if (!$ret) {
+ $this->markTestSkipped($condition);
+ }
+ }
+
+ $loader = new Twig_Loader_Array($templates);
+
+ foreach ($outputs as $match) {
+ $config = array_merge(array(
+ 'cache' => false,
+ 'strict_variables' => true,
+ ), $match[2] ? eval($match[2].';') : array());
+ $twig = new Twig_Environment($loader, $config);
+ $twig->addGlobal('global', 'global');
+ foreach ($this->getExtensions() as $extension) {
+ $twig->addExtension($extension);
+ }
+
+ try {
+ $template = $twig->loadTemplate('index.twig');
+ } catch (Exception $e) {
+ if (false !== $exception) {
+ $this->assertEquals(trim($exception), trim(sprintf('%s: %s', get_class($e), $e->getMessage())));
+
+ return;
+ }
+
+ if ($e instanceof Twig_Error_Syntax) {
+ $e->setTemplateFile($file);
+
+ throw $e;
+ }
+
+ throw new Twig_Error(sprintf('%s: %s', get_class($e), $e->getMessage()), -1, $file, $e);
+ }
+
+ try {
+ $output = trim($template->render(eval($match[1].';')), "\n ");
+ } catch (Exception $e) {
+ if (false !== $exception) {
+ $this->assertEquals(trim($exception), trim(sprintf('%s: %s', get_class($e), $e->getMessage())));
+
+ return;
+ }
+
+ if ($e instanceof Twig_Error_Syntax) {
+ $e->setTemplateFile($file);
+ } else {
+ $e = new Twig_Error(sprintf('%s: %s', get_class($e), $e->getMessage()), -1, $file, $e);
+ }
+
+ $output = trim(sprintf('%s: %s', get_class($e), $e->getMessage()));
+ }
+
+ if (false !== $exception) {
+ list($class, ) = explode(':', $exception);
+ $this->assertThat(null, new PHPUnit_Framework_Constraint_Exception($class));
+ }
+
+ $expected = trim($match[3], "\n ");
+
+ if ($expected != $output) {
+ echo 'Compiled template that failed:';
+
+ foreach (array_keys($templates) as $name) {
+ echo "Template: $name\n";
+ $source = $loader->getSource($name);
+ echo $twig->compile($twig->parse($twig->tokenize($source, $name)));
+ }
+ }
+ $this->assertEquals($expected, $output, $message.' (in '.$file.')');
+ }
+ }
+
+ protected static function parseTemplates($test)
+ {
+ $templates = array();
+ preg_match_all('/--TEMPLATE(?:\((.*?)\))?--(.*?)(?=\-\-TEMPLATE|$)/s', $test, $matches, PREG_SET_ORDER);
+ foreach ($matches as $match) {
+ $templates[($match[1] ? $match[1] : 'index.twig')] = $match[2];
+ }
+
+ return $templates;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Test/Method.php b/vendor/twig/twig/lib/Twig/Test/Method.php
new file mode 100755
index 0000000..17c6c04
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test/Method.php
@@ -0,0 +1,37 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Test_Method extends Twig_Test
+{
+ protected $extension;
+ protected $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method, array $options = array())
+ {
+ $options['callable'] = array($extension, $method);
+
+ parent::__construct($options);
+
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Test/Node.php b/vendor/twig/twig/lib/Twig/Test/Node.php
new file mode 100755
index 0000000..c832a57
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test/Node.php
@@ -0,0 +1,37 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_Test_Node extends Twig_Test
+{
+ protected $class;
+
+ public function __construct($class, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/Test/NodeTestCase.php b/vendor/twig/twig/lib/Twig/Test/NodeTestCase.php
new file mode 100755
index 0000000..bf86521
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Test/NodeTestCase.php
@@ -0,0 +1,60 @@
+assertNodeCompilation($source, $node, $environment);
+ }
+
+ public function assertNodeCompilation($source, Twig_Node $node, Twig_Environment $environment = null)
+ {
+ $compiler = $this->getCompiler($environment);
+ $compiler->compile($node);
+
+ $this->assertEquals($source, trim($compiler->getSource()));
+ }
+
+ protected function getCompiler(Twig_Environment $environment = null)
+ {
+ return new Twig_Compiler(null === $environment ? $this->getEnvironment() : $environment);
+ }
+
+ protected function getEnvironment()
+ {
+ return new Twig_Environment();
+ }
+
+ protected function getVariableGetter($name, $line = false)
+ {
+ $line = $line > 0 ? "// line {$line}\n" : '';
+
+ if (PHP_VERSION_ID >= 50400) {
+ return sprintf('%s(isset($context["%s"]) ? $context["%s"] : null)', $line, $name, $name);
+ }
+
+ return sprintf('%s$this->getContext($context, "%s")', $line, $name);
+ }
+
+ protected function getAttributeGetter()
+ {
+ if (function_exists('twig_template_get_attributes')) {
+ return 'twig_template_get_attributes($this, ';
+ }
+
+ return '$this->getAttribute(';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TestCallableInterface.php b/vendor/twig/twig/lib/Twig/TestCallableInterface.php
new file mode 100755
index 0000000..0db4368
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TestCallableInterface.php
@@ -0,0 +1,21 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_TestCallableInterface
+{
+ public function getCallable();
+}
diff --git a/vendor/twig/twig/lib/Twig/TestInterface.php b/vendor/twig/twig/lib/Twig/TestInterface.php
new file mode 100755
index 0000000..30d8a2c
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TestInterface.php
@@ -0,0 +1,26 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_TestInterface
+{
+ /**
+ * Compiles a test.
+ *
+ * @return string The PHP code for the test
+ */
+ public function compile();
+}
diff --git a/vendor/twig/twig/lib/Twig/Token.php b/vendor/twig/twig/lib/Twig/Token.php
new file mode 100755
index 0000000..15dd4eb
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/Token.php
@@ -0,0 +1,216 @@
+
+ */
+class Twig_Token
+{
+ protected $value;
+ protected $type;
+ protected $lineno;
+
+ const EOF_TYPE = -1;
+ const TEXT_TYPE = 0;
+ const BLOCK_START_TYPE = 1;
+ const VAR_START_TYPE = 2;
+ const BLOCK_END_TYPE = 3;
+ const VAR_END_TYPE = 4;
+ const NAME_TYPE = 5;
+ const NUMBER_TYPE = 6;
+ const STRING_TYPE = 7;
+ const OPERATOR_TYPE = 8;
+ const PUNCTUATION_TYPE = 9;
+ const INTERPOLATION_START_TYPE = 10;
+ const INTERPOLATION_END_TYPE = 11;
+
+ /**
+ * Constructor.
+ *
+ * @param int $type The type of the token
+ * @param string $value The token value
+ * @param int $lineno The line position in the source
+ */
+ public function __construct($type, $value, $lineno)
+ {
+ $this->type = $type;
+ $this->value = $value;
+ $this->lineno = $lineno;
+ }
+
+ /**
+ * Returns a string representation of the token.
+ *
+ * @return string A string representation of the token
+ */
+ public function __toString()
+ {
+ return sprintf('%s(%s)', self::typeToString($this->type, true), $this->value);
+ }
+
+ /**
+ * Tests the current token for a type and/or a value.
+ *
+ * Parameters may be:
+ * * just type
+ * * type and value (or array of possible values)
+ * * just value (or array of possible values) (NAME_TYPE is used as type)
+ *
+ * @param array|int $type The type to test
+ * @param array|string|null $values The token value
+ *
+ * @return bool
+ */
+ public function test($type, $values = null)
+ {
+ if (null === $values && !is_int($type)) {
+ $values = $type;
+ $type = self::NAME_TYPE;
+ }
+
+ return ($this->type === $type) && (
+ null === $values ||
+ (is_array($values) && in_array($this->value, $values)) ||
+ $this->value == $values
+ );
+ }
+
+ /**
+ * Gets the line.
+ *
+ * @return int The source line
+ */
+ public function getLine()
+ {
+ return $this->lineno;
+ }
+
+ /**
+ * Gets the token type.
+ *
+ * @return int The token type
+ */
+ public function getType()
+ {
+ return $this->type;
+ }
+
+ /**
+ * Gets the token value.
+ *
+ * @return string The token value
+ */
+ public function getValue()
+ {
+ return $this->value;
+ }
+
+ /**
+ * Returns the constant representation (internal) of a given type.
+ *
+ * @param int $type The type as an integer
+ * @param bool $short Whether to return a short representation or not
+ *
+ * @return string The string representation
+ */
+ public static function typeToString($type, $short = false)
+ {
+ switch ($type) {
+ case self::EOF_TYPE:
+ $name = 'EOF_TYPE';
+ break;
+ case self::TEXT_TYPE:
+ $name = 'TEXT_TYPE';
+ break;
+ case self::BLOCK_START_TYPE:
+ $name = 'BLOCK_START_TYPE';
+ break;
+ case self::VAR_START_TYPE:
+ $name = 'VAR_START_TYPE';
+ break;
+ case self::BLOCK_END_TYPE:
+ $name = 'BLOCK_END_TYPE';
+ break;
+ case self::VAR_END_TYPE:
+ $name = 'VAR_END_TYPE';
+ break;
+ case self::NAME_TYPE:
+ $name = 'NAME_TYPE';
+ break;
+ case self::NUMBER_TYPE:
+ $name = 'NUMBER_TYPE';
+ break;
+ case self::STRING_TYPE:
+ $name = 'STRING_TYPE';
+ break;
+ case self::OPERATOR_TYPE:
+ $name = 'OPERATOR_TYPE';
+ break;
+ case self::PUNCTUATION_TYPE:
+ $name = 'PUNCTUATION_TYPE';
+ break;
+ case self::INTERPOLATION_START_TYPE:
+ $name = 'INTERPOLATION_START_TYPE';
+ break;
+ case self::INTERPOLATION_END_TYPE:
+ $name = 'INTERPOLATION_END_TYPE';
+ break;
+ default:
+ throw new LogicException(sprintf('Token of type "%s" does not exist.', $type));
+ }
+
+ return $short ? $name : 'Twig_Token::'.$name;
+ }
+
+ /**
+ * Returns the english representation of a given type.
+ *
+ * @param int $type The type as an integer
+ *
+ * @return string The string representation
+ */
+ public static function typeToEnglish($type)
+ {
+ switch ($type) {
+ case self::EOF_TYPE:
+ return 'end of template';
+ case self::TEXT_TYPE:
+ return 'text';
+ case self::BLOCK_START_TYPE:
+ return 'begin of statement block';
+ case self::VAR_START_TYPE:
+ return 'begin of print statement';
+ case self::BLOCK_END_TYPE:
+ return 'end of statement block';
+ case self::VAR_END_TYPE:
+ return 'end of print statement';
+ case self::NAME_TYPE:
+ return 'name';
+ case self::NUMBER_TYPE:
+ return 'number';
+ case self::STRING_TYPE:
+ return 'string';
+ case self::OPERATOR_TYPE:
+ return 'operator';
+ case self::PUNCTUATION_TYPE:
+ return 'punctuation';
+ case self::INTERPOLATION_START_TYPE:
+ return 'begin of string interpolation';
+ case self::INTERPOLATION_END_TYPE:
+ return 'end of string interpolation';
+ default:
+ throw new LogicException(sprintf('Token of type "%s" does not exist.', $type));
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser.php b/vendor/twig/twig/lib/Twig/TokenParser.php
new file mode 100755
index 0000000..57b1825
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser.php
@@ -0,0 +1,33 @@
+
+ */
+abstract class Twig_TokenParser implements Twig_TokenParserInterface
+{
+ /**
+ * @var Twig_Parser
+ */
+ protected $parser;
+
+ /**
+ * Sets the parser associated with this token parser
+ *
+ * @param Twig_Parser $parser A Twig_Parser instance
+ */
+ public function setParser(Twig_Parser $parser)
+ {
+ $this->parser = $parser;
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/AutoEscape.php b/vendor/twig/twig/lib/Twig/TokenParser/AutoEscape.php
new file mode 100755
index 0000000..2756028
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/AutoEscape.php
@@ -0,0 +1,89 @@
+
+ * {% autoescape true %}
+ * Everything will be automatically escaped in this block
+ * {% endautoescape %}
+ *
+ * {% autoescape false %}
+ * Everything will be outputed as is in this block
+ * {% endautoescape %}
+ *
+ * {% autoescape true js %}
+ * Everything will be automatically escaped in this block
+ * using the js escaping strategy
+ * {% endautoescape %}
+ *
+ */
+class Twig_TokenParser_AutoEscape extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $stream = $this->parser->getStream();
+
+ if ($stream->test(Twig_Token::BLOCK_END_TYPE)) {
+ $value = 'html';
+ } else {
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+ if (!$expr instanceof Twig_Node_Expression_Constant) {
+ throw new Twig_Error_Syntax('An escaping strategy must be a string or a Boolean.', $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ $value = $expr->getAttribute('value');
+
+ $compat = true === $value || false === $value;
+
+ if (true === $value) {
+ $value = 'html';
+ }
+
+ if ($compat && $stream->test(Twig_Token::NAME_TYPE)) {
+ if (false === $value) {
+ throw new Twig_Error_Syntax('Unexpected escaping strategy as you set autoescaping to false.', $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+
+ $value = $stream->next()->getValue();
+ }
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_AutoEscape($value, $body, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endautoescape');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'autoescape';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Block.php b/vendor/twig/twig/lib/Twig/TokenParser/Block.php
new file mode 100755
index 0000000..0a46200
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Block.php
@@ -0,0 +1,81 @@
+
+ * {% block head %}
+ *
+ * {% block title %}{% endblock %} - My Webpage
+ * {% endblock %}
+ *
+ */
+class Twig_TokenParser_Block extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $stream = $this->parser->getStream();
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ if ($this->parser->hasBlock($name)) {
+ throw new Twig_Error_Syntax(sprintf("The block '$name' has already been defined line %d", $this->parser->getBlock($name)->getLine()), $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ $this->parser->setBlock($name, $block = new Twig_Node_Block($name, new Twig_Node(array()), $lineno));
+ $this->parser->pushLocalScope();
+ $this->parser->pushBlockStack($name);
+
+ if ($stream->nextIf(Twig_Token::BLOCK_END_TYPE)) {
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ if ($token = $stream->nextIf(Twig_Token::NAME_TYPE)) {
+ $value = $token->getValue();
+
+ if ($value != $name) {
+ throw new Twig_Error_Syntax(sprintf('Expected endblock for block "%s" (but "%s" given)', $name, $value), $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ }
+ } else {
+ $body = new Twig_Node(array(
+ new Twig_Node_Print($this->parser->getExpressionParser()->parseExpression(), $lineno),
+ ));
+ }
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $block->setNode('body', $body);
+ $this->parser->popBlockStack();
+ $this->parser->popLocalScope();
+
+ return new Twig_Node_BlockReference($name, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endblock');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'block';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Do.php b/vendor/twig/twig/lib/Twig/TokenParser/Do.php
new file mode 100755
index 0000000..f50939d
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Do.php
@@ -0,0 +1,42 @@
+parser->getExpressionParser()->parseExpression();
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Do($expr, $token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'do';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Embed.php b/vendor/twig/twig/lib/Twig/TokenParser/Embed.php
new file mode 100755
index 0000000..69cb5f3
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Embed.php
@@ -0,0 +1,66 @@
+parser->getStream();
+
+ $parent = $this->parser->getExpressionParser()->parseExpression();
+
+ list($variables, $only, $ignoreMissing) = $this->parseArguments();
+
+ // inject a fake parent to make the parent() function work
+ $stream->injectTokens(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', $token->getLine()),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'extends', $token->getLine()),
+ new Twig_Token(Twig_Token::STRING_TYPE, '__parent__', $token->getLine()),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', $token->getLine()),
+ ));
+
+ $module = $this->parser->parse($stream, array($this, 'decideBlockEnd'), true);
+
+ // override the parent with the correct one
+ $module->setNode('parent', $parent);
+
+ $this->parser->embedTemplate($module);
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Embed($module->getAttribute('filename'), $module->getAttribute('index'), $variables, $only, $ignoreMissing, $token->getLine(), $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endembed');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'embed';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Extends.php b/vendor/twig/twig/lib/Twig/TokenParser/Extends.php
new file mode 100755
index 0000000..f5ecee2
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Extends.php
@@ -0,0 +1,52 @@
+
+ * {% extends "base.html" %}
+ *
+ */
+class Twig_TokenParser_Extends extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ if (!$this->parser->isMainScope()) {
+ throw new Twig_Error_Syntax('Cannot extend from a block', $token->getLine(), $this->parser->getFilename());
+ }
+
+ if (null !== $this->parser->getParent()) {
+ throw new Twig_Error_Syntax('Multiple extends tags are forbidden', $token->getLine(), $this->parser->getFilename());
+ }
+ $this->parser->setParent($this->parser->getExpressionParser()->parseExpression());
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'extends';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Filter.php b/vendor/twig/twig/lib/Twig/TokenParser/Filter.php
new file mode 100755
index 0000000..2b97475
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Filter.php
@@ -0,0 +1,61 @@
+
+ * {% filter upper %}
+ * This text becomes uppercase
+ * {% endfilter %}
+ *
+ */
+class Twig_TokenParser_Filter extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $name = $this->parser->getVarName();
+ $ref = new Twig_Node_Expression_BlockReference(new Twig_Node_Expression_Constant($name, $token->getLine()), true, $token->getLine(), $this->getTag());
+
+ $filter = $this->parser->getExpressionParser()->parseFilterExpressionRaw($ref, $this->getTag());
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $block = new Twig_Node_Block($name, $body, $token->getLine());
+ $this->parser->setBlock($name, $block);
+
+ return new Twig_Node_Print($filter, $token->getLine(), $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endfilter');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'filter';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Flush.php b/vendor/twig/twig/lib/Twig/TokenParser/Flush.php
new file mode 100755
index 0000000..4e15e78
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Flush.php
@@ -0,0 +1,42 @@
+parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Flush($token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'flush';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/For.php b/vendor/twig/twig/lib/Twig/TokenParser/For.php
new file mode 100755
index 0000000..5c07d63
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/For.php
@@ -0,0 +1,135 @@
+
+ *
+ * {% for user in users %}
+ * {{ user.username|e }}
+ * {% endfor %}
+ *
+ *
+ */
+class Twig_TokenParser_For extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $stream = $this->parser->getStream();
+ $targets = $this->parser->getExpressionParser()->parseAssignmentExpression();
+ $stream->expect(Twig_Token::OPERATOR_TYPE, 'in');
+ $seq = $this->parser->getExpressionParser()->parseExpression();
+
+ $ifexpr = null;
+ if ($stream->nextIf(Twig_Token::NAME_TYPE, 'if')) {
+ $ifexpr = $this->parser->getExpressionParser()->parseExpression();
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideForFork'));
+ if ($stream->next()->getValue() == 'else') {
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $else = $this->parser->subparse(array($this, 'decideForEnd'), true);
+ } else {
+ $else = null;
+ }
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ if (count($targets) > 1) {
+ $keyTarget = $targets->getNode(0);
+ $keyTarget = new Twig_Node_Expression_AssignName($keyTarget->getAttribute('name'), $keyTarget->getLine());
+ $valueTarget = $targets->getNode(1);
+ $valueTarget = new Twig_Node_Expression_AssignName($valueTarget->getAttribute('name'), $valueTarget->getLine());
+ } else {
+ $keyTarget = new Twig_Node_Expression_AssignName('_key', $lineno);
+ $valueTarget = $targets->getNode(0);
+ $valueTarget = new Twig_Node_Expression_AssignName($valueTarget->getAttribute('name'), $valueTarget->getLine());
+ }
+
+ if ($ifexpr) {
+ $this->checkLoopUsageCondition($stream, $ifexpr);
+ $this->checkLoopUsageBody($stream, $body);
+ }
+
+ return new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, $lineno, $this->getTag());
+ }
+
+ public function decideForFork(Twig_Token $token)
+ {
+ return $token->test(array('else', 'endfor'));
+ }
+
+ public function decideForEnd(Twig_Token $token)
+ {
+ return $token->test('endfor');
+ }
+
+ // the loop variable cannot be used in the condition
+ protected function checkLoopUsageCondition(Twig_TokenStream $stream, Twig_NodeInterface $node)
+ {
+ if ($node instanceof Twig_Node_Expression_GetAttr && $node->getNode('node') instanceof Twig_Node_Expression_Name && 'loop' == $node->getNode('node')->getAttribute('name')) {
+ throw new Twig_Error_Syntax('The "loop" variable cannot be used in a looping condition', $node->getLine(), $stream->getFilename());
+ }
+
+ foreach ($node as $n) {
+ if (!$n) {
+ continue;
+ }
+
+ $this->checkLoopUsageCondition($stream, $n);
+ }
+ }
+
+ // check usage of non-defined loop-items
+ // it does not catch all problems (for instance when a for is included into another or when the variable is used in an include)
+ protected function checkLoopUsageBody(Twig_TokenStream $stream, Twig_NodeInterface $node)
+ {
+ if ($node instanceof Twig_Node_Expression_GetAttr && $node->getNode('node') instanceof Twig_Node_Expression_Name && 'loop' == $node->getNode('node')->getAttribute('name')) {
+ $attribute = $node->getNode('attribute');
+ if ($attribute instanceof Twig_Node_Expression_Constant && in_array($attribute->getAttribute('value'), array('length', 'revindex0', 'revindex', 'last'))) {
+ throw new Twig_Error_Syntax(sprintf('The "loop.%s" variable is not defined when looping with a condition', $attribute->getAttribute('value')), $node->getLine(), $stream->getFilename());
+ }
+ }
+
+ // should check for parent.loop.XXX usage
+ if ($node instanceof Twig_Node_For) {
+ return;
+ }
+
+ foreach ($node as $n) {
+ if (!$n) {
+ continue;
+ }
+
+ $this->checkLoopUsageBody($stream, $n);
+ }
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'for';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/From.php b/vendor/twig/twig/lib/Twig/TokenParser/From.php
new file mode 100755
index 0000000..dd73f99
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/From.php
@@ -0,0 +1,70 @@
+
+ * {% from 'forms.html' import forms %}
+ *
+ */
+class Twig_TokenParser_From extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $macro = $this->parser->getExpressionParser()->parseExpression();
+ $stream = $this->parser->getStream();
+ $stream->expect('import');
+
+ $targets = array();
+ do {
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $alias = $name;
+ if ($stream->nextIf('as')) {
+ $alias = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ }
+
+ $targets[$name] = $alias;
+
+ if (!$stream->nextIf(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ } while (true);
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $node = new Twig_Node_Import($macro, new Twig_Node_Expression_AssignName($this->parser->getVarName(), $token->getLine()), $token->getLine(), $this->getTag());
+
+ foreach ($targets as $name => $alias) {
+ $this->parser->addImportedSymbol('function', $alias, 'get'.$name, $node->getNode('var'));
+ }
+
+ return $node;
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'from';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/If.php b/vendor/twig/twig/lib/Twig/TokenParser/If.php
new file mode 100755
index 0000000..3d7d1f5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/If.php
@@ -0,0 +1,94 @@
+
+ * {% if users %}
+ *
+ * {% for user in users %}
+ * {{ user.username|e }}
+ * {% endfor %}
+ *
+ * {% endif %}
+ *
+ */
+class Twig_TokenParser_If extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+ $stream = $this->parser->getStream();
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideIfFork'));
+ $tests = array($expr, $body);
+ $else = null;
+
+ $end = false;
+ while (!$end) {
+ switch ($stream->next()->getValue()) {
+ case 'else':
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $else = $this->parser->subparse(array($this, 'decideIfEnd'));
+ break;
+
+ case 'elseif':
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideIfFork'));
+ $tests[] = $expr;
+ $tests[] = $body;
+ break;
+
+ case 'endif':
+ $end = true;
+ break;
+
+ default:
+ throw new Twig_Error_Syntax(sprintf('Unexpected end of template. Twig was looking for the following tags "else", "elseif", or "endif" to close the "if" block started at line %d)', $lineno), $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_If(new Twig_Node($tests), $else, $lineno, $this->getTag());
+ }
+
+ public function decideIfFork(Twig_Token $token)
+ {
+ return $token->test(array('elseif', 'else', 'endif'));
+ }
+
+ public function decideIfEnd(Twig_Token $token)
+ {
+ return $token->test(array('endif'));
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'if';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Import.php b/vendor/twig/twig/lib/Twig/TokenParser/Import.php
new file mode 100755
index 0000000..e7050c7
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Import.php
@@ -0,0 +1,49 @@
+
+ * {% import 'forms.html' as forms %}
+ *
+ */
+class Twig_TokenParser_Import extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $macro = $this->parser->getExpressionParser()->parseExpression();
+ $this->parser->getStream()->expect('as');
+ $var = new Twig_Node_Expression_AssignName($this->parser->getStream()->expect(Twig_Token::NAME_TYPE)->getValue(), $token->getLine());
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $this->parser->addImportedSymbol('template', $var->getAttribute('name'));
+
+ return new Twig_Node_Import($macro, $var, $token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'import';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Include.php b/vendor/twig/twig/lib/Twig/TokenParser/Include.php
new file mode 100755
index 0000000..9c3099a
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Include.php
@@ -0,0 +1,75 @@
+
+ * {% include 'header.html' %}
+ * Body
+ * {% include 'footer.html' %}
+ *
+ */
+class Twig_TokenParser_Include extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+
+ list($variables, $only, $ignoreMissing) = $this->parseArguments();
+
+ return new Twig_Node_Include($expr, $variables, $only, $ignoreMissing, $token->getLine(), $this->getTag());
+ }
+
+ protected function parseArguments()
+ {
+ $stream = $this->parser->getStream();
+
+ $ignoreMissing = false;
+ if ($stream->nextIf(Twig_Token::NAME_TYPE, 'ignore')) {
+ $stream->expect(Twig_Token::NAME_TYPE, 'missing');
+
+ $ignoreMissing = true;
+ }
+
+ $variables = null;
+ if ($stream->nextIf(Twig_Token::NAME_TYPE, 'with')) {
+ $variables = $this->parser->getExpressionParser()->parseExpression();
+ }
+
+ $only = false;
+ if ($stream->nextIf(Twig_Token::NAME_TYPE, 'only')) {
+ $only = true;
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return array($variables, $only, $ignoreMissing);
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'include';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Macro.php b/vendor/twig/twig/lib/Twig/TokenParser/Macro.php
new file mode 100755
index 0000000..ad910b5
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Macro.php
@@ -0,0 +1,68 @@
+
+ * {% macro input(name, value, type, size) %}
+ *
+ * {% endmacro %}
+ *
+ */
+class Twig_TokenParser_Macro extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $stream = $this->parser->getStream();
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $arguments = $this->parser->getExpressionParser()->parseArguments(true, true);
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ $this->parser->pushLocalScope();
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ if ($token = $stream->nextIf(Twig_Token::NAME_TYPE)) {
+ $value = $token->getValue();
+
+ if ($value != $name) {
+ throw new Twig_Error_Syntax(sprintf('Expected endmacro for macro "%s" (but "%s" given)', $name, $value), $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ }
+ $this->parser->popLocalScope();
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $this->parser->setMacro($name, new Twig_Node_Macro($name, new Twig_Node_Body(array($body)), $arguments, $lineno, $this->getTag()));
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endmacro');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'macro';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Sandbox.php b/vendor/twig/twig/lib/Twig/TokenParser/Sandbox.php
new file mode 100755
index 0000000..9457325
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Sandbox.php
@@ -0,0 +1,68 @@
+
+ * {% sandbox %}
+ * {% include 'user.html' %}
+ * {% endsandbox %}
+ *
+ *
+ * @see http://www.twig-project.org/doc/api.html#sandbox-extension for details
+ */
+class Twig_TokenParser_Sandbox extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ // in a sandbox tag, only include tags are allowed
+ if (!$body instanceof Twig_Node_Include) {
+ foreach ($body as $node) {
+ if ($node instanceof Twig_Node_Text && ctype_space($node->getAttribute('data'))) {
+ continue;
+ }
+
+ if (!$node instanceof Twig_Node_Include) {
+ throw new Twig_Error_Syntax('Only "include" tags are allowed within a "sandbox" section', $node->getLine(), $this->parser->getFilename());
+ }
+ }
+ }
+
+ return new Twig_Node_Sandbox($body, $token->getLine(), $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endsandbox');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'sandbox';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Set.php b/vendor/twig/twig/lib/Twig/TokenParser/Set.php
new file mode 100755
index 0000000..0b41909
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Set.php
@@ -0,0 +1,83 @@
+
+ * {% set foo = 'foo' %}
+ *
+ * {% set foo = [1, 2] %}
+ *
+ * {% set foo = {'foo': 'bar'} %}
+ *
+ * {% set foo = 'foo' ~ 'bar' %}
+ *
+ * {% set foo, bar = 'foo', 'bar' %}
+ *
+ * {% set foo %}Some content{% endset %}
+ *
+ */
+class Twig_TokenParser_Set extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+ $stream = $this->parser->getStream();
+ $names = $this->parser->getExpressionParser()->parseAssignmentExpression();
+
+ $capture = false;
+ if ($stream->nextIf(Twig_Token::OPERATOR_TYPE, '=')) {
+ $values = $this->parser->getExpressionParser()->parseMultitargetExpression();
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ if (count($names) !== count($values)) {
+ throw new Twig_Error_Syntax('When using set, you must have the same number of variables and assignments.', $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+ } else {
+ $capture = true;
+
+ if (count($names) > 1) {
+ throw new Twig_Error_Syntax('When using set with a block, you cannot have a multi-target.', $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $values = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ }
+
+ return new Twig_Node_Set($capture, $names, $values, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endset');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'set';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Spaceless.php b/vendor/twig/twig/lib/Twig/TokenParser/Spaceless.php
new file mode 100755
index 0000000..1e3fa8f
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Spaceless.php
@@ -0,0 +1,59 @@
+
+ * {% spaceless %}
+ *
+ * foo
+ *
+ * {% endspaceless %}
+ *
+ * {# output will be foo
#}
+ *
+ */
+class Twig_TokenParser_Spaceless extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $lineno = $token->getLine();
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideSpacelessEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Spaceless($body, $lineno, $this->getTag());
+ }
+
+ public function decideSpacelessEnd(Twig_Token $token)
+ {
+ return $token->test('endspaceless');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'spaceless';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParser/Use.php b/vendor/twig/twig/lib/Twig/TokenParser/Use.php
new file mode 100755
index 0000000..3ea68b1
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParser/Use.php
@@ -0,0 +1,76 @@
+
+ * {% extends "base.html" %}
+ *
+ * {% use "blocks.html" %}
+ *
+ * {% block title %}{% endblock %}
+ * {% block content %}{% endblock %}
+ *
+ *
+ * @see http://www.twig-project.org/doc/templates.html#horizontal-reuse for details.
+ */
+class Twig_TokenParser_Use extends Twig_TokenParser
+{
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ public function parse(Twig_Token $token)
+ {
+ $template = $this->parser->getExpressionParser()->parseExpression();
+ $stream = $this->parser->getStream();
+
+ if (!$template instanceof Twig_Node_Expression_Constant) {
+ throw new Twig_Error_Syntax('The template references in a "use" statement must be a string.', $stream->getCurrent()->getLine(), $stream->getFilename());
+ }
+
+ $targets = array();
+ if ($stream->nextIf('with')) {
+ do {
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $alias = $name;
+ if ($stream->nextIf('as')) {
+ $alias = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ }
+
+ $targets[$name] = new Twig_Node_Expression_Constant($alias, -1);
+
+ if (!$stream->nextIf(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ } while (true);
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $this->parser->addTrait(new Twig_Node(array('template' => $template, 'targets' => new Twig_Node($targets))));
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'use';
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParserBroker.php b/vendor/twig/twig/lib/Twig/TokenParserBroker.php
new file mode 100755
index 0000000..ec3fba6
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParserBroker.php
@@ -0,0 +1,136 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+class Twig_TokenParserBroker implements Twig_TokenParserBrokerInterface
+{
+ protected $parser;
+ protected $parsers = array();
+ protected $brokers = array();
+
+ /**
+ * Constructor.
+ *
+ * @param array|Traversable $parsers A Traversable of Twig_TokenParserInterface instances
+ * @param array|Traversable $brokers A Traversable of Twig_TokenParserBrokerInterface instances
+ */
+ public function __construct($parsers = array(), $brokers = array())
+ {
+ foreach ($parsers as $parser) {
+ if (!$parser instanceof Twig_TokenParserInterface) {
+ throw new LogicException('$parsers must a an array of Twig_TokenParserInterface');
+ }
+ $this->parsers[$parser->getTag()] = $parser;
+ }
+ foreach ($brokers as $broker) {
+ if (!$broker instanceof Twig_TokenParserBrokerInterface) {
+ throw new LogicException('$brokers must a an array of Twig_TokenParserBrokerInterface');
+ }
+ $this->brokers[] = $broker;
+ }
+ }
+
+ /**
+ * Adds a TokenParser.
+ *
+ * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
+ */
+ public function addTokenParser(Twig_TokenParserInterface $parser)
+ {
+ $this->parsers[$parser->getTag()] = $parser;
+ }
+
+ /**
+ * Removes a TokenParser.
+ *
+ * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
+ */
+ public function removeTokenParser(Twig_TokenParserInterface $parser)
+ {
+ $name = $parser->getTag();
+ if (isset($this->parsers[$name]) && $parser === $this->parsers[$name]) {
+ unset($this->parsers[$name]);
+ }
+ }
+
+ /**
+ * Adds a TokenParserBroker.
+ *
+ * @param Twig_TokenParserBroker $broker A Twig_TokenParserBroker instance
+ */
+ public function addTokenParserBroker(Twig_TokenParserBroker $broker)
+ {
+ $this->brokers[] = $broker;
+ }
+
+ /**
+ * Removes a TokenParserBroker.
+ *
+ * @param Twig_TokenParserBroker $broker A Twig_TokenParserBroker instance
+ */
+ public function removeTokenParserBroker(Twig_TokenParserBroker $broker)
+ {
+ if (false !== $pos = array_search($broker, $this->brokers)) {
+ unset($this->brokers[$pos]);
+ }
+ }
+
+ /**
+ * Gets a suitable TokenParser for a tag.
+ *
+ * First looks in parsers, then in brokers.
+ *
+ * @param string $tag A tag name
+ *
+ * @return null|Twig_TokenParserInterface A Twig_TokenParserInterface or null if no suitable TokenParser was found
+ */
+ public function getTokenParser($tag)
+ {
+ if (isset($this->parsers[$tag])) {
+ return $this->parsers[$tag];
+ }
+ $broker = end($this->brokers);
+ while (false !== $broker) {
+ $parser = $broker->getTokenParser($tag);
+ if (null !== $parser) {
+ return $parser;
+ }
+ $broker = prev($this->brokers);
+ }
+ }
+
+ public function getParsers()
+ {
+ return $this->parsers;
+ }
+
+ public function getParser()
+ {
+ return $this->parser;
+ }
+
+ public function setParser(Twig_ParserInterface $parser)
+ {
+ $this->parser = $parser;
+ foreach ($this->parsers as $tokenParser) {
+ $tokenParser->setParser($parser);
+ }
+ foreach ($this->brokers as $broker) {
+ $broker->setParser($parser);
+ }
+ }
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParserBrokerInterface.php b/vendor/twig/twig/lib/Twig/TokenParserBrokerInterface.php
new file mode 100755
index 0000000..3f006e3
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParserBrokerInterface.php
@@ -0,0 +1,45 @@
+
+ * @deprecated since 1.12 (to be removed in 2.0)
+ */
+interface Twig_TokenParserBrokerInterface
+{
+ /**
+ * Gets a TokenParser suitable for a tag.
+ *
+ * @param string $tag A tag name
+ *
+ * @return null|Twig_TokenParserInterface A Twig_TokenParserInterface or null if no suitable TokenParser was found
+ */
+ public function getTokenParser($tag);
+
+ /**
+ * Calls Twig_TokenParserInterface::setParser on all parsers the implementation knows of.
+ *
+ * @param Twig_ParserInterface $parser A Twig_ParserInterface interface
+ */
+ public function setParser(Twig_ParserInterface $parser);
+
+ /**
+ * Gets the Twig_ParserInterface.
+ *
+ * @return null|Twig_ParserInterface A Twig_ParserInterface instance or null
+ */
+ public function getParser();
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenParserInterface.php b/vendor/twig/twig/lib/Twig/TokenParserInterface.php
new file mode 100755
index 0000000..17e394b
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenParserInterface.php
@@ -0,0 +1,43 @@
+
+ */
+interface Twig_TokenParserInterface
+{
+ /**
+ * Sets the parser associated with this token parser
+ *
+ * @param Twig_Parser $parser A Twig_Parser instance
+ */
+ public function setParser(Twig_Parser $parser);
+
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ *
+ * @throws Twig_Error_Syntax
+ */
+ public function parse(Twig_Token $token);
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag();
+}
diff --git a/vendor/twig/twig/lib/Twig/TokenStream.php b/vendor/twig/twig/lib/Twig/TokenStream.php
new file mode 100755
index 0000000..7e95a4f
--- /dev/null
+++ b/vendor/twig/twig/lib/Twig/TokenStream.php
@@ -0,0 +1,156 @@
+
+ */
+class Twig_TokenStream
+{
+ protected $tokens;
+ protected $current;
+ protected $filename;
+
+ /**
+ * Constructor.
+ *
+ * @param array $tokens An array of tokens
+ * @param string $filename The name of the filename which tokens are associated with
+ */
+ public function __construct(array $tokens, $filename = null)
+ {
+ $this->tokens = $tokens;
+ $this->current = 0;
+ $this->filename = $filename;
+ }
+
+ /**
+ * Returns a string representation of the token stream.
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return implode("\n", $this->tokens);
+ }
+
+ public function injectTokens(array $tokens)
+ {
+ $this->tokens = array_merge(array_slice($this->tokens, 0, $this->current), $tokens, array_slice($this->tokens, $this->current));
+ }
+
+ /**
+ * Sets the pointer to the next token and returns the old one.
+ *
+ * @return Twig_Token
+ */
+ public function next()
+ {
+ if (!isset($this->tokens[++$this->current])) {
+ throw new Twig_Error_Syntax('Unexpected end of template', $this->tokens[$this->current - 1]->getLine(), $this->filename);
+ }
+
+ return $this->tokens[$this->current - 1];
+ }
+
+ /**
+ * Tests a token, sets the pointer to the next one and returns it or throws a syntax error.
+ *
+ * @return Twig_Token|null The next token if the condition is true, null otherwise
+ */
+ public function nextIf($primary, $secondary = null)
+ {
+ if ($this->tokens[$this->current]->test($primary, $secondary)) {
+ return $this->next();
+ }
+ }
+
+ /**
+ * Tests a token and returns it or throws a syntax error.
+ *
+ * @return Twig_Token
+ */
+ public function expect($type, $value = null, $message = null)
+ {
+ $token = $this->tokens[$this->current];
+ if (!$token->test($type, $value)) {
+ $line = $token->getLine();
+ throw new Twig_Error_Syntax(sprintf('%sUnexpected token "%s" of value "%s" ("%s" expected%s)',
+ $message ? $message.'. ' : '',
+ Twig_Token::typeToEnglish($token->getType()), $token->getValue(),
+ Twig_Token::typeToEnglish($type), $value ? sprintf(' with value "%s"', $value) : ''),
+ $line,
+ $this->filename
+ );
+ }
+ $this->next();
+
+ return $token;
+ }
+
+ /**
+ * Looks at the next token.
+ *
+ * @param int $number
+ *
+ * @return Twig_Token
+ */
+ public function look($number = 1)
+ {
+ if (!isset($this->tokens[$this->current + $number])) {
+ throw new Twig_Error_Syntax('Unexpected end of template', $this->tokens[$this->current + $number - 1]->getLine(), $this->filename);
+ }
+
+ return $this->tokens[$this->current + $number];
+ }
+
+ /**
+ * Tests the current token
+ *
+ * @return bool
+ */
+ public function test($primary, $secondary = null)
+ {
+ return $this->tokens[$this->current]->test($primary, $secondary);
+ }
+
+ /**
+ * Checks if end of stream was reached
+ *
+ * @return bool
+ */
+ public function isEOF()
+ {
+ return $this->tokens[$this->current]->getType() === Twig_Token::EOF_TYPE;
+ }
+
+ /**
+ * Gets the current token
+ *
+ * @return Twig_Token
+ */
+ public function getCurrent()
+ {
+ return $this->tokens[$this->current];
+ }
+
+ /**
+ * Gets the filename associated with this stream
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return $this->filename;
+ }
+}
diff --git a/vendor/twig/twig/phpunit.xml.dist b/vendor/twig/twig/phpunit.xml.dist
new file mode 100755
index 0000000..6c5046f
--- /dev/null
+++ b/vendor/twig/twig/phpunit.xml.dist
@@ -0,0 +1,25 @@
+
+
+
+
+
+ ./test/Twig/
+
+
+
+
+
+ ./lib/Twig/
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/AutoloaderTest.php b/vendor/twig/twig/test/Twig/Tests/AutoloaderTest.php
new file mode 100755
index 0000000..c8b7999
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/AutoloaderTest.php
@@ -0,0 +1,21 @@
+assertFalse(class_exists('FooBarFoo'), '->autoload() does not try to load classes that does not begin with Twig');
+
+ $autoloader = new Twig_Autoloader();
+ $this->assertNull($autoloader->autoload('Foo'), '->autoload() returns false if it is not able to load a class');
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/CompilerTest.php b/vendor/twig/twig/test/Twig/Tests/CompilerTest.php
new file mode 100755
index 0000000..e24b0b5
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/CompilerTest.php
@@ -0,0 +1,33 @@
+markTestSkipped('Your platform does not support locales.');
+ }
+
+ $required_locales = array('fr_FR.UTF-8', 'fr_FR.UTF8', 'fr_FR.utf-8', 'fr_FR.utf8', 'French_France.1252');
+ if (false === setlocale(LC_NUMERIC, $required_locales)) {
+ $this->markTestSkipped('Could not set any of required locales: '.implode(", ", $required_locales));
+ }
+
+ $this->assertEquals('1.2', $compiler->repr(1.2)->getSource());
+ $this->assertContains('fr', strtolower(setlocale(LC_NUMERIC, 0)));
+
+ setlocale(LC_NUMERIC, $locale);
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/EnvironmentTest.php b/vendor/twig/twig/test/Twig/Tests/EnvironmentTest.php
new file mode 100755
index 0000000..d0ada96
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/EnvironmentTest.php
@@ -0,0 +1,288 @@
+render('test');
+ }
+
+ public function testAutoescapeOption()
+ {
+ $loader = new Twig_Loader_Array(array(
+ 'html' => '{{ foo }} {{ foo }}',
+ 'js' => '{{ bar }} {{ bar }}',
+ ));
+
+ $twig = new Twig_Environment($loader, array(
+ 'debug' => true,
+ 'cache' => false,
+ 'autoescape' => array($this, 'escapingStrategyCallback'),
+ ));
+
+ $this->assertEquals('foo<br/ > foo<br/ >', $twig->render('html', array('foo' => 'foo ')));
+ $this->assertEquals('foo\x3Cbr\x2F\x20\x3E foo\x3Cbr\x2F\x20\x3E', $twig->render('js', array('bar' => 'foo ')));
+ }
+
+ public function escapingStrategyCallback($filename)
+ {
+ return $filename;
+ }
+
+ public function testGlobals()
+ {
+ // globals can be added after calling getGlobals
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->addGlobal('foo', 'bar');
+ $globals = $twig->getGlobals();
+ $this->assertEquals('bar', $globals['foo']);
+
+ // globals can be modified after runtime init
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->initRuntime();
+ $twig->addGlobal('foo', 'bar');
+ $globals = $twig->getGlobals();
+ $this->assertEquals('bar', $globals['foo']);
+
+ // globals can be modified after extensions init
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->getFunctions();
+ $twig->addGlobal('foo', 'bar');
+ $globals = $twig->getGlobals();
+ $this->assertEquals('bar', $globals['foo']);
+
+ // globals can be modified after extensions and runtime init
+ $twig = new Twig_Environment($loader = new Twig_Loader_Array(array('index' => '{{foo}}')));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->getFunctions();
+ $twig->initRuntime();
+ $twig->addGlobal('foo', 'bar');
+ $globals = $twig->getGlobals();
+ $this->assertEquals('bar', $globals['foo']);
+
+ $twig = new Twig_Environment($loader);
+ $twig->getGlobals();
+ $twig->addGlobal('foo', 'bar');
+ $template = $twig->loadTemplate('index');
+ $this->assertEquals('bar', $template->render(array()));
+
+ /* to be uncomment in Twig 2.0
+ // globals cannot be added after runtime init
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->initRuntime();
+ try {
+ $twig->addGlobal('bar', 'bar');
+ $this->fail();
+ } catch (LogicException $e) {
+ $this->assertFalse(array_key_exists('bar', $twig->getGlobals()));
+ }
+
+ // globals cannot be added after extensions init
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->getFunctions();
+ try {
+ $twig->addGlobal('bar', 'bar');
+ $this->fail();
+ } catch (LogicException $e) {
+ $this->assertFalse(array_key_exists('bar', $twig->getGlobals()));
+ }
+
+ // globals cannot be added after extensions and runtime init
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addGlobal('foo', 'foo');
+ $twig->getGlobals();
+ $twig->getFunctions();
+ $twig->initRuntime();
+ try {
+ $twig->addGlobal('bar', 'bar');
+ $this->fail();
+ } catch (LogicException $e) {
+ $this->assertFalse(array_key_exists('bar', $twig->getGlobals()));
+ }
+
+ // test adding globals after initRuntime without call to getGlobals
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->initRuntime();
+ try {
+ $twig->addGlobal('bar', 'bar');
+ $this->fail();
+ } catch (LogicException $e) {
+ $this->assertFalse(array_key_exists('bar', $twig->getGlobals()));
+ }
+ */
+ }
+
+ public function testExtensionsAreNotInitializedWhenRenderingACompiledTemplate()
+ {
+ $options = array('cache' => sys_get_temp_dir().'/twig', 'auto_reload' => false, 'debug' => false);
+
+ // force compilation
+ $twig = new Twig_Environment($loader = new Twig_Loader_Array(array('index' => '{{ foo }}')), $options);
+ $cache = $twig->getCacheFilename('index');
+ if (!is_dir(dirname($cache))) {
+ mkdir(dirname($cache), 0777, true);
+ }
+ file_put_contents($cache, $twig->compileSource('{{ foo }}', 'index'));
+
+ // check that extensions won't be initialized when rendering a template that is already in the cache
+ $twig = $this
+ ->getMockBuilder('Twig_Environment')
+ ->setConstructorArgs(array($loader, $options))
+ ->setMethods(array('initExtensions'))
+ ->getMock()
+ ;
+
+ $twig->expects($this->never())->method('initExtensions');
+
+ // render template
+ $output = $twig->render('index', array('foo' => 'bar'));
+ $this->assertEquals('bar', $output);
+
+ unlink($cache);
+ }
+
+ public function testAddExtension()
+ {
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addExtension(new Twig_Tests_EnvironmentTest_Extension());
+
+ $this->assertArrayHasKey('test', $twig->getTags());
+ $this->assertArrayHasKey('foo_filter', $twig->getFilters());
+ $this->assertArrayHasKey('foo_function', $twig->getFunctions());
+ $this->assertArrayHasKey('foo_test', $twig->getTests());
+ $this->assertArrayHasKey('foo_unary', $twig->getUnaryOperators());
+ $this->assertArrayHasKey('foo_binary', $twig->getBinaryOperators());
+ $this->assertArrayHasKey('foo_global', $twig->getGlobals());
+ $visitors = $twig->getNodeVisitors();
+ $this->assertEquals('Twig_Tests_EnvironmentTest_NodeVisitor', get_class($visitors[2]));
+ }
+
+ public function testRemoveExtension()
+ {
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+ $twig->addExtension(new Twig_Tests_EnvironmentTest_Extension());
+ $twig->removeExtension('environment_test');
+
+ $this->assertFalse(array_key_exists('test', $twig->getTags()));
+ $this->assertFalse(array_key_exists('foo_filter', $twig->getFilters()));
+ $this->assertFalse(array_key_exists('foo_function', $twig->getFunctions()));
+ $this->assertFalse(array_key_exists('foo_test', $twig->getTests()));
+ $this->assertFalse(array_key_exists('foo_unary', $twig->getUnaryOperators()));
+ $this->assertFalse(array_key_exists('foo_binary', $twig->getBinaryOperators()));
+ $this->assertFalse(array_key_exists('foo_global', $twig->getGlobals()));
+ $this->assertCount(2, $twig->getNodeVisitors());
+ }
+}
+
+class Twig_Tests_EnvironmentTest_Extension extends Twig_Extension
+{
+ public function getTokenParsers()
+ {
+ return array(
+ new Twig_Tests_EnvironmentTest_TokenParser(),
+ );
+ }
+
+ public function getNodeVisitors()
+ {
+ return array(
+ new Twig_Tests_EnvironmentTest_NodeVisitor(),
+ );
+ }
+
+ public function getFilters()
+ {
+ return array(
+ new Twig_SimpleFilter('foo_filter', 'foo_filter'),
+ );
+ }
+
+ public function getTests()
+ {
+ return array(
+ new Twig_SimpleTest('foo_test', 'foo_test'),
+ );
+ }
+
+ public function getFunctions()
+ {
+ return array(
+ new Twig_SimpleFunction('foo_function', 'foo_function'),
+ );
+ }
+
+ public function getOperators()
+ {
+ return array(
+ array('foo_unary' => array()),
+ array('foo_binary' => array()),
+ );
+ }
+
+ public function getGlobals()
+ {
+ return array(
+ 'foo_global' => 'foo_global',
+ );
+ }
+
+ public function getName()
+ {
+ return 'environment_test';
+ }
+}
+
+class Twig_Tests_EnvironmentTest_TokenParser extends Twig_TokenParser
+{
+ public function parse(Twig_Token $token)
+ {
+ }
+
+ public function getTag()
+ {
+ return 'test';
+ }
+}
+
+class Twig_Tests_EnvironmentTest_NodeVisitor implements Twig_NodeVisitorInterface
+{
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/ErrorTest.php b/vendor/twig/twig/test/Twig/Tests/ErrorTest.php
new file mode 100755
index 0000000..6a78d2b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/ErrorTest.php
@@ -0,0 +1,144 @@
+setTemplateFile(new SplFileInfo(__FILE__));
+
+ $this->assertContains('test'.DIRECTORY_SEPARATOR.'Twig'.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR.'ErrorTest.php', $error->getMessage());
+ }
+
+ public function testErrorWithArrayFilename()
+ {
+ $error = new Twig_Error('foo');
+ $error->setTemplateFile(array('foo' => 'bar'));
+
+ $this->assertEquals('foo in {"foo":"bar"}', $error->getMessage());
+ }
+
+ public function testTwigExceptionAddsFileAndLineWhenMissingWithInheritanceOnDisk()
+ {
+ $loader = new Twig_Loader_Filesystem(dirname(__FILE__).'/Fixtures/errors');
+ $twig = new Twig_Environment($loader, array('strict_variables' => true, 'debug' => true, 'cache' => false));
+
+ $template = $twig->loadTemplate('index.html');
+ try {
+ $template->render(array());
+
+ $this->fail();
+ } catch (Twig_Error_Runtime $e) {
+ $this->assertEquals('Variable "foo" does not exist in "index.html" at line 3', $e->getMessage());
+ $this->assertEquals(3, $e->getTemplateLine());
+ $this->assertEquals('index.html', $e->getTemplateFile());
+ }
+
+ try {
+ $template->render(array('foo' => new Twig_Tests_ErrorTest_Foo()));
+
+ $this->fail();
+ } catch (Twig_Error_Runtime $e) {
+ $this->assertEquals('An exception has been thrown during the rendering of a template ("Runtime error...") in "index.html" at line 3.', $e->getMessage());
+ $this->assertEquals(3, $e->getTemplateLine());
+ $this->assertEquals('index.html', $e->getTemplateFile());
+ }
+ }
+
+ /**
+ * @dataProvider getErroredTemplates
+ */
+ public function testTwigExceptionAddsFileAndLine($templates, $name, $line)
+ {
+ $loader = new Twig_Loader_Array($templates);
+ $twig = new Twig_Environment($loader, array('strict_variables' => true, 'debug' => true, 'cache' => false));
+
+ $template = $twig->loadTemplate('index');
+
+ try {
+ $template->render(array());
+
+ $this->fail();
+ } catch (Twig_Error_Runtime $e) {
+ $this->assertEquals(sprintf('Variable "foo" does not exist in "%s" at line %d', $name, $line), $e->getMessage());
+ $this->assertEquals($line, $e->getTemplateLine());
+ $this->assertEquals($name, $e->getTemplateFile());
+ }
+
+ try {
+ $template->render(array('foo' => new Twig_Tests_ErrorTest_Foo()));
+
+ $this->fail();
+ } catch (Twig_Error_Runtime $e) {
+ $this->assertEquals(sprintf('An exception has been thrown during the rendering of a template ("Runtime error...") in "%s" at line %d.', $name, $line), $e->getMessage());
+ $this->assertEquals($line, $e->getTemplateLine());
+ $this->assertEquals($name, $e->getTemplateFile());
+ }
+ }
+
+ public function getErroredTemplates()
+ {
+ return array(
+ // error occurs in a template
+ array(
+ array(
+ 'index' => "\n\n{{ foo.bar }}\n\n\n{{ 'foo' }}",
+ ),
+ 'index', 3,
+ ),
+
+ // error occurs in an included template
+ array(
+ array(
+ 'index' => "{% include 'partial' %}",
+ 'partial' => '{{ foo.bar }}',
+ ),
+ 'partial', 1,
+ ),
+
+ // error occurs in a parent block when called via parent()
+ array(
+ array(
+ 'index' => "{% extends 'base' %}
+ {% block content %}
+ {{ parent() }}
+ {% endblock %}",
+ 'base' => '{% block content %}{{ foo.bar }}{% endblock %}',
+ ),
+ 'base', 1,
+ ),
+
+ // error occurs in a block from the child
+ array(
+ array(
+ 'index' => "{% extends 'base' %}
+ {% block content %}
+ {{ foo.bar }}
+ {% endblock %}
+ {% block foo %}
+ {{ foo.bar }}
+ {% endblock %}",
+ 'base' => '{% block content %}{% endblock %}',
+ ),
+ 'index', 3,
+ ),
+ );
+ }
+}
+
+class Twig_Tests_ErrorTest_Foo
+{
+ public function bar()
+ {
+ throw new Exception('Runtime error...');
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/ExpressionParserTest.php b/vendor/twig/twig/test/Twig/Tests/ExpressionParserTest.php
new file mode 100755
index 0000000..ff263cf
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/ExpressionParserTest.php
@@ -0,0 +1,332 @@
+getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize($template, 'index'));
+ }
+
+ public function getFailingTestsForAssignment()
+ {
+ return array(
+ array('{% set false = "foo" %}'),
+ array('{% set true = "foo" %}'),
+ array('{% set none = "foo" %}'),
+ array('{% set 3 = "foo" %}'),
+ array('{% set 1 + 2 = "foo" %}'),
+ array('{% set "bar" = "foo" %}'),
+ array('{% set %}{% endset %}'),
+ );
+ }
+
+ /**
+ * @dataProvider getTestsForArray
+ */
+ public function testArrayExpression($template, $expected)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $stream = $env->tokenize($template, 'index');
+ $parser = new Twig_Parser($env);
+
+ $this->assertEquals($expected, $parser->parse($stream)->getNode('body')->getNode(0)->getNode('expr'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @dataProvider getFailingTestsForArray
+ */
+ public function testArraySyntaxError($template)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize($template, 'index'));
+ }
+
+ public function getFailingTestsForArray()
+ {
+ return array(
+ array('{{ [1, "a": "b"] }}'),
+ array('{{ {"a": "b", 2} }}'),
+ );
+ }
+
+ public function getTestsForArray()
+ {
+ return array(
+ // simple array
+ array('{{ [1, 2] }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant(0, 1),
+ new Twig_Node_Expression_Constant(1, 1),
+
+ new Twig_Node_Expression_Constant(1, 1),
+ new Twig_Node_Expression_Constant(2, 1),
+ ), 1),
+ ),
+
+ // array with trailing ,
+ array('{{ [1, 2, ] }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant(0, 1),
+ new Twig_Node_Expression_Constant(1, 1),
+
+ new Twig_Node_Expression_Constant(1, 1),
+ new Twig_Node_Expression_Constant(2, 1),
+ ), 1),
+ ),
+
+ // simple hash
+ array('{{ {"a": "b", "b": "c"} }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant('a', 1),
+ new Twig_Node_Expression_Constant('b', 1),
+
+ new Twig_Node_Expression_Constant('b', 1),
+ new Twig_Node_Expression_Constant('c', 1),
+ ), 1),
+ ),
+
+ // hash with trailing ,
+ array('{{ {"a": "b", "b": "c", } }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant('a', 1),
+ new Twig_Node_Expression_Constant('b', 1),
+
+ new Twig_Node_Expression_Constant('b', 1),
+ new Twig_Node_Expression_Constant('c', 1),
+ ), 1),
+ ),
+
+ // hash in an array
+ array('{{ [1, {"a": "b", "b": "c"}] }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant(0, 1),
+ new Twig_Node_Expression_Constant(1, 1),
+
+ new Twig_Node_Expression_Constant(1, 1),
+ new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant('a', 1),
+ new Twig_Node_Expression_Constant('b', 1),
+
+ new Twig_Node_Expression_Constant('b', 1),
+ new Twig_Node_Expression_Constant('c', 1),
+ ), 1),
+ ), 1),
+ ),
+
+ // array in a hash
+ array('{{ {"a": [1, 2], "b": "c"} }}', new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant('a', 1),
+ new Twig_Node_Expression_Array(array(
+ new Twig_Node_Expression_Constant(0, 1),
+ new Twig_Node_Expression_Constant(1, 1),
+
+ new Twig_Node_Expression_Constant(1, 1),
+ new Twig_Node_Expression_Constant(2, 1),
+ ), 1),
+ new Twig_Node_Expression_Constant('b', 1),
+ new Twig_Node_Expression_Constant('c', 1),
+ ), 1),
+ ),
+ );
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ */
+ public function testStringExpressionDoesNotConcatenateTwoConsecutiveStrings()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false, 'optimizations' => 0));
+ $stream = $env->tokenize('{{ "a" "b" }}', 'index');
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($stream);
+ }
+
+ /**
+ * @dataProvider getTestsForString
+ */
+ public function testStringExpression($template, $expected)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false, 'optimizations' => 0));
+ $stream = $env->tokenize($template, 'index');
+ $parser = new Twig_Parser($env);
+
+ $this->assertEquals($expected, $parser->parse($stream)->getNode('body')->getNode(0)->getNode('expr'));
+ }
+
+ public function getTestsForString()
+ {
+ return array(
+ array(
+ '{{ "foo" }}', new Twig_Node_Expression_Constant('foo', 1),
+ ),
+ array(
+ '{{ "foo #{bar}" }}', new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Constant('foo ', 1),
+ new Twig_Node_Expression_Name('bar', 1),
+ 1
+ ),
+ ),
+ array(
+ '{{ "foo #{bar} baz" }}', new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Constant('foo ', 1),
+ new Twig_Node_Expression_Name('bar', 1),
+ 1
+ ),
+ new Twig_Node_Expression_Constant(' baz', 1),
+ 1
+ ),
+ ),
+
+ array(
+ '{{ "foo #{"foo #{bar} baz"} baz" }}', new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Constant('foo ', 1),
+ new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Binary_Concat(
+ new Twig_Node_Expression_Constant('foo ', 1),
+ new Twig_Node_Expression_Name('bar', 1),
+ 1
+ ),
+ new Twig_Node_Expression_Constant(' baz', 1),
+ 1
+ ),
+ 1
+ ),
+ new Twig_Node_Expression_Constant(' baz', 1),
+ 1
+ ),
+ ),
+ );
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ */
+ public function testAttributeCallDoesNotSupportNamedArguments()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{{ foo.bar(name="Foo") }}', 'index'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ */
+ public function testMacroCallDoesNotSupportNamedArguments()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{% from _self import foo %}{% macro foo() %}{% endmacro %}{{ foo(name="Foo") }}', 'index'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage An argument must be a name. Unexpected token "string" of value "a" ("name" expected) in "index" at line 1
+ */
+ public function testMacroDefinitionDoesNotSupportNonNameVariableName()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{% macro foo("a") %}{% endmacro %}', 'index'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage A default value for an argument must be a constant (a boolean, a string, a number, or an array) in "index" at line 1
+ * @dataProvider getMacroDefinitionDoesNotSupportNonConstantDefaultValues
+ */
+ public function testMacroDefinitionDoesNotSupportNonConstantDefaultValues($template)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize($template, 'index'));
+ }
+
+ public function getMacroDefinitionDoesNotSupportNonConstantDefaultValues()
+ {
+ return array(
+ array('{% macro foo(name = "a #{foo} a") %}{% endmacro %}'),
+ array('{% macro foo(name = [["b", "a #{foo} a"]]) %}{% endmacro %}'),
+ );
+ }
+
+ /**
+ * @dataProvider getMacroDefinitionSupportsConstantDefaultValues
+ */
+ public function testMacroDefinitionSupportsConstantDefaultValues($template)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize($template, 'index'));
+ }
+
+ public function getMacroDefinitionSupportsConstantDefaultValues()
+ {
+ return array(
+ array('{% macro foo(name = "aa") %}{% endmacro %}'),
+ array('{% macro foo(name = 12) %}{% endmacro %}'),
+ array('{% macro foo(name = true) %}{% endmacro %}'),
+ array('{% macro foo(name = ["a"]) %}{% endmacro %}'),
+ array('{% macro foo(name = [["a"]]) %}{% endmacro %}'),
+ array('{% macro foo(name = {a: "a"}) %}{% endmacro %}'),
+ array('{% macro foo(name = {a: {b: "a"}}) %}{% endmacro %}'),
+ );
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The function "cycl" does not exist. Did you mean "cycle" in "index" at line 1
+ */
+ public function testUnknownFunction()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{{ cycl() }}', 'index'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The filter "lowe" does not exist. Did you mean "lower" in "index" at line 1
+ */
+ public function testUnknownFilter()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{{ 1|lowe }}', 'index'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The test "nul" does not exist. Did you mean "null" in "index" at line 1
+ */
+ public function testUnknownTest()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $parser = new Twig_Parser($env);
+
+ $parser->parse($env->tokenize('{{ 1 is nul }}', 'index'));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Extension/CoreTest.php b/vendor/twig/twig/test/Twig/Tests/Extension/CoreTest.php
new file mode 100755
index 0000000..b3b1cb0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Extension/CoreTest.php
@@ -0,0 +1,156 @@
+assertTrue(in_array(twig_random($env, $value), $expectedInArray, true)); // assertContains() would not consider the type
+ }
+ }
+
+ public function getRandomFunctionTestData()
+ {
+ return array(
+ array( // array
+ array('apple', 'orange', 'citrus'),
+ array('apple', 'orange', 'citrus'),
+ ),
+ array( // Traversable
+ new ArrayObject(array('apple', 'orange', 'citrus')),
+ array('apple', 'orange', 'citrus'),
+ ),
+ array( // unicode string
+ 'Ä€é',
+ array('Ä', '€', 'é'),
+ ),
+ array( // numeric but string
+ '123',
+ array('1', '2', '3'),
+ ),
+ array( // integer
+ 5,
+ range(0, 5, 1),
+ ),
+ array( // float
+ 5.9,
+ range(0, 5, 1),
+ ),
+ array( // negative
+ -2,
+ array(0, -1, -2),
+ ),
+ );
+ }
+
+ public function testRandomFunctionWithoutParameter()
+ {
+ $max = mt_getrandmax();
+
+ for ($i = 0; $i < 100; $i++) {
+ $val = twig_random(new Twig_Environment());
+ $this->assertTrue(is_int($val) && $val >= 0 && $val <= $max);
+ }
+ }
+
+ public function testRandomFunctionReturnsAsIs()
+ {
+ $this->assertSame('', twig_random(new Twig_Environment(), ''));
+ $this->assertSame('', twig_random(new Twig_Environment(null, array('charset' => null)), ''));
+
+ $instance = new stdClass();
+ $this->assertSame($instance, twig_random(new Twig_Environment(), $instance));
+ }
+
+ /**
+ * @expectedException Twig_Error_Runtime
+ */
+ public function testRandomFunctionOfEmptyArrayThrowsException()
+ {
+ twig_random(new Twig_Environment(), array());
+ }
+
+ public function testRandomFunctionOnNonUTF8String()
+ {
+ if (!function_exists('iconv') && !function_exists('mb_convert_encoding')) {
+ $this->markTestSkipped('needs iconv or mbstring');
+ }
+
+ $twig = new Twig_Environment();
+ $twig->setCharset('ISO-8859-1');
+
+ $text = twig_convert_encoding('Äé', 'ISO-8859-1', 'UTF-8');
+ for ($i = 0; $i < 30; $i++) {
+ $rand = twig_random($twig, $text);
+ $this->assertTrue(in_array(twig_convert_encoding($rand, 'UTF-8', 'ISO-8859-1'), array('Ä', 'é'), true));
+ }
+ }
+
+ public function testReverseFilterOnNonUTF8String()
+ {
+ if (!function_exists('iconv') && !function_exists('mb_convert_encoding')) {
+ $this->markTestSkipped('needs iconv or mbstring');
+ }
+
+ $twig = new Twig_Environment();
+ $twig->setCharset('ISO-8859-1');
+
+ $input = twig_convert_encoding('Äé', 'ISO-8859-1', 'UTF-8');
+ $output = twig_convert_encoding(twig_reverse_filter($twig, $input), 'UTF-8', 'ISO-8859-1');
+
+ $this->assertEquals($output, 'éÄ');
+ }
+
+ public function testCustomEscaper()
+ {
+ $twig = new Twig_Environment();
+ $twig->getExtension('core')->setEscaper('foo', 'foo_escaper_for_test');
+
+ $this->assertEquals('fooUTF-8', twig_escape_filter($twig, 'foo', 'foo'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Runtime
+ */
+ public function testUnknownCustomEscaper()
+ {
+ twig_escape_filter(new Twig_Environment(), 'foo', 'bar');
+ }
+
+ public function testTwigFirst()
+ {
+ $twig = new Twig_Environment();
+ $this->assertEquals('a', twig_first($twig, 'abc'));
+ $this->assertEquals(1, twig_first($twig, array(1, 2, 3)));
+ $this->assertSame('', twig_first($twig, null));
+ $this->assertSame('', twig_first($twig, ''));
+ }
+
+ public function testTwigLast()
+ {
+ $twig = new Twig_Environment();
+ $this->assertEquals('c', twig_last($twig, 'abc'));
+ $this->assertEquals(3, twig_last($twig, array(1, 2, 3)));
+ $this->assertSame('', twig_last($twig, null));
+ $this->assertSame('', twig_last($twig, ''));
+ }
+}
+
+function foo_escaper_for_test(Twig_Environment $env, $string, $charset)
+{
+ return $string.$charset;
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Extension/SandboxTest.php b/vendor/twig/twig/test/Twig/Tests/Extension/SandboxTest.php
new file mode 100755
index 0000000..fee35a0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Extension/SandboxTest.php
@@ -0,0 +1,220 @@
+ 'Fabien',
+ 'obj' => new FooObject(),
+ 'arr' => array('obj' => new FooObject()),
+ );
+
+ self::$templates = array(
+ '1_basic1' => '{{ obj.foo }}',
+ '1_basic2' => '{{ name|upper }}',
+ '1_basic3' => '{% if name %}foo{% endif %}',
+ '1_basic4' => '{{ obj.bar }}',
+ '1_basic5' => '{{ obj }}',
+ '1_basic6' => '{{ arr.obj }}',
+ '1_basic7' => '{{ cycle(["foo","bar"], 1) }}',
+ '1_basic8' => '{{ obj.getfoobar }}{{ obj.getFooBar }}',
+ '1_basic9' => '{{ obj.foobar }}{{ obj.fooBar }}',
+ '1_basic' => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
+ '1_layout' => '{% block content %}{% endblock %}',
+ '1_child' => "{% extends \"1_layout\" %}\n{% block content %}\n{{ \"a\"|json_encode }}\n{% endblock %}",
+ );
+ }
+
+ /**
+ * @expectedException Twig_Sandbox_SecurityError
+ * @expectedExceptionMessage Filter "json_encode" is not allowed in "1_child" at line 3.
+ */
+ public function testSandboxWithInheritance()
+ {
+ $twig = $this->getEnvironment(true, array(), self::$templates, array('block'));
+ $twig->loadTemplate('1_child')->render(array());
+ }
+
+ public function testSandboxGloballySet()
+ {
+ $twig = $this->getEnvironment(false, array(), self::$templates);
+ $this->assertEquals('FOO', $twig->loadTemplate('1_basic')->render(self::$params), 'Sandbox does nothing if it is disabled globally');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic1')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed method is called');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic2')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed filter is called');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic3')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed tag is used in the template');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic4')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed property is called in the template');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic5')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed method (__toString()) is called in the template');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic6')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed method (__toString()) is called in the template');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('1_basic7')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception if an unallowed function is called in the template');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => 'foo'));
+ FooObject::reset();
+ $this->assertEquals('foo', $twig->loadTemplate('1_basic1')->render(self::$params), 'Sandbox allow some methods');
+ $this->assertEquals(1, FooObject::$called['foo'], 'Sandbox only calls method once');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => '__toString'));
+ FooObject::reset();
+ $this->assertEquals('foo', $twig->loadTemplate('1_basic5')->render(self::$params), 'Sandbox allow some methods');
+ $this->assertEquals(1, FooObject::$called['__toString'], 'Sandbox only calls method once');
+
+ $twig = $this->getEnvironment(false, array(), self::$templates);
+ FooObject::reset();
+ $this->assertEquals('foo', $twig->loadTemplate('1_basic5')->render(self::$params), 'Sandbox allows __toString when sandbox disabled');
+ $this->assertEquals(1, FooObject::$called['__toString'], 'Sandbox only calls method once');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array('upper'));
+ $this->assertEquals('FABIEN', $twig->loadTemplate('1_basic2')->render(self::$params), 'Sandbox allow some filters');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array('if'));
+ $this->assertEquals('foo', $twig->loadTemplate('1_basic3')->render(self::$params), 'Sandbox allow some tags');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array(), array('FooObject' => 'bar'));
+ $this->assertEquals('bar', $twig->loadTemplate('1_basic4')->render(self::$params), 'Sandbox allow some properties');
+
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array(), array(), array('cycle'));
+ $this->assertEquals('bar', $twig->loadTemplate('1_basic7')->render(self::$params), 'Sandbox allow some functions');
+
+ foreach (array('getfoobar', 'getFoobar', 'getFooBar') as $name) {
+ $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => $name));
+ FooObject::reset();
+ $this->assertEquals('foobarfoobar', $twig->loadTemplate('1_basic8')->render(self::$params), 'Sandbox allow methods in a case-insensitive way');
+ $this->assertEquals(2, FooObject::$called['getFooBar'], 'Sandbox only calls method once');
+
+ $this->assertEquals('foobarfoobar', $twig->loadTemplate('1_basic9')->render(self::$params), 'Sandbox allow methods via shortcut names (ie. without get/set)');
+ }
+ }
+
+ public function testSandboxLocallySetForAnInclude()
+ {
+ self::$templates = array(
+ '2_basic' => '{{ obj.foo }}{% include "2_included" %}{{ obj.foo }}',
+ '2_included' => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
+ );
+
+ $twig = $this->getEnvironment(false, array(), self::$templates);
+ $this->assertEquals('fooFOOfoo', $twig->loadTemplate('2_basic')->render(self::$params), 'Sandbox does nothing if disabled globally and sandboxed not used for the include');
+
+ self::$templates = array(
+ '3_basic' => '{{ obj.foo }}{% sandbox %}{% include "3_included" %}{% endsandbox %}{{ obj.foo }}',
+ '3_included' => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
+ );
+
+ $twig = $this->getEnvironment(true, array(), self::$templates);
+ try {
+ $twig->loadTemplate('3_basic')->render(self::$params);
+ $this->fail('Sandbox throws a SecurityError exception when the included file is sandboxed');
+ } catch (Twig_Sandbox_SecurityError $e) {
+ }
+ }
+
+ public function testMacrosInASandbox()
+ {
+ $twig = $this->getEnvironment(true, array('autoescape' => true), array('index' => <<{{ text }}{% endmacro %}
+
+{{- macros.test('username') }}
+EOF
+ ), array('macro', 'import'), array('escape'));
+
+ $this->assertEquals('username
', $twig->loadTemplate('index')->render(array()));
+ }
+
+ protected function getEnvironment($sandboxed, $options, $templates, $tags = array(), $filters = array(), $methods = array(), $properties = array(), $functions = array())
+ {
+ $loader = new Twig_Loader_Array($templates);
+ $twig = new Twig_Environment($loader, array_merge(array('debug' => true, 'cache' => false, 'autoescape' => false), $options));
+ $policy = new Twig_Sandbox_SecurityPolicy($tags, $filters, $methods, $properties, $functions);
+ $twig->addExtension(new Twig_Extension_Sandbox($policy, $sandboxed));
+
+ return $twig;
+ }
+}
+
+class FooObject
+{
+ public static $called = array('__toString' => 0, 'foo' => 0, 'getFooBar' => 0);
+
+ public $bar = 'bar';
+
+ public static function reset()
+ {
+ self::$called = array('__toString' => 0, 'foo' => 0, 'getFooBar' => 0);
+ }
+
+ public function __toString()
+ {
+ ++self::$called['__toString'];
+
+ return 'foo';
+ }
+
+ public function foo()
+ {
+ ++self::$called['foo'];
+
+ return 'foo';
+ }
+
+ public function getFooBar()
+ {
+ ++self::$called['getFooBar'];
+
+ return 'foobar';
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/FileCachingTest.php b/vendor/twig/twig/test/Twig/Tests/FileCachingTest.php
new file mode 100755
index 0000000..6f5bfee
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/FileCachingTest.php
@@ -0,0 +1,79 @@
+tmpDir = sys_get_temp_dir().'/TwigTests';
+ if (!file_exists($this->tmpDir)) {
+ @mkdir($this->tmpDir, 0777, true);
+ }
+
+ if (!is_writable($this->tmpDir)) {
+ $this->markTestSkipped(sprintf('Unable to run the tests as "%s" is not writable.', $this->tmpDir));
+ }
+
+ $this->env = new Twig_Environment(new Twig_Loader_Array(array('index' => 'index', 'index2' => 'index2')), array('cache' => $this->tmpDir));
+ }
+
+ public function tearDown()
+ {
+ if ($this->fileName) {
+ unlink($this->fileName);
+ }
+
+ $this->removeDir($this->tmpDir);
+ }
+
+ public function testWritingCacheFiles()
+ {
+ $name = 'index';
+ $this->env->loadTemplate($name);
+ $cacheFileName = $this->env->getCacheFilename($name);
+
+ $this->assertTrue(file_exists($cacheFileName), 'Cache file does not exist.');
+ $this->fileName = $cacheFileName;
+ }
+
+ public function testClearingCacheFiles()
+ {
+ $name = 'index2';
+ $this->env->loadTemplate($name);
+ $cacheFileName = $this->env->getCacheFilename($name);
+
+ $this->assertTrue(file_exists($cacheFileName), 'Cache file does not exist.');
+ $this->env->clearCacheFiles();
+ $this->assertFalse(file_exists($cacheFileName), 'Cache file was not cleared.');
+ }
+
+ private function removeDir($target)
+ {
+ $fp = opendir($target);
+ while (false !== $file = readdir($fp)) {
+ if (in_array($file, array('.', '..'))) {
+ continue;
+ }
+
+ if (is_dir($target.'/'.$file)) {
+ self::removeDir($target.'/'.$file);
+ } else {
+ unlink($target.'/'.$file);
+ }
+ }
+ closedir($fp);
+ rmdir($target);
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/FileExtensionEscapingStrategyTest.php b/vendor/twig/twig/test/Twig/Tests/FileExtensionEscapingStrategyTest.php
new file mode 100755
index 0000000..d2f55eb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/FileExtensionEscapingStrategyTest.php
@@ -0,0 +1,49 @@
+assertEquals($strategy, Twig_FileExtensionEscapingStrategy::guess($filename));
+ }
+
+ public function getGuessData()
+ {
+ return array(
+ // default
+ array('html', 'foo.html'),
+ array('html', 'foo.html.twig'),
+ array('html', 'foo'),
+ array('html', 'foo.bar.twig'),
+ array('html', 'foo.txt/foo'),
+ array('html', 'foo.txt/foo.js/'),
+
+ // css
+ array('css', 'foo.css'),
+ array('css', 'foo.css.twig'),
+ array('css', 'foo.twig.css'),
+
+ // js
+ array('js', 'foo.js'),
+ array('js', 'foo.js.twig'),
+ array('js', 'foo.txt/foo.js'),
+ array('js', 'foo.txt.twig/foo.js'),
+
+ // txt
+ array(false, 'foo.txt'),
+ array(false, 'foo.txt.twig'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/autoescape/filename.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/autoescape/filename.test
new file mode 100755
index 0000000..b091ad3
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/autoescape/filename.test
@@ -0,0 +1,18 @@
+--TEST--
+"filename" autoescape strategy
+--TEMPLATE--
+{{ br -}}
+{{ include('index.html.twig') -}}
+{{ include('index.txt.twig') -}}
+--TEMPLATE(index.html.twig)--
+{{ br -}}
+--TEMPLATE(index.txt.twig)--
+{{ br -}}
+--DATA--
+return array('br' => ' ')
+--CONFIG--
+return array('autoescape' => 'filename')
+--EXPECT--
+<br />
+<br />
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/base.html b/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/base.html
new file mode 100755
index 0000000..cb0dbe4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/base.html
@@ -0,0 +1 @@
+{% block content %}{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/index.html b/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/index.html
new file mode 100755
index 0000000..df57c82
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/errors/index.html
@@ -0,0 +1,7 @@
+{% extends 'base.html' %}
+{% block content %}
+ {{ foo.bar }}
+{% endblock %}
+{% block foo %}
+ {{ foo.bar }}
+{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable.test
new file mode 100755
index 0000000..ce49165
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable.test
@@ -0,0 +1,18 @@
+--TEST--
+Exception for multiline array with undefined variable
+--TEMPLATE--
+{% set foo = {
+ foo: 'foo',
+ bar: 'bar',
+
+
+ foobar: foobar,
+
+
+
+ foo2: foo2,
+} %}
+--DATA--
+return array('foobar' => 'foobar')
+--EXCEPTION--
+Twig_Error_Runtime: Variable "foo2" does not exist in "index.twig" at line 11
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable_again.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable_again.test
new file mode 100755
index 0000000..e3c040f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_array_with_undefined_variable_again.test
@@ -0,0 +1,18 @@
+--TEST--
+Exception for multiline array with undefined variable
+--TEMPLATE--
+{% set foo = {
+ foo: 'foo',
+ bar: 'bar',
+
+
+ foobar: foobar,
+
+
+
+ foo2: foo2,
+} %}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Runtime: Variable "foobar" does not exist in "index.twig" at line 7
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_undefined_variable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_undefined_variable.test
new file mode 100755
index 0000000..d799a39
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_undefined_variable.test
@@ -0,0 +1,12 @@
+--TEST--
+Exception for multile function with undefined variable
+--TEMPLATE--
+{{ include('foo',
+ with_context=with_context
+) }}
+--TEMPLATE(foo)--
+Foo
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Runtime: Variable "with_context" does not exist in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_unknown_argument.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_unknown_argument.test
new file mode 100755
index 0000000..64761fc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_function_with_unknown_argument.test
@@ -0,0 +1,9 @@
+--TEST--
+Exception for multiline function with unknown argument
+--TEMPLATE--
+{{ include('foo',
+ with_context=True,
+ invalid=False
+) }}
+--EXCEPTION--
+Twig_Error_Syntax: Unknown argument "invalid" for function "include(template, variables, with_context, ignore_missing, sandboxed)" in "index.twig" at line 4.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_tag_with_undefined_variable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_tag_with_undefined_variable.test
new file mode 100755
index 0000000..096a5db
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/multiline_tag_with_undefined_variable.test
@@ -0,0 +1,12 @@
+--TEST--
+Exception for multiline tag with undefined variable
+--TEMPLATE--
+{% include 'foo'
+ with vars
+%}
+--TEMPLATE(foo)--
+Foo
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Runtime: Variable "vars" does not exist in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/syntax_error_in_reused_template.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/syntax_error_in_reused_template.test
new file mode 100755
index 0000000..5dd9f38
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/syntax_error_in_reused_template.test
@@ -0,0 +1,10 @@
+--TEST--
+Exception for syntax error in reused template
+--TEMPLATE--
+{% use 'foo.twig' %}
+--TEMPLATE(foo.twig)--
+{% block bar %}
+ {% do node.data = 5 %}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Unexpected token "operator" of value "=" ("end of statement block" expected) in "foo.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
new file mode 100755
index 0000000..02245e9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
@@ -0,0 +1,20 @@
+--TEST--
+Exception for an unclosed tag
+--TEMPLATE--
+{% block foo %}
+ {% if foo %}
+
+
+
+
+ {% for i in fo %}
+
+
+
+ {% endfor %}
+
+
+
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Unexpected tag name "endblock" (expecting closing tag for the "if" tag defined near line 4) in "index.twig" at line 16
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_parent.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_parent.test
new file mode 100755
index 0000000..c8e7a09
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_parent.test
@@ -0,0 +1,8 @@
+--TEST--
+Exception for an undefined parent
+--TEMPLATE--
+{% extends 'foo.html' %}
+
+{% set foo = "foo" %}
+--EXCEPTION--
+Twig_Error_Loader: Template "foo.html" is not defined in "index.twig" at line 2.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_trait.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_trait.test
new file mode 100755
index 0000000..6679fbe
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/exceptions/undefined_trait.test
@@ -0,0 +1,9 @@
+--TEST--
+Exception for an undefined trait
+--TEMPLATE--
+{% use 'foo' with foobar as bar %}
+--TEMPLATE(foo)--
+{% block bar %}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Runtime: Block "foobar" is not defined in trait "foo" in "index.twig" at line 2.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array.test
new file mode 100755
index 0000000..c69b119
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array.test
@@ -0,0 +1,61 @@
+--TEST--
+Twig supports array notation
+--TEMPLATE--
+{# empty array #}
+{{ []|join(',') }}
+
+{{ [1, 2]|join(',') }}
+{{ ['foo', "bar"]|join(',') }}
+{{ {0: 1, 'foo': 'bar'}|join(',') }}
+{{ {0: 1, 'foo': 'bar'}|keys|join(',') }}
+
+{{ {0: 1, foo: 'bar'}|join(',') }}
+{{ {0: 1, foo: 'bar'}|keys|join(',') }}
+
+{# nested arrays #}
+{% set a = [1, 2, [1, 2], {'foo': {'foo': 'bar'}}] %}
+{{ a[2]|join(',') }}
+{{ a[3]["foo"]|join(',') }}
+
+{# works even if [] is used inside the array #}
+{{ [foo[bar]]|join(',') }}
+
+{# elements can be any expression #}
+{{ ['foo'|upper, bar|upper, bar == foo]|join(',') }}
+
+{# arrays can have a trailing , like in PHP #}
+{{
+ [
+ 1,
+ 2,
+ ]|join(',')
+}}
+
+{# keys can be any expression #}
+{% set a = 1 %}
+{% set b = "foo" %}
+{% set ary = { (a): 'a', (b): 'b', 'c': 'c', (a ~ b): 'd' } %}
+{{ ary|keys|join(',') }}
+{{ ary|join(',') }}
+--DATA--
+return array('bar' => 'bar', 'foo' => array('bar' => 'bar'))
+--EXPECT--
+1,2
+foo,bar
+1,bar
+0,foo
+
+1,bar
+0,foo
+
+1,2
+bar
+
+bar
+
+FOO,BAR,
+
+1,2
+
+1,foo,c,1foo
+a,b,c,d
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array_call.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array_call.test
new file mode 100755
index 0000000..f3df328
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/array_call.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig supports method calls
+--TEMPLATE--
+{{ items.foo }}
+{{ items['foo'] }}
+{{ items[foo] }}
+{{ items[items[foo]] }}
+--DATA--
+return array('foo' => 'bar', 'items' => array('foo' => 'bar', 'bar' => 'foo'))
+--EXPECT--
+bar
+bar
+foo
+bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/binary.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/binary.test
new file mode 100755
index 0000000..f5e6845
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/binary.test
@@ -0,0 +1,46 @@
+--TEST--
+Twig supports binary operations (+, -, *, /, ~, %, and, or)
+--TEMPLATE--
+{{ 1 + 1 }}
+{{ 2 - 1 }}
+{{ 2 * 2 }}
+{{ 2 / 2 }}
+{{ 3 % 2 }}
+{{ 1 and 1 }}
+{{ 1 and 0 }}
+{{ 0 and 1 }}
+{{ 0 and 0 }}
+{{ 1 or 1 }}
+{{ 1 or 0 }}
+{{ 0 or 1 }}
+{{ 0 or 0 }}
+{{ 0 or 1 and 0 }}
+{{ 1 or 0 and 1 }}
+{{ "foo" ~ "bar" }}
+{{ foo ~ "bar" }}
+{{ "foo" ~ bar }}
+{{ foo ~ bar }}
+{{ 20 // 7 }}
+--DATA--
+return array('foo' => 'bar', 'bar' => 'foo')
+--EXPECT--
+2
+1
+4
+1
+1
+1
+
+
+
+1
+1
+1
+
+
+1
+foobar
+barbar
+foofoo
+barfoo
+2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/bitwise.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/bitwise.test
new file mode 100755
index 0000000..74fe6ca
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/bitwise.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig supports bitwise operations
+--TEMPLATE--
+{{ 1 b-and 5 }}
+{{ 1 b-or 5 }}
+{{ 1 b-xor 5 }}
+{{ (1 and 0 b-or 0) is same as(1 and (0 b-or 0)) ? 'ok' : 'ko' }}
+--DATA--
+return array()
+--EXPECT--
+1
+5
+4
+ok
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/comparison.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/comparison.test
new file mode 100755
index 0000000..726b850
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/comparison.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig supports comparison operators (==, !=, <, >, >=, <=)
+--TEMPLATE--
+{{ 1 > 2 }}/{{ 1 > 1 }}/{{ 1 >= 2 }}/{{ 1 >= 1 }}
+{{ 1 < 2 }}/{{ 1 < 1 }}/{{ 1 <= 2 }}/{{ 1 <= 1 }}
+{{ 1 == 1 }}/{{ 1 == 2 }}
+{{ 1 != 1 }}/{{ 1 != 2 }}
+--DATA--
+return array()
+--EXPECT--
+///1
+1//1/1
+1/
+/1
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/divisibleby.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/divisibleby.test
new file mode 100755
index 0000000..238dd27
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/divisibleby.test
@@ -0,0 +1,17 @@
+--TEST--
+Twig supports the "divisible by" operator
+--TEMPLATE--
+{{ 8 is divisible by(2) ? 'OK' }}
+{{ 8 is not divisible by(3) ? 'OK' }}
+{{ 8 is divisible by (2) ? 'OK' }}
+{{ 8 is not
+ divisible
+ by
+ (3) ? 'OK' }}
+--DATA--
+return array()
+--EXPECT--
+OK
+OK
+OK
+OK
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test
new file mode 100755
index 0000000..9cd0676
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test
@@ -0,0 +1,20 @@
+--TEST--
+Twig supports the .. operator
+--TEMPLATE--
+{% for i in 0..10 %}{{ i }} {% endfor %}
+
+{% for letter in 'a'..'z' %}{{ letter }} {% endfor %}
+
+{% for letter in 'a'|upper..'z'|upper %}{{ letter }} {% endfor %}
+
+{% for i in foo[0]..foo[1] %}{{ i }} {% endfor %}
+
+{% for i in 0 + 1 .. 10 - 1 %}{{ i }} {% endfor %}
+--DATA--
+return array('foo' => array(1, 10))
+--EXPECT--
+0 1 2 3 4 5 6 7 8 9 10
+a b c d e f g h i j k l m n o p q r s t u v w x y z
+A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+1 2 3 4 5 6 7 8 9 10
+1 2 3 4 5 6 7 8 9
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ends_with.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ends_with.test
new file mode 100755
index 0000000..9ad5e5e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ends_with.test
@@ -0,0 +1,26 @@
+--TEST--
+Twig supports the "ends with" operator
+--TEMPLATE--
+{{ 'foo' ends with 'o' ? 'OK' : 'KO' }}
+{{ not ('foo' ends with 'f') ? 'OK' : 'KO' }}
+{{ not ('foo' ends with 'foowaytoolong') ? 'OK' : 'KO' }}
+{{ 'foo' ends with '' ? 'OK' : 'KO' }}
+{{ '1' ends with true ? 'OK' : 'KO' }}
+{{ 1 ends with true ? 'OK' : 'KO' }}
+{{ 0 ends with false ? 'OK' : 'KO' }}
+{{ '' ends with false ? 'OK' : 'KO' }}
+{{ false ends with false ? 'OK' : 'KO' }}
+{{ false ends with '' ? 'OK' : 'KO' }}
+--DATA--
+return array()
+--EXPECT--
+OK
+OK
+OK
+OK
+KO
+KO
+KO
+KO
+KO
+KO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/grouping.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/grouping.test
new file mode 100755
index 0000000..79f8e0b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/grouping.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig supports grouping of expressions
+--TEMPLATE--
+{{ (2 + 2) / 2 }}
+--DATA--
+return array()
+--EXPECT--
+2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/literals.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/literals.test
new file mode 100755
index 0000000..7ae3bae
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/literals.test
@@ -0,0 +1,22 @@
+--TEST--
+Twig supports literals
+--TEMPLATE--
+1 {{ true }}
+2 {{ TRUE }}
+3 {{ false }}
+4 {{ FALSE }}
+5 {{ none }}
+6 {{ NONE }}
+7 {{ null }}
+8 {{ NULL }}
+--DATA--
+return array()
+--EXPECT--
+1 1
+2 1
+3
+4
+5
+6
+7
+8
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test
new file mode 100755
index 0000000..159db96
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test
@@ -0,0 +1,27 @@
+--TEST--
+Twig supports __call() for attributes
+--TEMPLATE--
+{{ foo.foo }}
+{{ foo.bar }}
+--DATA--
+class TestClassForMagicCallAttributes
+{
+ public function getBar()
+ {
+ return 'bar_from_getbar';
+ }
+
+ public function __call($method, $arguments)
+ {
+ if ('foo' === $method)
+ {
+ return 'foo_from_call';
+ }
+
+ return false;
+ }
+}
+return array('foo' => new TestClassForMagicCallAttributes())
+--EXPECT--
+foo_from_call
+bar_from_getbar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/matches.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/matches.test
new file mode 100755
index 0000000..b6c7716
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/matches.test
@@ -0,0 +1,12 @@
+--TEST--
+Twig supports the "matches" operator
+--TEMPLATE--
+{{ 'foo' matches '/o/' ? 'OK' : 'KO' }}
+{{ 'foo' matches '/^fo/' ? 'OK' : 'KO' }}
+{{ 'foo' matches '/O/i' ? 'OK' : 'KO' }}
+--DATA--
+return array()
+--EXPECT--
+OK
+OK
+OK
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/method_call.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/method_call.test
new file mode 100755
index 0000000..5f801e6
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/method_call.test
@@ -0,0 +1,28 @@
+--TEST--
+Twig supports method calls
+--TEMPLATE--
+{{ items.foo.foo }}
+{{ items.foo.getFoo() }}
+{{ items.foo.bar }}
+{{ items.foo['bar'] }}
+{{ items.foo.bar('a', 43) }}
+{{ items.foo.bar(foo) }}
+{{ items.foo.self.foo() }}
+{{ items.foo.is }}
+{{ items.foo.in }}
+{{ items.foo.not }}
+--DATA--
+return array('foo' => 'bar', 'items' => array('foo' => new TwigTestFoo(), 'bar' => 'foo'))
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+foo
+foo
+bar
+
+bar_a-43
+bar_bar
+foo
+is
+in
+not
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/negative_numbers.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/negative_numbers.test
new file mode 100755
index 0000000..1853b1b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/negative_numbers.test
@@ -0,0 +1,18 @@
+--TEST--
+Twig manages negative numbers correctly
+--TEMPLATE--
+{{ -1 }}
+{{ - 1 }}
+{{ 5 - 1 }}
+{{ 5-1 }}
+{{ 5 + -1 }}
+{{ 5 + - 1 }}
+--DATA--
+return array()
+--EXPECT--
+-1
+-1
+4
+4
+4
+4
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/operators_as_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/operators_as_variables.test
new file mode 100755
index 0000000..fe29d08
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/operators_as_variables.test
@@ -0,0 +1,16 @@
+--TEST--
+Twig allows to use named operators as variable names
+--TEMPLATE--
+{% for match in matches %}
+ {{- match }}
+{% endfor %}
+{{ in }}
+{{ is }}
+--DATA--
+return array('matches' => array(1, 2, 3), 'in' => 'in', 'is' => 'is')
+--EXPECT--
+1
+2
+3
+in
+is
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/postfix.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/postfix.test
new file mode 100755
index 0000000..542c350
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/postfix.test
@@ -0,0 +1,22 @@
+--TEST--
+Twig parses postfix expressions
+--TEMPLATE--
+{% import _self as macros %}
+
+{% macro foo() %}foo{% endmacro %}
+
+{{ 'a' }}
+{{ 'a'|upper }}
+{{ ('a')|upper }}
+{{ -1|upper }}
+{{ macros.foo() }}
+{{ (macros).foo() }}
+--DATA--
+return array();
+--EXPECT--
+a
+A
+A
+-1
+foo
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/sameas.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/sameas.test
new file mode 100755
index 0000000..601201d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/sameas.test
@@ -0,0 +1,21 @@
+--TEST--
+Twig supports the "same as" operator
+--TEMPLATE--
+{{ 1 is same as(1) ? 'OK' }}
+{{ 1 is not same as(true) ? 'OK' }}
+{{ 1 is same as(1) ? 'OK' }}
+{{ 1 is not same as(true) ? 'OK' }}
+{{ 1 is same as (1) ? 'OK' }}
+{{ 1 is not
+ same
+ as
+ (true) ? 'OK' }}
+--DATA--
+return array()
+--EXPECT--
+OK
+OK
+OK
+OK
+OK
+OK
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/starts_with.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/starts_with.test
new file mode 100755
index 0000000..75d331e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/starts_with.test
@@ -0,0 +1,27 @@
+--TEST--
+Twig supports the "starts with" operator
+--TEMPLATE--
+{{ 'foo' starts with 'f' ? 'OK' : 'KO' }}
+{{ not ('foo' starts with 'oo') ? 'OK' : 'KO' }}
+{{ not ('foo' starts with 'foowaytoolong') ? 'OK' : 'KO' }}
+{{ 'foo' starts with 'f' ? 'OK' : 'KO' }}
+{{ 'foo' starts
+with 'f' ? 'OK' : 'KO' }}
+{{ 'foo' starts with '' ? 'OK' : 'KO' }}
+{{ '1' starts with true ? 'OK' : 'KO' }}
+{{ '' starts with false ? 'OK' : 'KO' }}
+{{ 'a' starts with false ? 'OK' : 'KO' }}
+{{ false starts with '' ? 'OK' : 'KO' }}
+--DATA--
+return array()
+--EXPECT--
+OK
+OK
+OK
+OK
+OK
+OK
+KO
+KO
+KO
+KO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/strings.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/strings.test
new file mode 100755
index 0000000..a911661
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/strings.test
@@ -0,0 +1,10 @@
+--TEST--
+Twig supports string interpolation
+--TEMPLATE--
+{{ "foo #{"foo #{bar} baz"} baz" }}
+{{ "foo #{bar}#{bar} baz" }}
+--DATA--
+return array('bar' => 'BAR');
+--EXPECT--
+foo foo BAR baz baz
+foo BARBAR baz
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test
new file mode 100755
index 0000000..0e6fa96
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test
@@ -0,0 +1,18 @@
+--TEST--
+Twig supports the ternary operator
+--TEMPLATE--
+{{ 1 ? 'YES' : 'NO' }}
+{{ 0 ? 'YES' : 'NO' }}
+{{ 0 ? 'YES' : (1 ? 'YES1' : 'NO1') }}
+{{ 0 ? 'YES' : (0 ? 'YES1' : 'NO1') }}
+{{ 1 == 1 ? 'foo ':'' }}
+{{ foo ~ (bar ? ('-' ~ bar) : '') }}
+--DATA--
+return array('foo' => 'foo', 'bar' => 'bar')
+--EXPECT--
+YES
+NO
+YES1
+NO1
+foo
+foo-bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_noelse.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_noelse.test
new file mode 100755
index 0000000..fdc660f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_noelse.test
@@ -0,0 +1,10 @@
+--TEST--
+Twig supports the ternary operator
+--TEMPLATE--
+{{ 1 ? 'YES' }}
+{{ 0 ? 'YES' }}
+--DATA--
+return array()
+--EXPECT--
+YES
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_nothen.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_nothen.test
new file mode 100755
index 0000000..9057e83
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator_nothen.test
@@ -0,0 +1,10 @@
+--TEST--
+Twig supports the ternary operator
+--TEMPLATE--
+{{ 'YES' ?: 'NO' }}
+{{ 0 ?: 'NO' }}
+--DATA--
+return array()
+--EXPECT--
+YES
+NO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/two_word_operators_as_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/two_word_operators_as_variables.test
new file mode 100755
index 0000000..47f37e4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/two_word_operators_as_variables.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig does not allow to use two-word named operators as variable names
+--TEMPLATE--
+{{ starts with }}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Syntax: Unexpected token "operator" of value "starts with" in "index.twig" at line 2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary.test
new file mode 100755
index 0000000..b79219a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary.test
@@ -0,0 +1,12 @@
+--TEST--
+Twig supports unary operators (not, -, +)
+--TEMPLATE--
+{{ not 1 }}/{{ not 0 }}
+{{ +1 + 1 }}/{{ -1 - 1 }}
+{{ not (false or true) }}
+--DATA--
+return array()
+--EXPECT--
+/1
+2/-2
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_macro_arguments.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_macro_arguments.test
new file mode 100755
index 0000000..ad84a9c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_macro_arguments.test
@@ -0,0 +1,22 @@
+--TEST--
+Twig manages negative numbers as default parameters
+--TEMPLATE--
+{% import _self as macros %}
+{{ macros.negative_number1() }}
+{{ macros.negative_number2() }}
+{{ macros.negative_number3() }}
+{{ macros.positive_number1() }}
+{{ macros.positive_number2() }}
+{% macro negative_number1(nb=-1) %}{{ nb }}{% endmacro %}
+{% macro negative_number2(nb = --1) %}{{ nb }}{% endmacro %}
+{% macro negative_number3(nb = - 1) %}{{ nb }}{% endmacro %}
+{% macro positive_number1(nb = +1) %}{{ nb }}{% endmacro %}
+{% macro positive_number2(nb = ++1) %}{{ nb }}{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+-1
+1
+-1
+1
+1
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test
new file mode 100755
index 0000000..cc6eef8
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig unary operators precedence
+--TEMPLATE--
+{{ -1 - 1 }}
+{{ -1 - -1 }}
+{{ -1 * -1 }}
+{{ 4 / -1 * 5 }}
+--DATA--
+return array()
+--EXPECT--
+-2
+0
+1
+-20
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/abs.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/abs.test
new file mode 100755
index 0000000..27e93fd
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/abs.test
@@ -0,0 +1,30 @@
+--TEST--
+"abs" filter
+--TEMPLATE--
+{{ (-5.5)|abs }}
+{{ (-5)|abs }}
+{{ (-0)|abs }}
+{{ 0|abs }}
+{{ 5|abs }}
+{{ 5.5|abs }}
+{{ number1|abs }}
+{{ number2|abs }}
+{{ number3|abs }}
+{{ number4|abs }}
+{{ number5|abs }}
+{{ number6|abs }}
+--DATA--
+return array('number1' => -5.5, 'number2' => -5, 'number3' => -0, 'number4' => 0, 'number5' => 5, 'number6' => 5.5)
+--EXPECT--
+5.5
+5
+0
+0
+5
+5.5
+5.5
+5
+0
+0
+5
+5.5
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch.test
new file mode 100755
index 0000000..cb6de7f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch.test
@@ -0,0 +1,31 @@
+--TEST--
+"batch" filter
+--TEMPLATE--
+{% for row in items|batch(3) %}
+
+ {% for column in row %}
+
{{ column }}
+ {% endfor %}
+
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'))
+--EXPECT--
+
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_float.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_float.test
new file mode 100755
index 0000000..e2ec4be
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_float.test
@@ -0,0 +1,29 @@
+--TEST--
+"batch" filter
+--TEMPLATE--
+{% for row in items|batch(3.1) %}
+
+ {% for column in row %}
+
{{ column }}
+ {% endfor %}
+
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'))
+--EXPECT--
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_empty_fill.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_empty_fill.test
new file mode 100755
index 0000000..af996f2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_empty_fill.test
@@ -0,0 +1,37 @@
+--TEST--
+"batch" filter
+--TEMPLATE--
+
+{% for row in items|batch(3, '') %}
+
+ {% for column in row %}
+ {{ column }}
+ {% endfor %}
+
+{% endfor %}
+
+--DATA--
+return array('items' => array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'))
+--EXPECT--
+
+
+ a
+ b
+ c
+
+
+ d
+ e
+ f
+
+
+ g
+ h
+ i
+
+
+ j
+
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_exact_elements.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_exact_elements.test
new file mode 100755
index 0000000..72483f4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_exact_elements.test
@@ -0,0 +1,33 @@
+--TEST--
+"batch" filter
+--TEMPLATE--
+{% for row in items|batch(3, 'fill') %}
+
+ {% for column in row %}
+
{{ column }}
+ {% endfor %}
+
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l'))
+--EXPECT--
+
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_fill.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_fill.test
new file mode 100755
index 0000000..746295f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/batch_with_fill.test
@@ -0,0 +1,37 @@
+--TEST--
+"batch" filter
+--TEMPLATE--
+
+{% for row in items|batch(3, 'fill') %}
+
+ {% for column in row %}
+ {{ column }}
+ {% endfor %}
+
+{% endfor %}
+
+--DATA--
+return array('items' => array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'))
+--EXPECT--
+
+
+ a
+ b
+ c
+
+
+ d
+ e
+ f
+
+
+ g
+ h
+ i
+
+
+ j
+ fill
+ fill
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test
new file mode 100755
index 0000000..380b04b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test
@@ -0,0 +1,10 @@
+--TEST--
+"convert_encoding" filter
+--CONDITION--
+function_exists('iconv') || function_exists('mb_convert_encoding')
+--TEMPLATE--
+{{ "愛していますか?"|convert_encoding('ISO-2022-JP', 'UTF-8')|convert_encoding('UTF-8', 'ISO-2022-JP') }}
+--DATA--
+return array()
+--EXPECT--
+愛していますか?
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date.test
new file mode 100755
index 0000000..d17e5e2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date.test
@@ -0,0 +1,90 @@
+--TEST--
+"date" filter
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('d/m/Y') }}
+{{ date1|date('d/m/Y H:i:s', 'Asia/Hong_Kong') }}
+{{ date1|date('d/m/Y H:i:s P', 'Asia/Hong_Kong') }}
+{{ date1|date('d/m/Y H:i:s P', 'America/Chicago') }}
+{{ date1|date('e') }}
+{{ date1|date('d/m/Y H:i:s') }}
+
+{{ date2|date }}
+{{ date2|date('d/m/Y') }}
+{{ date2|date('d/m/Y H:i:s', 'Asia/Hong_Kong') }}
+{{ date2|date('d/m/Y H:i:s', timezone1) }}
+{{ date2|date('d/m/Y H:i:s') }}
+
+{{ date3|date }}
+{{ date3|date('d/m/Y') }}
+
+{{ date4|date }}
+{{ date4|date('d/m/Y') }}
+
+{{ date5|date }}
+{{ date5|date('d/m/Y') }}
+
+{{ date6|date('d/m/Y H:i:s P', 'Europe/Paris') }}
+{{ date6|date('d/m/Y H:i:s P', 'Asia/Hong_Kong') }}
+{{ date6|date('d/m/Y H:i:s P', false) }}
+{{ date6|date('e', 'Europe/Paris') }}
+{{ date6|date('e', false) }}
+
+{{ date7|date }}
+{{ date7|date(timezone='Europe/Paris') }}
+{{ date7|date(timezone='Asia/Hong_Kong') }}
+{{ date7|date(timezone=false) }}
+{{ date7|date(timezone='Indian/Mauritius') }}
+
+{{ '2010-01-28 15:00:00'|date(timezone="Europe/Paris") }}
+{{ '2010-01-28 15:00:00'|date(timezone="Asia/Hong_Kong") }}
+--DATA--
+date_default_timezone_set('Europe/Paris');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+ 'date2' => new DateTime('2010-10-04 13:45'),
+ 'date3' => '2010-10-04 13:45',
+ 'date4' => 1286199900, // DateTime::createFromFormat('Y-m-d H:i', '2010-10-04 13:45', new DateTimeZone('UTC'))->getTimestamp() -- A unixtimestamp is always GMT
+ 'date5' => -189291360, // DateTime::createFromFormat('Y-m-d H:i', '1964-01-02 03:04', new DateTimeZone('UTC'))->getTimestamp(),
+ 'date6' => new DateTime('2010-10-04 13:45', new DateTimeZone('America/New_York')),
+ 'date7' => '2010-01-28T15:00:00+04:00',
+ 'timezone1' => new DateTimeZone('America/New_York'),
+)
+--EXPECT--
+October 4, 2010 13:45
+04/10/2010
+04/10/2010 19:45:00
+04/10/2010 19:45:00 +08:00
+04/10/2010 06:45:00 -05:00
+Europe/Paris
+04/10/2010 13:45:00
+
+October 4, 2010 13:45
+04/10/2010
+04/10/2010 19:45:00
+04/10/2010 07:45:00
+04/10/2010 13:45:00
+
+October 4, 2010 13:45
+04/10/2010
+
+October 4, 2010 15:45
+04/10/2010
+
+January 2, 1964 04:04
+02/01/1964
+
+04/10/2010 19:45:00 +02:00
+05/10/2010 01:45:00 +08:00
+04/10/2010 13:45:00 -04:00
+Europe/Paris
+America/New_York
+
+January 28, 2010 12:00
+January 28, 2010 12:00
+January 28, 2010 19:00
+January 28, 2010 15:00
+January 28, 2010 15:00
+
+January 28, 2010 15:00
+January 28, 2010 22:00
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test
new file mode 100755
index 0000000..11a1ef4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test
@@ -0,0 +1,14 @@
+--TEST--
+"date" filter
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('d/m/Y') }}
+--DATA--
+date_default_timezone_set('UTC');
+$twig->getExtension('core')->setDateFormat('Y-m-d', '%d days %h hours');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+)
+--EXPECT--
+2010-10-04
+04/10/2010
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test
new file mode 100755
index 0000000..e6d3707
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test
@@ -0,0 +1,16 @@
+--TEST--
+"date" filter (interval support as of PHP 5.3)
+--CONDITION--
+version_compare(phpversion(), '5.3.0', '>=')
+--TEMPLATE--
+{{ date2|date }}
+{{ date2|date('%d days') }}
+--DATA--
+date_default_timezone_set('UTC');
+$twig->getExtension('core')->setDateFormat('Y-m-d', '%d days %h hours');
+return array(
+ 'date2' => new DateInterval('P2D'),
+)
+--EXPECT--
+2 days 0 hours
+2 days
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_immutable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_immutable.test
new file mode 100755
index 0000000..4e18325
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_immutable.test
@@ -0,0 +1,37 @@
+--TEST--
+"date" filter
+--CONDITION--
+version_compare(phpversion(), '5.5.0', '>=')
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('d/m/Y') }}
+{{ date1|date('d/m/Y H:i:s', 'Asia/Hong_Kong') }}
+{{ date1|date('d/m/Y H:i:s', timezone1) }}
+{{ date1|date('d/m/Y H:i:s') }}
+{{ date1|date_modify('+1 hour')|date('d/m/Y H:i:s') }}
+
+{{ date2|date('d/m/Y H:i:s P', 'Europe/Paris') }}
+{{ date2|date('d/m/Y H:i:s P', 'Asia/Hong_Kong') }}
+{{ date2|date('d/m/Y H:i:s P', false) }}
+{{ date2|date('e', 'Europe/Paris') }}
+{{ date2|date('e', false) }}
+--DATA--
+date_default_timezone_set('Europe/Paris');
+return array(
+ 'date1' => new DateTimeImmutable('2010-10-04 13:45'),
+ 'date2' => new DateTimeImmutable('2010-10-04 13:45', new DateTimeZone('America/New_York')),
+ 'timezone1' => new DateTimeZone('America/New_York'),
+)
+--EXPECT--
+October 4, 2010 13:45
+04/10/2010
+04/10/2010 19:45:00
+04/10/2010 07:45:00
+04/10/2010 13:45:00
+04/10/2010 14:45:00
+
+04/10/2010 19:45:00 +02:00
+05/10/2010 01:45:00 +08:00
+04/10/2010 13:45:00 -04:00
+Europe/Paris
+America/New_York
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_interval.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_interval.test
new file mode 100755
index 0000000..0c8c6f1
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_interval.test
@@ -0,0 +1,19 @@
+--TEST--
+"date" filter (interval support as of PHP 5.3)
+--CONDITION--
+version_compare(phpversion(), '5.3.0', '>=')
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('%d days %h hours') }}
+{{ date1|date('%d days %h hours', timezone1) }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date1' => new DateInterval('P2D'),
+ // This should have no effect on DateInterval formatting
+ 'timezone1' => new DateTimeZone('America/New_York'),
+)
+--EXPECT--
+2 days
+2 days 0 hours
+2 days 0 hours
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_modify.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_modify.test
new file mode 100755
index 0000000..53d3a69
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_modify.test
@@ -0,0 +1,14 @@
+--TEST--
+"date_modify" filter
+--TEMPLATE--
+{{ date1|date_modify('-1day')|date('Y-m-d H:i:s') }}
+{{ date2|date_modify('-1day')|date('Y-m-d H:i:s') }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date1' => '2010-10-04 13:45',
+ 'date2' => new DateTime('2010-10-04 13:45'),
+)
+--EXPECT--
+2010-10-03 13:45:00
+2010-10-03 13:45:00
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_namedargs.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_namedargs.test
new file mode 100755
index 0000000..4ecde8a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/date_namedargs.test
@@ -0,0 +1,13 @@
+--TEST--
+"date" filter
+--TEMPLATE--
+{{ date|date(format='d/m/Y H:i:s P', timezone='America/Chicago') }}
+{{ date|date(timezone='America/Chicago', format='d/m/Y H:i:s P') }}
+{{ date|date('d/m/Y H:i:s P', timezone='America/Chicago') }}
+--DATA--
+date_default_timezone_set('UTC');
+return array('date' => mktime(13, 45, 0, 10, 4, 2010))
+--EXPECT--
+04/10/2010 08:45:00 -05:00
+04/10/2010 08:45:00 -05:00
+04/10/2010 08:45:00 -05:00
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/default.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/default.test
new file mode 100755
index 0000000..b8d1d66
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/default.test
@@ -0,0 +1,150 @@
+--TEST--
+"default" filter
+--TEMPLATE--
+Variable:
+{{ definedVar |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ zeroVar |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ emptyVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ nullVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ undefinedVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+Array access:
+{{ nested.definedVar |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ nested['definedVar'] |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ nested.zeroVar |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ nested.emptyVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ nested.nullVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ nested.undefinedVar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ nested['undefinedVar'] |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ undefinedVar.foo |default('default') is same as('default') ? 'ok' : 'ko' }}
+Plain values:
+{{ 'defined' |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ 0 |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ '' |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ null |default('default') is same as('default') ? 'ok' : 'ko' }}
+Precedence:
+{{ 'o' ~ nullVar |default('k') }}
+{{ 'o' ~ nested.nullVar |default('k') }}
+Object methods:
+{{ object.foo |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ object.undefinedMethod |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ object.getFoo() |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ object.getFoo('a') |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ object.undefinedMethod() |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ object.undefinedMethod('a') |default('default') is same as('default') ? 'ok' : 'ko' }}
+Deep nested:
+{{ nested.undefinedVar.foo.bar |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ nested.definedArray.0 |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ nested['definedArray'][0] |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ object.self.foo |default('default') is same as('default') ? 'ko' : 'ok' }}
+{{ object.self.undefinedMethod |default('default') is same as('default') ? 'ok' : 'ko' }}
+{{ object.undefinedMethod.self |default('default') is same as('default') ? 'ok' : 'ko' }}
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new TwigTestFoo(),
+)
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+Variable:
+ok
+ok
+ok
+ok
+ok
+Array access:
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+Plain values:
+ok
+ok
+ok
+ok
+Precedence:
+ok
+ok
+Object methods:
+ok
+ok
+ok
+ok
+ok
+ok
+Deep nested:
+ok
+ok
+ok
+ok
+ok
+ok
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new TwigTestFoo(),
+)
+--CONFIG--
+return array('strict_variables' => true)
+--EXPECT--
+Variable:
+ok
+ok
+ok
+ok
+ok
+Array access:
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+Plain values:
+ok
+ok
+ok
+ok
+Precedence:
+ok
+ok
+Object methods:
+ok
+ok
+ok
+ok
+ok
+ok
+Deep nested:
+ok
+ok
+ok
+ok
+ok
+ok
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test
new file mode 100755
index 0000000..93c5913
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test
@@ -0,0 +1,10 @@
+--TEST--
+dynamic filter
+--TEMPLATE--
+{{ 'bar'|foo_path }}
+{{ 'bar'|a_foo_b_bar }}
+--DATA--
+return array()
+--EXPECT--
+foo/bar
+a/b/bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape.test
new file mode 100755
index 0000000..a606c10
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape.test
@@ -0,0 +1,8 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{{ "foo "|e }}
+--DATA--
+return array()
+--EXPECT--
+foo <br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_html_attr.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_html_attr.test
new file mode 100755
index 0000000..009a245
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_html_attr.test
@@ -0,0 +1,8 @@
+--TEST--
+"escape" filter does not escape with the html strategy when using the html_attr strategy
+--TEMPLATE--
+{{ ' '|escape('html_attr') }}
+--DATA--
+return array()
+--EXPECT--
+<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test
new file mode 100755
index 0000000..bba26a0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test
@@ -0,0 +1,8 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{{ "愛していますか? "|e }}
+--DATA--
+return array()
+--EXPECT--
+愛していますか? <br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/first.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/first.test
new file mode 100755
index 0000000..aa54645
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/first.test
@@ -0,0 +1,17 @@
+--TEST--
+"first" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4]|first }}
+{{ {a: 1, b: 2, c: 3, d: 4}|first }}
+{{ '1234'|first }}
+{{ arr|first }}
+{{ 'Ä€é'|first }}
+{{ ''|first }}
+--DATA--
+return array('arr' => new ArrayObject(array(1, 2, 3, 4)))
+--EXPECT--
+1
+1
+1
+1
+Ä
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/force_escape.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/force_escape.test
new file mode 100755
index 0000000..85a9b71
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/force_escape.test
@@ -0,0 +1,18 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{% set foo %}
+ foo
+{% endset %}
+
+{{ foo|e('html') -}}
+{{ foo|e('js') }}
+{% autoescape true %}
+ {{ foo }}
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+ foo<br />
+\x20\x20\x20\x20foo\x3Cbr\x20\x2F\x3E\x0A
+ foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/format.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/format.test
new file mode 100755
index 0000000..97221ff
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/format.test
@@ -0,0 +1,8 @@
+--TEST--
+"format" filter
+--TEMPLATE--
+{{ string|format(foo, 3) }}
+--DATA--
+return array('string' => '%s/%d', 'foo' => 'bar')
+--EXPECT--
+bar/3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/join.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/join.test
new file mode 100755
index 0000000..b342c17
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/join.test
@@ -0,0 +1,12 @@
+--TEST--
+"join" filter
+--TEMPLATE--
+{{ ["foo", "bar"]|join(', ') }}
+{{ foo|join(', ') }}
+{{ bar|join(', ') }}
+--DATA--
+return array('foo' => new TwigTestFoo(), 'bar' => new ArrayObject(array(3, 4)))
+--EXPECT--
+foo, bar
+1, 2
+3, 4
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/json_encode.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/json_encode.test
new file mode 100755
index 0000000..1738d40
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/json_encode.test
@@ -0,0 +1,12 @@
+--TEST--
+"json_encode" filter
+--TEMPLATE--
+{{ "foo"|json_encode|raw }}
+{{ foo|json_encode|raw }}
+{{ [foo, "foo"]|json_encode|raw }}
+--DATA--
+return array('foo' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+"foo"
+"foo"
+["foo","foo"]
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/last.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/last.test
new file mode 100755
index 0000000..1b8031e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/last.test
@@ -0,0 +1,17 @@
+--TEST--
+"last" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4]|last }}
+{{ {a: 1, b: 2, c: 3, d: 4}|last }}
+{{ '1234'|last }}
+{{ arr|last }}
+{{ 'Ä€é'|last }}
+{{ ''|last }}
+--DATA--
+return array('arr' => new ArrayObject(array(1, 2, 3, 4)))
+--EXPECT--
+4
+4
+4
+4
+é
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length.test
new file mode 100755
index 0000000..3347474
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length.test
@@ -0,0 +1,14 @@
+--TEST--
+"length" filter
+--TEMPLATE--
+{{ array|length }}
+{{ string|length }}
+{{ number|length }}
+{{ markup|length }}
+--DATA--
+return array('array' => array(1, 4), 'string' => 'foo', 'number' => 1000, 'markup' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+2
+3
+4
+3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test
new file mode 100755
index 0000000..5d5e243
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test
@@ -0,0 +1,12 @@
+--TEST--
+"length" filter
+--CONDITION--
+function_exists('mb_get_info')
+--TEMPLATE--
+{{ string|length }}
+{{ markup|length }}
+--DATA--
+return array('string' => 'été', 'markup' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+3
+3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/merge.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/merge.test
new file mode 100755
index 0000000..2bd3d4c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/merge.test
@@ -0,0 +1,16 @@
+--TEST--
+"merge" filter
+--TEMPLATE--
+{{ items|merge({'bar': 'foo'})|join }}
+{{ items|merge({'bar': 'foo'})|keys|join }}
+{{ {'bar': 'foo'}|merge(items)|join }}
+{{ {'bar': 'foo'}|merge(items)|keys|join }}
+{{ numerics|merge([4, 5, 6])|join }}
+--DATA--
+return array('items' => array('foo' => 'bar'), 'numerics' => array(1, 2, 3))
+--EXPECT--
+barfoo
+foobar
+foobar
+barfoo
+123456
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/nl2br.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/nl2br.test
new file mode 100755
index 0000000..6545a9b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/nl2br.test
@@ -0,0 +1,14 @@
+--TEST--
+"nl2br" filter
+--TEMPLATE--
+{{ "I like Twig.\nYou will like it too.\n\nEverybody like it!"|nl2br }}
+{{ text|nl2br }}
+--DATA--
+return array('text' => "If you have some HTML \nit will be escaped.")
+--EXPECT--
+I like Twig.
+You will like it too.
+
+Everybody like it!
+If you have some <strong>HTML</strong>
+it will be escaped.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format.test
new file mode 100755
index 0000000..639a865
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format.test
@@ -0,0 +1,18 @@
+--TEST--
+"number_format" filter
+--TEMPLATE--
+{{ 20|number_format }}
+{{ 20.25|number_format }}
+{{ 20.25|number_format(2) }}
+{{ 20.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',', '.') }}
+--DATA--
+return array();
+--EXPECT--
+20
+20
+20.25
+20,25
+1,020,25
+1.020,25
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test
new file mode 100755
index 0000000..c6903cc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test
@@ -0,0 +1,21 @@
+--TEST--
+"number_format" filter with defaults.
+--TEMPLATE--
+{{ 20|number_format }}
+{{ 20.25|number_format }}
+{{ 20.25|number_format(1) }}
+{{ 20.25|number_format(2, ',') }}
+{{ 1020.25|number_format }}
+{{ 1020.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',', '.') }}
+--DATA--
+$twig->getExtension('core')->setNumberFormat(2, '!', '=');
+return array();
+--EXPECT--
+20!00
+20!25
+20!3
+20,25
+1=020!25
+1=020,25
+1.020,25
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/replace.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/replace.test
new file mode 100755
index 0000000..4021660
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/replace.test
@@ -0,0 +1,8 @@
+--TEST--
+"replace" filter
+--TEMPLATE--
+{{ "I like %this% and %that%."|replace({'%this%': "foo", '%that%': "bar"}) }}
+--DATA--
+return array()
+--EXPECT--
+I like foo and bar.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/reverse.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/reverse.test
new file mode 100755
index 0000000..7948ac4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/reverse.test
@@ -0,0 +1,18 @@
+--TEST--
+"reverse" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4]|reverse|join('') }}
+{{ '1234évènement'|reverse }}
+{{ arr|reverse|join('') }}
+{{ {'a': 'c', 'b': 'a'}|reverse()|join(',') }}
+{{ {'a': 'c', 'b': 'a'}|reverse(preserveKeys=true)|join(glue=',') }}
+{{ {'a': 'c', 'b': 'a'}|reverse(preserve_keys=true)|join(glue=',') }}
+--DATA--
+return array('arr' => new ArrayObject(array(1, 2, 3, 4)))
+--EXPECT--
+4321
+tnemenèvé4321
+4321
+a,c
+a,c
+a,c
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/round.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/round.test
new file mode 100755
index 0000000..57806b6
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/round.test
@@ -0,0 +1,22 @@
+--TEST--
+"round" filter
+--TEMPLATE--
+{{ 2.7|round }}
+{{ 2.1|round }}
+{{ 2.1234|round(3, 'floor') }}
+{{ 2.1|round(0, 'ceil') }}
+
+{{ 21.3|round(-1)}}
+{{ 21.3|round(-1, 'ceil')}}
+{{ 21.3|round(-1, 'floor')}}
+--DATA--
+return array()
+--EXPECT--
+3
+2
+2.123
+3
+
+20
+30
+20
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/slice.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/slice.test
new file mode 100755
index 0000000..b49b89f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/slice.test
@@ -0,0 +1,54 @@
+--TEST--
+"slice" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4][1:2]|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}[1:2]|join('') }}
+{{ [1, 2, 3, 4][start:length]|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2)|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2)|keys|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2, true)|keys|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}|slice(1, 2)|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}|slice(1, 2)|keys|join('') }}
+{{ '1234'|slice(1, 2) }}
+{{ '1234'[1:2] }}
+{{ arr|slice(1, 2)|join('') }}
+{{ arr[1:2]|join('') }}
+{{ arr[4:1]|join('') }}
+{{ arr[3:2]|join('') }}
+
+{{ [1, 2, 3, 4]|slice(1)|join('') }}
+{{ [1, 2, 3, 4][1:]|join('') }}
+{{ '1234'|slice(1) }}
+{{ '1234'[1:] }}
+{{ '1234'[:1] }}
+
+{{ arr|slice(3)|join('') }}
+{{ arr[2:]|join('') }}
+{{ xml|slice(1)|join('')}}
+--DATA--
+return array('start' => 1, 'length' => 2, 'arr' => new ArrayObject(array(1, 2, 3, 4)), 'xml' => new SimpleXMLElement('- 1
- 2
'))
+--EXPECT--
+23
+23
+23
+23
+01
+12
+23
+bc
+23
+23
+23
+23
+
+4
+
+234
+234
+234
+234
+1
+
+4
+34
+2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/sort.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/sort.test
new file mode 100755
index 0000000..21d575f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/sort.test
@@ -0,0 +1,10 @@
+--TEST--
+"sort" filter
+--TEMPLATE--
+{{ array1|sort|join }}
+{{ array2|sort|join }}
+--DATA--
+return array('array1' => array(4, 1), 'array2' => array('foo', 'bar'))
+--EXPECT--
+14
+barfoo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/special_chars.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/special_chars.test
new file mode 100755
index 0000000..dbaf7dc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"§" custom filter
+--TEMPLATE--
+{{ 'foo'|§ }}
+--DATA--
+return array()
+--EXPECT--
+§foo§
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split.test
new file mode 100755
index 0000000..a093ed7
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split.test
@@ -0,0 +1,20 @@
+--TEST--
+"split" filter
+--TEMPLATE--
+{{ "one,two,three,four,five"|split(',')|join('-') }}
+{{ foo|split(',')|join('-') }}
+{{ foo|split(',', 3)|join('-') }}
+{{ baz|split('')|join('-') }}
+{{ baz|split('', 1)|join('-') }}
+{{ baz|split('', 2)|join('-') }}
+{{ foo|split(',', -2)|join('-') }}
+--DATA--
+return array('foo' => "one,two,three,four,five", 'baz' => '12345',)
+--EXPECT--
+one-two-three-four-five
+one-two-three-four-five
+one-two-three,four,five
+1-2-3-4-5
+1-2-3-4-5
+12-34-5
+one-two-three
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split_utf8.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split_utf8.test
new file mode 100755
index 0000000..305e162
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/split_utf8.test
@@ -0,0 +1,24 @@
+--TEST--
+"split" filter
+--CONDITION--
+function_exists('mb_get_info')
+--TEMPLATE--
+{{ "é"|split('', 10)|join('-') }}
+{{ foo|split(',')|join('-') }}
+{{ foo|split(',', 1)|join('-') }}
+{{ foo|split(',', 2)|join('-') }}
+{{ foo|split(',', 3)|join('-') }}
+{{ baz|split('')|join('-') }}
+{{ baz|split('', 1)|join('-') }}
+{{ baz|split('', 2)|join('-') }}
+--DATA--
+return array('foo' => 'Ä,é,Äほ', 'baz' => 'éÄßごa',)
+--EXPECT--
+é
+Ä-é-Äほ
+Ä,é,Äほ
+Ä-é,Äほ
+Ä-é-Äほ
+é-Ä-ß-ご-a
+é-Ä-ß-ご-a
+éÄ-ßご-a
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/trim.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/trim.test
new file mode 100755
index 0000000..3192062
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/trim.test
@@ -0,0 +1,12 @@
+--TEST--
+"trim" filter
+--TEMPLATE--
+{{ " I like Twig. "|trim }}
+{{ text|trim }}
+{{ " foo/"|trim("/") }}
+--DATA--
+return array('text' => " If you have some HTML it will be escaped. ")
+--EXPECT--
+I like Twig.
+If you have some <strong>HTML</strong> it will be escaped.
+ foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode.test
new file mode 100755
index 0000000..8726159
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode.test
@@ -0,0 +1,16 @@
+--TEST--
+"url_encode" filter
+--CONDITION--
+defined('PHP_QUERY_RFC3986')
+--TEMPLATE--
+{{ {foo: "bar", number: 3, "spéßi%l": "e%c0d@d", "spa ce": ""}|url_encode }}
+{{ {foo: "bar", number: 3, "spéßi%l": "e%c0d@d", "spa ce": ""}|url_encode|raw }}
+{{ {}|url_encode|default("default") }}
+{{ 'spéßi%le%c0d@dspa ce'|url_encode }}
+--DATA--
+return array()
+--EXPECT--
+foo=bar&number=3&sp%C3%A9%C3%9Fi%25l=e%25c0d%40d&spa%20ce=
+foo=bar&number=3&sp%C3%A9%C3%9Fi%25l=e%25c0d%40d&spa%20ce=
+default
+sp%C3%A9%C3%9Fi%25le%25c0d%40dspa%20ce
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode_deprecated.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode_deprecated.test
new file mode 100755
index 0000000..11800e9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/filters/urlencode_deprecated.test
@@ -0,0 +1,16 @@
+--TEST--
+"url_encode" filter for PHP < 5.4 and HHVM
+--CONDITION--
+defined('PHP_QUERY_RFC3986')
+--TEMPLATE--
+{{ {foo: "bar", number: 3, "spéßi%l": "e%c0d@d", "spa ce": ""}|url_encode }}
+{{ {foo: "bar", number: 3, "spéßi%l": "e%c0d@d", "spa ce": ""}|url_encode|raw }}
+{{ {}|url_encode|default("default") }}
+{{ 'spéßi%le%c0d@dspa ce'|url_encode }}
+--DATA--
+return array()
+--EXPECT--
+foo=bar&number=3&sp%C3%A9%C3%9Fi%25l=e%25c0d%40d&spa%20ce=
+foo=bar&number=3&sp%C3%A9%C3%9Fi%25l=e%25c0d%40d&spa%20ce=
+default
+sp%C3%A9%C3%9Fi%25le%25c0d%40dspa%20ce
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/attribute.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/attribute.test
new file mode 100755
index 0000000..71b2038
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/attribute.test
@@ -0,0 +1,18 @@
+--TEST--
+"attribute" function
+--TEMPLATE--
+{{ attribute(obj, method) }}
+{{ attribute(array, item) }}
+{{ attribute(obj, "bar", ["a", "b"]) }}
+{{ attribute(obj, "bar", arguments) }}
+{{ attribute(obj, method) is defined ? 'ok' : 'ko' }}
+{{ attribute(obj, nonmethod) is defined ? 'ok' : 'ko' }}
+--DATA--
+return array('obj' => new TwigTestFoo(), 'method' => 'foo', 'array' => array('foo' => 'bar'), 'item' => 'foo', 'nonmethod' => 'xxx', 'arguments' => array('a', 'b'))
+--EXPECT--
+foo
+bar
+bar_a-b
+bar_a-b
+ok
+ko
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/block.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/block.test
new file mode 100755
index 0000000..8e54059
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/block.test
@@ -0,0 +1,12 @@
+--TEST--
+"block" function
+--TEMPLATE--
+{% extends 'base.twig' %}
+{% block bar %}BAR{% endblock %}
+--TEMPLATE(base.twig)--
+{% block foo %}{{ block('bar') }}{% endblock %}
+{% block bar %}BAR_BASE{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+BARBAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/constant.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/constant.test
new file mode 100755
index 0000000..6312879
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/constant.test
@@ -0,0 +1,10 @@
+--TEST--
+"constant" function
+--TEMPLATE--
+{{ constant('DATE_W3C') == expect ? 'true' : 'false' }}
+{{ constant('ARRAY_AS_PROPS', object) }}
+--DATA--
+return array('expect' => DATE_W3C, 'object' => new ArrayObject(array('hi')));
+--EXPECT--
+true
+2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/cycle.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/cycle.test
new file mode 100755
index 0000000..522a63b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/cycle.test
@@ -0,0 +1,16 @@
+--TEST--
+"cycle" function
+--TEMPLATE--
+{% for i in 0..6 %}
+{{ cycle(array1, i) }}-{{ cycle(array2, i) }}
+{% endfor %}
+--DATA--
+return array('array1' => array('odd', 'even'), 'array2' => array('apple', 'orange', 'citrus'))
+--EXPECT--
+odd-apple
+even-orange
+odd-citrus
+even-apple
+odd-orange
+even-citrus
+odd-apple
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date.test
new file mode 100755
index 0000000..8be9c0c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date.test
@@ -0,0 +1,25 @@
+--TEST--
+"date" function
+--TEMPLATE--
+{{ date() == date('now') ? 'OK' : 'KO' }}
+{{ date(date1) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date2) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date3) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date4) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date5) == date('1964-01-02 03:04') ? 'OK' : 'KO' }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+ 'date2' => new DateTime('2010-10-04 13:45'),
+ 'date3' => '2010-10-04 13:45',
+ 'date4' => 1286199900, // DateTime::createFromFormat('Y-m-d H:i', '2010-10-04 13:45', new DateTimeZone('UTC'))->getTimestamp() -- A unixtimestamp is always GMT
+ 'date5' => -189291360, // DateTime::createFromFormat('Y-m-d H:i', '1964-01-02 03:04', new DateTimeZone('UTC'))->getTimestamp(),
+)
+--EXPECT--
+OK
+OK
+OK
+OK
+OK
+OK
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date_namedargs.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date_namedargs.test
new file mode 100755
index 0000000..b9dd9e3
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/date_namedargs.test
@@ -0,0 +1,11 @@
+--TEST--
+"date" function
+--TEMPLATE--
+{{ date(date, "America/New_York")|date('d/m/Y H:i:s P', false) }}
+{{ date(timezone="America/New_York", date=date)|date('d/m/Y H:i:s P', false) }}
+--DATA--
+date_default_timezone_set('UTC');
+return array('date' => mktime(13, 45, 0, 10, 4, 2010))
+--EXPECT--
+04/10/2010 09:45:00 -04:00
+04/10/2010 09:45:00 -04:00
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump.test
new file mode 100755
index 0000000..f407237
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump.test
@@ -0,0 +1,16 @@
+--TEST--
+"dump" function
+--CONDITION--
+!extension_loaded('xdebug')
+--TEMPLATE--
+{{ dump('foo') }}
+{{ dump('foo', 'bar') }}
+--DATA--
+return array('foo' => 'foo', 'bar' => 'bar')
+--CONFIG--
+return array('debug' => true, 'autoescape' => false);
+--EXPECT--
+string(3) "foo"
+
+string(3) "foo"
+string(3) "bar"
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump_array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump_array.test
new file mode 100755
index 0000000..889b7a9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dump_array.test
@@ -0,0 +1,19 @@
+--TEST--
+"dump" function, xdebug is not loaded or xdebug <2.2-dev is loaded
+--CONDITION--
+!extension_loaded('xdebug') || (($r = new ReflectionExtension('xdebug')) && version_compare($r->getVersion(), '2.2-dev', '<'))
+--TEMPLATE--
+{{ dump() }}
+--DATA--
+return array('foo' => 'foo', 'bar' => 'bar')
+--CONFIG--
+return array('debug' => true, 'autoescape' => false);
+--EXPECT--
+array(3) {
+ ["foo"]=>
+ string(3) "foo"
+ ["bar"]=>
+ string(3) "bar"
+ ["global"]=>
+ string(6) "global"
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test
new file mode 100755
index 0000000..913fbc9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test
@@ -0,0 +1,10 @@
+--TEST--
+dynamic function
+--TEMPLATE--
+{{ foo_path('bar') }}
+{{ a_foo_b_bar('bar') }}
+--DATA--
+return array()
+--EXPECT--
+foo/bar
+a/b/bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/assignment.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/assignment.test
new file mode 100755
index 0000000..b7653b4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/assignment.test
@@ -0,0 +1,13 @@
+--TEST--
+"include" function
+--TEMPLATE--
+{% set tmp = include("foo.twig") %}
+
+FOO{{ tmp }}BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array()
+--EXPECT--
+FOO
+FOOBARBAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/autoescaping.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/autoescaping.test
new file mode 100755
index 0000000..56f8f3b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/autoescaping.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" function is safe for auto-escaping
+--TEMPLATE--
+{{ include("foo.twig") }}
+--TEMPLATE(foo.twig)--
+Test
+--DATA--
+return array()
+--EXPECT--
+Test
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/basic.test
new file mode 100755
index 0000000..a434182
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/basic.test
@@ -0,0 +1,17 @@
+--TEST--
+"include" function
+--TEMPLATE--
+FOO
+{{ include("foo.twig") }}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+FOOBAR
+
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/expression.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/expression.test
new file mode 100755
index 0000000..aba30ce
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/expression.test
@@ -0,0 +1,17 @@
+--TEST--
+"include" function allows expressions for the template to include
+--TEMPLATE--
+FOO
+{{ include(foo) }}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array('foo' => 'foo.twig')
+--EXPECT--
+FOO
+
+FOOBAR
+
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/ignore_missing.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/ignore_missing.test
new file mode 100755
index 0000000..43a2ccc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/ignore_missing.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" function
+--TEMPLATE--
+{{ include(["foo.twig", "bar.twig"], ignore_missing = true) }}
+{{ include("foo.twig", ignore_missing = true) }}
+{{ include("foo.twig", ignore_missing = true, variables = {}) }}
+{{ include("foo.twig", ignore_missing = true, variables = {}, with_context = true) }}
+--DATA--
+return array()
+--EXPECT--
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing.test
new file mode 100755
index 0000000..4d2f6cf
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing.test
@@ -0,0 +1,8 @@
+--TEST--
+"include" function
+--TEMPLATE--
+{{ include("foo.twig") }}
+--DATA--
+return array();
+--EXCEPTION--
+Twig_Error_Loader: Template "foo.twig" is not defined in "index.twig" at line 2.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing_nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing_nested.test
new file mode 100755
index 0000000..78fddc7
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/missing_nested.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" function
+--TEMPLATE--
+{% extends "base.twig" %}
+
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}
+ {{ include("foo.twig") }}
+{% endblock %}
+--DATA--
+return array();
+--EXCEPTION--
+Twig_Error_Loader: Template "foo.twig" is not defined in "base.twig" at line 3.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/sandbox.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/sandbox.test
new file mode 100755
index 0000000..7b9ccac
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/sandbox.test
@@ -0,0 +1,13 @@
+--TEST--
+"include" tag sandboxed
+--TEMPLATE--
+{{ include("foo.twig", sandboxed = true) }}
+--TEMPLATE(foo.twig)--
+
+
+{{ foo|e }}
+{{ foo|e }}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Sandbox_SecurityNotAllowedFilterError: Filter "e" is not allowed in "foo.twig" at line 4.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/template_instance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/template_instance.test
new file mode 100755
index 0000000..18d405a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/template_instance.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" function accepts Twig_Template instance
+--TEMPLATE--
+{{ include(foo) }} FOO
+--TEMPLATE(foo.twig)--
+BAR
+--DATA--
+return array('foo' => $twig->loadTemplate('foo.twig'))
+--EXPECT--
+BAR FOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/templates_as_array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/templates_as_array.test
new file mode 100755
index 0000000..1a81006
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/templates_as_array.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" function
+--TEMPLATE--
+{{ include(["foo.twig", "bar.twig"]) }}
+{{- include(["bar.twig", "foo.twig"]) }}
+--TEMPLATE(foo.twig)--
+foo
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_context.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_context.test
new file mode 100755
index 0000000..35611fb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_context.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" function accept variables and with_context
+--TEMPLATE--
+{{ include("foo.twig") }}
+{{- include("foo.twig", with_context = false) }}
+{{- include("foo.twig", {'foo1': 'bar'}) }}
+{{- include("foo.twig", {'foo1': 'bar'}, with_context = false) }}
+--TEMPLATE(foo.twig)--
+{% for k, v in _context %}{{ k }},{% endfor %}
+--DATA--
+return array('foo' => 'bar')
+--EXPECT--
+foo,global,_parent,
+global,_parent,
+foo,global,foo1,_parent,
+foo1,global,_parent,
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_variables.test
new file mode 100755
index 0000000..b2ace94
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/include/with_variables.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" function accept variables
+--TEMPLATE--
+{{ include("foo.twig", {'foo': 'bar'}) }}
+{{- include("foo.twig", vars) }}
+--TEMPLATE(foo.twig)--
+{{ foo }}
+--DATA--
+return array('vars' => array('foo' => 'bar'))
+--EXPECT--
+bar
+bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/max.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/max.test
new file mode 100755
index 0000000..e6c94af
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/max.test
@@ -0,0 +1,12 @@
+--TEST--
+"max" function
+--TEMPLATE--
+{{ max([2, 1, 3, 5, 4]) }}
+{{ max(2, 1, 3, 5, 4) }}
+{{ max({2:"two", 1:"one", 3:"three", 5:"five", 4:"for"}) }}
+--DATA--
+return array()
+--EXPECT--
+5
+5
+two
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/min.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/min.test
new file mode 100755
index 0000000..660471c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/min.test
@@ -0,0 +1,12 @@
+--TEST--
+"min" function
+--TEMPLATE--
+{{ min(2, 1, 3, 5, 4) }}
+{{ min([2, 1, 3, 5, 4]) }}
+{{ min({2:"two", 1:"one", 3:"three", 5:"five", 4:"for"}) }}
+--DATA--
+return array()
+--EXPECT--
+1
+1
+five
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/range.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/range.test
new file mode 100755
index 0000000..e0377c8
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/range.test
@@ -0,0 +1,8 @@
+--TEST--
+"range" function
+--TEMPLATE--
+{{ range(low=0+1, high=10+0, step=2)|join(',') }}
+--DATA--
+return array()
+--EXPECT--
+1,3,5,7,9
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/recursive_block_with_inheritance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/recursive_block_with_inheritance.test
new file mode 100755
index 0000000..f39712d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/recursive_block_with_inheritance.test
@@ -0,0 +1,21 @@
+--TEST--
+"block" function recursively called in a parent template
+--TEMPLATE--
+{% extends "ordered_menu.twig" %}
+{% block label %}"{{ parent() }}"{% endblock %}
+{% block list %}{% set class = 'b' %}{{ parent() }}{% endblock %}
+--TEMPLATE(ordered_menu.twig)--
+{% extends "menu.twig" %}
+{% block list %}{% set class = class|default('a') %}{{ block('children') }} {% endblock %}
+--TEMPLATE(menu.twig)--
+{% extends "base.twig" %}
+{% block list %}{% endblock %}
+{% block children %}{% set currentItem = item %}{% for item in currentItem %}{{ block('item') }}{% endfor %}{% set item = currentItem %}{% endblock %}
+{% block item %}{% if item is not iterable %}{{ block('label') }}{% else %}{{ block('list') }}{% endif %} {% endblock %}
+{% block label %}{{ item }}{{ block('unknown') }}{% endblock %}
+--TEMPLATE(base.twig)--
+{{ block('list') }}
+--DATA--
+return array('item' => array('1', '2', array('3.1', array('3.2.1', '3.2.2'), '3.4')))
+--EXPECT--
+"1" "2" "3.1" "3.2.1" "3.2.2" "3.4"
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/source.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/source.test
new file mode 100755
index 0000000..0e094c3
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/source.test
@@ -0,0 +1,17 @@
+--TEST--
+"source" function
+--TEMPLATE--
+FOO
+{{ source("foo.twig") }}
+
+BAR
+--TEMPLATE(foo.twig)--
+{{ foo }}
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+{{ foo }}
+
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/special_chars.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/special_chars.test
new file mode 100755
index 0000000..30c3df5
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"§" custom function
+--TEMPLATE--
+{{ §('foo') }}
+--DATA--
+return array()
+--EXPECT--
+§foo§
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/template_from_string.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/template_from_string.test
new file mode 100755
index 0000000..3d3b958
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/functions/template_from_string.test
@@ -0,0 +1,15 @@
+--TEST--
+"template_from_string" function
+--TEMPLATE--
+{% include template_from_string(template) %}
+
+{% include template_from_string("Hello {{ name }}") %}
+{% include template_from_string('{% extends "parent.twig" %}{% block content %}Hello {{ name }}{% endblock %}') %}
+--TEMPLATE(parent.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array('name' => 'Fabien', 'template' => "Hello {{ name }}")
+--EXPECT--
+Hello Fabien
+Hello Fabien
+Hello Fabien
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/default_values.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/default_values.test
new file mode 100755
index 0000000..4ccff7b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/default_values.test
@@ -0,0 +1,16 @@
+--TEST--
+macro
+--TEMPLATE--
+{% from _self import test %}
+
+{% macro test(a, b = 'bar') -%}
+{{ a }}{{ b }}
+{%- endmacro %}
+
+{{ test('foo') }}
+{{ test('bar', 'foo') }}
+--DATA--
+return array();
+--EXPECT--
+foobar
+barfoo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/nested_calls.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/nested_calls.test
new file mode 100755
index 0000000..cd25428
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/nested_calls.test
@@ -0,0 +1,18 @@
+--TEST--
+macro
+--TEMPLATE--
+{% import _self as macros %}
+
+{% macro foo(data) %}
+ {{ data }}
+{% endmacro %}
+
+{% macro bar() %}
+
+{% endmacro %}
+
+{{ macros.foo(macros.bar()) }}
+--DATA--
+return array();
+--EXPECT--
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/reserved_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/reserved_variables.test
new file mode 100755
index 0000000..cbfb921
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/reserved_variables.test
@@ -0,0 +1,14 @@
+--TEST--
+macro
+--TEMPLATE--
+{% from _self import test %}
+
+{% macro test(this) -%}
+ {{ this }}
+{%- endmacro %}
+
+{{ test(this) }}
+--DATA--
+return array('this' => 'foo');
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/simple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/simple.test
new file mode 100755
index 0000000..6a366cd
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/simple.test
@@ -0,0 +1,22 @@
+--TEST--
+macro
+--TEMPLATE--
+{% import _self as test %}
+{% from _self import test %}
+
+{% macro test(a, b) -%}
+ {{ a|default('a') }}
+ {{- b|default('b') }}
+{%- endmacro %}
+
+{{ test.test() }}
+{{ test() }}
+{{ test.test(1, "c") }}
+{{ test(1, "c") }}
+--DATA--
+return array();
+--EXPECT--
+a b
+a b
+1 c
+1 c
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/with_filters.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/with_filters.test
new file mode 100755
index 0000000..685626f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/macros/with_filters.test
@@ -0,0 +1,14 @@
+--TEST--
+macro with a filter
+--TEMPLATE--
+{% import _self as test %}
+
+{% macro test() %}
+ {% filter escape %}foo {% endfilter %}
+{% endmacro %}
+
+{{ test.test() }}
+--DATA--
+return array();
+--EXPECT--
+foo<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/combined_debug_info.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/combined_debug_info.test
new file mode 100755
index 0000000..df48578
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/combined_debug_info.test
@@ -0,0 +1,15 @@
+--TEST--
+Exception with bad line number
+--TEMPLATE--
+{% block content %}
+ {{ foo }}
+ {{ include("foo") }}
+{% endblock %}
+index
+--TEMPLATE(foo)--
+foo
+{{ foo.bar }}
+--DATA--
+return array('foo' => 'foo');
+--EXCEPTION--
+Twig_Error_Runtime: Impossible to access an attribute ("bar") on a string variable ("foo") in "foo" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/empty_token.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/empty_token.test
new file mode 100755
index 0000000..65f6cd2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/empty_token.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig outputs 0 nodes correctly
+--TEMPLATE--
+{{ foo }}0{{ foo }}
+--DATA--
+return array('foo' => 'foo')
+--EXPECT--
+foo0foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/issue_1143.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/issue_1143.test
new file mode 100755
index 0000000..ff7c8bb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/issue_1143.test
@@ -0,0 +1,23 @@
+--TEST--
+error in twig extension
+--TEMPLATE--
+{{ object.region is not null ? object.regionChoices[object.region] }}
+--DATA--
+class House
+{
+ const REGION_S = 1;
+ const REGION_P = 2;
+
+ public static $regionChoices = array(self::REGION_S => 'house.region.s', self::REGION_P => 'house.region.p');
+
+ public function getRegionChoices()
+ {
+ return self::$regionChoices;
+ }
+}
+
+$object = new House();
+$object->region = 1;
+return array('object' => $object)
+--EXPECT--
+house.region.s
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/multi_word_tests.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/multi_word_tests.test
new file mode 100755
index 0000000..269a305
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/multi_word_tests.test
@@ -0,0 +1,10 @@
+--TEST--
+Twig allows multi-word tests without a custom node class
+--TEMPLATE--
+{{ 'foo' is multi word ? 'yes' : 'no' }}
+{{ 'foo bar' is multi word ? 'yes' : 'no' }}
+--DATA--
+return array()
+--EXPECT--
+no
+yes
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/simple_xml_element.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/simple_xml_element.test
new file mode 100755
index 0000000..60c3c51
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/simple_xml_element.test
@@ -0,0 +1,19 @@
+--TEST--
+Twig is able to deal with SimpleXMLElement instances as variables
+--CONDITION--
+version_compare(phpversion(), '5.3.0', '>=')
+--TEMPLATE--
+Hello '{{ images.image.0.group }}'!
+{{ images.image.0.group.attributes.myattr }}
+{{ images.children().image.count() }}
+{% for image in images %}
+ - {{ image.group }}
+{% endfor %}
+--DATA--
+return array('images' => new SimpleXMLElement('foo bar '))
+--EXPECT--
+Hello 'foo'!
+example
+2
+ - foo
+ - bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/strings_like_numbers.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/strings_like_numbers.test
new file mode 100755
index 0000000..e18e110
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/regression/strings_like_numbers.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig does not confuse strings with integers in getAttribute()
+--TEMPLATE--
+{{ hash['2e2'] }}
+--DATA--
+return array('hash' => array('2e2' => 'works'))
+--EXPECT--
+works
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test
new file mode 100755
index 0000000..2f6a3e1
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test
@@ -0,0 +1,26 @@
+--TEST--
+"autoescape" tag applies escaping on its children
+--TEMPLATE--
+{% autoescape %}
+{{ var }}
+{% endautoescape %}
+{% autoescape 'html' %}
+{{ var }}
+{% endautoescape %}
+{% autoescape false %}
+{{ var }}
+{% endautoescape %}
+{% autoescape true %}
+{{ var }}
+{% endautoescape %}
+{% autoescape false %}
+{{ var }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
+<br />
+
+<br />
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test
new file mode 100755
index 0000000..05ab83c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test
@@ -0,0 +1,12 @@
+--TEST--
+"autoescape" tag applies escaping on embedded blocks
+--TEMPLATE--
+{% autoescape 'html' %}
+ {% block foo %}
+ {{ var }}
+ {% endblock %}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test
new file mode 100755
index 0000000..9c09724
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test
@@ -0,0 +1,10 @@
+--TEST--
+"autoescape" tag does not double-escape
+--TEMPLATE--
+{% autoescape 'html' %}
+{{ var|escape }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test
new file mode 100755
index 0000000..ce7ea78
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test
@@ -0,0 +1,83 @@
+--TEST--
+"autoescape" tag applies escaping after calling functions
+--TEMPLATE--
+
+autoescape false
+{% autoescape false %}
+
+safe_br
+{{ safe_br() }}
+
+unsafe_br
+{{ unsafe_br() }}
+
+{% endautoescape %}
+
+autoescape 'html'
+{% autoescape 'html' %}
+
+safe_br
+{{ safe_br() }}
+
+unsafe_br
+{{ unsafe_br() }}
+
+unsafe_br()|raw
+{{ (unsafe_br())|raw }}
+
+safe_br()|escape
+{{ (safe_br())|escape }}
+
+safe_br()|raw
+{{ (safe_br())|raw }}
+
+unsafe_br()|escape
+{{ (unsafe_br())|escape }}
+
+{% endautoescape %}
+
+autoescape js
+{% autoescape 'js' %}
+
+safe_br
+{{ safe_br() }}
+
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+
+autoescape false
+
+safe_br
+
+
+unsafe_br
+
+
+
+autoescape 'html'
+
+safe_br
+
+
+unsafe_br
+<br />
+
+unsafe_br()|raw
+
+
+safe_br()|escape
+<br />
+
+safe_br()|raw
+
+
+unsafe_br()|escape
+<br />
+
+
+autoescape js
+
+safe_br
+\x3Cbr\x20\x2F\x3E
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test
new file mode 100755
index 0000000..e389d4d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test
@@ -0,0 +1,45 @@
+--TEST--
+"autoescape" tag does not apply escaping on literals
+--TEMPLATE--
+{% autoescape 'html' %}
+
+1. Simple literal
+{{ " " }}
+
+2. Conditional expression with only literals
+{{ true ? " " : " " }}
+
+3. Conditional expression with a variable
+{{ true ? " " : someVar }}
+
+4. Nested conditionals with only literals
+{{ true ? (true ? " " : " ") : "\n" }}
+
+5. Nested conditionals with a variable
+{{ true ? (true ? " " : someVar) : "\n" }}
+
+6. Nested conditionals with a variable marked safe
+{{ true ? (true ? " " : someVar|raw) : "\n" }}
+
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+
+1. Simple literal
+
+
+2. Conditional expression with only literals
+
+
+3. Conditional expression with a variable
+<br />
+
+4. Nested conditionals with only literals
+
+
+5. Nested conditionals with a variable
+<br />
+
+6. Nested conditionals with a variable marked safe
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test
new file mode 100755
index 0000000..798e6fe
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test
@@ -0,0 +1,26 @@
+--TEST--
+"autoescape" tags can be nested at will
+--TEMPLATE--
+{{ var }}
+{% autoescape 'html' %}
+ {{ var }}
+ {% autoescape false %}
+ {{ var }}
+ {% autoescape 'html' %}
+ {{ var }}
+ {% endautoescape %}
+ {{ var }}
+ {% endautoescape %}
+ {{ var }}
+{% endautoescape %}
+{{ var }}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
+ <br />
+
+ <br />
+
+ <br />
+<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test
new file mode 100755
index 0000000..e896aa4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test
@@ -0,0 +1,26 @@
+--TEST--
+"autoescape" tag applies escaping to object method calls
+--TEMPLATE--
+{% autoescape 'html' %}
+{{ user.name }}
+{{ user.name|lower }}
+{{ user }}
+{% endautoescape %}
+--DATA--
+class UserForAutoEscapeTest
+{
+ public function getName()
+ {
+ return 'Fabien ';
+ }
+
+ public function __toString()
+ {
+ return 'Fabien ';
+ }
+}
+return array('user' => new UserForAutoEscapeTest())
+--EXPECT--
+Fabien<br />
+fabien<br />
+Fabien<br />
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test
new file mode 100755
index 0000000..9f1cedd
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test
@@ -0,0 +1,10 @@
+--TEST--
+"autoescape" tag does not escape when raw is used as a filter
+--TEMPLATE--
+{% autoescape 'html' %}
+{{ var|raw }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test
new file mode 100755
index 0000000..cf8ccee
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test
@@ -0,0 +1,17 @@
+--TEST--
+"autoescape" tag accepts an escaping strategy
+--TEMPLATE--
+{% autoescape true js %}{{ var }}{% endautoescape %}
+
+{% autoescape true html %}{{ var }}{% endautoescape %}
+
+{% autoescape 'js' %}{{ var }}{% endautoescape %}
+
+{% autoescape 'html' %}{{ var }}{% endautoescape %}
+--DATA--
+return array('var' => ' "')
+--EXPECT--
+\x3Cbr\x20\x2F\x3E\x22
+<br />"
+\x3Cbr\x20\x2F\x3E\x22
+<br />"
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test
new file mode 100755
index 0000000..4f41520
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test
@@ -0,0 +1,69 @@
+--TEST--
+escape types
+--TEMPLATE--
+
+1. autoescape 'html' |escape('js')
+
+{% autoescape 'html' %}
+
+{% endautoescape %}
+
+2. autoescape 'html' |escape('js')
+
+{% autoescape 'html' %}
+
+{% endautoescape %}
+
+3. autoescape 'js' |escape('js')
+
+{% autoescape 'js' %}
+
+{% endautoescape %}
+
+4. no escape
+
+{% autoescape false %}
+
+{% endautoescape %}
+
+5. |escape('js')|escape('html')
+
+{% autoescape false %}
+
+{% endautoescape %}
+
+6. autoescape 'html' |escape('js')|escape('html')
+
+{% autoescape 'html' %}
+
+{% endautoescape %}
+
+--DATA--
+return array('msg' => "<>\n'\"")
+--EXPECT--
+
+1. autoescape 'html' |escape('js')
+
+
+
+2. autoescape 'html' |escape('js')
+
+
+
+3. autoescape 'js' |escape('js')
+
+
+
+4. no escape
+
+
+
+5. |escape('js')|escape('html')
+
+
+
+6. autoescape 'html' |escape('js')|escape('html')
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test
new file mode 100755
index 0000000..7821a9a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test
@@ -0,0 +1,131 @@
+--TEST--
+"autoescape" tag applies escaping after calling filters
+--TEMPLATE--
+{% autoescape 'html' %}
+
+(escape_and_nl2br is an escaper filter)
+
+1. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped )
+{{ var|escape_and_nl2br }}
+
+2. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped, |raw is redundant )
+{{ var|escape_and_nl2br|raw }}
+
+3. Explicit escape
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is explicitly escaped by |escape )
+{{ var|escape_and_nl2br|escape }}
+
+4. Escape non-escaper filter output
+( var is upper-cased by |upper,
+ the output is auto-escaped )
+{{ var|upper }}
+
+5. Escape if last filter is not an escaper
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is upper-cased by |upper,
+ the output is auto-escaped as |upper is not an escaper )
+{{ var|escape_and_nl2br|upper }}
+
+6. Don't escape escaper filter output
+( var is upper cased by upper,
+ the output is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped as |escape_and_nl2br is an escaper )
+{{ var|upper|escape_and_nl2br }}
+
+7. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ the output is auto-escaped )
+{{ "%s "|format(var) }}
+
+8. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ |raw is redundant,
+ the output is auto-escaped )
+{{ "%s "|raw|format(var) }}
+
+9. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end )
+{{ "%s "|format(var)|raw }}
+
+10. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end,
+ the |raw filter on var is redundant )
+{{ "%s "|format(var|raw)|raw }}
+
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig")
+--EXPECT--
+
+(escape_and_nl2br is an escaper filter)
+
+1. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped )
+<Fabien>
+Twig
+
+2. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped, |raw is redundant )
+<Fabien>
+Twig
+
+3. Explicit escape
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is explicitly escaped by |escape )
+<Fabien><br />
+Twig
+
+4. Escape non-escaper filter output
+( var is upper-cased by |upper,
+ the output is auto-escaped )
+<FABIEN>
+TWIG
+
+5. Escape if last filter is not an escaper
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is upper-cased by |upper,
+ the output is auto-escaped as |upper is not an escaper )
+<FABIEN><BR />
+TWIG
+
+6. Don't escape escaper filter output
+( var is upper cased by upper,
+ the output is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped as |escape_and_nl2br is an escaper )
+<FABIEN>
+TWIG
+
+7. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ the output is auto-escaped )
+<b><Fabien>
+Twig</b>
+
+8. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ |raw is redundant,
+ the output is auto-escaped )
+<b><Fabien>
+Twig</b>
+
+9. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end )
+
+Twig
+
+10. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end,
+ the |raw filter on var is redundant )
+
+Twig
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test
new file mode 100755
index 0000000..f58a1e0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test
@@ -0,0 +1,23 @@
+--TEST--
+"autoescape" tag do not applies escaping on filter arguments
+--TEMPLATE--
+{% autoescape 'html' %}
+{{ var|nl2br(" ") }}
+{{ var|nl2br(" "|escape) }}
+{{ var|nl2br(sep) }}
+{{ var|nl2br(sep|raw) }}
+{{ var|nl2br(sep|escape) }}
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig", 'sep' => ' ')
+--EXPECT--
+<Fabien>
+Twig
+<Fabien><br />
+Twig
+<Fabien>
+Twig
+<Fabien>
+Twig
+<Fabien><br />
+Twig
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test
new file mode 100755
index 0000000..134c77e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test
@@ -0,0 +1,68 @@
+--TEST--
+"autoescape" tag applies escaping after calling filters, and before calling pre_escape filters
+--TEMPLATE--
+{% autoescape 'html' %}
+
+(nl2br is pre_escaped for "html" and declared safe for "html")
+
+1. Pre-escape and don't post-escape
+( var|escape|nl2br )
+{{ var|nl2br }}
+
+2. Don't double-pre-escape
+( var|escape|nl2br )
+{{ var|escape|nl2br }}
+
+3. Don't escape safe values
+( var|raw|nl2br )
+{{ var|raw|nl2br }}
+
+4. Don't escape safe values
+( var|escape|nl2br|nl2br )
+{{ var|nl2br|nl2br }}
+
+5. Re-escape values that are escaped for an other contexts
+( var|escape_something|escape|nl2br )
+{{ var|escape_something|nl2br }}
+
+6. Still escape when using filters not declared safe
+( var|escape|nl2br|upper|escape )
+{{ var|nl2br|upper }}
+
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig")
+--EXPECT--
+
+(nl2br is pre_escaped for "html" and declared safe for "html")
+
+1. Pre-escape and don't post-escape
+( var|escape|nl2br )
+<Fabien>
+Twig
+
+2. Don't double-pre-escape
+( var|escape|nl2br )
+<Fabien>
+Twig
+
+3. Don't escape safe values
+( var|raw|nl2br )
+
+Twig
+
+4. Don't escape safe values
+( var|escape|nl2br|nl2br )
+<Fabien>
+Twig
+
+5. Re-escape values that are escaped for an other contexts
+( var|escape_something|escape|nl2br )
+<FABIEN>
+TWIG
+
+6. Still escape when using filters not declared safe
+( var|escape|nl2br|upper|escape )
+<FABIEN><BR />
+TWIG
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_preserves_safety_filters.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_preserves_safety_filters.test
new file mode 100755
index 0000000..32d3943
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_preserves_safety_filters.test
@@ -0,0 +1,50 @@
+--TEST--
+"autoescape" tag handles filters preserving the safety
+--TEMPLATE--
+{% autoescape 'html' %}
+
+(preserves_safety is preserving safety for "html")
+
+1. Unsafe values are still unsafe
+( var|preserves_safety|escape )
+{{ var|preserves_safety }}
+
+2. Safe values are still safe
+( var|escape|preserves_safety )
+{{ var|escape|preserves_safety }}
+
+3. Re-escape values that are escaped for an other contexts
+( var|escape_something|preserves_safety|escape )
+{{ var|escape_something|preserves_safety }}
+
+4. Still escape when using filters not declared safe
+( var|escape|preserves_safety|replace({'FABIEN': 'FABPOT'})|escape )
+{{ var|escape|preserves_safety|replace({'FABIEN': 'FABPOT'}) }}
+
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig")
+--EXPECT--
+
+(preserves_safety is preserving safety for "html")
+
+1. Unsafe values are still unsafe
+( var|preserves_safety|escape )
+<FABIEN>
+TWIG
+
+2. Safe values are still safe
+( var|escape|preserves_safety )
+<FABIEN>
+TWIG
+
+3. Re-escape values that are escaped for an other contexts
+( var|escape_something|preserves_safety|escape )
+<FABIEN>
+TWIG
+
+4. Still escape when using filters not declared safe
+( var|escape|preserves_safety|replace({'FABIEN': 'FABPOT'})|escape )
+<FABPOT>
+TWIG
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/basic.test
new file mode 100755
index 0000000..360dcf0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/basic.test
@@ -0,0 +1,11 @@
+--TEST--
+"block" tag
+--TEMPLATE--
+{% block title1 %}FOO{% endblock %}
+{% block title2 foo|lower %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array('foo' => 'bar')
+--EXPECT--
+FOObar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/block_unique_name.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/block_unique_name.test
new file mode 100755
index 0000000..5c205c0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/block_unique_name.test
@@ -0,0 +1,11 @@
+--TEST--
+"block" tag
+--TEMPLATE--
+{% block content %}
+ {% block content %}
+ {% endblock %}
+{% endblock %}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Syntax: The block 'content' has already been defined line 2 in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test
new file mode 100755
index 0000000..be17fed
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test
@@ -0,0 +1,10 @@
+--TEST--
+"§" special chars in a block name
+--TEMPLATE--
+{% block § %}
+§
+{% endblock § %}
+--DATA--
+return array()
+--EXPECT--
+§
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/basic.test
new file mode 100755
index 0000000..f44296e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/basic.test
@@ -0,0 +1,35 @@
+--TEST--
+"embed" tag
+--TEMPLATE--
+FOO
+{% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ block1extended
+ {% endblock %}
+{% endembed %}
+
+BAR
+--TEMPLATE(foo.twig)--
+A
+{% block c1 %}
+ block1
+{% endblock %}
+B
+{% block c2 %}
+ block2
+{% endblock %}
+C
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+A
+ block1
+
+ block1extended
+ B
+ block2
+C
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/error_line.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/error_line.test
new file mode 100755
index 0000000..71ab2e0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/error_line.test
@@ -0,0 +1,16 @@
+--TEST--
+"embed" tag
+--TEMPLATE(index.twig)--
+FOO
+{% embed "foo.twig" %}
+ {% block c1 %}
+ {{ nothing }}
+ {% endblock %}
+{% endembed %}
+BAR
+--TEMPLATE(foo.twig)--
+{% block c1 %}{% endblock %}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Runtime: Variable "nothing" does not exist in "index.twig" at line 5
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/multiple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/multiple.test
new file mode 100755
index 0000000..da161e6
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/multiple.test
@@ -0,0 +1,50 @@
+--TEST--
+"embed" tag
+--TEMPLATE--
+FOO
+{% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ block1extended
+ {% endblock %}
+{% endembed %}
+
+{% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ block1extended
+ {% endblock %}
+{% endembed %}
+
+BAR
+--TEMPLATE(foo.twig)--
+A
+{% block c1 %}
+ block1
+{% endblock %}
+B
+{% block c2 %}
+ block2
+{% endblock %}
+C
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+A
+ block1
+
+ block1extended
+ B
+ block2
+C
+
+A
+ block1
+
+ block1extended
+ B
+ block2
+C
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/nested.test
new file mode 100755
index 0000000..81563dc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/nested.test
@@ -0,0 +1,42 @@
+--TEST--
+"embed" tag
+--TEMPLATE--
+{% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ {% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ block1extended
+ {% endblock %}
+ {% endembed %}
+
+ {% endblock %}
+{% endembed %}
+--TEMPLATE(foo.twig)--
+A
+{% block c1 %}
+ block1
+{% endblock %}
+B
+{% block c2 %}
+ block2
+{% endblock %}
+C
+--DATA--
+return array()
+--EXPECT--
+A
+ block1
+
+
+A
+ block1
+
+ block1extended
+ B
+ block2
+C
+ B
+ block2
+C
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/with_extends.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/with_extends.test
new file mode 100755
index 0000000..cf7953d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/embed/with_extends.test
@@ -0,0 +1,57 @@
+--TEST--
+"embed" tag
+--TEMPLATE--
+{% extends "base.twig" %}
+
+{% block c1 %}
+ {{ parent() }}
+ blockc1baseextended
+{% endblock %}
+
+{% block c2 %}
+ {{ parent() }}
+
+ {% embed "foo.twig" %}
+ {% block c1 %}
+ {{ parent() }}
+ block1extended
+ {% endblock %}
+ {% endembed %}
+{% endblock %}
+--TEMPLATE(base.twig)--
+A
+{% block c1 %}
+ blockc1base
+{% endblock %}
+{% block c2 %}
+ blockc2base
+{% endblock %}
+B
+--TEMPLATE(foo.twig)--
+A
+{% block c1 %}
+ block1
+{% endblock %}
+B
+{% block c2 %}
+ block2
+{% endblock %}
+C
+--DATA--
+return array()
+--EXPECT--
+A
+ blockc1base
+
+ blockc1baseextended
+ blockc2base
+
+
+
+A
+ block1
+
+ block1extended
+ B
+ block2
+CB
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test
new file mode 100755
index 0000000..82094f2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test
@@ -0,0 +1,10 @@
+--TEST--
+"filter" tag applies a filter on its children
+--TEMPLATE--
+{% filter upper %}
+Some text with a {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'var')
+--EXPECT--
+SOME TEXT WITH A VAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test
new file mode 100755
index 0000000..3e7148b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test
@@ -0,0 +1,8 @@
+--TEST--
+"filter" tag applies a filter on its children
+--TEMPLATE--
+{% filter json_encode|raw %}test{% endfilter %}
+--DATA--
+return array()
+--EXPECT--
+"test"
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test
new file mode 100755
index 0000000..75512ef
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test
@@ -0,0 +1,10 @@
+--TEST--
+"filter" tags accept multiple chained filters
+--TEMPLATE--
+{% filter lower|title %}
+ {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'VAR')
+--EXPECT--
+ Var
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test
new file mode 100755
index 0000000..7e4e4eb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test
@@ -0,0 +1,16 @@
+--TEST--
+"filter" tags can be nested at will
+--TEMPLATE--
+{% filter lower|title %}
+ {{ var }}
+ {% filter upper %}
+ {{ var }}
+ {% endfilter %}
+ {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'var')
+--EXPECT--
+ Var
+ Var
+ Var
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test
new file mode 100755
index 0000000..22745ea
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test
@@ -0,0 +1,13 @@
+--TEST--
+"filter" tag applies the filter on "for" tags
+--TEMPLATE--
+{% filter upper %}
+{% for item in items %}
+{{ item }}
+{% endfor %}
+{% endfilter %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+A
+B
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test
new file mode 100755
index 0000000..afd95b2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test
@@ -0,0 +1,29 @@
+--TEST--
+"filter" tag applies the filter on "if" tags
+--TEMPLATE--
+{% filter upper %}
+{% if items %}
+{{ items|join(', ') }}
+{% endif %}
+
+{% if items.3 is defined %}
+FOO
+{% else %}
+{{ items.1 }}
+{% endif %}
+
+{% if items.3 is defined %}
+FOO
+{% elseif items.1 %}
+{{ items.0 }}
+{% endif %}
+
+{% endfilter %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+A, B
+
+B
+
+A
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/condition.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/condition.test
new file mode 100755
index 0000000..380531f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/condition.test
@@ -0,0 +1,14 @@
+--TEST--
+"for" tag takes a condition
+--TEMPLATE--
+{% for i in 1..5 if i is odd -%}
+ {{ loop.index }}.{{ i }}{{ foo.bar }}
+{% endfor %}
+--DATA--
+return array('foo' => array('bar' => 'X'))
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+1.1X
+2.3X
+3.5X
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/context.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/context.test
new file mode 100755
index 0000000..ddc6930
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/context.test
@@ -0,0 +1,18 @@
+--TEST--
+"for" tag keeps the context safe
+--TEMPLATE--
+{% for item in items %}
+ {% for item in items %}
+ * {{ item }}
+ {% endfor %}
+ * {{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
+ * a
+ * a
+ * b
+ * b
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/else.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/else.test
new file mode 100755
index 0000000..20ccc88
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/else.test
@@ -0,0 +1,23 @@
+--TEST--
+"for" tag can use an "else" clause
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+{% else %}
+ no item
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
+--DATA--
+return array('items' => array())
+--EXPECT--
+ no item
+--DATA--
+return array()
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+ no item
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test
new file mode 100755
index 0000000..49fb9ca
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test
@@ -0,0 +1,17 @@
+--TEST--
+"for" tag does not reset inner variables
+--TEMPLATE--
+{% for i in 1..2 %}
+ {% for j in 0..2 %}
+ {{k}}{% set k = k+1 %} {{ loop.parent.loop.index }}
+ {% endfor %}
+{% endfor %}
+--DATA--
+return array('k' => 0)
+--EXPECT--
+ 0 1
+ 1 1
+ 2 1
+ 3 2
+ 4 2
+ 5 2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys.test
new file mode 100755
index 0000000..4e22cb4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag can iterate over keys
+--TEMPLATE--
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 0
+ * 1
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test
new file mode 100755
index 0000000..4c21168
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag can iterate over keys and values
+--TEMPLATE--
+{% for key, item in items %}
+ * {{ key }}/{{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 0/a
+ * 1/b
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test
new file mode 100755
index 0000000..93bc76a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test
@@ -0,0 +1,19 @@
+--TEST--
+"for" tag adds a loop variable to the context
+--TEMPLATE--
+{% for item in items %}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.revindex }}/{{ loop.revindex0 }}
+ * {{ loop.first }}/{{ loop.last }}/{{ loop.length }}
+
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 1/0
+ * 2/1
+ * 1//2
+
+ * 2/1
+ * 1/0
+ * /1/2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test
new file mode 100755
index 0000000..58af2c3
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test
@@ -0,0 +1,10 @@
+--TEST--
+"for" tag adds a loop variable to the context locally
+--TEMPLATE--
+{% for item in items %}
+{% endfor %}
+{% if loop is not defined %}WORKS{% endif %}
+--DATA--
+return array('items' => array())
+--EXPECT--
+WORKS
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined.test
new file mode 100755
index 0000000..4301ef2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined.test
@@ -0,0 +1,10 @@
+--TEST--
+"for" tag
+--TEMPLATE--
+{% for i, item in items if i > 0 %}
+ {{ loop.last }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXCEPTION--
+Twig_Error_Syntax: The "loop.last" variable is not defined when looping with a condition in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined_cond.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined_cond.test
new file mode 100755
index 0000000..c7e723a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/loop_not_defined_cond.test
@@ -0,0 +1,9 @@
+--TEST--
+"for" tag
+--TEMPLATE--
+{% for i, item in items if loop.last > 0 %}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXCEPTION--
+Twig_Error_Syntax: The "loop" variable cannot be used in a looping condition in "index.twig" at line 2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test
new file mode 100755
index 0000000..f8b9f6b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test
@@ -0,0 +1,17 @@
+--TEST--
+"for" tag can use an "else" clause
+--TEMPLATE--
+{% for item in items %}
+ {% for item in items1 %}
+ * {{ item }}
+ {% else %}
+ no {{ item }}
+ {% endfor %}
+{% else %}
+ no item1
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'), 'items1' => array())
+--EXPECT--
+no a
+ no b
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects.test
new file mode 100755
index 0000000..5034437
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects.test
@@ -0,0 +1,43 @@
+--TEST--
+"for" tag iterates over iterable objects
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.first }}
+
+{% endfor %}
+
+{% for key, value in items %}
+ * {{ key }}/{{ value }}
+{% endfor %}
+
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+class ItemsIterator implements Iterator
+{
+ protected $values = array('foo' => 'bar', 'bar' => 'foo');
+ public function current() { return current($this->values); }
+ public function key() { return key($this->values); }
+ public function next() { return next($this->values); }
+ public function rewind() { return reset($this->values); }
+ public function valid() { return false !== current($this->values); }
+}
+return array('items' => new ItemsIterator())
+--EXPECT--
+ * bar
+ * 1/0
+ * 1
+
+ * foo
+ * 2/1
+ *
+
+
+ * foo/bar
+ * bar/foo
+
+ * foo
+ * bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test
new file mode 100755
index 0000000..4a1ff61
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test
@@ -0,0 +1,47 @@
+--TEST--
+"for" tag iterates over iterable and countable objects
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.revindex }}/{{ loop.revindex0 }}
+ * {{ loop.first }}/{{ loop.last }}/{{ loop.length }}
+
+{% endfor %}
+
+{% for key, value in items %}
+ * {{ key }}/{{ value }}
+{% endfor %}
+
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+class ItemsIteratorCountable implements Iterator, Countable
+{
+ protected $values = array('foo' => 'bar', 'bar' => 'foo');
+ public function current() { return current($this->values); }
+ public function key() { return key($this->values); }
+ public function next() { return next($this->values); }
+ public function rewind() { return reset($this->values); }
+ public function valid() { return false !== current($this->values); }
+ public function count() { return count($this->values); }
+}
+return array('items' => new ItemsIteratorCountable())
+--EXPECT--
+ * bar
+ * 1/0
+ * 2/1
+ * 1//2
+
+ * foo
+ * 2/1
+ * 1/0
+ * /1/2
+
+
+ * foo/bar
+ * bar/foo
+
+ * foo
+ * bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test
new file mode 100755
index 0000000..17b2e22
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test
@@ -0,0 +1,18 @@
+--TEST--
+"for" tags can be nested
+--TEMPLATE--
+{% for key, item in items %}
+* {{ key }} ({{ loop.length }}):
+{% for value in item %}
+ * {{ value }} ({{ loop.length }})
+{% endfor %}
+{% endfor %}
+--DATA--
+return array('items' => array('a' => array('a1', 'a2', 'a3'), 'b' => array('b1')))
+--EXPECT--
+* a (2):
+ * a1 (3)
+ * a2 (3)
+ * a3 (3)
+* b (2):
+ * b1 (1)
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/values.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/values.test
new file mode 100755
index 0000000..82f2ae8
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/for/values.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag iterates over item values
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/from.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/from.test
new file mode 100755
index 0000000..5f5da0e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/from.test
@@ -0,0 +1,14 @@
+--TEST--
+global variables
+--TEMPLATE--
+{% include "included.twig" %}
+{% from "included.twig" import foobar %}
+{{ foobar() }}
+--TEMPLATE(included.twig)--
+{% macro foobar() %}
+called foobar
+{% endmacro %}
+--DATA--
+return array();
+--EXPECT--
+called foobar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/basic.test
new file mode 100755
index 0000000..c1c3d27
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/basic.test
@@ -0,0 +1,22 @@
+--TEST--
+"if" creates a condition
+--TEMPLATE--
+{% if a is defined %}
+ {{ a }}
+{% elseif b is defined %}
+ {{ b }}
+{% else %}
+ NOTHING
+{% endif %}
+--DATA--
+return array('a' => 'a')
+--EXPECT--
+ a
+--DATA--
+return array('b' => 'b')
+--EXPECT--
+ b
+--DATA--
+return array()
+--EXPECT--
+ NOTHING
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/expression.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/expression.test
new file mode 100755
index 0000000..edfb73d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/if/expression.test
@@ -0,0 +1,22 @@
+--TEST--
+"if" takes an expression as a test
+--TEMPLATE--
+{% if a < 2 %}
+ A1
+{% elseif a > 10 %}
+ A2
+{% else %}
+ A3
+{% endif %}
+--DATA--
+return array('a' => 1)
+--EXPECT--
+ A1
+--DATA--
+return array('a' => 12)
+--EXPECT--
+ A2
+--DATA--
+return array('a' => 7)
+--EXPECT--
+ A3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/basic.test
new file mode 100755
index 0000000..8fe1a6c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/basic.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+FOO
+{% include "foo.twig" %}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+FOOBAR
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/expression.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/expression.test
new file mode 100755
index 0000000..eaeeb11
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/expression.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag allows expressions for the template to include
+--TEMPLATE--
+FOO
+{% include foo %}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array('foo' => 'foo.twig')
+--EXPECT--
+FOO
+
+FOOBAR
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test
new file mode 100755
index 0000000..24aed06
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% include ["foo.twig", "bar.twig"] ignore missing %}
+{% include "foo.twig" ignore missing %}
+{% include "foo.twig" ignore missing with {} %}
+{% include "foo.twig" ignore missing with {} only %}
+--DATA--
+return array()
+--EXPECT--
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing.test
new file mode 100755
index 0000000..f25e871
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing.test
@@ -0,0 +1,8 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% include "foo.twig" %}
+--DATA--
+return array();
+--EXCEPTION--
+Twig_Error_Loader: Template "foo.twig" is not defined in "index.twig" at line 2.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing_nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing_nested.test
new file mode 100755
index 0000000..86c1864
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/missing_nested.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% extends "base.twig" %}
+
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}
+ {% include "foo.twig" %}
+{% endblock %}
+--DATA--
+return array();
+--EXCEPTION--
+Twig_Error_Loader: Template "foo.twig" is not defined in "base.twig" at line 3.
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/only.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/only.test
new file mode 100755
index 0000000..77760a0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/only.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag accept variables and only
+--TEMPLATE--
+{% include "foo.twig" %}
+{% include "foo.twig" only %}
+{% include "foo.twig" with {'foo1': 'bar'} %}
+{% include "foo.twig" with {'foo1': 'bar'} only %}
+--TEMPLATE(foo.twig)--
+{% for k, v in _context %}{{ k }},{% endfor %}
+--DATA--
+return array('foo' => 'bar')
+--EXPECT--
+foo,global,_parent,
+global,_parent,
+foo,global,foo1,_parent,
+foo1,global,_parent,
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test
new file mode 100755
index 0000000..6ba064a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" tag accepts Twig_Template instance
+--TEMPLATE--
+{% include foo %} FOO
+--TEMPLATE(foo.twig)--
+BAR
+--DATA--
+return array('foo' => $twig->loadTemplate('foo.twig'))
+--EXPECT--
+BAR FOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test
new file mode 100755
index 0000000..ab670ee
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% include ["foo.twig", "bar.twig"] %}
+{% include ["bar.twig", "foo.twig"] %}
+--TEMPLATE(foo.twig)--
+foo
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test
new file mode 100755
index 0000000..41384ac
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" tag accept variables
+--TEMPLATE--
+{% include "foo.twig" with {'foo': 'bar'} %}
+{% include "foo.twig" with vars %}
+--TEMPLATE(foo.twig)--
+{{ foo }}
+--DATA--
+return array('vars' => array('foo' => 'bar'))
+--EXPECT--
+bar
+bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test
new file mode 100755
index 0000000..0778a4b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}
+FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+FOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr.test
new file mode 100755
index 0000000..9a81499
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr.test
@@ -0,0 +1,32 @@
+--TEST--
+block_expr
+--TEMPLATE--
+{% extends "base.twig" %}
+
+{% block element -%}
+ Element:
+ {{- parent() -}}
+{% endblock %}
+--TEMPLATE(base.twig)--
+{% spaceless %}
+{% block element -%}
+
+ {%- if item.children is defined %}
+ {%- for item in item.children %}
+ {{- block('element') -}}
+ {% endfor %}
+ {%- endif -%}
+
+{%- endblock %}
+{% endspaceless %}
+--DATA--
+return array(
+ 'item' => array(
+ 'children' => array(
+ null,
+ null,
+ )
+ )
+)
+--EXPECT--
+Element:
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr2.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr2.test
new file mode 100755
index 0000000..3e868c0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/block_expr2.test
@@ -0,0 +1,34 @@
+--TEST--
+block_expr2
+--TEMPLATE--
+{% extends "base2.twig" %}
+
+{% block element -%}
+ Element:
+ {{- parent() -}}
+{% endblock %}
+--TEMPLATE(base2.twig)--
+{% extends "base.twig" %}
+--TEMPLATE(base.twig)--
+{% spaceless %}
+{% block element -%}
+
+ {%- if item.children is defined %}
+ {%- for item in item.children %}
+ {{- block('element') -}}
+ {% endfor %}
+ {%- endif -%}
+
+{%- endblock %}
+{% endspaceless %}
+--DATA--
+return array(
+ 'item' => array(
+ 'children' => array(
+ null,
+ null,
+ )
+ )
+)
+--EXPECT--
+Element:
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test
new file mode 100755
index 0000000..8576e77
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends standalone ? foo : 'bar.twig' %}
+
+{% block content %}{{ parent() }}FOO{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}FOO{% endblock %}
+--TEMPLATE(bar.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array('foo' => 'foo.twig', 'standalone' => true)
+--EXPECT--
+FOOFOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test
new file mode 100755
index 0000000..ee06ddc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends foo %}
+
+{% block content %}
+FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array('foo' => 'foo.twig')
+--EXPECT--
+FOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/empty.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/empty.test
new file mode 100755
index 0000000..784f357
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/empty.test
@@ -0,0 +1,10 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+--TEMPLATE(foo.twig)--
+{% block content %}FOO{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+FOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test
new file mode 100755
index 0000000..a1cb1ce
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends ["foo.twig", "bar.twig"] %}
+--TEMPLATE(bar.twig)--
+{% block content %}
+foo
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_empty_name.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_empty_name.test
new file mode 100755
index 0000000..acc74f6
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_empty_name.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends ["", "bar.twig"] %}
+--TEMPLATE(bar.twig)--
+{% block content %}
+foo
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_null_name.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_null_name.test
new file mode 100755
index 0000000..cfa648d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array_with_null_name.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends [null, "bar.twig"] %}
+--TEMPLATE(bar.twig)--
+{% block content %}
+foo
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test
new file mode 100755
index 0000000..dfc2b6c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "layout.twig" %}{% block content %}{{ parent() }}index {% endblock %}
+--TEMPLATE(layout.twig)--
+{% extends "base.twig" %}{% block content %}{{ parent() }}layout {% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}base {% endblock %}
+--DATA--
+return array()
+--EXPECT--
+base layout index
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple_dynamic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple_dynamic.test
new file mode 100755
index 0000000..1d3e639
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple_dynamic.test
@@ -0,0 +1,22 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% set foo = 1 %}
+{{ include('parent.twig') }}
+{{ include('parent.twig') }}
+{% set foo = 2 %}
+{{ include('parent.twig') }}
+--TEMPLATE(parent.twig)--
+{% extends foo~'_parent.twig' %}{% block content %}{{ parent() }} parent{% endblock %}
+--TEMPLATE(1_parent.twig)--
+{% block content %}1{% endblock %}
+--TEMPLATE(2_parent.twig)--
+{% block content %}2{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+1 parent
+
+1 parent
+
+2 parent
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks.test
new file mode 100755
index 0000000..faca925
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks.test
@@ -0,0 +1,22 @@
+--TEST--
+"block" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}
+ {% block subcontent %}
+ {% block subsubcontent %}
+ SUBSUBCONTENT
+ {% endblock %}
+ {% endblock %}
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}
+ {% block subcontent %}
+ SUBCONTENT
+ {% endblock %}
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+SUBSUBCONTENT
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks_parent_only.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks_parent_only.test
new file mode 100755
index 0000000..0ad11d0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_blocks_parent_only.test
@@ -0,0 +1,15 @@
+--TEST--
+"block" tag
+--TEMPLATE--
+{% block content %}
+ CONTENT
+ {%- block subcontent -%}
+ SUBCONTENT
+ {%- endblock -%}
+ ENDCONTENT
+{% endblock %}
+--TEMPLATE(foo.twig)--
+--DATA--
+return array()
+--EXPECT--
+CONTENTSUBCONTENTENDCONTENT
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test
new file mode 100755
index 0000000..71e3cdf
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test
@@ -0,0 +1,16 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "layout.twig" %}
+{% block inside %}INSIDE{% endblock inside %}
+--TEMPLATE(layout.twig)--
+{% extends "base.twig" %}
+{% block body %}
+ {% block inside '' %}
+{% endblock body %}
+--TEMPLATE(base.twig)--
+{% block body '' %}
+--DATA--
+return array()
+--EXPECT--
+INSIDE
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test
new file mode 100755
index 0000000..4f975db
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}{{ parent() }}FOO{{ parent() }}{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+BARFOOBAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test
new file mode 100755
index 0000000..a8bc90c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test
@@ -0,0 +1,16 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends foo ? 'foo.twig' : 'bar.twig' %}
+--TEMPLATE(foo.twig)--
+FOO
+--TEMPLATE(bar.twig)--
+BAR
+--DATA--
+return array('foo' => true)
+--EXPECT--
+FOO
+--DATA--
+return array('foo' => false)
+--EXPECT--
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test
new file mode 100755
index 0000000..c9e86b1
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test
@@ -0,0 +1,8 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% block content %}
+ {% extends "foo.twig" %}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Cannot extend from a block in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test
new file mode 100755
index 0000000..6281671
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test
@@ -0,0 +1,20 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "base.twig" %}
+{% block content %}{% include "included.twig" %}{% endblock %}
+
+{% block footer %}Footer{% endblock %}
+--TEMPLATE(included.twig)--
+{% extends "base.twig" %}
+{% block content %}Included Content{% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}Default Content{% endblock %}
+
+{% block footer %}Default Footer{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+Included Content
+Default Footer
+Footer
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test
new file mode 100755
index 0000000..71e7c20
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test
@@ -0,0 +1,28 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}
+ {% block inside %}
+ INSIDE OVERRIDDEN
+ {% endblock %}
+
+ BEFORE
+ {{ parent() }}
+ AFTER
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}
+ BAR
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+
+INSIDE OVERRIDDEN
+
+ BEFORE
+ BAR
+
+ AFTER
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test
new file mode 100755
index 0000000..a9eaa4c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test
@@ -0,0 +1,8 @@
+--TEST--
+"parent" tag
+--TEMPLATE--
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Calling "parent" on a template that does not extend nor "use" another template is forbidden in "index.twig" at line 3
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test
new file mode 100755
index 0000000..63c7305
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test
@@ -0,0 +1,14 @@
+--TEST--
+"parent" tag
+--TEMPLATE--
+{% use 'foo.twig' %}
+
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+BAR
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test
new file mode 100755
index 0000000..d1876a5
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag accepts Twig_Template instance
+--TEMPLATE--
+{% extends foo %}
+
+{% block content %}
+{{ parent() }}FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array('foo' => $twig->loadTemplate('foo.twig'))
+--EXPECT--
+BARFOO
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test
new file mode 100755
index 0000000..8f9ece7
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test
@@ -0,0 +1,44 @@
+--TEST--
+"parent" function
+--TEMPLATE--
+{% extends "parent.twig" %}
+
+{% use "use1.twig" %}
+{% use "use2.twig" %}
+
+{% block content_parent %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content_use1 %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content_use2 %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content %}
+ {{ block('content_use1_only') }}
+ {{ block('content_use2_only') }}
+{% endblock %}
+--TEMPLATE(parent.twig)--
+{% block content_parent 'content_parent' %}
+{% block content_use1 'content_parent' %}
+{% block content_use2 'content_parent' %}
+{% block content '' %}
+--TEMPLATE(use1.twig)--
+{% block content_use1 'content_use1' %}
+{% block content_use2 'content_use1' %}
+{% block content_use1_only 'content_use1_only' %}
+--TEMPLATE(use2.twig)--
+{% block content_use2 'content_use2' %}
+{% block content_use2_only 'content_use2_only' %}
+--DATA--
+return array()
+--EXPECT--
+ content_parent
+ content_use1
+ content_use2
+ content_use1_only
+ content_use2_only
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test
new file mode 100755
index 0000000..eef0c10
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test
@@ -0,0 +1,17 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% import _self as macros %}
+
+{{ macros.input('username') }}
+{{ macros.input('password', null, 'password', 1) }}
+
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test
new file mode 100755
index 0000000..ae6203b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test
@@ -0,0 +1,16 @@
+--TEST--
+"macro" tag supports name for endmacro
+--TEMPLATE--
+{% import _self as macros %}
+
+{{ macros.foo() }}
+{{ macros.bar() }}
+
+{% macro foo() %}foo{% endmacro %}
+{% macro bar() %}bar{% endmacro bar %}
+--DATA--
+return array()
+--EXPECT--
+foo
+bar
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/external.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/external.test
new file mode 100755
index 0000000..5cd3dae
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/external.test
@@ -0,0 +1,17 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% import 'forms.twig' as forms %}
+
+{{ forms.input('username') }}
+{{ forms.input('password', null, 'password', 1) }}
+--TEMPLATE(forms.twig)--
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/from.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/from.test
new file mode 100755
index 0000000..205f591
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/from.test
@@ -0,0 +1,18 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% from 'forms.twig' import foo %}
+{% from 'forms.twig' import foo as foobar, bar %}
+
+{{ foo('foo') }}
+{{ foobar('foo') }}
+{{ bar('foo') }}
+--TEMPLATE(forms.twig)--
+{% macro foo(name) %}foo{{ name }}{% endmacro %}
+{% macro bar(name) %}bar{{ name }}{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+foofoo
+foofoo
+barfoo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/global.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/global.test
new file mode 100755
index 0000000..6b37176
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/global.test
@@ -0,0 +1,14 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% from 'forms.twig' import foo %}
+
+{{ foo('foo') }}
+{{ foo() }}
+--TEMPLATE(forms.twig)--
+{% macro foo(name) %}{{ name|default('foo') }}{{ global }}{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+fooglobal
+fooglobal
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test
new file mode 100755
index 0000000..17756cb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test
@@ -0,0 +1,17 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% import _self as forms %}
+
+{{ forms.input('username') }}
+{{ forms.input('password', null, 'password', 1) }}
+
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test
new file mode 100755
index 0000000..3721770
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test
@@ -0,0 +1,14 @@
+--TEST--
+"§" as a macro name
+--TEMPLATE--
+{% import _self as macros %}
+
+{{ macros.§('foo') }}
+
+{% macro §(foo) %}
+ §{{ foo }}§
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+§foo§
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/super_globals.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/super_globals.test
new file mode 100755
index 0000000..5679462
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/macro/super_globals.test
@@ -0,0 +1,14 @@
+--TEST--
+Super globals as macro arguments
+--TEMPLATE--
+{% import _self as macros %}
+
+{{ macros.foo('foo') }}
+
+{% macro foo(GET) %}
+ {{ GET }}
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test
new file mode 100755
index 0000000..0445e85
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test
@@ -0,0 +1,10 @@
+--TEST--
+"raw" tag
+--TEMPLATE--
+{% raw %}
+{{ foo }}
+{% endraw %}
+--DATA--
+return array()
+--EXPECT--
+{{ foo }}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/mixed_usage_with_raw.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/mixed_usage_with_raw.test
new file mode 100755
index 0000000..2fd9fb2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/mixed_usage_with_raw.test
@@ -0,0 +1,10 @@
+--TEST--
+"raw" tag
+--TEMPLATE--
+{% raw %}
+{{ foo }}
+{% endverbatim %}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Syntax: Unexpected end of file: Unclosed "raw" block in "index.twig" at line 2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test
new file mode 100755
index 0000000..352bb18
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test
@@ -0,0 +1,56 @@
+--TEST--
+"raw" tag
+--TEMPLATE--
+1***
+
+{%- raw %}
+ {{ 'bla' }}
+{% endraw %}
+
+1***
+2***
+
+{%- raw -%}
+ {{ 'bla' }}
+{% endraw %}
+
+2***
+3***
+
+{%- raw -%}
+ {{ 'bla' }}
+{% endraw -%}
+
+3***
+4***
+
+{%- raw -%}
+ {{ 'bla' }}
+{%- endraw %}
+
+4***
+5***
+
+{%- raw -%}
+ {{ 'bla' }}
+{%- endraw -%}
+
+5***
+--DATA--
+return array()
+--EXPECT--
+1***
+ {{ 'bla' }}
+
+
+1***
+2***{{ 'bla' }}
+
+
+2***
+3***{{ 'bla' }}
+3***
+4***{{ 'bla' }}
+
+4***
+5***{{ 'bla' }}5***
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid1.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid1.test
new file mode 100755
index 0000000..683c59a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid1.test
@@ -0,0 +1,11 @@
+--TEST--
+sandbox tag
+--TEMPLATE--
+{%- sandbox %}
+ {%- include "foo.twig" %}
+ a
+{%- endsandbox %}
+--TEMPLATE(foo.twig)--
+foo
+--EXCEPTION--
+Twig_Error_Syntax: Only "include" tags are allowed within a "sandbox" section in "index.twig" at line 4
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid2.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid2.test
new file mode 100755
index 0000000..3dcfa88
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/not_valid2.test
@@ -0,0 +1,14 @@
+--TEST--
+sandbox tag
+--TEMPLATE--
+{%- sandbox %}
+ {%- include "foo.twig" %}
+
+ {% if 1 %}
+ {%- include "foo.twig" %}
+ {% endif %}
+{%- endsandbox %}
+--TEMPLATE(foo.twig)--
+foo
+--EXCEPTION--
+Twig_Error_Syntax: Only "include" tags are allowed within a "sandbox" section in "index.twig" at line 5
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/simple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/simple.test
new file mode 100755
index 0000000..de20f3d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/sandbox/simple.test
@@ -0,0 +1,22 @@
+--TEST--
+sandbox tag
+--TEMPLATE--
+{%- sandbox %}
+ {%- include "foo.twig" %}
+{%- endsandbox %}
+
+{%- sandbox %}
+ {%- include "foo.twig" %}
+ {%- include "foo.twig" %}
+{%- endsandbox %}
+
+{%- sandbox %}{% include "foo.twig" %}{% endsandbox %}
+--TEMPLATE(foo.twig)--
+foo
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
+foo
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/basic.test
new file mode 100755
index 0000000..a5a9f83
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/basic.test
@@ -0,0 +1,20 @@
+--TEST--
+"set" tag
+--TEMPLATE--
+{% set foo = 'foo' %}
+{% set bar = 'foo ' %}
+
+{{ foo }}
+{{ bar }}
+
+{% set foo, bar = 'foo', 'bar' %}
+
+{{ foo }}{{ bar }}
+--DATA--
+return array()
+--EXPECT--
+foo
+foo<br />
+
+
+foobar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test
new file mode 100755
index 0000000..ec657f0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test
@@ -0,0 +1,9 @@
+--TEST--
+"set" tag block empty capture
+--TEMPLATE--
+{% set foo %}{% endset %}
+
+{% if foo %}FAIL{% endif %}
+--DATA--
+return array()
+--EXPECT--
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture.test
new file mode 100755
index 0000000..f156a1a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/capture.test
@@ -0,0 +1,10 @@
+--TEST--
+"set" tag block capture
+--TEMPLATE--
+{% set foo %}f o o{% endset %}
+
+{{ foo }}
+--DATA--
+return array()
+--EXPECT--
+f o o
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/expression.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/expression.test
new file mode 100755
index 0000000..8ff434a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/set/expression.test
@@ -0,0 +1,12 @@
+--TEST--
+"set" tag
+--TEMPLATE--
+{% set foo, bar = 'foo' ~ 'bar', 'bar' ~ 'foo' %}
+
+{{ foo }}
+{{ bar }}
+--DATA--
+return array()
+--EXPECT--
+foobar
+barfoo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test
new file mode 100755
index 0000000..dd06dec
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test
@@ -0,0 +1,12 @@
+--TEST--
+"spaceless" tag removes whites between HTML tags
+--TEMPLATE--
+{% spaceless %}
+
+
+
+{% endspaceless %}
+--DATA--
+return array()
+--EXPECT--
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/special_chars.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/special_chars.test
new file mode 100755
index 0000000..789b4ba
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"§" custom tag
+--TEMPLATE--
+{% § %}
+--DATA--
+return array()
+--EXPECT--
+§
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/trim_block.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/trim_block.test
new file mode 100755
index 0000000..1d2273f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/trim_block.test
@@ -0,0 +1,74 @@
+--TEST--
+Whitespace trimming on tags.
+--TEMPLATE--
+{{ 5 * '{#-'|length }}
+{{ '{{-'|length * 5 + '{%-'|length }}
+
+Trim on control tag:
+{% for i in range(1, 9) -%}
+ {{ i }}
+{%- endfor %}
+
+
+Trim on output tag:
+{% for i in range(1, 9) %}
+ {{- i -}}
+{% endfor %}
+
+
+Trim comments:
+
+{#- Invisible -#}
+
+After the comment.
+
+Trim leading space:
+{% if leading %}
+
+ {{- leading }}
+{% endif %}
+
+{%- if leading %}
+ {{- leading }}
+
+{%- endif %}
+
+
+Trim trailing space:
+{% if trailing -%}
+ {{ trailing -}}
+
+{% endif -%}
+
+Combined:
+
+{%- if both -%}
+
+
+{%- endif -%}
+
+end
+--DATA--
+return array('leading' => 'leading space', 'trailing' => 'trailing space', 'both' => 'both')
+--EXPECT--
+15
+18
+
+Trim on control tag:
+123456789
+
+Trim on output tag:
+123456789
+
+Trim comments:After the comment.
+
+Trim leading space:
+leading space
+leading space
+
+Trim trailing space:
+trailing spaceCombined:end
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test
new file mode 100755
index 0000000..f887006
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test
@@ -0,0 +1,12 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "blocks.twig" with content as foo %}
+
+{{ block('foo') }}
+--TEMPLATE(blocks.twig)--
+{% block content 'foo' %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/basic.test
new file mode 100755
index 0000000..7364d76
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/basic.test
@@ -0,0 +1,12 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "blocks.twig" %}
+
+{{ block('content') }}
+--TEMPLATE(blocks.twig)--
+{% block content 'foo' %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep.test
new file mode 100755
index 0000000..b551a1e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep.test
@@ -0,0 +1,22 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+--TEMPLATE(foo.twig)--
+{% use "bar.twig" %}
+
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
+bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test
new file mode 100755
index 0000000..05cca68
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test
@@ -0,0 +1,10 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+--TEMPLATE(foo.twig)--
+{% use "bar.twig" %}
+--TEMPLATE(bar.twig)--
+--DATA--
+return array()
+--EXPECT--
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance.test
new file mode 100755
index 0000000..6368b08
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance.test
@@ -0,0 +1,25 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "parent.twig" %}
+
+{{ block('container') }}
+--TEMPLATE(parent.twig)--
+{% use "ancestor.twig" %}
+
+{% block sub_container %}
+ overriden sub_container
+{% endblock %}
+--TEMPLATE(ancestor.twig)--
+{% block container %}
+ {{ block('sub_container') }}
+{% endblock %}
+
+{% block sub_container %}
+ sub_container
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+ overriden sub_container
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance2.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance2.test
new file mode 100755
index 0000000..114e301
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/inheritance2.test
@@ -0,0 +1,24 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "ancestor.twig" %}
+{% use "parent.twig" %}
+
+{{ block('container') }}
+--TEMPLATE(parent.twig)--
+{% block sub_container %}
+ overriden sub_container
+{% endblock %}
+--TEMPLATE(ancestor.twig)--
+{% block container %}
+ {{ block('sub_container') }}
+{% endblock %}
+
+{% block sub_container %}
+ sub_container
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+ overriden sub_container
+
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test
new file mode 100755
index 0000000..198be0c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test
@@ -0,0 +1,21 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+{% use "bar.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+--TEMPLATE(foo.twig)--
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+bar
+foo
+bar
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test
new file mode 100755
index 0000000..8de871a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test
@@ -0,0 +1,23 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" with content as foo_content %}
+{% use "bar.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+{{ block('foo_content') }}
+--TEMPLATE(foo.twig)--
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+bar
+foo
+bar
+foo
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block.test
new file mode 100755
index 0000000..59db23d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block.test
@@ -0,0 +1,24 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use 'file2.html.twig' with foobar as base_base_foobar %}
+{% block foobar %}
+ {{- block('base_base_foobar') -}}
+ Content of block (second override)
+{% endblock foobar %}
+--TEMPLATE(file2.html.twig)--
+{% use 'file1.html.twig' with foobar as base_foobar %}
+{% block foobar %}
+ {{- block('base_foobar') -}}
+ Content of block (first override)
+{% endblock foobar %}
+--TEMPLATE(file1.html.twig)--
+{% block foobar -%}
+ Content of block
+{% endblock foobar %}
+--DATA--
+return array()
+--EXPECT--
+Content of block
+Content of block (first override)
+Content of block (second override)
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block2.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block2.test
new file mode 100755
index 0000000..d3f302d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block2.test
@@ -0,0 +1,24 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use 'file2.html.twig'%}
+{% block foobar %}
+ {{- parent() -}}
+ Content of block (second override)
+{% endblock foobar %}
+--TEMPLATE(file2.html.twig)--
+{% use 'file1.html.twig' %}
+{% block foobar %}
+ {{- parent() -}}
+ Content of block (first override)
+{% endblock foobar %}
+--TEMPLATE(file1.html.twig)--
+{% block foobar -%}
+ Content of block
+{% endblock foobar %}
+--DATA--
+return array()
+--EXPECT--
+Content of block
+Content of block (first override)
+Content of block (second override)
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block3.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block3.test
new file mode 100755
index 0000000..95b55a4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/use/parent_block3.test
@@ -0,0 +1,38 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use 'file2.html.twig' %}
+{% use 'file1.html.twig' with foo %}
+{% block foo %}
+ {{- parent() -}}
+ Content of foo (second override)
+{% endblock foo %}
+{% block bar %}
+ {{- parent() -}}
+ Content of bar (second override)
+{% endblock bar %}
+--TEMPLATE(file2.html.twig)--
+{% use 'file1.html.twig' %}
+{% block foo %}
+ {{- parent() -}}
+ Content of foo (first override)
+{% endblock foo %}
+{% block bar %}
+ {{- parent() -}}
+ Content of bar (first override)
+{% endblock bar %}
+--TEMPLATE(file1.html.twig)--
+{% block foo -%}
+ Content of foo
+{% endblock foo %}
+{% block bar -%}
+ Content of bar
+{% endblock bar %}
+--DATA--
+return array()
+--EXPECT--
+Content of foo
+Content of foo (first override)
+Content of foo (second override)
+Content of bar
+Content of bar (second override)
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/basic.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/basic.test
new file mode 100755
index 0000000..a95be55
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/basic.test
@@ -0,0 +1,10 @@
+--TEST--
+"verbatim" tag
+--TEMPLATE--
+{% verbatim %}
+{{ foo }}
+{% endverbatim %}
+--DATA--
+return array()
+--EXPECT--
+{{ foo }}
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/mixed_usage_with_raw.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/mixed_usage_with_raw.test
new file mode 100755
index 0000000..941dddc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/mixed_usage_with_raw.test
@@ -0,0 +1,10 @@
+--TEST--
+"verbatim" tag
+--TEMPLATE--
+{% verbatim %}
+{{ foo }}
+{% endraw %}
+--DATA--
+return array()
+--EXCEPTION--
+Twig_Error_Syntax: Unexpected end of file: Unclosed "verbatim" block in "index.twig" at line 2
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/whitespace_control.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/whitespace_control.test
new file mode 100755
index 0000000..eb61044
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tags/verbatim/whitespace_control.test
@@ -0,0 +1,56 @@
+--TEST--
+"verbatim" tag
+--TEMPLATE--
+1***
+
+{%- verbatim %}
+ {{ 'bla' }}
+{% endverbatim %}
+
+1***
+2***
+
+{%- verbatim -%}
+ {{ 'bla' }}
+{% endverbatim %}
+
+2***
+3***
+
+{%- verbatim -%}
+ {{ 'bla' }}
+{% endverbatim -%}
+
+3***
+4***
+
+{%- verbatim -%}
+ {{ 'bla' }}
+{%- endverbatim %}
+
+4***
+5***
+
+{%- verbatim -%}
+ {{ 'bla' }}
+{%- endverbatim -%}
+
+5***
+--DATA--
+return array()
+--EXPECT--
+1***
+ {{ 'bla' }}
+
+
+1***
+2***{{ 'bla' }}
+
+
+2***
+3***{{ 'bla' }}
+3***
+4***{{ 'bla' }}
+
+4***
+5***{{ 'bla' }}5***
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/array.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/array.test
new file mode 100755
index 0000000..1429d37
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/array.test
@@ -0,0 +1,24 @@
+--TEST--
+array index test
+--TEMPLATE--
+{% for key, value in days %}
+{{ key }}
+{% endfor %}
+--DATA--
+return array('days' => array(
+ 1 => array('money' => 9),
+ 2 => array('money' => 21),
+ 3 => array('money' => 38),
+ 4 => array('money' => 6),
+ 18 => array('money' => 6),
+ 19 => array('money' => 3),
+ 31 => array('money' => 11),
+));
+--EXPECT--
+1
+2
+3
+4
+18
+19
+31
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/constant.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/constant.test
new file mode 100755
index 0000000..60218ac
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/constant.test
@@ -0,0 +1,14 @@
+--TEST--
+"const" test
+--TEMPLATE--
+{{ 8 is constant('E_NOTICE') ? 'ok' : 'no' }}
+{{ 'bar' is constant('TwigTestFoo::BAR_NAME') ? 'ok' : 'no' }}
+{{ value is constant('TwigTestFoo::BAR_NAME') ? 'ok' : 'no' }}
+{{ 2 is constant('ARRAY_AS_PROPS', object) ? 'ok' : 'no' }}
+--DATA--
+return array('value' => 'bar', 'object' => new ArrayObject(array('hi')));
+--EXPECT--
+ok
+ok
+ok
+ok
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/defined.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/defined.test
new file mode 100755
index 0000000..cbfe03d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/defined.test
@@ -0,0 +1,108 @@
+--TEST--
+"defined" test
+--TEMPLATE--
+{{ definedVar is defined ? 'ok' : 'ko' }}
+{{ definedVar is not defined ? 'ko' : 'ok' }}
+{{ undefinedVar is defined ? 'ko' : 'ok' }}
+{{ undefinedVar is not defined ? 'ok' : 'ko' }}
+{{ zeroVar is defined ? 'ok' : 'ko' }}
+{{ nullVar is defined ? 'ok' : 'ko' }}
+{{ nested.definedVar is defined ? 'ok' : 'ko' }}
+{{ nested['definedVar'] is defined ? 'ok' : 'ko' }}
+{{ nested.definedVar is not defined ? 'ko' : 'ok' }}
+{{ nested.undefinedVar is defined ? 'ko' : 'ok' }}
+{{ nested['undefinedVar'] is defined ? 'ko' : 'ok' }}
+{{ nested.undefinedVar is not defined ? 'ok' : 'ko' }}
+{{ nested.zeroVar is defined ? 'ok' : 'ko' }}
+{{ nested.nullVar is defined ? 'ok' : 'ko' }}
+{{ nested.definedArray.0 is defined ? 'ok' : 'ko' }}
+{{ nested['definedArray'][0] is defined ? 'ok' : 'ko' }}
+{{ object.foo is defined ? 'ok' : 'ko' }}
+{{ object.undefinedMethod is defined ? 'ko' : 'ok' }}
+{{ object.getFoo() is defined ? 'ok' : 'ko' }}
+{{ object.getFoo('a') is defined ? 'ok' : 'ko' }}
+{{ object.undefinedMethod() is defined ? 'ko' : 'ok' }}
+{{ object.undefinedMethod('a') is defined ? 'ko' : 'ok' }}
+{{ object.self.foo is defined ? 'ok' : 'ko' }}
+{{ object.self.undefinedMethod is defined ? 'ko' : 'ok' }}
+{{ object.undefinedMethod.self is defined ? 'ko' : 'ok' }}
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new TwigTestFoo(),
+);
+--EXPECT--
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new TwigTestFoo(),
+);
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/empty.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/empty.test
new file mode 100755
index 0000000..a776d03
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/empty.test
@@ -0,0 +1,45 @@
+--TEST--
+"empty" test
+--TEMPLATE--
+{{ foo is empty ? 'ok' : 'ko' }}
+{{ bar is empty ? 'ok' : 'ko' }}
+{{ foobar is empty ? 'ok' : 'ko' }}
+{{ array is empty ? 'ok' : 'ko' }}
+{{ zero is empty ? 'ok' : 'ko' }}
+{{ string is empty ? 'ok' : 'ko' }}
+{{ countable_empty is empty ? 'ok' : 'ko' }}
+{{ countable_not_empty is empty ? 'ok' : 'ko' }}
+{{ markup_empty is empty ? 'ok' : 'ko' }}
+{{ markup_not_empty is empty ? 'ok' : 'ko' }}
+--DATA--
+
+class CountableStub implements Countable
+{
+ private $items;
+
+ public function __construct(array $items)
+ {
+ $this->items = $items;
+ }
+
+ public function count()
+ {
+ return count($this->items);
+ }
+}
+return array(
+ 'foo' => '', 'bar' => null, 'foobar' => false, 'array' => array(), 'zero' => 0, 'string' => '0',
+ 'countable_empty' => new CountableStub(array()), 'countable_not_empty' => new CountableStub(array(1, 2)),
+ 'markup_empty' => new Twig_Markup('', 'UTF-8'), 'markup_not_empty' => new Twig_Markup('test', 'UTF-8'),
+);
+--EXPECT--
+ok
+ok
+ok
+ok
+ko
+ko
+ok
+ko
+ok
+ko
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/even.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/even.test
new file mode 100755
index 0000000..695b4c2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/even.test
@@ -0,0 +1,14 @@
+--TEST--
+"even" test
+--TEMPLATE--
+{{ 1 is even ? 'ko' : 'ok' }}
+{{ 2 is even ? 'ok' : 'ko' }}
+{{ 1 is not even ? 'ok' : 'ko' }}
+{{ 2 is not even ? 'ko' : 'ok' }}
+--DATA--
+return array()
+--EXPECT--
+ok
+ok
+ok
+ok
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in.test
new file mode 100755
index 0000000..545f51f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in.test
@@ -0,0 +1,128 @@
+--TEST--
+Twig supports the in operator
+--TEMPLATE--
+{% if bar in foo %}
+TRUE
+{% endif %}
+{% if not (bar in foo) %}
+{% else %}
+TRUE
+{% endif %}
+{% if bar not in foo %}
+{% else %}
+TRUE
+{% endif %}
+{% if 'a' in bar %}
+TRUE
+{% endif %}
+{% if 'c' not in bar %}
+TRUE
+{% endif %}
+{% if '' in bar %}
+TRUE
+{% endif %}
+{% if '' in '' %}
+TRUE
+{% endif %}
+{% if '0' not in '' %}
+TRUE
+{% endif %}
+{% if 'a' not in '0' %}
+TRUE
+{% endif %}
+{% if '0' in '0' %}
+TRUE
+{% endif %}
+
+{{ false in [0, 1] ? 'TRUE' : 'FALSE' }}
+{{ true in [0, 1] ? 'TRUE' : 'FALSE' }}
+{{ '0' in [0, 1] ? 'TRUE' : 'FALSE' }}
+{{ '' in [0, 1] ? 'TRUE' : 'FALSE' }}
+{{ 0 in ['', 1] ? 'TRUE' : 'FALSE' }}
+
+{{ '' in 'foo' ? 'TRUE' : 'FALSE' }}
+{{ 0 in 'foo' ? 'TRUE' : 'FALSE' }}
+{{ false in 'foo' ? 'TRUE' : 'FALSE' }}
+{{ false in '100' ? 'TRUE' : 'FALSE' }}
+{{ true in '100' ? 'TRUE' : 'FALSE' }}
+
+{{ [] in [true, false] ? 'TRUE' : 'FALSE' }}
+{{ [] in [true, ''] ? 'TRUE' : 'FALSE' }}
+{{ [] in [true, []] ? 'TRUE' : 'FALSE' }}
+
+{{ resource ? 'TRUE' : 'FALSE' }}
+{{ resource in 'foo'~resource ? 'TRUE' : 'FALSE' }}
+{{ object in 'stdClass' ? 'TRUE' : 'FALSE' }}
+{{ [] in 'Array' ? 'TRUE' : 'FALSE' }}
+{{ dir_object in 'foo'~dir_object ? 'TRUE' : 'FALSE' }}
+
+{{ ''~resource in resource ? 'TRUE' : 'FALSE' }}
+{{ 'stdClass' in object ? 'TRUE' : 'FALSE' }}
+{{ 'Array' in [] ? 'TRUE' : 'FALSE' }}
+{{ ''~dir_object in dir_object ? 'TRUE' : 'FALSE' }}
+
+{{ resource in [''~resource] ? 'TRUE' : 'FALSE' }}
+{{ resource in [resource + 1 - 1] ? 'TRUE' : 'FALSE' }}
+{{ dir_object in [''~dir_object] ? 'TRUE' : 'FALSE' }}
+
+{{ 5 in 125 ? 'TRUE' : 'FALSE' }}
+{{ 5 in '125' ? 'TRUE' : 'FALSE' }}
+{{ '5' in 125 ? 'TRUE' : 'FALSE' }}
+{{ '5' in '125' ? 'TRUE' : 'FALSE' }}
+
+{{ 5.5 in 125.5 ? 'TRUE' : 'FALSE' }}
+{{ 5.5 in '125.5' ? 'TRUE' : 'FALSE' }}
+{{ '5.5' in 125.5 ? 'TRUE' : 'FALSE' }}
+--DATA--
+return array('bar' => 'bar', 'foo' => array('bar' => 'bar'), 'dir_object' => new SplFileInfo(dirname(__FILE__)), 'object' => new stdClass(), 'resource' => opendir(dirname(__FILE__)))
+--EXPECT--
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+
+TRUE
+FALSE
+FALSE
+FALSE
+FALSE
+
+TRUE
+FALSE
+TRUE
+
+TRUE
+FALSE
+FALSE
+FALSE
+FALSE
+
+FALSE
+FALSE
+FALSE
+FALSE
+
+FALSE
+FALSE
+FALSE
+
+FALSE
+TRUE
+FALSE
+TRUE
+
+FALSE
+TRUE
+FALSE
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in_with_objects.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in_with_objects.test
new file mode 100755
index 0000000..8e08061
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/in_with_objects.test
@@ -0,0 +1,19 @@
+--TEST--
+Twig supports the in operator when using objects
+--TEMPLATE--
+{% if object in object_list %}
+TRUE
+{% endif %}
+--DATA--
+$foo = new TwigTestFoo();
+$foo1 = new TwigTestFoo();
+
+$foo->position = $foo1;
+$foo1->position = $foo;
+
+return array(
+ 'object' => $foo,
+ 'object_list' => array($foo1, $foo),
+);
+--EXPECT--
+TRUE
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/iterable.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/iterable.test
new file mode 100755
index 0000000..ec52550
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/iterable.test
@@ -0,0 +1,19 @@
+--TEST--
+"iterable" test
+--TEMPLATE--
+{{ foo is iterable ? 'ok' : 'ko' }}
+{{ traversable is iterable ? 'ok' : 'ko' }}
+{{ obj is iterable ? 'ok' : 'ko' }}
+{{ val is iterable ? 'ok' : 'ko' }}
+--DATA--
+return array(
+ 'foo' => array(),
+ 'traversable' => new ArrayIterator(array()),
+ 'obj' => new stdClass(),
+ 'val' => 'test',
+);
+--EXPECT--
+ok
+ok
+ko
+ko
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/odd.test b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/odd.test
new file mode 100755
index 0000000..1b8311e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Fixtures/tests/odd.test
@@ -0,0 +1,10 @@
+--TEST--
+"odd" test
+--TEMPLATE--
+{{ 1 is odd ? 'ok' : 'ko' }}
+{{ 2 is odd ? 'ko' : 'ok' }}
+--DATA--
+return array()
+--EXPECT--
+ok
+ok
\ No newline at end of file
diff --git a/vendor/twig/twig/test/Twig/Tests/IntegrationTest.php b/vendor/twig/twig/test/Twig/Tests/IntegrationTest.php
new file mode 100755
index 0000000..70f9b80
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/IntegrationTest.php
@@ -0,0 +1,229 @@
+position = 0;
+ }
+
+ public function current()
+ {
+ return $this->array[$this->position];
+ }
+
+ public function key()
+ {
+ return 'a';
+ }
+
+ public function next()
+ {
+ ++$this->position;
+ }
+
+ public function valid()
+ {
+ return isset($this->array[$this->position]);
+ }
+}
+
+class TwigTestTokenParser_§ extends Twig_TokenParser
+{
+ public function parse(Twig_Token $token)
+ {
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Print(new Twig_Node_Expression_Constant('§', -1), -1);
+ }
+
+ public function getTag()
+ {
+ return '§';
+ }
+}
+
+class TwigTestExtension extends Twig_Extension
+{
+ public function getTokenParsers()
+ {
+ return array(
+ new TwigTestTokenParser_§(),
+ );
+ }
+
+ public function getFilters()
+ {
+ return array(
+ new Twig_SimpleFilter('§', array($this, '§Filter')),
+ new Twig_SimpleFilter('escape_and_nl2br', array($this, 'escape_and_nl2br'), array('needs_environment' => true, 'is_safe' => array('html'))),
+ new Twig_SimpleFilter('nl2br', array($this, 'nl2br'), array('pre_escape' => 'html', 'is_safe' => array('html'))),
+ new Twig_SimpleFilter('escape_something', array($this, 'escape_something'), array('is_safe' => array('something'))),
+ new Twig_SimpleFilter('preserves_safety', array($this, 'preserves_safety'), array('preserves_safety' => array('html'))),
+ new Twig_SimpleFilter('*_path', array($this, 'dynamic_path')),
+ new Twig_SimpleFilter('*_foo_*_bar', array($this, 'dynamic_foo')),
+ );
+ }
+
+ public function getFunctions()
+ {
+ return array(
+ new Twig_SimpleFunction('§', array($this, '§Function')),
+ new Twig_SimpleFunction('safe_br', array($this, 'br'), array('is_safe' => array('html'))),
+ new Twig_SimpleFunction('unsafe_br', array($this, 'br')),
+ new Twig_SimpleFunction('*_path', array($this, 'dynamic_path')),
+ new Twig_SimpleFunction('*_foo_*_bar', array($this, 'dynamic_foo')),
+ );
+ }
+
+ public function getTests()
+ {
+ return array(
+ new Twig_SimpleTest('multi word', array($this, 'is_multi_word')),
+ );
+ }
+
+ public function §Filter($value)
+ {
+ return "§{$value}§";
+ }
+
+ public function §Function($value)
+ {
+ return "§{$value}§";
+ }
+
+ /**
+ * nl2br which also escapes, for testing escaper filters
+ */
+ public function escape_and_nl2br($env, $value, $sep = ' ')
+ {
+ return $this->nl2br(twig_escape_filter($env, $value, 'html'), $sep);
+ }
+
+ /**
+ * nl2br only, for testing filters with pre_escape
+ */
+ public function nl2br($value, $sep = ' ')
+ {
+ // not secure if $value contains html tags (not only entities)
+ // don't use
+ return str_replace("\n", "$sep\n", $value);
+ }
+
+ public function dynamic_path($element, $item)
+ {
+ return $element.'/'.$item;
+ }
+
+ public function dynamic_foo($foo, $bar, $item)
+ {
+ return $foo.'/'.$bar.'/'.$item;
+ }
+
+ public function escape_something($value)
+ {
+ return strtoupper($value);
+ }
+
+ public function preserves_safety($value)
+ {
+ return strtoupper($value);
+ }
+
+ public function br()
+ {
+ return ' ';
+ }
+
+ public function is_multi_word($value)
+ {
+ return false !== strpos($value, ' ');
+ }
+
+ public function getName()
+ {
+ return 'integration_test';
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/LexerTest.php b/vendor/twig/twig/test/Twig/Tests/LexerTest.php
new file mode 100755
index 0000000..4ef58e5
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/LexerTest.php
@@ -0,0 +1,300 @@
+tokenize($template);
+
+ $stream->expect(Twig_Token::BLOCK_START_TYPE);
+ $this->assertSame('§', $stream->expect(Twig_Token::NAME_TYPE)->getValue());
+ }
+
+ public function testNameLabelForFunction()
+ {
+ $template = '{{ §() }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $this->assertSame('§', $stream->expect(Twig_Token::NAME_TYPE)->getValue());
+ }
+
+ public function testBracketsNesting()
+ {
+ $template = '{{ {"a":{"b":"c"}} }}';
+
+ $this->assertEquals(2, $this->countToken($template, Twig_Token::PUNCTUATION_TYPE, '{'));
+ $this->assertEquals(2, $this->countToken($template, Twig_Token::PUNCTUATION_TYPE, '}'));
+ }
+
+ protected function countToken($template, $type, $value = null)
+ {
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ $count = 0;
+ while (!$stream->isEOF()) {
+ $token = $stream->next();
+ if ($type === $token->getType()) {
+ if (null === $value || $value === $token->getValue()) {
+ ++$count;
+ }
+ }
+ }
+
+ return $count;
+ }
+
+ public function testLineDirective()
+ {
+ $template = "foo\n"
+ ."bar\n"
+ ."{% line 10 %}\n"
+ ."{{\n"
+ ."baz\n"
+ ."}}\n";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // foo\nbar\n
+ $this->assertSame(1, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // \n (after {% line %})
+ $this->assertSame(10, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // {{
+ $this->assertSame(11, $stream->expect(Twig_Token::VAR_START_TYPE)->getLine());
+ // baz
+ $this->assertSame(12, $stream->expect(Twig_Token::NAME_TYPE)->getLine());
+ }
+
+ public function testLineDirectiveInline()
+ {
+ $template = "foo\n"
+ ."bar{% line 10 %}{{\n"
+ ."baz\n"
+ ."}}\n";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // foo\nbar
+ $this->assertSame(1, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // {{
+ $this->assertSame(10, $stream->expect(Twig_Token::VAR_START_TYPE)->getLine());
+ // baz
+ $this->assertSame(11, $stream->expect(Twig_Token::NAME_TYPE)->getLine());
+ }
+
+ public function testLongComments()
+ {
+ $template = '{# '.str_repeat('*', 100000).' #}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongRaw()
+ {
+ $template = '{% raw %}'.str_repeat('*', 100000).'{% endraw %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongVar()
+ {
+ $template = '{{ '.str_repeat('x', 100000).' }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongBlock()
+ {
+ $template = '{% '.str_repeat('x', 100000).' %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testBigNumbers()
+ {
+ $template = '{{ 922337203685477580700 }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->next();
+ $node = $stream->next();
+ $this->assertEquals("922337203685477580700", $node->getValue());
+ }
+
+ public function testStringWithEscapedDelimiter()
+ {
+ $tests = array(
+ "{{ 'foo \' bar' }}" => 'foo \' bar',
+ '{{ "foo \" bar" }}' => "foo \" bar",
+ );
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ foreach ($tests as $template => $expected) {
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, $expected);
+ }
+ }
+
+ public function testStringWithInterpolation()
+ {
+ $template = 'foo {{ "bar #{ baz + 1 }" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::TEXT_TYPE, 'foo ');
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'baz');
+ $stream->expect(Twig_Token::OPERATOR_TYPE, '+');
+ $stream->expect(Twig_Token::NUMBER_TYPE, '1');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithEscapedInterpolation()
+ {
+ $template = '{{ "bar \#{baz+1}" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar #{baz+1}');
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithHash()
+ {
+ $template = '{{ "bar # baz" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar # baz');
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unclosed """
+ */
+ public function testStringWithUnterminatedInterpolation()
+ {
+ $template = '{{ "bar #{x" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+ }
+
+ public function testStringWithNestedInterpolations()
+ {
+ $template = '{{ "bar #{ "foo#{bar}" }" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'foo');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'bar');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithNestedInterpolationsInBlock()
+ {
+ $template = '{% foo "bar #{ "foo#{bar}" }" %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::BLOCK_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'foo');
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'foo');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'bar');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ }
+
+ public function testOperatorEndingWithALetterAtTheEndOfALine()
+ {
+ $template = "{{ 1 and\n0}}";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::NUMBER_TYPE, 1);
+ $stream->expect(Twig_Token::OPERATOR_TYPE, 'and');
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unclosed "variable" at line 3
+ */
+ public function testUnterminatedVariable()
+ {
+ $template = '
+
+{{
+
+bar
+
+
+';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unclosed "block" at line 3
+ */
+ public function testUnterminatedBlock()
+ {
+ $template = '
+
+{%
+
+bar
+
+
+';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/ArrayTest.php b/vendor/twig/twig/test/Twig/Tests/Loader/ArrayTest.php
new file mode 100755
index 0000000..1369a6b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/ArrayTest.php
@@ -0,0 +1,97 @@
+ 'bar'));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetSourceWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->getSource('foo');
+ }
+
+ public function testGetCacheKey()
+ {
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+
+ $this->assertEquals('bar', $loader->getCacheKey('foo'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetCacheKeyWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->getCacheKey('foo');
+ }
+
+ public function testSetTemplate()
+ {
+ $loader = new Twig_Loader_Array(array());
+ $loader->setTemplate('foo', 'bar');
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+
+ public function testIsFresh()
+ {
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+ $this->assertTrue($loader->isFresh('foo', time()));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testIsFreshWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->isFresh('foo', time());
+ }
+
+ public function testTemplateReference()
+ {
+ $name = new Twig_Test_Loader_TemplateReference('foo');
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+
+ $loader->getCacheKey($name);
+ $loader->getSource($name);
+ $loader->isFresh($name, time());
+ $loader->setTemplate($name, 'foobar');
+ }
+}
+
+class Twig_Test_Loader_TemplateReference
+{
+ private $name;
+
+ public function __construct($name)
+ {
+ $this->name = $name;
+ }
+
+ public function __toString()
+ {
+ return $this->name;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/ChainTest.php b/vendor/twig/twig/test/Twig/Tests/Loader/ChainTest.php
new file mode 100755
index 0000000..4fe0db9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/ChainTest.php
@@ -0,0 +1,79 @@
+ 'bar')),
+ new Twig_Loader_Array(array('foo' => 'foobar', 'bar' => 'foo')),
+ ));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ $this->assertEquals('foo', $loader->getSource('bar'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetSourceWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Chain(array());
+
+ $loader->getSource('foo');
+ }
+
+ public function testGetCacheKey()
+ {
+ $loader = new Twig_Loader_Chain(array(
+ new Twig_Loader_Array(array('foo' => 'bar')),
+ new Twig_Loader_Array(array('foo' => 'foobar', 'bar' => 'foo')),
+ ));
+
+ $this->assertEquals('bar', $loader->getCacheKey('foo'));
+ $this->assertEquals('foo', $loader->getCacheKey('bar'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetCacheKeyWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Chain(array());
+
+ $loader->getCacheKey('foo');
+ }
+
+ public function testAddLoader()
+ {
+ $loader = new Twig_Loader_Chain();
+ $loader->addLoader(new Twig_Loader_Array(array('foo' => 'bar')));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+
+ public function testExists()
+ {
+ $loader1 = $this->getMock('Twig_Loader_Array', array('exists', 'getSource'), array(), '', false);
+ $loader1->expects($this->once())->method('exists')->will($this->returnValue(false));
+ $loader1->expects($this->never())->method('getSource');
+
+ $loader2 = $this->getMock('Twig_LoaderInterface');
+ $loader2->expects($this->once())->method('getSource')->will($this->returnValue('content'));
+
+ $loader = new Twig_Loader_Chain();
+ $loader->addLoader($loader1);
+ $loader->addLoader($loader2);
+
+ $this->assertTrue($loader->exists('foo'));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/FilesystemTest.php b/vendor/twig/twig/test/Twig/Tests/Loader/FilesystemTest.php
new file mode 100755
index 0000000..e07f374
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/FilesystemTest.php
@@ -0,0 +1,175 @@
+getCacheKey($template);
+ $this->fail();
+ } catch (Twig_Error_Loader $e) {
+ $this->assertNotContains('Unable to find template', $e->getMessage());
+ }
+ }
+
+ public function getSecurityTests()
+ {
+ return array(
+ array("AutoloaderTest\0.php"),
+ array('..\\AutoloaderTest.php'),
+ array('..\\\\\\AutoloaderTest.php'),
+ array('../AutoloaderTest.php'),
+ array('..////AutoloaderTest.php'),
+ array('./../AutoloaderTest.php'),
+ array('.\\..\\AutoloaderTest.php'),
+ array('././././././../AutoloaderTest.php'),
+ array('.\\./.\\./.\\./../AutoloaderTest.php'),
+ array('foo/../../AutoloaderTest.php'),
+ array('foo\\..\\..\\AutoloaderTest.php'),
+ array('foo/../bar/../../AutoloaderTest.php'),
+ array('foo/bar/../../../AutoloaderTest.php'),
+ array('filters/../../AutoloaderTest.php'),
+ array('filters//..//..//AutoloaderTest.php'),
+ array('filters\\..\\..\\AutoloaderTest.php'),
+ array('filters\\\\..\\\\..\\\\AutoloaderTest.php'),
+ array('filters\\//../\\/\\..\\AutoloaderTest.php'),
+ array('/../AutoloaderTest.php'),
+ );
+ }
+
+ public function testPaths()
+ {
+ $basePath = dirname(__FILE__).'/Fixtures';
+
+ $loader = new Twig_Loader_Filesystem(array($basePath.'/normal', $basePath.'/normal_bis'));
+ $loader->setPaths(array($basePath.'/named', $basePath.'/named_bis'), 'named');
+ $loader->addPath($basePath.'/named_ter', 'named');
+ $loader->addPath($basePath.'/normal_ter');
+ $loader->prependPath($basePath.'/normal_final');
+ $loader->prependPath($basePath.'/named/../named_quater', 'named');
+ $loader->prependPath($basePath.'/named_final', 'named');
+
+ $this->assertEquals(array(
+ $basePath.'/normal_final',
+ $basePath.'/normal',
+ $basePath.'/normal_bis',
+ $basePath.'/normal_ter',
+ ), $loader->getPaths());
+ $this->assertEquals(array(
+ $basePath.'/named_final',
+ $basePath.'/named/../named_quater',
+ $basePath.'/named',
+ $basePath.'/named_bis',
+ $basePath.'/named_ter',
+ ), $loader->getPaths('named'));
+
+ $this->assertEquals(
+ realpath($basePath.'/named_quater/named_absolute.html'),
+ realpath($loader->getCacheKey('@named/named_absolute.html'))
+ );
+ $this->assertEquals("path (final)\n", $loader->getSource('index.html'));
+ $this->assertEquals("path (final)\n", $loader->getSource('@__main__/index.html'));
+ $this->assertEquals("named path (final)\n", $loader->getSource('@named/index.html'));
+ }
+
+ public function testEmptyConstructor()
+ {
+ $loader = new Twig_Loader_Filesystem();
+ $this->assertEquals(array(), $loader->getPaths());
+ }
+
+ public function testGetNamespaces()
+ {
+ $loader = new Twig_Loader_Filesystem(sys_get_temp_dir());
+ $this->assertEquals(array(Twig_Loader_Filesystem::MAIN_NAMESPACE), $loader->getNamespaces());
+
+ $loader->addPath(sys_get_temp_dir(), 'named');
+ $this->assertEquals(array(Twig_Loader_Filesystem::MAIN_NAMESPACE, 'named'), $loader->getNamespaces());
+ }
+
+ public function testFindTemplateExceptionNamespace()
+ {
+ $basePath = dirname(__FILE__).'/Fixtures';
+
+ $loader = new Twig_Loader_Filesystem(array($basePath.'/normal'));
+ $loader->addPath($basePath.'/named', 'named');
+
+ try {
+ $loader->getSource('@named/nowhere.html');
+ } catch (Exception $e) {
+ $this->assertInstanceof('Twig_Error_Loader', $e);
+ $this->assertContains('Unable to find template "@named/nowhere.html"', $e->getMessage());
+ }
+ }
+
+ public function testFindTemplateWithCache()
+ {
+ $basePath = dirname(__FILE__).'/Fixtures';
+
+ $loader = new Twig_Loader_Filesystem(array($basePath.'/normal'));
+ $loader->addPath($basePath.'/named', 'named');
+
+ // prime the cache for index.html in the named namespace
+ $namedSource = $loader->getSource('@named/index.html');
+ $this->assertEquals("named path\n", $namedSource);
+
+ // get index.html from the main namespace
+ $this->assertEquals("path\n", $loader->getSource('index.html'));
+ }
+
+ public function testLoadTemplateAndRenderBlockWithCache()
+ {
+ $loader = new Twig_Loader_Filesystem(array());
+ $loader->addPath(dirname(__FILE__).'/Fixtures/themes/theme2');
+ $loader->addPath(dirname(__FILE__).'/Fixtures/themes/theme1');
+ $loader->addPath(dirname(__FILE__).'/Fixtures/themes/theme1', 'default_theme');
+
+ $twig = new Twig_Environment($loader);
+
+ $template = $twig->loadTemplate('blocks.html.twig');
+ $this->assertSame('block from theme 1', $template->renderBlock('b1', array()));
+
+ $template = $twig->loadTemplate('blocks.html.twig');
+ $this->assertSame('block from theme 2', $template->renderBlock('b2', array()));
+ }
+
+ public function getArrayInheritanceTests()
+ {
+ return array(
+ 'valid array inheritance' => array('array_inheritance_valid_parent.html.twig'),
+ 'array inheritance with null first template' => array('array_inheritance_null_parent.html.twig'),
+ 'array inheritance with empty first template' => array('array_inheritance_empty_parent.html.twig'),
+ 'array inheritance with non-existent first template' => array('array_inheritance_nonexistent_parent.html.twig'),
+ );
+ }
+
+ /**
+ * @dataProvider getArrayInheritanceTests
+ *
+ * @param $templateName string Template name with array inheritance
+ */
+ public function testArrayInheritance($templateName)
+ {
+ $loader = new Twig_Loader_Filesystem(array());
+ $loader->addPath(dirname(__FILE__).'/Fixtures/inheritance');
+
+ $twig = new Twig_Environment($loader);
+
+ $template = $twig->loadTemplate($templateName);
+ $this->assertSame('VALID Child', $template->renderBlock('body', array()));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_empty_parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_empty_parent.html.twig
new file mode 100755
index 0000000..6977ebf
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_empty_parent.html.twig
@@ -0,0 +1,3 @@
+{% extends ['','parent.html.twig'] %}
+
+{% block body %}{{ parent() }} Child{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_nonexistent_parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_nonexistent_parent.html.twig
new file mode 100755
index 0000000..5b50a8b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_nonexistent_parent.html.twig
@@ -0,0 +1,3 @@
+{% extends ['nonexistent.html.twig','parent.html.twig'] %}
+
+{% block body %}{{ parent() }} Child{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_null_parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_null_parent.html.twig
new file mode 100755
index 0000000..a16b3ad
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_null_parent.html.twig
@@ -0,0 +1,3 @@
+{% extends [null,'parent.html.twig'] %}
+
+{% block body %}{{ parent() }} Child{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_valid_parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_valid_parent.html.twig
new file mode 100755
index 0000000..4940dad
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/array_inheritance_valid_parent.html.twig
@@ -0,0 +1,3 @@
+{% extends ['parent.html.twig','spare_parent.html.twig'] %}
+
+{% block body %}{{ parent() }} Child{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/parent.html.twig
new file mode 100755
index 0000000..d594c0e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/parent.html.twig
@@ -0,0 +1 @@
+{% block body %}VALID{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/spare_parent.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/spare_parent.html.twig
new file mode 100755
index 0000000..70b7360
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/inheritance/spare_parent.html.twig
@@ -0,0 +1 @@
+{% block body %}SPARE PARENT{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named/index.html
new file mode 100755
index 0000000..9e5449c
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named/index.html
@@ -0,0 +1 @@
+named path
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_bis/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_bis/index.html
new file mode 100755
index 0000000..d3a272b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_bis/index.html
@@ -0,0 +1 @@
+named path (bis)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_final/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_final/index.html
new file mode 100755
index 0000000..9f05d15
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_final/index.html
@@ -0,0 +1 @@
+named path (final)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_quater/named_absolute.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_quater/named_absolute.html
new file mode 100755
index 0000000..b1fb5f5
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_quater/named_absolute.html
@@ -0,0 +1 @@
+named path (quater)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_ter/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_ter/index.html
new file mode 100755
index 0000000..24fb68a
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/named_ter/index.html
@@ -0,0 +1 @@
+named path (ter)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal/index.html
new file mode 100755
index 0000000..e7a8fd4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal/index.html
@@ -0,0 +1 @@
+path
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_bis/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_bis/index.html
new file mode 100755
index 0000000..bfa9160
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_bis/index.html
@@ -0,0 +1 @@
+path (bis)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_final/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_final/index.html
new file mode 100755
index 0000000..73a089b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_final/index.html
@@ -0,0 +1 @@
+path (final)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_ter/index.html b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_ter/index.html
new file mode 100755
index 0000000..b7ad97d
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/normal_ter/index.html
@@ -0,0 +1 @@
+path (ter)
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme1/blocks.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme1/blocks.html.twig
new file mode 100755
index 0000000..dd0cbc2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme1/blocks.html.twig
@@ -0,0 +1,3 @@
+{% block b1 %}block from theme 1{% endblock %}
+
+{% block b2 %}block from theme 1{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme2/blocks.html.twig b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme2/blocks.html.twig
new file mode 100755
index 0000000..07cf9db
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Loader/Fixtures/themes/theme2/blocks.html.twig
@@ -0,0 +1,3 @@
+{% use '@default_theme/blocks.html.twig' %}
+
+{% block b2 %}block from theme 2{% endblock %}
diff --git a/vendor/twig/twig/test/Twig/Tests/NativeExtensionTest.php b/vendor/twig/twig/test/Twig/Tests/NativeExtensionTest.php
new file mode 100755
index 0000000..36b6329
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/NativeExtensionTest.php
@@ -0,0 +1,33 @@
+markTestSkipped('Skip under HHVM as the behavior is not the same as plain PHP (which is an edge case anyway)');
+ }
+
+ $twig = new Twig_Environment(new Twig_Loader_Array(array('index' => '{{ d1.date }}{{ d2.date }}')), array(
+ 'debug' => true,
+ 'cache' => false,
+ 'autoescape' => false,
+ ));
+
+ $d1 = new DateTime();
+ $d2 = new DateTime();
+ $output = $twig->render('index', compact('d1', 'd2'));
+
+ // If it fails, PHP will crash.
+ $this->assertEquals($output, $d1->date.$d2->date);
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/AutoEscapeTest.php b/vendor/twig/twig/test/Twig/Tests/Node/AutoEscapeTest.php
new file mode 100755
index 0000000..25d1602
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/AutoEscapeTest.php
@@ -0,0 +1,32 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertTrue($node->getAttribute('value'));
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node(array(new Twig_Node_Text('foo', 1)));
+ $node = new Twig_Node_AutoEscape(true, $body, 1);
+
+ return array(
+ array($node, "// line 1\necho \"foo\";"),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/BlockReferenceTest.php b/vendor/twig/twig/test/Twig/Tests/Node/BlockReferenceTest.php
new file mode 100755
index 0000000..84dac9b
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/BlockReferenceTest.php
@@ -0,0 +1,31 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ return array(
+ array(new Twig_Node_BlockReference('foo', 1), <<displayBlock('foo', \$context, \$blocks);
+EOF
+ ),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/BlockTest.php b/vendor/twig/twig/test/Twig/Tests/Node/BlockTest.php
new file mode 100755
index 0000000..e7246dc
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/BlockTest.php
@@ -0,0 +1,39 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node_Text('foo', 1);
+ $node = new Twig_Node_Block('foo', $body, 1);
+
+ return array(
+ array($node, <<assertEquals($expr, $node->getNode('expr'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 1);
+ $node = new Twig_Node_Do($expr, 1);
+ $tests[] = array($node, "// line 1\n\"foo\";");
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/ArrayTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ArrayTest.php
new file mode 100755
index 0000000..4f83ab1
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ArrayTest.php
@@ -0,0 +1,37 @@
+assertEquals($foo, $node->getNode(1));
+ }
+
+ public function getTests()
+ {
+ $elements = array(
+ new Twig_Node_Expression_Constant('foo', 1),
+ new Twig_Node_Expression_Constant('bar', 1),
+
+ new Twig_Node_Expression_Constant('bar', 1),
+ new Twig_Node_Expression_Constant('foo', 1),
+ );
+ $node = new Twig_Node_Expression_Array($elements, 1);
+
+ return array(
+ array($node, 'array("foo" => "bar", "bar" => "foo")'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php
new file mode 100755
index 0000000..bf365de
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php
@@ -0,0 +1,29 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_AssignName('foo', 1);
+
+ return array(
+ array($node, '$context["foo"]'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php
new file mode 100755
index 0000000..02310a1
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Add($left, $right, 1);
+
+ return array(
+ array($node, '(1 + 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php
new file mode 100755
index 0000000..2df3c8e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_And($left, $right, 1);
+
+ return array(
+ array($node, '(1 && 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php
new file mode 100755
index 0000000..759e482
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Concat($left, $right, 1);
+
+ return array(
+ array($node, '(1 . 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php
new file mode 100755
index 0000000..0e54b10
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Div($left, $right, 1);
+
+ return array(
+ array($node, '(1 / 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php
new file mode 100755
index 0000000..602888f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_FloorDiv($left, $right, 1);
+
+ return array(
+ array($node, 'intval(floor((1 / 2)))'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php
new file mode 100755
index 0000000..4c663c7
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Mod($left, $right, 1);
+
+ return array(
+ array($node, '(1 % 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php
new file mode 100755
index 0000000..e92c95e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Mul($left, $right, 1);
+
+ return array(
+ array($node, '(1 * 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php
new file mode 100755
index 0000000..ec37c83
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Or($left, $right, 1);
+
+ return array(
+ array($node, '(1 || 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php
new file mode 100755
index 0000000..061cb27
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php
@@ -0,0 +1,34 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 1);
+ $right = new Twig_Node_Expression_Constant(2, 1);
+ $node = new Twig_Node_Expression_Binary_Sub($left, $right, 1);
+
+ return array(
+ array($node, '(1 - 2)'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/CallTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/CallTest.php
new file mode 100755
index 0000000..af4e351
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/CallTest.php
@@ -0,0 +1,102 @@
+ 'function', 'name' => 'date'));
+ $this->assertEquals(array('U', null), $node->getArguments('date', array('format' => 'U', 'timestamp' => null)));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Positional arguments cannot be used after named arguments for function "date".
+ */
+ public function testGetArgumentsWhenPositionalArgumentsAfterNamedArguments()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'date'));
+ $node->getArguments('date', array('timestamp' => 123456, 'Y-m-d'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Argument "format" is defined twice for function "date".
+ */
+ public function testGetArgumentsWhenArgumentIsDefinedTwice()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'date'));
+ $node->getArguments('date', array('Y-m-d', 'format' => 'U'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unknown argument "unknown" for function "date(format, timestamp)".
+ */
+ public function testGetArgumentsWithWrongNamedArgumentName()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'date'));
+ $node->getArguments('date', array('Y-m-d', 'timestamp' => null, 'unknown' => ''));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unknown arguments "unknown1", "unknown2" for function "date(format, timestamp)".
+ */
+ public function testGetArgumentsWithWrongNamedArgumentNames()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'date'));
+ $node->getArguments('date', array('Y-m-d', 'timestamp' => null, 'unknown1' => '', 'unknown2' => ''));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Argument "case_sensitivity" could not be assigned for function "substr_compare(main_str, str, offset, length, case_sensitivity)" because it is mapped to an internal PHP function which cannot determine default value for optional argument "length".
+ */
+ public function testResolveArgumentsWithMissingValueForOptionalArgument()
+ {
+ if (defined('HHVM_VERSION')) {
+ $this->markTestSkipped('Skip under HHVM as the behavior is not the same as plain PHP (which is an edge case anyway)');
+ }
+
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'substr_compare'));
+ $node->getArguments('substr_compare', array('abcd', 'bc', 'offset' => 1, 'case_sensitivity' => true));
+ }
+
+ public function testResolveArgumentsOnlyNecessaryArgumentsForCustomFunction()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'custom_function'));
+
+ $this->assertEquals(array('arg1'), $node->getArguments(array($this, 'customFunction'), array('arg1' => 'arg1')));
+ }
+
+ public function testGetArgumentsForStaticMethod()
+ {
+ $node = new Twig_Tests_Node_Expression_Call(array(), array('type' => 'function', 'name' => 'custom_static_function'));
+ $this->assertEquals(array('arg1'), $node->getArguments(__CLASS__.'::customStaticFunction', array('arg1' => 'arg1')));
+ }
+
+ public static function customStaticFunction($arg1, $arg2 = 'default', $arg3 = array())
+ {
+ }
+
+ public function customFunction($arg1, $arg2 = 'default', $arg3 = array())
+ {
+ }
+}
+
+class Twig_Tests_Node_Expression_Call extends Twig_Node_Expression_Call
+{
+ public function getArguments($callable, $arguments)
+ {
+ return parent::getArguments($callable, $arguments);
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php
new file mode 100755
index 0000000..a3e8bad
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php
@@ -0,0 +1,38 @@
+assertEquals($expr1, $node->getNode('expr1'));
+ $this->assertEquals($expr2, $node->getNode('expr2'));
+ $this->assertEquals($expr3, $node->getNode('expr3'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr1 = new Twig_Node_Expression_Constant(1, 1);
+ $expr2 = new Twig_Node_Expression_Constant(2, 1);
+ $expr3 = new Twig_Node_Expression_Constant(3, 1);
+ $node = new Twig_Node_Expression_Conditional($expr1, $expr2, $expr3, 1);
+ $tests[] = array($node, '((1) ? (2) : (3))');
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConstantTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConstantTest.php
new file mode 100755
index 0000000..2ff9318
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ConstantTest.php
@@ -0,0 +1,30 @@
+assertEquals('foo', $node->getAttribute('value'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $node = new Twig_Node_Expression_Constant('foo', 1);
+ $tests[] = array($node, '"foo"');
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/FilterTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/FilterTest.php
new file mode 100755
index 0000000..4aefa7e
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/FilterTest.php
@@ -0,0 +1,121 @@
+assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($name, $node->getNode('filter'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 1);
+ $node = $this->createFilter($expr, 'upper');
+ $node = $this->createFilter($node, 'number_format', array(new Twig_Node_Expression_Constant(2, 1), new Twig_Node_Expression_Constant('.', 1), new Twig_Node_Expression_Constant(',', 1)));
+
+ if (function_exists('mb_get_info')) {
+ $tests[] = array($node, 'twig_number_format_filter($this->env, twig_upper_filter($this->env, "foo"), 2, ".", ",")');
+ } else {
+ $tests[] = array($node, 'twig_number_format_filter($this->env, strtoupper("foo"), 2, ".", ",")');
+ }
+
+ // named arguments
+ $date = new Twig_Node_Expression_Constant(0, 1);
+ $node = $this->createFilter($date, 'date', array(
+ 'timezone' => new Twig_Node_Expression_Constant('America/Chicago', 1),
+ 'format' => new Twig_Node_Expression_Constant('d/m/Y H:i:s P', 1),
+ ));
+ $tests[] = array($node, 'twig_date_format_filter($this->env, 0, "d/m/Y H:i:s P", "America/Chicago")');
+
+ // skip an optional argument
+ $date = new Twig_Node_Expression_Constant(0, 1);
+ $node = $this->createFilter($date, 'date', array(
+ 'timezone' => new Twig_Node_Expression_Constant('America/Chicago', 1),
+ ));
+ $tests[] = array($node, 'twig_date_format_filter($this->env, 0, null, "America/Chicago")');
+
+ // underscores vs camelCase for named arguments
+ $string = new Twig_Node_Expression_Constant('abc', 1);
+ $node = $this->createFilter($string, 'reverse', array(
+ 'preserve_keys' => new Twig_Node_Expression_Constant(true, 1),
+ ));
+ $tests[] = array($node, 'twig_reverse_filter($this->env, "abc", true)');
+ $node = $this->createFilter($string, 'reverse', array(
+ 'preserveKeys' => new Twig_Node_Expression_Constant(true, 1),
+ ));
+ $tests[] = array($node, 'twig_reverse_filter($this->env, "abc", true)');
+
+ // filter as an anonymous function
+ if (PHP_VERSION_ID >= 50300) {
+ $node = $this->createFilter(new Twig_Node_Expression_Constant('foo', 1), 'anonymous');
+ $tests[] = array($node, 'call_user_func_array($this->env->getFilter(\'anonymous\')->getCallable(), array("foo"))');
+ }
+
+ return $tests;
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unknown argument "foobar" for filter "date(format, timezone)" at line 1.
+ */
+ public function testCompileWithWrongNamedArgumentName()
+ {
+ $date = new Twig_Node_Expression_Constant(0, 1);
+ $node = $this->createFilter($date, 'date', array(
+ 'foobar' => new Twig_Node_Expression_Constant('America/Chicago', 1),
+ ));
+
+ $compiler = $this->getCompiler();
+ $compiler->compile($node);
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Value for argument "from" is required for filter "replace".
+ */
+ public function testCompileWithMissingNamedArgument()
+ {
+ $value = new Twig_Node_Expression_Constant(0, 1);
+ $node = $this->createFilter($value, 'replace', array(
+ 'to' => new Twig_Node_Expression_Constant('foo', 1),
+ ));
+
+ $compiler = $this->getCompiler();
+ $compiler->compile($node);
+ }
+
+ protected function createFilter($node, $name, array $arguments = array())
+ {
+ $name = new Twig_Node_Expression_Constant($name, 1);
+ $arguments = new Twig_Node($arguments);
+
+ return new Twig_Node_Expression_Filter($node, $name, $arguments, 1);
+ }
+
+ protected function getEnvironment()
+ {
+ if (PHP_VERSION_ID >= 50300) {
+ return include 'PHP53/FilterInclude.php';
+ }
+
+ return parent::getEnvironment();
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/FunctionTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/FunctionTest.php
new file mode 100755
index 0000000..209b8cf
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/FunctionTest.php
@@ -0,0 +1,87 @@
+assertEquals($name, $node->getAttribute('name'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ }
+
+ public function getTests()
+ {
+ $environment = new Twig_Environment();
+ $environment->addFunction(new Twig_SimpleFunction('foo', 'foo', array()));
+ $environment->addFunction(new Twig_SimpleFunction('bar', 'bar', array('needs_environment' => true)));
+ $environment->addFunction(new Twig_SimpleFunction('foofoo', 'foofoo', array('needs_context' => true)));
+ $environment->addFunction(new Twig_SimpleFunction('foobar', 'foobar', array('needs_environment' => true, 'needs_context' => true)));
+
+ $tests = array();
+
+ $node = $this->createFunction('foo');
+ $tests[] = array($node, 'foo()', $environment);
+
+ $node = $this->createFunction('foo', array(new Twig_Node_Expression_Constant('bar', 1), new Twig_Node_Expression_Constant('foobar', 1)));
+ $tests[] = array($node, 'foo("bar", "foobar")', $environment);
+
+ $node = $this->createFunction('bar');
+ $tests[] = array($node, 'bar($this->env)', $environment);
+
+ $node = $this->createFunction('bar', array(new Twig_Node_Expression_Constant('bar', 1)));
+ $tests[] = array($node, 'bar($this->env, "bar")', $environment);
+
+ $node = $this->createFunction('foofoo');
+ $tests[] = array($node, 'foofoo($context)', $environment);
+
+ $node = $this->createFunction('foofoo', array(new Twig_Node_Expression_Constant('bar', 1)));
+ $tests[] = array($node, 'foofoo($context, "bar")', $environment);
+
+ $node = $this->createFunction('foobar');
+ $tests[] = array($node, 'foobar($this->env, $context)', $environment);
+
+ $node = $this->createFunction('foobar', array(new Twig_Node_Expression_Constant('bar', 1)));
+ $tests[] = array($node, 'foobar($this->env, $context, "bar")', $environment);
+
+ // named arguments
+ $node = $this->createFunction('date', array(
+ 'timezone' => new Twig_Node_Expression_Constant('America/Chicago', 1),
+ 'date' => new Twig_Node_Expression_Constant(0, 1),
+ ));
+ $tests[] = array($node, 'twig_date_converter($this->env, 0, "America/Chicago")');
+
+ // function as an anonymous function
+ if (PHP_VERSION_ID >= 50300) {
+ $node = $this->createFunction('anonymous', array(new Twig_Node_Expression_Constant('foo', 1)));
+ $tests[] = array($node, 'call_user_func_array($this->env->getFunction(\'anonymous\')->getCallable(), array("foo"))');
+ }
+
+ return $tests;
+ }
+
+ protected function createFunction($name, array $arguments = array())
+ {
+ return new Twig_Node_Expression_Function($name, new Twig_Node($arguments), 1);
+ }
+
+ protected function getEnvironment()
+ {
+ if (PHP_VERSION_ID >= 50300) {
+ return include 'PHP53/FunctionInclude.php';
+ }
+
+ return parent::getEnvironment();
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php
new file mode 100755
index 0000000..2764478
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php
@@ -0,0 +1,50 @@
+addElement(new Twig_Node_Expression_Name('foo', 1));
+ $args->addElement(new Twig_Node_Expression_Constant('bar', 1));
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_Template::ARRAY_CALL, 1);
+
+ $this->assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($attr, $node->getNode('attribute'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ $this->assertEquals(Twig_Template::ARRAY_CALL, $node->getAttribute('type'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Name('foo', 1);
+ $attr = new Twig_Node_Expression_Constant('bar', 1);
+ $args = new Twig_Node_Expression_Array(array(), 1);
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_Template::ANY_CALL, 1);
+ $tests[] = array($node, sprintf('%s%s, "bar", array())', $this->getAttributeGetter(), $this->getVariableGetter('foo', 1)));
+
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_Template::ARRAY_CALL, 1);
+ $tests[] = array($node, sprintf('%s%s, "bar", array(), "array")', $this->getAttributeGetter(), $this->getVariableGetter('foo', 1)));
+
+ $args = new Twig_Node_Expression_Array(array(), 1);
+ $args->addElement(new Twig_Node_Expression_Name('foo', 1));
+ $args->addElement(new Twig_Node_Expression_Constant('bar', 1));
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_Template::METHOD_CALL, 1);
+ $tests[] = array($node, sprintf('%s%s, "bar", array(0 => %s, 1 => "bar"), "method")', $this->getAttributeGetter(), $this->getVariableGetter('foo', 1), $this->getVariableGetter('foo')));
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/NameTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/NameTest.php
new file mode 100755
index 0000000..905d8ee
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/NameTest.php
@@ -0,0 +1,37 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Name('foo', 1);
+ $self = new Twig_Node_Expression_Name('_self', 1);
+ $context = new Twig_Node_Expression_Name('_context', 1);
+
+ $env = new Twig_Environment(null, array('strict_variables' => true));
+ $env1 = new Twig_Environment(null, array('strict_variables' => false));
+
+ return array(
+ array($node, "// line 1\n".(PHP_VERSION_ID >= 50400 ? '(isset($context["foo"]) ? $context["foo"] : $this->getContext($context, "foo"))' : '$this->getContext($context, "foo")'), $env),
+ array($node, $this->getVariableGetter('foo', 1), $env1),
+ array($self, "// line 1\n\$this"),
+ array($context, "// line 1\n\$context"),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FilterInclude.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FilterInclude.php
new file mode 100755
index 0000000..15e3aa9
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FilterInclude.php
@@ -0,0 +1,6 @@
+addFilter(new Twig_SimpleFilter('anonymous', function () {}));
+
+return $env;
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FunctionInclude.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FunctionInclude.php
new file mode 100755
index 0000000..d2170ed
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/FunctionInclude.php
@@ -0,0 +1,6 @@
+addFunction(new Twig_SimpleFunction('anonymous', function () {}));
+
+return $env;
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/TestInclude.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/TestInclude.php
new file mode 100755
index 0000000..6366286
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/PHP53/TestInclude.php
@@ -0,0 +1,6 @@
+addTest(new Twig_SimpleTest('anonymous', function () {}));
+
+return $env;
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/ParentTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ParentTest.php
new file mode 100755
index 0000000..ab2bbe0
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/ParentTest.php
@@ -0,0 +1,28 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Expression_Parent('foo', 1), '$this->renderParentBlock("foo", $context, $blocks)');
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/TestTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/TestTest.php
new file mode 100755
index 0000000..e62a8af
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/TestTest.php
@@ -0,0 +1,56 @@
+assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ $this->assertEquals($name, $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 1);
+ $node = new Twig_Node_Expression_Test_Null($expr, 'null', new Twig_Node(array()), 1);
+ $tests[] = array($node, '(null === "foo")');
+
+ // test as an anonymous function
+ if (PHP_VERSION_ID >= 50300) {
+ $node = $this->createTest(new Twig_Node_Expression_Constant('foo', 1), 'anonymous', array(new Twig_Node_Expression_Constant('foo', 1)));
+ $tests[] = array($node, 'call_user_func_array($this->env->getTest(\'anonymous\')->getCallable(), array("foo", "foo"))');
+ }
+
+ return $tests;
+ }
+
+ protected function createTest($node, $name, array $arguments = array())
+ {
+ return new Twig_Node_Expression_Test($node, $name, new Twig_Node($arguments), 1);
+ }
+
+ protected function getEnvironment()
+ {
+ if (PHP_VERSION_ID >= 50300) {
+ return include 'PHP53/TestInclude.php';
+ }
+
+ return parent::getEnvironment();
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php
new file mode 100755
index 0000000..b633371
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php
@@ -0,0 +1,32 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 1);
+ $node = new Twig_Node_Expression_Unary_Neg($node, 1);
+
+ return array(
+ array($node, '-1'),
+ array(new Twig_Node_Expression_Unary_Neg($node, 1), '- -1'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php
new file mode 100755
index 0000000..d7c6f85
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php
@@ -0,0 +1,31 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 1);
+ $node = new Twig_Node_Expression_Unary_Not($node, 1);
+
+ return array(
+ array($node, '!1'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php
new file mode 100755
index 0000000..057250f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php
@@ -0,0 +1,31 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 1);
+ $node = new Twig_Node_Expression_Unary_Pos($node, 1);
+
+ return array(
+ array($node, '+1'),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/ForTest.php b/vendor/twig/twig/test/Twig/Tests/Node/ForTest.php
new file mode 100755
index 0000000..b289592
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/ForTest.php
@@ -0,0 +1,191 @@
+setAttribute('with_loop', false);
+
+ $this->assertEquals($keyTarget, $node->getNode('key_target'));
+ $this->assertEquals($valueTarget, $node->getNode('value_target'));
+ $this->assertEquals($seq, $node->getNode('seq'));
+ $this->assertTrue($node->getAttribute('ifexpr'));
+ $this->assertEquals('Twig_Node_If', get_class($node->getNode('body')));
+ $this->assertEquals($body, $node->getNode('body')->getNode('tests')->getNode(1)->getNode(0));
+ $this->assertNull($node->getNode('else'));
+
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1);
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 1);
+ $node->setAttribute('with_loop', false);
+ $this->assertEquals($else, $node->getNode('else'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $keyTarget = new Twig_Node_Expression_AssignName('key', 1);
+ $valueTarget = new Twig_Node_Expression_AssignName('item', 1);
+ $seq = new Twig_Node_Expression_Name('items', 1);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1)), array(), 1);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 1);
+ $node->setAttribute('with_loop', false);
+
+ $tests[] = array($node, <<getVariableGetter('items')});
+foreach (\$context['_seq'] as \$context["key"] => \$context["item"]) {
+ echo {$this->getVariableGetter('foo')};
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['key'], \$context['item'], \$context['_parent'], \$context['loop']);
+\$context = array_intersect_key(\$context, \$_parent) + \$_parent;
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 1);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 1);
+ $seq = new Twig_Node_Expression_Name('values', 1);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1)), array(), 1);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 1);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {
+ \$length = count(\$context['_seq']);
+ \$context['loop']['revindex0'] = \$length - 1;
+ \$context['loop']['revindex'] = \$length;
+ \$context['loop']['length'] = \$length;
+ \$context['loop']['last'] = 1 === \$length;
+}
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ echo {$this->getVariableGetter('foo')};
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ if (isset(\$context['loop']['length'])) {
+ --\$context['loop']['revindex0'];
+ --\$context['loop']['revindex'];
+ \$context['loop']['last'] = 0 === \$context['loop']['revindex0'];
+ }
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_intersect_key(\$context, \$_parent) + \$_parent;
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 1);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 1);
+ $seq = new Twig_Node_Expression_Name('values', 1);
+ $ifexpr = new Twig_Node_Expression_Constant(true, 1);
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1)), array(), 1);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 1);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ if (true) {
+ echo {$this->getVariableGetter('foo')};
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ }
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_intersect_key(\$context, \$_parent) + \$_parent;
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 1);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 1);
+ $seq = new Twig_Node_Expression_Name('values', 1);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1)), array(), 1);
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1);
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 1);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['_iterated'] = false;
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {
+ \$length = count(\$context['_seq']);
+ \$context['loop']['revindex0'] = \$length - 1;
+ \$context['loop']['revindex'] = \$length;
+ \$context['loop']['length'] = \$length;
+ \$context['loop']['last'] = 1 === \$length;
+}
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ echo {$this->getVariableGetter('foo')};
+ \$context['_iterated'] = true;
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ if (isset(\$context['loop']['length'])) {
+ --\$context['loop']['revindex0'];
+ --\$context['loop']['revindex'];
+ \$context['loop']['last'] = 0 === \$context['loop']['revindex0'];
+ }
+}
+if (!\$context['_iterated']) {
+ echo {$this->getVariableGetter('foo')};
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_intersect_key(\$context, \$_parent) + \$_parent;
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/IfTest.php b/vendor/twig/twig/test/Twig/Tests/Node/IfTest.php
new file mode 100755
index 0000000..e47dd65
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/IfTest.php
@@ -0,0 +1,88 @@
+assertEquals($t, $node->getNode('tests'));
+ $this->assertNull($node->getNode('else'));
+
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 1), 1);
+ $node = new Twig_Node_If($t, $else, 1);
+ $this->assertEquals($else, $node->getNode('else'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 1),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1),
+ ), array(), 1);
+ $else = null;
+ $node = new Twig_Node_If($t, $else, 1);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+}
+EOF
+ );
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 1),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1),
+ new Twig_Node_Expression_Constant(false, 1),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 1), 1),
+ ), array(), 1);
+ $else = null;
+ $node = new Twig_Node_If($t, $else, 1);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+} elseif (false) {
+ echo {$this->getVariableGetter('bar')};
+}
+EOF
+ );
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 1),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 1), 1),
+ ), array(), 1);
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 1), 1);
+ $node = new Twig_Node_If($t, $else, 1);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+} else {
+ echo {$this->getVariableGetter('bar')};
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/ImportTest.php b/vendor/twig/twig/test/Twig/Tests/Node/ImportTest.php
new file mode 100755
index 0000000..36525b2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/ImportTest.php
@@ -0,0 +1,40 @@
+assertEquals($macro, $node->getNode('expr'));
+ $this->assertEquals($var, $node->getNode('var'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $macro = new Twig_Node_Expression_Constant('foo.twig', 1);
+ $var = new Twig_Node_Expression_AssignName('macro', 1);
+ $node = new Twig_Node_Import($macro, $var, 1);
+
+ $tests[] = array($node, <<loadTemplate("foo.twig", null, 1);
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/IncludeTest.php b/vendor/twig/twig/test/Twig/Tests/Node/IncludeTest.php
new file mode 100755
index 0000000..6fe5c17
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/IncludeTest.php
@@ -0,0 +1,83 @@
+assertNull($node->getNode('variables'));
+ $this->assertEquals($expr, $node->getNode('expr'));
+ $this->assertFalse($node->getAttribute('only'));
+
+ $vars = new Twig_Node_Expression_Array(array(new Twig_Node_Expression_Constant('foo', 1), new Twig_Node_Expression_Constant(true, 1)), 1);
+ $node = new Twig_Node_Include($expr, $vars, true, false, 1);
+ $this->assertEquals($vars, $node->getNode('variables'));
+ $this->assertTrue($node->getAttribute('only'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo.twig', 1);
+ $node = new Twig_Node_Include($expr, null, false, false, 1);
+ $tests[] = array($node, <<loadTemplate("foo.twig", null, 1)->display(\$context);
+EOF
+ );
+
+ $expr = new Twig_Node_Expression_Conditional(
+ new Twig_Node_Expression_Constant(true, 1),
+ new Twig_Node_Expression_Constant('foo', 1),
+ new Twig_Node_Expression_Constant('foo', 1),
+ 0
+ );
+ $node = new Twig_Node_Include($expr, null, false, false, 1);
+ $tests[] = array($node, <<loadTemplate(((true) ? ("foo") : ("foo")), null, 1)->display(\$context);
+EOF
+ );
+
+ $expr = new Twig_Node_Expression_Constant('foo.twig', 1);
+ $vars = new Twig_Node_Expression_Array(array(new Twig_Node_Expression_Constant('foo', 1), new Twig_Node_Expression_Constant(true, 1)), 1);
+ $node = new Twig_Node_Include($expr, $vars, false, false, 1);
+ $tests[] = array($node, <<loadTemplate("foo.twig", null, 1)->display(array_merge(\$context, array("foo" => true)));
+EOF
+ );
+
+ $node = new Twig_Node_Include($expr, $vars, true, false, 1);
+ $tests[] = array($node, <<loadTemplate("foo.twig", null, 1)->display(array("foo" => true));
+EOF
+ );
+
+ $node = new Twig_Node_Include($expr, $vars, true, true, 1);
+ $tests[] = array($node, <<loadTemplate("foo.twig", null, 1)->display(array("foo" => true));
+} catch (Twig_Error_Loader \$e) {
+ // ignore missing template
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/MacroTest.php b/vendor/twig/twig/test/Twig/Tests/Node/MacroTest.php
new file mode 100755
index 0000000..52ee8b7
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/MacroTest.php
@@ -0,0 +1,61 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals($arguments, $node->getNode('arguments'));
+ $this->assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node_Text('foo', 1);
+ $arguments = new Twig_Node(array(
+ 'foo' => new Twig_Node_Expression_Constant(null, 1),
+ 'bar' => new Twig_Node_Expression_Constant('Foo', 1),
+ ), array(), 1);
+ $node = new Twig_Node_Macro('foo', $body, $arguments, 1);
+
+ return array(
+ array($node, <<env->mergeGlobals(array(
+ "foo" => \$__foo__,
+ "bar" => \$__bar__,
+ ));
+
+ \$blocks = array();
+
+ ob_start();
+ try {
+ echo "foo";
+ } catch (Exception \$e) {
+ ob_end_clean();
+
+ throw \$e;
+ }
+
+ return ('' === \$tmp = ob_get_clean()) ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset());
+}
+EOF
+ ),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/ModuleTest.php b/vendor/twig/twig/test/Twig/Tests/Node/ModuleTest.php
new file mode 100755
index 0000000..5688af8
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/ModuleTest.php
@@ -0,0 +1,183 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals($blocks, $node->getNode('blocks'));
+ $this->assertEquals($macros, $node->getNode('macros'));
+ $this->assertEquals($parent, $node->getNode('parent'));
+ $this->assertEquals($filename, $node->getAttribute('filename'));
+ }
+
+ public function getTests()
+ {
+ $twig = new Twig_Environment($this->getMock('Twig_LoaderInterface'));
+
+ $tests = array();
+
+ $body = new Twig_Node_Text('foo', 1);
+ $extends = null;
+ $blocks = new Twig_Node();
+ $macros = new Twig_Node();
+ $traits = new Twig_Node();
+ $filename = 'foo.twig';
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, new Twig_Node(array()), $filename);
+ $tests[] = array($node, <<parent = false;
+
+ \$this->blocks = array(
+ );
+ }
+
+ protected function doDisplay(array \$context, array \$blocks = array())
+ {
+ // line 1
+ echo "foo";
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function getDebugInfo()
+ {
+ return array ( 19 => 1,);
+ }
+}
+EOF
+ , $twig);
+
+ $import = new Twig_Node_Import(new Twig_Node_Expression_Constant('foo.twig', 1), new Twig_Node_Expression_AssignName('macro', 1), 2);
+
+ $body = new Twig_Node(array($import));
+ $extends = new Twig_Node_Expression_Constant('layout.twig', 1);
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, new Twig_Node(array()), $filename);
+ $tests[] = array($node, <<parent = \$this->loadTemplate("layout.twig", "foo.twig", 1);
+ \$this->blocks = array(
+ );
+ }
+
+ protected function doGetParent(array \$context)
+ {
+ return "layout.twig";
+ }
+
+ protected function doDisplay(array \$context, array \$blocks = array())
+ {
+ // line 2
+ \$context["macro"] = \$this->loadTemplate("foo.twig", "foo.twig", 2);
+ // line 1
+ \$this->parent->display(\$context, array_merge(\$this->blocks, \$blocks));
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function isTraitable()
+ {
+ return false;
+ }
+
+ public function getDebugInfo()
+ {
+ return array ( 26 => 1, 24 => 2, 11 => 1,);
+ }
+}
+EOF
+ , $twig);
+
+ $set = new Twig_Node_Set(false, new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 4))), new Twig_Node(array(new Twig_Node_Expression_Constant('foo', 4))), 4);
+ $body = new Twig_Node(array($set));
+ $extends = new Twig_Node_Expression_Conditional(
+ new Twig_Node_Expression_Constant(true, 2),
+ new Twig_Node_Expression_Constant('foo', 2),
+ new Twig_Node_Expression_Constant('foo', 2),
+ 2
+ );
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, new Twig_Node(array()), $filename);
+ $tests[] = array($node, <<loadTemplate(((true) ? ("foo") : ("foo")), "foo.twig", 2);
+ }
+
+ protected function doDisplay(array \$context, array \$blocks = array())
+ {
+ // line 4
+ \$context["foo"] = "foo";
+ // line 2
+ \$this->getParent(\$context)->display(\$context, array_merge(\$this->blocks, \$blocks));
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function isTraitable()
+ {
+ return false;
+ }
+
+ public function getDebugInfo()
+ {
+ return array ( 17 => 2, 15 => 4, 9 => 2,);
+ }
+}
+EOF
+ , $twig);
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/PrintTest.php b/vendor/twig/twig/test/Twig/Tests/Node/PrintTest.php
new file mode 100755
index 0000000..4e0990f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/PrintTest.php
@@ -0,0 +1,29 @@
+assertEquals($expr, $node->getNode('expr'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Print(new Twig_Node_Expression_Constant('foo', 1), 1), "// line 1\necho \"foo\";");
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/SandboxTest.php b/vendor/twig/twig/test/Twig/Tests/Node/SandboxTest.php
new file mode 100755
index 0000000..46ecf97
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/SandboxTest.php
@@ -0,0 +1,44 @@
+assertEquals($body, $node->getNode('body'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $body = new Twig_Node_Text('foo', 1);
+ $node = new Twig_Node_Sandbox($body, 1);
+
+ $tests[] = array($node, <<env->getExtension('sandbox');
+if (!\$alreadySandboxed = \$sandbox->isSandboxed()) {
+ \$sandbox->enableSandbox();
+}
+echo "foo";
+if (!\$alreadySandboxed) {
+ \$sandbox->disableSandbox();
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/SandboxedPrintTest.php b/vendor/twig/twig/test/Twig/Tests/Node/SandboxedPrintTest.php
new file mode 100755
index 0000000..05e1854
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/SandboxedPrintTest.php
@@ -0,0 +1,33 @@
+assertEquals($expr, $node->getNode('expr'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $tests[] = array(new Twig_Node_SandboxedPrint(new Twig_Node_Expression_Constant('foo', 1), 1), <<env->getExtension('sandbox')->ensureToStringAllowed("foo");
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/SetTest.php b/vendor/twig/twig/test/Twig/Tests/Node/SetTest.php
new file mode 100755
index 0000000..62ad280
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/SetTest.php
@@ -0,0 +1,69 @@
+assertEquals($names, $node->getNode('names'));
+ $this->assertEquals($values, $node->getNode('values'));
+ $this->assertFalse($node->getAttribute('capture'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 1)), array(), 1);
+ $values = new Twig_Node(array(new Twig_Node_Expression_Constant('foo', 1)), array(), 1);
+ $node = new Twig_Node_Set(false, $names, $values, 1);
+ $tests[] = array($node, <<env->getCharset());
+EOF
+ );
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 1)), array(), 1);
+ $values = new Twig_Node_Text('foo', 1);
+ $node = new Twig_Node_Set(true, $names, $values, 1);
+ $tests[] = array($node, <<env->getCharset());
+EOF
+ );
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 1), new Twig_Node_Expression_AssignName('bar', 1)), array(), 1);
+ $values = new Twig_Node(array(new Twig_Node_Expression_Constant('foo', 1), new Twig_Node_Expression_Name('bar', 1)), array(), 1);
+ $node = new Twig_Node_Set(false, $names, $values, 1);
+ $tests[] = array($node, <<getVariableGetter('bar')});
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/SpacelessTest.php b/vendor/twig/twig/test/Twig/Tests/Node/SpacelessTest.php
new file mode 100755
index 0000000..222ca09
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/SpacelessTest.php
@@ -0,0 +1,37 @@
+ foo
', 1)));
+ $node = new Twig_Node_Spaceless($body, 1);
+
+ $this->assertEquals($body, $node->getNode('body'));
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node(array(new Twig_Node_Text('', 1)));
+ $node = new Twig_Node_Spaceless($body, 1);
+
+ return array(
+ array($node, << foo
";
+echo trim(preg_replace('/>\s+', '><', ob_get_clean()));
+EOF
+ ),
+ );
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Node/TextTest.php b/vendor/twig/twig/test/Twig/Tests/Node/TextTest.php
new file mode 100755
index 0000000..ceaf67f
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Node/TextTest.php
@@ -0,0 +1,28 @@
+assertEquals('foo', $node->getAttribute('data'));
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Text('foo', 1), "// line 1\necho \"foo\";");
+
+ return $tests;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php b/vendor/twig/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php
new file mode 100755
index 0000000..b5ea7aa
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php
@@ -0,0 +1,124 @@
+getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+
+ $stream = $env->parse($env->tokenize('{{ block("foo") }}', 'index'));
+
+ $node = $stream->getNode('body')->getNode(0);
+
+ $this->assertEquals('Twig_Node_Expression_BlockReference', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ public function testRenderParentBlockOptimizer()
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+
+ $stream = $env->parse($env->tokenize('{% extends "foo" %}{% block content %}{{ parent() }}{% endblock %}', 'index'));
+
+ $node = $stream->getNode('blocks')->getNode('content')->getNode(0)->getNode('body');
+
+ $this->assertEquals('Twig_Node_Expression_Parent', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ public function testRenderVariableBlockOptimizer()
+ {
+ if (PHP_VERSION_ID >= 50400) {
+ return;
+ }
+
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false, 'autoescape' => false));
+ $stream = $env->parse($env->tokenize('{{ block(name|lower) }}', 'index'));
+
+ $node = $stream->getNode('body')->getNode(0)->getNode(1);
+
+ $this->assertEquals('Twig_Node_Expression_BlockReference', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ /**
+ * @dataProvider getTestsForForOptimizer
+ */
+ public function testForOptimizer($template, $expected)
+ {
+ $env = new Twig_Environment($this->getMock('Twig_LoaderInterface'), array('cache' => false));
+
+ $stream = $env->parse($env->tokenize($template, 'index'));
+
+ foreach ($expected as $target => $withLoop) {
+ $this->assertTrue($this->checkForConfiguration($stream, $target, $withLoop), sprintf('variable %s is %soptimized', $target, $withLoop ? 'not ' : ''));
+ }
+ }
+
+ public function getTestsForForOptimizer()
+ {
+ return array(
+ array('{% for i in foo %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{{ loop.index }}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{% endfor %}{% endfor %}', array('i' => false, 'j' => false)),
+
+ array('{% for i in foo %}{% include "foo" %}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% include "foo" only %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{% include "foo" with { "foo": "bar" } only %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{% include "foo" with { "foo": loop.index } only %}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop.index }}{% endfor %}{% endfor %}', array('i' => false, 'j' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop.parent.loop.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => true)),
+
+ array('{% for i in foo %}{% set l = loop %}{% for j in foo %}{{ l.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => false)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ foo.parent.loop.index }}{% endfor %}{% endfor %}', array('i' => false, 'j' => false)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop["parent"].loop.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => true)),
+
+ array('{% for i in foo %}{{ include("foo") }}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{{ include("foo", with_context = false) }}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{{ include("foo", with_context = true) }}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{{ include("foo", { "foo": "bar" }, with_context = false) }}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{{ include("foo", { "foo": loop.index }, with_context = false) }}{% endfor %}', array('i' => true)),
+ );
+ }
+
+ public function checkForConfiguration(Twig_NodeInterface $node = null, $target, $withLoop)
+ {
+ if (null === $node) {
+ return;
+ }
+
+ foreach ($node as $n) {
+ if ($n instanceof Twig_Node_For) {
+ if ($target === $n->getNode('value_target')->getAttribute('name')) {
+ return $withLoop == $n->getAttribute('with_loop');
+ }
+ }
+
+ $ret = $this->checkForConfiguration($n, $target, $withLoop);
+ if (null !== $ret) {
+ return $ret;
+ }
+ }
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/ParserTest.php b/vendor/twig/twig/test/Twig/Tests/ParserTest.php
new file mode 100755
index 0000000..b4a3abb
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/ParserTest.php
@@ -0,0 +1,180 @@
+getParser();
+ $parser->setMacro('display', $this->getMock('Twig_Node_Macro', array(), array(), '', null));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unknown tag name "foo". Did you mean "for" at line 1
+ */
+ public function testUnknownTag()
+ {
+ $stream = new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 1),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'foo', 1),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 1),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 1),
+ ));
+ $parser = new Twig_Parser(new Twig_Environment());
+ $parser->parse($stream);
+ }
+
+ /**
+ * @dataProvider getFilterBodyNodesData
+ */
+ public function testFilterBodyNodes($input, $expected)
+ {
+ $parser = $this->getParser();
+
+ $this->assertEquals($expected, $parser->filterBodyNodes($input));
+ }
+
+ public function getFilterBodyNodesData()
+ {
+ return array(
+ array(
+ new Twig_Node(array(new Twig_Node_Text(' ', 1))),
+ new Twig_Node(array()),
+ ),
+ array(
+ $input = new Twig_Node(array(new Twig_Node_Set(false, new Twig_Node(), new Twig_Node(), 1))),
+ $input,
+ ),
+ array(
+ $input = new Twig_Node(array(new Twig_Node_Set(true, new Twig_Node(), new Twig_Node(array(new Twig_Node(array(new Twig_Node_Text('foo', 1))))), 1))),
+ $input,
+ ),
+ );
+ }
+
+ /**
+ * @dataProvider getFilterBodyNodesDataThrowsException
+ * @expectedException Twig_Error_Syntax
+ */
+ public function testFilterBodyNodesThrowsException($input)
+ {
+ $parser = $this->getParser();
+
+ $parser->filterBodyNodes($input);
+ }
+
+ public function getFilterBodyNodesDataThrowsException()
+ {
+ return array(
+ array(new Twig_Node_Text('foo', 1)),
+ array(new Twig_Node(array(new Twig_Node(array(new Twig_Node_Text('foo', 1)))))),
+ );
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage A template that extends another one cannot have a body but a byte order mark (BOM) has been detected; it must be removed at line 1.
+ */
+ public function testFilterBodyNodesWithBOM()
+ {
+ $parser = $this->getParser();
+ $parser->filterBodyNodes(new Twig_Node_Text(chr(0xEF).chr(0xBB).chr(0xBF), 1));
+ }
+
+ public function testParseIsReentrant()
+ {
+ $twig = new Twig_Environment(null, array(
+ 'autoescape' => false,
+ 'optimizations' => 0,
+ ));
+ $twig->addTokenParser(new TestTokenParser());
+
+ $parser = new Twig_Parser($twig);
+
+ $parser->parse(new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 1),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'test', 1),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 1),
+ new Twig_Token(Twig_Token::VAR_START_TYPE, '', 1),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'foo', 1),
+ new Twig_Token(Twig_Token::VAR_END_TYPE, '', 1),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 1),
+ )));
+
+ $this->assertNull($parser->getParent());
+ }
+
+ // The getVarName() must not depend on the template loaders,
+ // If this test does not throw any exception, that's good.
+ // see https://github.com/symfony/symfony/issues/4218
+ public function testGetVarName()
+ {
+ $twig = new Twig_Environment(null, array(
+ 'autoescape' => false,
+ 'optimizations' => 0,
+ ));
+
+ $twig->parse($twig->tokenize(<<setParent(new Twig_Node());
+ $parser->stream = $this->getMockBuilder('Twig_TokenStream')->disableOriginalConstructor()->getMock();
+
+ return $parser;
+ }
+}
+
+class TestParser extends Twig_Parser
+{
+ public $stream;
+
+ public function filterBodyNodes(Twig_NodeInterface $node)
+ {
+ return parent::filterBodyNodes($node);
+ }
+}
+
+class TestTokenParser extends Twig_TokenParser
+{
+ public function parse(Twig_Token $token)
+ {
+ // simulate the parsing of another template right in the middle of the parsing of the current template
+ $this->parser->parse(new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 1),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'extends', 1),
+ new Twig_Token(Twig_Token::STRING_TYPE, 'base', 1),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 1),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 1),
+ )));
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node(array());
+ }
+
+ public function getTag()
+ {
+ return 'test';
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/AbstractTest.php b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/AbstractTest.php
new file mode 100755
index 0000000..d855664
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/AbstractTest.php
@@ -0,0 +1,101 @@
+getMockBuilder('Twig_Profiler_Profile')->disableOriginalConstructor()->getMock();
+
+ $profile->expects($this->any())->method('isRoot')->will($this->returnValue(true));
+ $profile->expects($this->any())->method('getName')->will($this->returnValue('main'));
+ $profile->expects($this->any())->method('getDuration')->will($this->returnValue(1));
+ $profile->expects($this->any())->method('getMemoryUsage')->will($this->returnValue(0));
+ $profile->expects($this->any())->method('getPeakMemoryUsage')->will($this->returnValue(0));
+
+ $subProfiles = array(
+ $this->getIndexProfile(
+ array(
+ $this->getEmbeddedBlockProfile(),
+ $this->getEmbeddedTemplateProfile(
+ array(
+ $this->getIncludedTemplateProfile(),
+ )
+ ),
+ $this->getMacroProfile(),
+ $this->getEmbeddedTemplateProfile(
+ array(
+ $this->getIncludedTemplateProfile(),
+ )
+ ),
+ )
+ ),
+ );
+
+ $profile->expects($this->any())->method('getProfiles')->will($this->returnValue($subProfiles));
+ $profile->expects($this->any())->method('getIterator')->will($this->returnValue(new ArrayIterator($subProfiles)));
+
+ return $profile;
+ }
+
+ private function getIndexProfile(array $subProfiles = array())
+ {
+ return $this->generateProfile('main', 1, true, 'template', 'index.twig', $subProfiles);
+ }
+
+ private function getEmbeddedBlockProfile(array $subProfiles = array())
+ {
+ return $this->generateProfile('body', 0.0001, false, 'block', 'embedded.twig', $subProfiles);
+ }
+
+ private function getEmbeddedTemplateProfile(array $subProfiles = array())
+ {
+ return $this->generateProfile('main', 0.0001, true, 'template', 'embedded.twig', $subProfiles);
+ }
+
+ private function getIncludedTemplateProfile(array $subProfiles = array())
+ {
+ return $this->generateProfile('main', 0.0001, true, 'template', 'included.twig', $subProfiles);
+ }
+
+ private function getMacroProfile(array $subProfiles = array())
+ {
+ return $this->generateProfile('foo', 0.0001, false, 'macro', 'index.twig', $subProfiles);
+ }
+
+ /**
+ * @param string $name
+ * @param float $duration
+ * @param bool $isTemplate
+ * @param string $type
+ * @param string $templateName
+ * @param array $subProfiles
+ *
+ * @return Twig_Profiler_Profile
+ */
+ private function generateProfile($name, $duration, $isTemplate, $type, $templateName, array $subProfiles = array())
+ {
+ $profile = $this->getMockBuilder('Twig_Profiler_Profile')->disableOriginalConstructor()->getMock();
+
+ $profile->expects($this->any())->method('isRoot')->will($this->returnValue(false));
+ $profile->expects($this->any())->method('getName')->will($this->returnValue($name));
+ $profile->expects($this->any())->method('getDuration')->will($this->returnValue($duration));
+ $profile->expects($this->any())->method('getMemoryUsage')->will($this->returnValue(0));
+ $profile->expects($this->any())->method('getPeakMemoryUsage')->will($this->returnValue(0));
+ $profile->expects($this->any())->method('isTemplate')->will($this->returnValue($isTemplate));
+ $profile->expects($this->any())->method('getType')->will($this->returnValue($type));
+ $profile->expects($this->any())->method('getTemplate')->will($this->returnValue($templateName));
+ $profile->expects($this->any())->method('getProfiles')->will($this->returnValue($subProfiles));
+ $profile->expects($this->any())->method('getIterator')->will($this->returnValue(new ArrayIterator($subProfiles)));
+
+ return $profile;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/BlackfireTest.php b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/BlackfireTest.php
new file mode 100755
index 0000000..1a1b9d2
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/BlackfireTest.php
@@ -0,0 +1,32 @@
+assertStringMatchesFormat(<<index.twig//1 %d %d %d
+index.twig==>embedded.twig::block(body)//1 %d %d 0
+index.twig==>embedded.twig//2 %d %d %d
+embedded.twig==>included.twig//2 %d %d %d
+index.twig==>index.twig::macro(foo)//1 %d %d %d
+EOF
+ , $dumper->dump($this->getProfile()));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/HtmlTest.php b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/HtmlTest.php
new file mode 100755
index 0000000..66a68c4
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/HtmlTest.php
@@ -0,0 +1,30 @@
+assertStringMatchesFormat(<<main %d.%dms/%d%
+└ index.twig %d.%dms/%d%
+ └ embedded.twig::block(body )
+ └ embedded.twig
+ │ └ included.twig
+ └ index.twig::macro(foo )
+ └ embedded.twig
+ └ included.twig
+
+EOF
+ , $dumper->dump($this->getProfile()));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/TextTest.php b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/TextTest.php
new file mode 100755
index 0000000..e2ea165
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Profiler/Dumper/TextTest.php
@@ -0,0 +1,30 @@
+assertStringMatchesFormat(<<dump($this->getProfile()));
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/Profiler/ProfileTest.php b/vendor/twig/twig/test/Twig/Tests/Profiler/ProfileTest.php
new file mode 100755
index 0000000..f786f06
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/Profiler/ProfileTest.php
@@ -0,0 +1,100 @@
+assertEquals('template', $profile->getTemplate());
+ $this->assertEquals('type', $profile->getType());
+ $this->assertEquals('name', $profile->getName());
+ }
+
+ public function testIsRoot()
+ {
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::ROOT);
+ $this->assertTrue($profile->isRoot());
+
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::TEMPLATE);
+ $this->assertFalse($profile->isRoot());
+ }
+
+ public function testIsTemplate()
+ {
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::TEMPLATE);
+ $this->assertTrue($profile->isTemplate());
+
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::ROOT);
+ $this->assertFalse($profile->isTemplate());
+ }
+
+ public function testIsBlock()
+ {
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::BLOCK);
+ $this->assertTrue($profile->isBlock());
+
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::ROOT);
+ $this->assertFalse($profile->isBlock());
+ }
+
+ public function testIsMacro()
+ {
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::MACRO);
+ $this->assertTrue($profile->isMacro());
+
+ $profile = new Twig_Profiler_Profile('template', Twig_Profiler_Profile::ROOT);
+ $this->assertFalse($profile->isMacro());
+ }
+
+ public function testGetAddProfile()
+ {
+ $profile = new Twig_Profiler_Profile();
+ $profile->addProfile($a = new Twig_Profiler_Profile());
+ $profile->addProfile($b = new Twig_Profiler_Profile());
+
+ $this->assertSame(array($a, $b), $profile->getProfiles());
+ $this->assertSame(array($a, $b), iterator_to_array($profile));
+ }
+
+ public function testGetDuration()
+ {
+ $profile = new Twig_Profiler_Profile();
+ usleep(1);
+ $profile->leave();
+
+ $this->assertTrue($profile->getDuration() > 0, sprintf('Expected duration > 0, got: %f', $profile->getDuration()));
+ }
+
+ public function testSerialize()
+ {
+ $profile = new Twig_Profiler_Profile('template', 'type', 'name');
+ $profile1 = new Twig_Profiler_Profile('template1', 'type1', 'name1');
+ $profile->addProfile($profile1);
+ $profile->leave();
+ $profile1->leave();
+
+ $profile2 = unserialize(serialize($profile));
+ $profiles = $profile->getProfiles();
+ $this->assertCount(1, $profiles);
+ $profile3 = $profiles[0];
+
+ $this->assertEquals($profile->getTemplate(), $profile2->getTemplate());
+ $this->assertEquals($profile->getType(), $profile2->getType());
+ $this->assertEquals($profile->getName(), $profile2->getName());
+ $this->assertEquals($profile->getDuration(), $profile2->getDuration());
+
+ $this->assertEquals($profile1->getTemplate(), $profile3->getTemplate());
+ $this->assertEquals($profile1->getType(), $profile3->getType());
+ $this->assertEquals($profile1->getName(), $profile3->getName());
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/TemplateTest.php b/vendor/twig/twig/test/Twig/Tests/TemplateTest.php
new file mode 100755
index 0000000..cac7926
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/TemplateTest.php
@@ -0,0 +1,670 @@
+ $template.$useExt, // appending $useExt makes the template content unique
+ );
+
+ $env = new Twig_Environment(new Twig_Loader_Array($templates), array('strict_variables' => true));
+ if (!$useExt) {
+ $env->addNodeVisitor(new CExtDisablingNodeVisitor());
+ }
+ $template = $env->loadTemplate($name);
+
+ $context = array(
+ 'string' => 'foo',
+ 'null' => null,
+ 'empty_array' => array(),
+ 'array' => array('foo' => 'foo'),
+ 'array_access' => new Twig_TemplateArrayAccessObject(),
+ 'magic_exception' => new Twig_TemplateMagicPropertyObjectWithException(),
+ 'object' => new stdClass(),
+ );
+
+ try {
+ $template->render($context);
+ $this->fail('Accessing an invalid attribute should throw an exception.');
+ } catch (Twig_Error_Runtime $e) {
+ $this->assertSame(sprintf($message, $name), $e->getMessage());
+ }
+ }
+
+ public function getAttributeExceptions()
+ {
+ $tests = array(
+ array('{{ string["a"] }}', 'Impossible to access a key ("a") on a string variable ("foo") in "%s" at line 1', false),
+ array('{{ null["a"] }}', 'Impossible to access a key ("a") on a null variable in "%s" at line 1', false),
+ array('{{ empty_array["a"] }}', 'Key "a" does not exist as the array is empty in "%s" at line 1', false),
+ array('{{ array["a"] }}', 'Key "a" for array with keys "foo" does not exist in "%s" at line 1', false),
+ array('{{ array_access["a"] }}', 'Key "a" in object with ArrayAccess of class "Twig_TemplateArrayAccessObject" does not exist in "%s" at line 1', false),
+ array('{{ string.a }}', 'Impossible to access an attribute ("a") on a string variable ("foo") in "%s" at line 1', false),
+ array('{{ string.a() }}', 'Impossible to invoke a method ("a") on a string variable ("foo") in "%s" at line 1', false),
+ array('{{ null.a }}', 'Impossible to access an attribute ("a") on a null variable in "%s" at line 1', false),
+ array('{{ null.a() }}', 'Impossible to invoke a method ("a") on a null variable in "%s" at line 1', false),
+ array('{{ empty_array.a }}', 'Key "a" does not exist as the array is empty in "%s" at line 1', false),
+ array('{{ array.a }}', 'Key "a" for array with keys "foo" does not exist in "%s" at line 1', false),
+ array('{{ attribute(array, -10) }}', 'Key "-10" for array with keys "foo" does not exist in "%s" at line 1', false),
+ array('{{ array_access.a }}', 'Method "a" for object "Twig_TemplateArrayAccessObject" does not exist in "%s" at line 1', false),
+ array('{% macro foo(obj) %}{{ obj.missing_method() }}{% endmacro %}{{ _self.foo(array_access) }}', 'Method "missing_method" for object "Twig_TemplateArrayAccessObject" does not exist in "%s" at line 1', false),
+ array('{{ magic_exception.test }}', 'An exception has been thrown during the rendering of a template ("Hey! Don\'t try to isset me!") in "%s" at line 1.', false),
+ array('{{ object["a"] }}', 'Impossible to access a key "a" on an object of class "stdClass" that does not implement ArrayAccess interface in "%s" at line 1', false),
+ );
+
+ if (function_exists('twig_template_get_attributes')) {
+ foreach (array_slice($tests, 0) as $test) {
+ $test[2] = true;
+ $tests[] = $test;
+ }
+ }
+
+ return $tests;
+ }
+
+ /**
+ * @dataProvider getGetAttributeWithSandbox
+ */
+ public function testGetAttributeWithSandbox($object, $item, $allowed, $useExt)
+ {
+ $twig = new Twig_Environment();
+ $policy = new Twig_Sandbox_SecurityPolicy(array(), array(), array(/*method*/), array(/*prop*/), array());
+ $twig->addExtension(new Twig_Extension_Sandbox($policy, !$allowed));
+ $template = new Twig_TemplateTest($twig, $useExt);
+
+ try {
+ $template->getAttribute($object, $item, array(), 'any');
+
+ if (!$allowed) {
+ $this->fail();
+ }
+ } catch (Twig_Sandbox_SecurityError $e) {
+ if ($allowed) {
+ $this->fail();
+ }
+
+ $this->assertContains('is not allowed', $e->getMessage());
+ }
+ }
+
+ public function getGetAttributeWithSandbox()
+ {
+ $tests = array(
+ array(new Twig_TemplatePropertyObject(), 'defined', false, false),
+ array(new Twig_TemplatePropertyObject(), 'defined', true, false),
+ array(new Twig_TemplateMethodObject(), 'defined', false, false),
+ array(new Twig_TemplateMethodObject(), 'defined', true, false),
+ );
+
+ if (function_exists('twig_template_get_attributes')) {
+ foreach (array_slice($tests, 0) as $test) {
+ $test[3] = true;
+ $tests[] = $test;
+ }
+ }
+
+ return $tests;
+ }
+
+ /**
+ * @dataProvider getGetAttributeWithTemplateAsObject
+ */
+ public function testGetAttributeWithTemplateAsObject($useExt)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(), $useExt);
+ $template1 = new Twig_TemplateTest(new Twig_Environment(), false);
+
+ $this->assertInstanceof('Twig_Markup', $template->getAttribute($template1, 'string'));
+ $this->assertEquals('some_string', $template->getAttribute($template1, 'string'));
+
+ $this->assertInstanceof('Twig_Markup', $template->getAttribute($template1, 'true'));
+ $this->assertEquals('1', $template->getAttribute($template1, 'true'));
+
+ $this->assertInstanceof('Twig_Markup', $template->getAttribute($template1, 'zero'));
+ $this->assertEquals('0', $template->getAttribute($template1, 'zero'));
+
+ $this->assertNotInstanceof('Twig_Markup', $template->getAttribute($template1, 'empty'));
+ $this->assertSame('', $template->getAttribute($template1, 'empty'));
+ }
+
+ public function getGetAttributeWithTemplateAsObject()
+ {
+ $bools = array(
+ array(false),
+ );
+
+ if (function_exists('twig_template_get_attributes')) {
+ $bools[] = array(true);
+ }
+
+ return $bools;
+ }
+
+ /**
+ * @dataProvider getTestsDependingOnExtensionAvailability
+ */
+ public function testGetAttributeOnArrayWithConfusableKey($useExt = false)
+ {
+ $template = new Twig_TemplateTest(
+ new Twig_Environment(),
+ $useExt
+ );
+
+ $array = array('Zero', 'One', -1 => 'MinusOne', '' => 'EmptyString', '1.5' => 'FloatButString', '01' => 'IntegerButStringWithLeadingZeros');
+
+ $this->assertSame('Zero', $array[false]);
+ $this->assertSame('One', $array[true]);
+ $this->assertSame('One', $array[1.5]);
+ $this->assertSame('One', $array['1']);
+ $this->assertSame('MinusOne', $array[-1.5]);
+ $this->assertSame('FloatButString', $array['1.5']);
+ $this->assertSame('IntegerButStringWithLeadingZeros', $array['01']);
+ $this->assertSame('EmptyString', $array[null]);
+
+ $this->assertSame('Zero', $template->getAttribute($array, false), 'false is treated as 0 when accessing an array (equals PHP behavior)');
+ $this->assertSame('One', $template->getAttribute($array, true), 'true is treated as 1 when accessing an array (equals PHP behavior)');
+ $this->assertSame('One', $template->getAttribute($array, 1.5), 'float is casted to int when accessing an array (equals PHP behavior)');
+ $this->assertSame('One', $template->getAttribute($array, '1'), '"1" is treated as integer 1 when accessing an array (equals PHP behavior)');
+ $this->assertSame('MinusOne', $template->getAttribute($array, -1.5), 'negative float is casted to int when accessing an array (equals PHP behavior)');
+ $this->assertSame('FloatButString', $template->getAttribute($array, '1.5'), '"1.5" is treated as-is when accessing an array (equals PHP behavior)');
+ $this->assertSame('IntegerButStringWithLeadingZeros', $template->getAttribute($array, '01'), '"01" is treated as-is when accessing an array (equals PHP behavior)');
+ $this->assertSame('EmptyString', $template->getAttribute($array, null), 'null is treated as "" when accessing an array (equals PHP behavior)');
+ }
+
+ public function getTestsDependingOnExtensionAvailability()
+ {
+ if (function_exists('twig_template_get_attributes')) {
+ return array(array(false), array(true));
+ }
+
+ return array(array(false));
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttribute($defined, $value, $object, $item, $arguments, $type, $useExt = false)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(), $useExt);
+
+ $this->assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeStrict($defined, $value, $object, $item, $arguments, $type, $useExt = false, $exceptionMessage = null)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(null, array('strict_variables' => true)), $useExt);
+
+ if ($defined) {
+ $this->assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+ } else {
+ try {
+ $this->assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+
+ throw new Exception('Expected Twig_Error_Runtime exception.');
+ } catch (Twig_Error_Runtime $e) {
+ if (null !== $exceptionMessage) {
+ $this->assertSame($exceptionMessage, $e->getMessage());
+ }
+ }
+ }
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeDefined($defined, $value, $object, $item, $arguments, $type, $useExt = false)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(), $useExt);
+
+ $this->assertEquals($defined, $template->getAttribute($object, $item, $arguments, $type, true));
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeDefinedStrict($defined, $value, $object, $item, $arguments, $type, $useExt = false)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(null, array('strict_variables' => true)), $useExt);
+
+ $this->assertEquals($defined, $template->getAttribute($object, $item, $arguments, $type, true));
+ }
+
+ /**
+ * @dataProvider getTestsDependingOnExtensionAvailability
+ */
+ public function testGetAttributeCallExceptions($useExt = false)
+ {
+ $template = new Twig_TemplateTest(new Twig_Environment(), $useExt);
+
+ $object = new Twig_TemplateMagicMethodExceptionObject();
+
+ $this->assertNull($template->getAttribute($object, 'foo'));
+ }
+
+ public function getGetAttributeTests()
+ {
+ $array = array(
+ 'defined' => 'defined',
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ 'bar' => true,
+ '09' => '09',
+ '+4' => '+4',
+ );
+
+ $objectArray = new Twig_TemplateArrayAccessObject();
+ $stdObject = (object) $array;
+ $magicPropertyObject = new Twig_TemplateMagicPropertyObject();
+ $propertyObject = new Twig_TemplatePropertyObject();
+ $propertyObject1 = new Twig_TemplatePropertyObjectAndIterator();
+ $propertyObject2 = new Twig_TemplatePropertyObjectAndArrayAccess();
+ $propertyObject3 = new Twig_TemplatePropertyObjectDefinedWithUndefinedValue();
+ $methodObject = new Twig_TemplateMethodObject();
+ $magicMethodObject = new Twig_TemplateMagicMethodObject();
+
+ $anyType = Twig_Template::ANY_CALL;
+ $methodType = Twig_Template::METHOD_CALL;
+ $arrayType = Twig_Template::ARRAY_CALL;
+
+ $basicTests = array(
+ // array(defined, value, property to fetch)
+ array(true, 'defined', 'defined'),
+ array(false, null, 'undefined'),
+ array(false, null, 'protected'),
+ array(true, 0, 'zero'),
+ array(true, 1, 1),
+ array(true, 1, 1.0),
+ array(true, null, 'null'),
+ array(true, true, 'bar'),
+ array(true, '09', '09'),
+ array(true, '+4', '+4'),
+ );
+ $testObjects = array(
+ // array(object, type of fetch)
+ array($array, $arrayType),
+ array($objectArray, $arrayType),
+ array($stdObject, $anyType),
+ array($magicPropertyObject, $anyType),
+ array($methodObject, $methodType),
+ array($methodObject, $anyType),
+ array($propertyObject, $anyType),
+ array($propertyObject1, $anyType),
+ array($propertyObject2, $anyType),
+ );
+
+ $tests = array();
+ foreach ($testObjects as $testObject) {
+ foreach ($basicTests as $test) {
+ // properties cannot be numbers
+ if (($testObject[0] instanceof stdClass || $testObject[0] instanceof Twig_TemplatePropertyObject) && is_numeric($test[2])) {
+ continue;
+ }
+
+ if ('+4' === $test[2] && $methodObject === $testObject[0]) {
+ continue;
+ }
+
+ $tests[] = array($test[0], $test[1], $testObject[0], $test[2], array(), $testObject[1]);
+ }
+ }
+
+ // additional properties tests
+ $tests = array_merge($tests, array(
+ array(true, null, $propertyObject3, 'foo', array(), $anyType),
+ ));
+
+ // additional method tests
+ $tests = array_merge($tests, array(
+ array(true, 'defined', $methodObject, 'defined', array(), $methodType),
+ array(true, 'defined', $methodObject, 'DEFINED', array(), $methodType),
+ array(true, 'defined', $methodObject, 'getDefined', array(), $methodType),
+ array(true, 'defined', $methodObject, 'GETDEFINED', array(), $methodType),
+ array(true, 'static', $methodObject, 'static', array(), $methodType),
+ array(true, 'static', $methodObject, 'getStatic', array(), $methodType),
+
+ array(true, '__call_undefined', $magicMethodObject, 'undefined', array(), $methodType),
+ array(true, '__call_UNDEFINED', $magicMethodObject, 'UNDEFINED', array(), $methodType),
+ ));
+
+ // add the same tests for the any type
+ foreach ($tests as $test) {
+ if ($anyType !== $test[5]) {
+ $test[5] = $anyType;
+ $tests[] = $test;
+ }
+ }
+
+ $methodAndPropObject = new Twig_TemplateMethodAndPropObject();
+
+ // additional method tests
+ $tests = array_merge($tests, array(
+ array(true, 'a', $methodAndPropObject, 'a', array(), $anyType),
+ array(true, 'a', $methodAndPropObject, 'a', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'a', array(), $arrayType),
+
+ array(true, 'b_prop', $methodAndPropObject, 'b', array(), $anyType),
+ array(true, 'b', $methodAndPropObject, 'B', array(), $anyType),
+ array(true, 'b', $methodAndPropObject, 'b', array(), $methodType),
+ array(true, 'b', $methodAndPropObject, 'B', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'b', array(), $arrayType),
+
+ array(false, null, $methodAndPropObject, 'c', array(), $anyType),
+ array(false, null, $methodAndPropObject, 'c', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'c', array(), $arrayType),
+
+ ));
+
+ // tests when input is not an array or object
+ $tests = array_merge($tests, array(
+ array(false, null, 42, 'a', array(), $anyType, false, 'Impossible to access an attribute ("a") on a integer variable ("42")'),
+ array(false, null, "string", 'a', array(), $anyType, false, 'Impossible to access an attribute ("a") on a string variable ("string")'),
+ array(false, null, array(), 'a', array(), $anyType, false, 'Key "a" does not exist as the array is empty'),
+ ));
+
+ // add twig_template_get_attributes tests
+
+ if (function_exists('twig_template_get_attributes')) {
+ foreach (array_slice($tests, 0) as $test) {
+ $test = array_pad($test, 7, null);
+ $test[6] = true;
+ $tests[] = $test;
+ }
+ }
+
+ return $tests;
+ }
+}
+
+class Twig_TemplateTest extends Twig_Template
+{
+ protected $useExtGetAttribute = false;
+
+ public function __construct(Twig_Environment $env, $useExtGetAttribute = false)
+ {
+ parent::__construct($env);
+ $this->useExtGetAttribute = $useExtGetAttribute;
+ self::$cache = array();
+ }
+
+ public function getZero()
+ {
+ return 0;
+ }
+
+ public function getEmpty()
+ {
+ return '';
+ }
+
+ public function getString()
+ {
+ return 'some_string';
+ }
+
+ public function getTrue()
+ {
+ return true;
+ }
+
+ public function getTemplateName()
+ {
+ }
+
+ public function getDebugInfo()
+ {
+ return array();
+ }
+
+ protected function doGetParent(array $context)
+ {
+ }
+
+ protected function doDisplay(array $context, array $blocks = array())
+ {
+ }
+
+ public function getAttribute($object, $item, array $arguments = array(), $type = Twig_Template::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
+ {
+ if ($this->useExtGetAttribute) {
+ return twig_template_get_attributes($this, $object, $item, $arguments, $type, $isDefinedTest, $ignoreStrictCheck);
+ } else {
+ return parent::getAttribute($object, $item, $arguments, $type, $isDefinedTest, $ignoreStrictCheck);
+ }
+ }
+}
+
+class Twig_TemplateArrayAccessObject implements ArrayAccess
+{
+ protected $protected = 'protected';
+
+ public $attributes = array(
+ 'defined' => 'defined',
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ 'bar' => true,
+ '09' => '09',
+ '+4' => '+4',
+ );
+
+ public function offsetExists($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ public function offsetGet($name)
+ {
+ return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : null;
+ }
+
+ public function offsetSet($name, $value)
+ {
+ }
+
+ public function offsetUnset($name)
+ {
+ }
+}
+
+class Twig_TemplateMagicPropertyObject
+{
+ public $defined = 'defined';
+
+ public $attributes = array(
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ 'bar' => true,
+ '09' => '09',
+ '+4' => '+4',
+ );
+
+ protected $protected = 'protected';
+
+ public function __isset($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ public function __get($name)
+ {
+ return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : null;
+ }
+}
+
+class Twig_TemplateMagicPropertyObjectWithException
+{
+ public function __isset($key)
+ {
+ throw new Exception('Hey! Don\'t try to isset me!');
+ }
+}
+
+class Twig_TemplatePropertyObject
+{
+ public $defined = 'defined';
+ public $zero = 0;
+ public $null = null;
+ public $bar = true;
+
+ protected $protected = 'protected';
+}
+
+class Twig_TemplatePropertyObjectAndIterator extends Twig_TemplatePropertyObject implements IteratorAggregate
+{
+ public function getIterator()
+ {
+ return new ArrayIterator(array('foo', 'bar'));
+ }
+}
+
+class Twig_TemplatePropertyObjectAndArrayAccess extends Twig_TemplatePropertyObject implements ArrayAccess
+{
+ private $data = array();
+
+ public function offsetExists($offset)
+ {
+ return array_key_exists($offset, $this->data);
+ }
+
+ public function offsetGet($offset)
+ {
+ return $this->offsetExists($offset) ? $this->data[$offset] : 'n/a';
+ }
+
+ public function offsetSet($offset, $value)
+ {
+ }
+
+ public function offsetUnset($offset)
+ {
+ }
+}
+
+class Twig_TemplatePropertyObjectDefinedWithUndefinedValue
+{
+ public $foo;
+
+ public function __construct()
+ {
+ $this->foo = @$notExist;
+ }
+}
+
+class Twig_TemplateMethodObject
+{
+ public function getDefined()
+ {
+ return 'defined';
+ }
+
+ public function get1()
+ {
+ return 1;
+ }
+
+ public function get09()
+ {
+ return '09';
+ }
+
+ public function getZero()
+ {
+ return 0;
+ }
+
+ public function getNull()
+ {
+ }
+
+ public function isBar()
+ {
+ return true;
+ }
+
+ protected function getProtected()
+ {
+ return 'protected';
+ }
+
+ public static function getStatic()
+ {
+ return 'static';
+ }
+}
+
+class Twig_TemplateMethodAndPropObject
+{
+ private $a = 'a_prop';
+ public function getA()
+ {
+ return 'a';
+ }
+
+ public $b = 'b_prop';
+ public function getB()
+ {
+ return 'b';
+ }
+
+ private $c = 'c_prop';
+ private function getC()
+ {
+ return 'c';
+ }
+}
+
+class Twig_TemplateMagicMethodObject
+{
+ public function __call($method, $arguments)
+ {
+ return '__call_'.$method;
+ }
+}
+
+class Twig_TemplateMagicMethodExceptionObject
+{
+ public function __call($method, $arguments)
+ {
+ throw new BadMethodCallException(sprintf('Unkown method %s', $method));
+ }
+}
+
+class CExtDisablingNodeVisitor implements Twig_NodeVisitorInterface
+{
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Expression_GetAttr) {
+ $node->setAttribute('disable_c_ext', true);
+ }
+
+ return $node;
+ }
+
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/TokenStreamTest.php b/vendor/twig/twig/test/Twig/Tests/TokenStreamTest.php
new file mode 100755
index 0000000..fd4ec63
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/TokenStreamTest.php
@@ -0,0 +1,70 @@
+isEOF()) {
+ $token = $stream->next();
+
+ $repr[] = $token->getValue();
+ }
+ $this->assertEquals('1, 2, 3, 4, 5, 6, 7', implode(', ', $repr), '->next() advances the pointer and returns the current token');
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedMessage Unexpected end of template
+ */
+ public function testEndOfTemplateNext()
+ {
+ $stream = new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, 1, 1),
+ ));
+ while (!$stream->isEOF()) {
+ $stream->next();
+ }
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedMessage Unexpected end of template
+ */
+ public function testEndOfTemplateLook()
+ {
+ $stream = new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, 1, 1),
+ ));
+ while (!$stream->isEOF()) {
+ $stream->look();
+ $stream->next();
+ }
+ }
+}
diff --git a/vendor/twig/twig/test/Twig/Tests/escapingTest.php b/vendor/twig/twig/test/Twig/Tests/escapingTest.php
new file mode 100755
index 0000000..dfa9d43
--- /dev/null
+++ b/vendor/twig/twig/test/Twig/Tests/escapingTest.php
@@ -0,0 +1,320 @@
+ ''',
+ '"' => '"',
+ '<' => '<',
+ '>' => '>',
+ '&' => '&',
+ );
+
+ protected $htmlAttrSpecialChars = array(
+ '\'' => ''',
+ /* Characters beyond ASCII value 255 to unicode escape */
+ 'Ā' => 'Ā',
+ /* Immune chars excluded */
+ ',' => ',',
+ '.' => '.',
+ '-' => '-',
+ '_' => '_',
+ /* Basic alnums excluded */
+ 'a' => 'a',
+ 'A' => 'A',
+ 'z' => 'z',
+ 'Z' => 'Z',
+ '0' => '0',
+ '9' => '9',
+ /* Basic control characters and null */
+ "\r" => '
',
+ "\n" => '
',
+ "\t" => ' ',
+ "\0" => '�', // should use Unicode replacement char
+ /* Encode chars as named entities where possible */
+ '<' => '<',
+ '>' => '>',
+ '&' => '&',
+ '"' => '"',
+ /* Encode spaces for quoteless attribute protection */
+ ' ' => ' ',
+ );
+
+ protected $jsSpecialChars = array(
+ /* HTML special chars - escape without exception to hex */
+ '<' => '\\x3C',
+ '>' => '\\x3E',
+ '\'' => '\\x27',
+ '"' => '\\x22',
+ '&' => '\\x26',
+ /* Characters beyond ASCII value 255 to unicode escape */
+ 'Ā' => '\\u0100',
+ /* Immune chars excluded */
+ ',' => ',',
+ '.' => '.',
+ '_' => '_',
+ /* Basic alnums excluded */
+ 'a' => 'a',
+ 'A' => 'A',
+ 'z' => 'z',
+ 'Z' => 'Z',
+ '0' => '0',
+ '9' => '9',
+ /* Basic control characters and null */
+ "\r" => '\\x0D',
+ "\n" => '\\x0A',
+ "\t" => '\\x09',
+ "\0" => '\\x00',
+ /* Encode spaces for quoteless attribute protection */
+ ' ' => '\\x20',
+ );
+
+ protected $urlSpecialChars = array(
+ /* HTML special chars - escape without exception to percent encoding */
+ '<' => '%3C',
+ '>' => '%3E',
+ '\'' => '%27',
+ '"' => '%22',
+ '&' => '%26',
+ /* Characters beyond ASCII value 255 to hex sequence */
+ 'Ā' => '%C4%80',
+ /* Punctuation and unreserved check */
+ ',' => '%2C',
+ '.' => '.',
+ '_' => '_',
+ '-' => '-',
+ ':' => '%3A',
+ ';' => '%3B',
+ '!' => '%21',
+ /* Basic alnums excluded */
+ 'a' => 'a',
+ 'A' => 'A',
+ 'z' => 'z',
+ 'Z' => 'Z',
+ '0' => '0',
+ '9' => '9',
+ /* Basic control characters and null */
+ "\r" => '%0D',
+ "\n" => '%0A',
+ "\t" => '%09',
+ "\0" => '%00',
+ /* PHP quirks from the past */
+ ' ' => '%20',
+ '~' => '~',
+ '+' => '%2B',
+ );
+
+ protected $cssSpecialChars = array(
+ /* HTML special chars - escape without exception to hex */
+ '<' => '\\3C ',
+ '>' => '\\3E ',
+ '\'' => '\\27 ',
+ '"' => '\\22 ',
+ '&' => '\\26 ',
+ /* Characters beyond ASCII value 255 to unicode escape */
+ 'Ā' => '\\100 ',
+ /* Immune chars excluded */
+ ',' => '\\2C ',
+ '.' => '\\2E ',
+ '_' => '\\5F ',
+ /* Basic alnums excluded */
+ 'a' => 'a',
+ 'A' => 'A',
+ 'z' => 'z',
+ 'Z' => 'Z',
+ '0' => '0',
+ '9' => '9',
+ /* Basic control characters and null */
+ "\r" => '\\D ',
+ "\n" => '\\A ',
+ "\t" => '\\9 ',
+ "\0" => '\\0 ',
+ /* Encode spaces for quoteless attribute protection */
+ ' ' => '\\20 ',
+ );
+
+ protected $env;
+
+ public function setUp()
+ {
+ $this->env = new Twig_Environment();
+ }
+
+ public function testHtmlEscapingConvertsSpecialChars()
+ {
+ foreach ($this->htmlSpecialChars as $key => $value) {
+ $this->assertEquals($value, twig_escape_filter($this->env, $key, 'html'), 'Failed to escape: '.$key);
+ }
+ }
+
+ public function testHtmlAttributeEscapingConvertsSpecialChars()
+ {
+ foreach ($this->htmlAttrSpecialChars as $key => $value) {
+ $this->assertEquals($value, twig_escape_filter($this->env, $key, 'html_attr'), 'Failed to escape: '.$key);
+ }
+ }
+
+ public function testJavascriptEscapingConvertsSpecialChars()
+ {
+ foreach ($this->jsSpecialChars as $key => $value) {
+ $this->assertEquals($value, twig_escape_filter($this->env, $key, 'js'), 'Failed to escape: '.$key);
+ }
+ }
+
+ public function testJavascriptEscapingReturnsStringIfZeroLength()
+ {
+ $this->assertEquals('', twig_escape_filter($this->env, '', 'js'));
+ }
+
+ public function testJavascriptEscapingReturnsStringIfContainsOnlyDigits()
+ {
+ $this->assertEquals('123', twig_escape_filter($this->env, '123', 'js'));
+ }
+
+ public function testCssEscapingConvertsSpecialChars()
+ {
+ foreach ($this->cssSpecialChars as $key => $value) {
+ $this->assertEquals($value, twig_escape_filter($this->env, $key, 'css'), 'Failed to escape: '.$key);
+ }
+ }
+
+ public function testCssEscapingReturnsStringIfZeroLength()
+ {
+ $this->assertEquals('', twig_escape_filter($this->env, '', 'css'));
+ }
+
+ public function testCssEscapingReturnsStringIfContainsOnlyDigits()
+ {
+ $this->assertEquals('123', twig_escape_filter($this->env, '123', 'css'));
+ }
+
+ public function testUrlEscapingConvertsSpecialChars()
+ {
+ foreach ($this->urlSpecialChars as $key => $value) {
+ $this->assertEquals($value, twig_escape_filter($this->env, $key, 'url'), 'Failed to escape: '.$key);
+ }
+ }
+
+ /**
+ * Range tests to confirm escaped range of characters is within OWASP recommendation
+ */
+
+ /**
+ * Only testing the first few 2 ranges on this prot. function as that's all these
+ * other range tests require
+ */
+ public function testUnicodeCodepointConversionToUtf8()
+ {
+ $expected = " ~ޙ";
+ $codepoints = array(0x20, 0x7e, 0x799);
+ $result = '';
+ foreach ($codepoints as $value) {
+ $result .= $this->codepointToUtf8($value);
+ }
+ $this->assertEquals($expected, $result);
+ }
+
+ /**
+ * Convert a Unicode Codepoint to a literal UTF-8 character.
+ *
+ * @param int $codepoint Unicode codepoint in hex notation
+ *
+ * @return string UTF-8 literal string
+ */
+ protected function codepointToUtf8($codepoint)
+ {
+ if ($codepoint < 0x80) {
+ return chr($codepoint);
+ }
+ if ($codepoint < 0x800) {
+ return chr($codepoint >> 6 & 0x3f | 0xc0)
+ .chr($codepoint & 0x3f | 0x80);
+ }
+ if ($codepoint < 0x10000) {
+ return chr($codepoint >> 12 & 0x0f | 0xe0)
+ .chr($codepoint >> 6 & 0x3f | 0x80)
+ .chr($codepoint & 0x3f | 0x80);
+ }
+ if ($codepoint < 0x110000) {
+ return chr($codepoint >> 18 & 0x07 | 0xf0)
+ .chr($codepoint >> 12 & 0x3f | 0x80)
+ .chr($codepoint >> 6 & 0x3f | 0x80)
+ .chr($codepoint & 0x3f | 0x80);
+ }
+ throw new Exception('Codepoint requested outside of Unicode range');
+ }
+
+ public function testJavascriptEscapingEscapesOwaspRecommendedRanges()
+ {
+ $immune = array(',', '.', '_'); // Exceptions to escaping ranges
+ for ($chr = 0; $chr < 0xFF; $chr++) {
+ if ($chr >= 0x30 && $chr <= 0x39
+ || $chr >= 0x41 && $chr <= 0x5A
+ || $chr >= 0x61 && $chr <= 0x7A) {
+ $literal = $this->codepointToUtf8($chr);
+ $this->assertEquals($literal, twig_escape_filter($this->env, $literal, 'js'));
+ } else {
+ $literal = $this->codepointToUtf8($chr);
+ if (in_array($literal, $immune)) {
+ $this->assertEquals($literal, twig_escape_filter($this->env, $literal, 'js'));
+ } else {
+ $this->assertNotEquals(
+ $literal,
+ twig_escape_filter($this->env, $literal, 'js'),
+ "$literal should be escaped!");
+ }
+ }
+ }
+ }
+
+ public function testHtmlAttributeEscapingEscapesOwaspRecommendedRanges()
+ {
+ $immune = array(',', '.', '-', '_'); // Exceptions to escaping ranges
+ for ($chr = 0; $chr < 0xFF; $chr++) {
+ if ($chr >= 0x30 && $chr <= 0x39
+ || $chr >= 0x41 && $chr <= 0x5A
+ || $chr >= 0x61 && $chr <= 0x7A) {
+ $literal = $this->codepointToUtf8($chr);
+ $this->assertEquals($literal, twig_escape_filter($this->env, $literal, 'html_attr'));
+ } else {
+ $literal = $this->codepointToUtf8($chr);
+ if (in_array($literal, $immune)) {
+ $this->assertEquals($literal, twig_escape_filter($this->env, $literal, 'html_attr'));
+ } else {
+ $this->assertNotEquals(
+ $literal,
+ twig_escape_filter($this->env, $literal, 'html_attr'),
+ "$literal should be escaped!");
+ }
+ }
+ }
+ }
+
+ public function testCssEscapingEscapesOwaspRecommendedRanges()
+ {
+ // CSS has no exceptions to escaping ranges
+ for ($chr = 0; $chr < 0xFF; $chr++) {
+ if ($chr >= 0x30 && $chr <= 0x39
+ || $chr >= 0x41 && $chr <= 0x5A
+ || $chr >= 0x61 && $chr <= 0x7A) {
+ $literal = $this->codepointToUtf8($chr);
+ $this->assertEquals($literal, twig_escape_filter($this->env, $literal, 'css'));
+ } else {
+ $literal = $this->codepointToUtf8($chr);
+ $this->assertNotEquals(
+ $literal,
+ twig_escape_filter($this->env, $literal, 'css'),
+ "$literal should be escaped!");
+ }
+ }
+ }
+}
diff --git a/vendor/twig/twig/test/bootstrap.php b/vendor/twig/twig/test/bootstrap.php
new file mode 100755
index 0000000..aecb976
--- /dev/null
+++ b/vendor/twig/twig/test/bootstrap.php
@@ -0,0 +1,13 @@
+