def load_template(self, template_name, template_dirs=None):
key = template_name
if template_dirs:
# If template directories were specified, use a hash to differentiate
key = '-'.join([template_name, hashlib.sha1('|'.join(template_dirs)).hexdigest()])
if settings.DEBUG or key not in self.template_cache:
if os.path.splitext(template_name)[1] in ('.pug',):
try:
source, display_name = self.load_template_source(template_name, template_dirs)
source = process(source,filename=template_name,compiler=Compiler)
origin = make_origin(display_name, self.load_template_source, template_name, template_dirs)
template = Template(source, origin, template_name)
except NotImplementedError:
template, origin = self.find_template(template_name, template_dirs)
else:
template, origin = self.find_template(template_name, template_dirs)
if not hasattr(template, 'render'):
try:
template = Template(process(source,filename=template_name,compiler=Compiler), origin, template_name)
except (TemplateDoesNotExist, UnboundLocalError):
# If compiling the template we found raises TemplateDoesNotExist,
# back off to returning he source and display name for the template
# we were asked to load. This allows for correct identification (later)
# of the actual template that does not exist.
return template, origin
self.template_cache[key] = template
return self.template_cache[key], None
def django_process(src, filename):
compiled = process(src, filename=filename, compiler=DjangoCompiler)
print(compiled)
t = django.template.Template(compiled)
ctx = django.template.Context()
return t.render(ctx)
def templatize(src, origin=None):
src = to_text(src, settings.FILE_CHARSET)
if origin.endswith(".pug"):
html = process(src, compiler=Compiler)
else:
html = src
return func(html, origin)
def convert_file():
support_compilers_list = ['django', 'jinja', 'underscore', 'mako', 'tornado', 'html']
available_compilers = {}
for i in support_compilers_list:
try:
compiler_class = __import__('pypugjs.ext.%s' % i, fromlist=['pypugjs']).Compiler
except ImportError as e:
logging.warning(e)
else:
available_compilers[i] = compiler_class
usage = "usage: %prog [options] [file [output]]"
parser = OptionParser(usage)
parser.add_option("-o", "--output", dest="output",
help="Write output to FILE", metavar="FILE")
# use a default compiler here to sidestep making a particular
# compiler absolutely necessary (ex. django)
default_compiler = sorted(available_compilers.keys())[0]
parser.add_option("-c", "--compiler", dest="compiler",
choices=list(available_compilers.keys()),
default=default_compiler,
type="choice",
help=("COMPILER must be one of %s, default is %s" %
(', '.join(list(available_compilers.keys())), default_compiler)))
parser.add_option("-e", "--ext", dest="extension",
help="Set import/extends default file extension",
metavar="FILE")
options, args = parser.parse_args()
file_output = options.output or (args[1] if len(args) > 1 else None)
compiler = options.compiler
if options.extension:
extension = '.%s' % options.extension
elif options.output:
extension = os.path.splitext(options.output)[1]
else:
extension = None
if compiler in available_compilers:
import six
if len(args) >= 1:
template = codecs.open(args[0], 'r', encoding='utf-8').read()
elif six.PY3:
template = sys.stdin.read()
else:
template = codecs.getreader('utf-8')(sys.stdin).read()
output = process(template, compiler=available_compilers[compiler],
staticAttrs=True, extension=extension)
if file_output:
outfile = codecs.open(file_output, 'w', encoding='utf-8')
outfile.write(output)
elif six.PY3:
sys.stdout.write(output)
else:
codecs.getwriter('utf-8')(sys.stdout).write(output)
else:
raise Exception('You must have %s installed!' % compiler)
def preprocess(self, source, name, filename=None):
if (not name or
(name and not os.path.splitext(name)[1] in self.file_extensions)):
return source
return process(source,
filename=name,
compiler=Compiler,
**self.options)
def get_contents(self, origin):
contents = origin.loader.get_contents(origin)
if os.path.splitext(origin.template_name)[1] in ('.pug', '.jade'):
contents = self.include_pug_sources(contents)
contents = process(contents,
filename=origin.template_name,
compiler=Compiler)
return contents
def templatize(src, origin=None, charset=None):
src = to_text(src, charset or settings.FILE_CHARSET)
if origin.endswith(".pug"):
html = process(src,
compiler=Compiler,
base_directory=os.path.basename(origin))
else:
html = src
return func(html, origin)
def __init__(self, template_string, name="<string>", *args, **kwargs):
is_pugjs = name.endswith(".pug")
if is_pugjs:
template_string = process(template_string, filename=name, compiler=Compiler)
super(Template, self).__init__(template_string, name, *args, **kwargs)
if is_pugjs:
self.namespace.update(
{ATTRS_FUNC: attrs, ESCAPE_FUNC: escape, ITER_FUNC: iteration}
)
def preprocess(self, source, name, filename=None):
loader = self.environment.loader
try:
# we're in a Flask app
loader = loader.app.jinja_loader
except AttributeError:
pass
if hasattr(loader, 'searchpath') and len(loader.searchpath):
self.options["basedir"] = loader.searchpath[0]
if not name or (name and not os.path.splitext(name)[1] in self.file_extensions):
return source
return process(source, filename=name, compiler=Compiler, **self.options)
def get_contents(self, origin):
if os.path.splitext(origin.template_name)[1] in ('.pug', '.jade'):
contents = origin.loader.get_contents(origin)
contents = self.include_pug_sources(contents)
contents = process(contents,
filename=origin.template_name,
compiler=Compiler,
base_directory=os.path.dirname(origin.name))
else:
contents = origin.loader.get_contents(origin)
return contents
def preprocess(self, source, name, filename=None):
loader = self.environment.loader
try:
# we're in a Flask app
loader = loader.app.jinja_loader
except AttributeError:
pass
if len(loader.searchpath):
self.options["basedir"] = loader.searchpath[0]
if not name or (name and not os.path.splitext(name)[1] in self.file_extensions):
return source
return process(source, filename=name, compiler=Compiler, **self.options)
def apps_mosaic(self, request, feed, profile):
apps, source = [''], ''
apps.extend(settings.EFFORIA_APPS)
for app in apps:
source += open('.%s%sgrid.jade' %
(settings.STATIC_URL, app)).read()
compiled = process(src=source, compiler=Compiler)
contexts = Context({
'f': feed,
'p': profile,
'path': request.path,
'apps': apps,
'static_url': settings.STATIC_URL
})
return Template(compiled).render(contexts)
def get_contents(self, origin):
contents = self.template_cache.get(origin.name)
if settings.DEBUG or not contents:
if os.path.splitext(origin.template_name)[1] in ('.pug', '.jade'):
try:
contents = origin.loader.get_contents(origin)
contents = self.include_pug_sources(contents)
contents = process(contents,
filename=origin.template_name,
compiler=Compiler)
except FileNotFoundError:
raise TemplateDoesNotExist(origin)
else:
contents = origin.loader.get_contents(origin)
self.template_cache[origin.name] = contents
return contents
def preprocess(self, source, name, filename=None):
if 'include' in source:
loader = self.environment.loader
try:
# we're in a Flask app
loader = loader.app.jinja_loader
except AttributeError:
pass
basedir = loader.searchpath[0]
basedir = os.path.join(basedir, '')
pattern = r'((^|\n)\s*include )(?!{})'.format(basedir)
replace = '\\1{}'.format(basedir)
source = re.sub(pattern, replace, source)
if (not name or
(name and not os.path.splitext(name)[1] in self.file_extensions)):
return source
return process(source,
filename=name,
compiler=Compiler,
**self.options)
def preprocessor(source):
return process(source, compiler=Compiler)
def convert_file():
support_compilers_list = [
'django',
'jinja',
'underscore',
'mako',
'tornado',
'html',
]
available_compilers = {}
for i in support_compilers_list:
try:
compiler_class = __import__(
'pypugjs.ext.%s' % i, fromlist=['pypugjs']
).Compiler
except ImportError as e:
logging.warning(e)
else:
available_compilers[i] = compiler_class
usage = "usage: %prog [options] [file [output]]"
parser = OptionParser(usage)
parser.add_option(
"-o", "--output", dest="output", help="Write output to FILE", metavar="FILE"
)
# use a default compiler here to sidestep making a particular
# compiler absolutely necessary (ex. django)
default_compiler = sorted(available_compilers.keys())[0]
parser.add_option(
"-c",
"--compiler",
dest="compiler",
choices=list(available_compilers.keys()),
default=default_compiler,
type="choice",
help=(
"COMPILER must be one of %s, default is %s"
% (', '.join(list(available_compilers.keys())), default_compiler)
),
)
parser.add_option(
"-e",
"--ext",
dest="extension",
help="Set import/extends default file extension",
metavar="FILE",
)
options, args = parser.parse_args()
file_output = options.output or (args[1] if len(args) > 1 else None)
compiler = options.compiler
if options.extension:
extension = '.%s' % options.extension
elif options.output:
extension = os.path.splitext(options.output)[1]
else:
extension = None
if compiler in available_compilers:
import six
if len(args) >= 1:
template = codecs.open(args[0], 'r', encoding='utf-8').read()
elif six.PY3:
template = sys.stdin.read()
else:
template = codecs.getreader('utf-8')(sys.stdin).read()
output = process(
template,
compiler=available_compilers[compiler],
staticAttrs=True,
extension=extension,
)
if file_output:
outfile = codecs.open(file_output, 'w', encoding='utf-8')
outfile.write(output)
elif six.PY3:
sys.stdout.write(output)
else:
codecs.getwriter('utf-8')(sys.stdout).write(output)
else:
raise Exception('You must have %s installed!' % compiler)
def preprocessor(source):
return process(source, compiler=Compiler)
