class CompressedJSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_JS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages={}, js_packages=package)
try:
package = self.packager.package_for('js', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if 'externals' in package:
return '\n'.join([self.render_external(package, url) for url in package['externals']])
if settings.PIPELINE:
compressed_path = self.packager.pack_javascripts(package)
return self.render_js(package, compressed_path)
else:
package['paths'] = self.packager.compile(package['paths'])
templates = self.packager.pack_templates(package)
return self.render_individual(package, templates)
def render_js(self, package, path):
context = {}
if not 'template' in package:
package['template'] = "pipeline/js.html"
if 'context' in package:
context = package['context']
context.update({
'url': self.packager.individual_url(path)
})
return render_to_string(package['template'], context)
def render_external(self, package, url):
if not 'template' in package:
package['template'] = "pipeline/js.html"
return render_to_string(package['template'], {
'url': url
})
def render_inline(self, package, js):
context = {}
if 'context' in package:
context = package['context']
context.update({
'source': js
})
return render_to_string("pipeline/inline_js.html", context)
def render_individual(self, package, templates=None):
tags = [self.render_js(package, js) for js in package['paths']]
if templates:
tags.append(self.render_inline(package, templates))
return '\n'.join(tags)
class CompressedJSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_JS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages={}, js_packages=package)
try:
package = self.packager.package_for('js', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if 'externals' in package:
return '\n'.join([self.render_external(package, url) for url in package['externals']])
if settings.PIPELINE:
compressed_path = self.packager.pack_javascripts(package)
return self.render_js(package, compressed_path)
else:
package['paths'] = self.packager.compile(package['paths'])
templates = self.packager.pack_templates(package)
return self.render_individual(package, templates)
def render_js(self, package, path):
context = {}
if 'template' not in package:
package['template'] = "pipeline/js.html"
if 'context' in package:
context = package['context']
context.update({
'url': self.packager.individual_url(path)
})
return render_to_string(package['template'], context)
def render_external(self, package, url):
if 'template' not in package:
package['template'] = "pipeline/js.html"
return render_to_string(package['template'], {
'url': url
})
def render_inline(self, package, js):
context = {}
if 'context' in package:
context = package['context']
context.update({
'source': js
})
return render_to_string("pipeline/inline_js.html", context)
def render_individual(self, package, templates=None):
tags = [self.render_js(package, js) for js in package['paths']]
if templates:
tags.append(self.render_inline(package, templates))
return '\n'.join(tags)
def render_compressed(self, package, package_type):
if not settings.DEBUG:
method = getattr(self, "render_{0}".format(package_type))
return method(package, package.output_filename)
else:
packager = Packager()
method = getattr(self, "render_individual_{0}".format(package_type))
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
return method(package, paths, templates=templates)
def compressed_js(package_name):
package = settings.PIPELINE_JS.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages={}, js_packages=package)
package = packager.package_for('js', package_name)
if settings.PIPELINE_ENABLED:
return render_js(package, package.output_filename)
else:
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
return render_individual_js(package, paths, templates)
def compressed_js(package_name):
package = settings.JAVASCRIPT.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages={}, js_packages=package)
package = packager.package_for('js', package_name)
if settings.PIPELINE_ENABLED:
return render_js(package, package.output_filename)
else:
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
return render_individual_js(package, paths, templates)
def compressed_js(package_name): # lint-amnesty, pylint: disable=missing-function-docstring
package = settings.JAVASCRIPT.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages={}, js_packages=package)
package = packager.package_for('js', package_name)
if settings.PIPELINE_ENABLED:
return render_js(package, package.output_filename)
else:
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
return render_individual_js(package, paths, templates)
class CompressedJSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_JS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages={}, js_packages=package)
try:
package = self.packager.package_for('js', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_js(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
templates = self.packager.pack_templates(package)
return self.render_individual(package, paths, templates)
def render_js(self, package, path):
template_name = package.template_name or "pipeline/js.html"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
def render_inline(self, package, js):
context = package.extra_context
context.update({
'source': js
})
return render_to_string("pipeline/inline_js.html", context)
def render_individual(self, package, paths, templates=None):
tags = [self.render_js(package, js) for js in paths]
if templates:
tags.append(self.render_inline(package, templates))
return '\n'.join(tags)
def compressed_js(ctx, name):
package = settings.PIPELINE_JS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages={}, js_packages=package)
try:
package = packager.package_for("js", name)
except PackageNotFound:
return ""
def _render_js(path):
template_name = package.template_name or "pipeline/js.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path),
})
template = ctx.environment.get_template(template_name)
return template.render(context)
def _render_inline_js(js):
context = package.extra_context
context.update({
'source': js
})
template = ctx.environment.get_template("pipeline/inline_js.jinja")
return template.render(context)
# Render a optimized one
if settings.PIPELINE_ENABLED:
return _render_js(package.output_filename)
else:
default_collector.collect()
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
tags = [_render_js(js) for js in paths]
if templates:
tags.append(_render_inline_js(templates))
return '\n'.join(tags)
def compressed_js(ctx, name):
package = settings.PIPELINE_JS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages={}, js_packages=package)
try:
package = packager.package_for("js", name)
except PackageNotFound:
return ""
def _render_js(path):
template_name = package.template_name or "pipeline/js.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path),
})
template = ctx.environment.get_template(template_name)
return template.render(context)
def _render_inline_js(js):
context = package.extra_context
context.update({
'source': js
})
template = ctx.environment.get_template("pipeline/inline_js.jinja")
return template.render(context)
# Render a optimized one
if settings.PIPELINE_ENABLED:
return _render_js(package.output_filename)
else:
default_collector.collect()
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
tags = [_render_js(js) for js in paths]
if templates:
tags.append(_render_inline_js(templates))
return '\n'.join(tags)
class CompressedJSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_JS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages={}, js_packages=package)
try:
package = self.packager.package_for('js', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_js(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
templates = self.packager.pack_templates(package)
return self.render_individual(package, paths, templates)
def render_js(self, package, path):
template_name = package.template_name or "pipeline/js.html"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
def render_inline(self, package, js):
context = package.extra_context
context.update({
'source': js
})
return render_to_string("pipeline/inline_js.html", context)
def render_individual(self, package, paths, templates=None):
tags = [self.render_js(package, js) for js in paths]
if templates:
tags.append(self.render_inline(package, templates))
return '\n'.join(tags)
def compressed_js(name):
package = settings.PIPELINE_JS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages={}, js_packages=package)
try:
package = packager.package_for('js', name)
except PackageNotFound:
return ""
def _render_js(path):
template_name = package.template_name or "pipeline/js.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path),
})
return render_to_string(template_name, context)
def _render_inline_js(js):
context = package.extra_context
context.update({
'source': js
})
return render_to_string("pipeline/inline_js.jinja", context)
if not settings.DEBUG:
return _render_js(package.output_filename)
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
tags = [_render_js(js) for js in paths]
if templates:
tags.append(_render_inline(templates))
return '\n'.join(tags)
def compressed_js(name):
package = settings.PIPELINE_JS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages={}, js_packages=package)
try:
package = packager.package_for('js', name)
except PackageNotFound:
return ""
def _render_js(path):
template_name = package.template_name or "pipeline/js.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/javascript'),
'url': staticfiles_storage.url(path),
})
return render_to_string(template_name, context)
def _render_inline_js(js):
context = package.extra_context
context.update({'source': js})
return render_to_string("pipeline/inline_js.jinja", context)
if not settings.DEBUG:
return _render_js(package.output_filename)
paths = packager.compile(package.paths)
templates = packager.pack_templates(package)
tags = [_render_js(js) for js in paths]
if templates:
tags.append(_render_inline(templates))
return '\n'.join(tags)
