def test_searchpath_as_pathlib(self):
import pathlib
searchpath = pathlib.Path(self.searchpath)
filesystem_loader = loaders.FileSystemLoader(searchpath)
env = Environment(loader=filesystem_loader)
self._test_common(env)
def ready(self):
global JINJA_RENDERER
jinja_env = jinja2.Environment(
loader=loaders.FileSystemLoader(TEMPALTES_PATH),
trim_blocks=True,
lstrip_blocks=True,
extensions=['jinja2.ext.do'])
JINJA_RENDERER = jinja2py.JinjaRenderer(jinja_env)
generate_names = list()
codes = dict()
for f in os.listdir(TEMPALTES_PATH):
if f in BANED_NAMES:
continue
if os.path.isfile(os.path.join(TEMPALTES_PATH, f)):
if f.endswith('.py.jinja2'):
generate_names.append(f[:-len('.jinja2')])
elif f.endswith('.py'):
with open(os.path.join(TEMPALTES_PATH, f)) as c:
codes[f] = c.read()
global GENERATE_NAMES
GENERATE_NAMES = generate_names
global CODES
CODES = codes
def test_filename_normpath(self):
"""Nested template names should only contain ``os.sep`` in the
loaded filename.
"""
loader = loaders.FileSystemLoader(self.searchpath)
e = Environment(loader=loader)
t = e.get_template("foo/test.html")
assert t.filename == str(self.searchpath / "foo" / "test.html")
def filesystem_loader():
"""returns FileSystemLoader initialized to res/templates directory"""
try:
import yatest.common
here = yatest.common.test_source_path()
except ImportError:
here = os.path.dirname(os.path.abspath(__file__))
return loaders.FileSystemLoader(here + "/res/templates")
def test_searchpath_as_list_including_pathlib(self):
import pathlib
searchpath = pathlib.Path(self.searchpath)
filesystem_loader = loaders.FileSystemLoader(
["/tmp/templates", searchpath])
env = Environment(loader=filesystem_loader)
self._test_common(env)
def _make_jinja_app_loader():
"""Makes an 'app loader' for Jinja which acts like
:mod:`django.template.loaders.app_directories`.
"""
from django.template.loaders.app_directories import app_template_dirs
loader = loaders.FileSystemLoader([])
loader.searchpath = GetTemplateDirs(lambda: app_template_dirs)
return loader
def _make_jinja_filesystem_loader():
"""Makes a 'filesystem loader' for Jinja which acts like
:mod:`django.template.loaders.filesystem`.
"""
from django.conf import settings
loader = loaders.FileSystemLoader([])
loader.searchpath = GetTemplateDirs(lambda: settings.TEMPLATE_DIRS)
return loader
def test_filesystem_loader_searchpaths(self):
pathlib = pytest.importorskip('pathlib')
here = os.path.dirname(os.path.abspath(__file__))
tmpl_path = os.path.join(here, 'res', 'templates', 'foo')
for p in [tmpl_path, pathlib.Path(tmpl_path)]:
loader = loaders.FileSystemLoader(p)
env = Environment(loader=loader)
tmpl = env.get_template('test.html')
assert tmpl.render().strip() == 'FOO'
def _get_loaders(self):
"""this method is not used
over-ridden function _get_loaders that creates
the loader for the skin templates
"""
loaders = list()
skin_dirs = utils.get_available_skins(selected=self.skin).values()
template_dirs = [os.path.join(skin_dir, 'templates') for skin_dir in skin_dirs]
loaders.append(jinja_loaders.FileSystemLoader(template_dirs))
return loaders
def test_caches_template_based_on_mtime(self):
filesystem_loader = loaders.FileSystemLoader(self.searchpath)
env = Environment(loader=filesystem_loader)
tmpl1 = env.get_template("test.html")
tmpl2 = env.get_template("test.html")
assert tmpl1 is tmpl2
os.utime(self.searchpath / "test.html", (time.time(), time.time()))
tmpl3 = env.get_template("test.html")
assert tmpl1 is not tmpl3
def __init__(self, packages):
self.searchpath = ['templates']
try:
self.fsl = loaders.FileSystemLoader(self.searchpath)
except Exception as e:
log.error(e)
self.modules = packages
self.packages = {}
self.encoding = 'utf-8'
self.package_path = "templates"
self.manager = ResourceManager()
def filesystem_loader():
'''returns FileSystemLoader initialized to res/templates directory
'''
here = os.path.dirname(os.path.abspath(__file__))
return loaders.FileSystemLoader(here + '/res/templates')
def test_uses_specified_encoding(self, encoding, expect):
loader = loaders.FileSystemLoader(self.searchpath, encoding=encoding)
e = Environment(loader=loader)
t = e.get_template("mojibake.txt")
assert t.render() == expect
def test_searchpath_as_str(self):
filesystem_loader = loaders.FileSystemLoader(str(self.searchpath))
env = Environment(loader=filesystem_loader)
self._test_common(env)
def main():
# Parse anli dir, data persistence.
dic = _parse_dir()
_create_db(dic)
# Read data from database
anli_table = _read_db()
# Hold data needed to be rendered in one list.
html_result = []
# Create index.html template render data.
# {
# "html_title": "",
# "xiaotu_dict": {
# "keji": {
# "name": "KEJI",
# "list": [
# ("cx_keji_01_1_shouyexiaotu1", 1),
# ("cx_keji_02_1_shouyexiaotu2", 2)
# ]
# }
# },
# "datu_list": [
# ("cx_keji_01_1_shouyedatu1", 1),
# ("cx_keji_02_1_shouyedatu2", 2)
# ],
# "meta": {}
# }
xiaotu_dict = {}
datu_list = []
for anli in anli_table:
anli_dir_name = anli["id"]
if "shouyexiaotu_order" in anli:
order = anli["shouyexiaotu_order"]
anli_name = anli["mingcheng"]
fengge_key = _get_fengge_key(anli_dir_name)
# Create empty list when not exist.
if fengge_key not in xiaotu_dict:
xiaotu_dict[fengge_key] = {}
xiaotu_dict[fengge_key]["name"] = anli["fengge_name"]
xiaotu_dict[fengge_key]["list"] = []
fengge = xiaotu_dict[fengge_key]
fengge["list"].append((anli_dir_name, anli_name, order))
# Sort with order number
fengge["list"] = sorted(fengge["list"], key=lambda anli: anli[2])
if "shouyedatu_order" in anli:
order = anli["shouyedatu_order"]
datu_list.append((anli_dir_name, order - 1))
# Sort with order number
datu_list = sorted(datu_list, key=lambda anli: anli[1])
html_result.append({
"file_name": "index.html",
"template_name": "anlizhanshi/index.html",
"render_data": {
"html_title": u"3D展厅模板 - 首页",
"fengge_dict": xiaotu_dict,
"datu_list": datu_list,
"meta": META
}
})
# Create more.html template render data.
# {
# "html_title": "",
# "fengge_name": "",
# "item_list": {
# "name": "KEJI",
# "list": [
# ("cx_keji_01_1", "cx_keji_01_1", 1452661512, "2016-01-13T05:05:12+00:00"),
# ("cx_keji_02_1", "科技案例02", 1452661512, "2016-01-13T05:05:12+00:00")
# ]
# },
# "count": 45,
# "option": {
# "limit": 20
# },
# "meta": {}
# }
for fengge_key in _db_group("fengge_key", anli_table):
anli_list = _db_select("fengge_key", fengge_key, anli_table)
anli_count = len(anli_list)
page_number = 1
current_page_list = []
current_anli_index = 1
for anli in anli_list:
anli_dir_name = anli[0]
anli_name = anli[1]
fengge_name = _get_fengge_name(anli_dir_name)
dir_created_unix_time = _get_created_date(anli_dir_name) # int
dir_created_time = time.ctime(dir_created_unix_time)
current_page_list.append(
# dir_name # dir_created_date
(anli_dir_name, anli_name, dir_created_unix_time,
str(dir_created_time)))
if current_anli_index % LIMIT == 0 or current_anli_index == anli_count:
file_name = "more-" + fengge_key + "-" + str(
page_number) + ".html"
html_result.append({
"file_name": file_name,
"template_name": "anlizhanshi/more.html",
"render_data": {
"html_title": u"3D展厅模板 - " + fengge_name,
"fengge_name": fengge_name,
"item_list": current_page_list,
"fengge_key": fengge_key,
"current_page": page_number,
"count": anli_count,
"option": {
"limit": LIMIT
},
"meta": META
}
})
current_page_list = []
page_number += 1
current_anli_index += 1
#env = Environment(loader=filesystem_loader)
env = Environment(loader=loaders.FileSystemLoader(_get_template_path()))
for html_file in html_result:
tmpl = env.get_template(html_file["template_name"])
html_path = os.path.join(_get_output_path(), html_file["file_name"])
output = tmpl.render(data=html_file["render_data"]).encode('utf8')
with open(html_path, "wb") as fh:
fh.write(output)
def _get_loaders(self):
template_dirs = self.get_all_template_dirs()
return [jinja_loaders.FileSystemLoader(template_dirs)]
def _make_jinja_filesystem_loader():
"""Makes a 'filesystem loader' for Jinja which acts like
:mod:`django.template.loaders.filesystem`.
"""
from django.conf import settings
return loaders.FileSystemLoader(settings.TEMPLATE_DIRS)
def _make_jinja_app_loader():
"""Makes an 'app loader' for Jinja which acts like
:mod:`django.template.loaders.app_directories`.
"""
from django.template.loaders.app_directories import app_template_dirs
return loaders.FileSystemLoader(app_template_dirs)
def file_loader(here):
return loaders.FileSystemLoader(os.path.join(here, 'templates'))
def test_uses_specified_encoding(self, encoding, expected_text):
filesystem_loader = loaders.FileSystemLoader(self.searchpath,
encoding=encoding)
env = Environment(loader=filesystem_loader)
tmpl = env.get_template('variable_encoding.txt')
assert tmpl.render().strip() == expected_text
:license: BSD, see LICENSE for more details.
"""
from py.test import raises
import time
import tempfile
from jinja2 import Environment, loaders
from jinja2.loaders import split_template_path
from jinja2.exceptions import TemplateNotFound
dict_loader = loaders.DictLoader({
'justdict.html': 'FOO'
})
package_loader = loaders.PackageLoader('loaderres', 'templates')
filesystem_loader = loaders.FileSystemLoader('loaderres/templates')
function_loader = loaders.FunctionLoader({'justfunction.html': 'FOO'}.get)
choice_loader = loaders.ChoiceLoader([dict_loader, package_loader])
prefix_loader = loaders.PrefixLoader({
'a': filesystem_loader,
'b': dict_loader
})
def test_dict_loader():
env = Environment(loader=dict_loader)
tmpl = env.get_template('justdict.html')
assert tmpl.render().strip() == 'FOO'
raises(TemplateNotFound, env.get_template, 'missing.html')
def filesystem_loader():
"""returns FileSystemLoader initialized to res/templates directory"""
here = Path(__file__).parent.resolve()
return loaders.FileSystemLoader(here / "res" / "templates")
def filesystem_loader():
"""returns FileSystemLoader initialized to res/templates directory"""
import yatest.common
here = Path(yatest.common.test_source_path())
return loaders.FileSystemLoader(here / "res" / "templates")
:copyright: (c) 2010 by the Jinja Team.
:license: BSD, see LICENSE for more details.
"""
import os
import re
import sys
import unittest
from traceback import format_exception
from jinja2 import loaders
from jinja2._compat import PY2
here = os.path.dirname(os.path.abspath(__file__))
dict_loader = loaders.DictLoader({'justdict.html': 'FOO'})
package_loader = loaders.PackageLoader('jinja2.testsuite.res', 'templates')
filesystem_loader = loaders.FileSystemLoader(here + '/res/templates')
function_loader = loaders.FunctionLoader({'justfunction.html': 'FOO'}.get)
choice_loader = loaders.ChoiceLoader([dict_loader, package_loader])
prefix_loader = loaders.PrefixLoader({
'a': filesystem_loader,
'b': dict_loader
})
class JinjaTestCase(unittest.TestCase):
### use only these methods for testing. If you need standard
### unittest method, wrap them!
def setup(self):
pass
def build_loader(paths, packages):
fs_loaders = [loaders.FileSystemLoader(path) for path in paths]
package_loaders = [loaders.PackageLoader(package.package_name, package.template_path)
for package in packages]
return loaders.ChoiceLoader(fs_loaders + package_loaders)
