class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finders = get_finders()
self.package_files = self.get_package_files()
def get_package_files(self):
files = list()
for package in self.packages:
files.append(package.output_filename)
for path in self.packager.compile(package.paths):
files.append(path)
return files
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package.manifest:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package.manifest:
packages.append(package)
return packages
def cache(self):
ignore_patterns = getattr(settings, "STATICFILES_IGNORE_PATTERNS", None)
if PIPELINE:
for package in self.packages:
yield str(self.packager.individual_url(package.output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
yield str(self.packager.individual_url(path))
for finder in self.finders:
for path, storage in finder.list(ignore_patterns):
# Prefix the relative path if the source storage contains it
if getattr(storage, 'prefix', None):
prefixed_path = os.path.join(storage.prefix, path)
else:
prefixed_path = path
# Dont add any doubles
if prefixed_path not in self.package_files:
yield str(self.packager.individual_url(prefixed_path))
class CompressedCSSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_CSS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages=package, js_packages={})
try:
package = self.packager.package_for('css', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_css(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
return self.render_individual(package, paths)
def render_css(self, package, path):
template_name = package.template_name or "pipeline/css.html"
context = package.extra_context
context.update({
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
def render_individual(self, package, paths):
tags = [self.render_css(package, path) for path in paths]
return '\n'.join(tags)
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finder = DefaultStorageFinder()
def collect_packages(self):
packages = []
for package_name in self.packager.packages["css"]:
package = self.packager.package_for("css", package_name)
if package.manifest:
packages.append(package)
for package_name in self.packager.packages["js"]:
package = self.packager.package_for("js", package_name)
if package.manifest:
packages.append(package)
return packages
def cache(self):
if settings.PIPELINE:
for package in self.packages:
yield str(self.packager.individual_url(package.output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
yield str(self.packager.individual_url(path))
for path in self.finder.list():
yield str(self.packager.individual_url(path))
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finder = DefaultStorageFinder()
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package.manifest:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package.manifest:
packages.append(package)
return packages
def cache(self):
ignore_patterns = getattr(settings, "STATICFILES_IGNORE_PATTERNS", None)
if settings.PIPELINE:
for package in self.packages:
yield str(self.packager.individual_url(package.output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
yield str(self.packager.individual_url(path))
for path in self.finder.list(ignore_patterns):
yield str(self.packager.individual_url(path))
class CommonNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = self.packages.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages=package, js_packages=package)
try:
package = self.packager.package_for(self.type, package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_type_specific(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
return self.render_individual(package, paths)
def render_individual(self, package, paths):
tags = [self.render_type_specific(package, path) for path in paths]
return '\n'.join(tags)
def get_url(self, path):
if path_is_url(path):
return path
return default_storage.url(path)
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finder = DefaultStorageFinder()
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package.manifest:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package.manifest:
packages.append(package)
return packages
def cache(self):
ignore_patterns = getattr(settings, "STATICFILES_IGNORE_PATTERNS",
None)
if settings.PIPELINE:
for package in self.packages:
yield str(self.packager.individual_url(
package.output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
yield str(self.packager.individual_url(path))
for path, _ in self.finder.list(ignore_patterns):
yield str(self.packager.individual_url(path))
def compressed_css(name):
package = settings.PIPELINE_CSS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages=package, js_packages={})
try:
package = packager.package_for('css', name)
except PackageNotFound:
return ""
def _render_css(path):
template_name = package.template_name or "pipeline/css.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/css'),
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
if not settings.DEBUG:
return _render_css(package.output_filename)
paths = packager.compile(package.paths)
tags = [_render_css(path) for path in paths]
return '\n'.join(tags)
def compressed_css(name):
package = settings.PIPELINE_CSS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages=package, js_packages={})
try:
package = packager.package_for('css', name)
except PackageNotFound:
return ""
def _render_css(path):
template_name = package.template_name or "pipeline/css.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/css'),
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
if not settings.DEBUG:
return _render_css(package.output_filename)
paths = packager.compile(package.paths)
tags = [_render_css(path) for path in paths]
return '\n'.join(tags)
def add_css(self):
# compile assets
default_collector.collect(self.request)
# add the files that produce export.css
pkg = self.package_for('epub', 'css')
packager = Packager()
paths = packager.compile(pkg.paths)
self.stylesheets = []
for path in paths:
with codecs.open(staticfiles_storage.path(path), 'r',
'utf-8') as f:
css = f.read()
self.book.add_item(
epub.EpubItem(file_name=path,
media_type="text/css",
content=css))
self.stylesheets.append(path)
# now ensure all html items link to the stylesheets
for item in self.book.items:
if isinstance(item, (epub.EpubHtml, epub.EpubNav)):
for stylesheet in self.stylesheets:
# relativise path
href = '/'.join(['..'] * item.file_name.count('/') +
[stylesheet])
item.add_link(href=href, rel='stylesheet', type='text/css')
class CommonNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = self.packages.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages=package, js_packages=package)
try:
package = self.packager.package_for(self.type, package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_type_specific(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
return self.render_individual(package, paths)
def render_individual(self, package, paths):
tags = [self.render_type_specific(package, path) for path in paths]
return '\n'.join(tags)
def get_url(self, path):
if path_is_url(path):
return path
return default_storage.url(path)
def compressed_css(ctx, name):
package = settings.PIPELINE_CSS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages=package, js_packages={})
try:
package = packager.package_for('css', name)
except PackageNotFound:
return ""
def _render_css(path):
template_name = package.template_name or "pipeline/css.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/css'),
'url': staticfiles_storage.url(path)
})
template = ctx.environment.get_template(template_name)
return template.render(context)
if settings.PIPELINE_ENABLED:
return _render_css(package.output_filename)
else:
default_collector.collect()
paths = packager.compile(package.paths)
tags = [_render_css(path) for path in paths]
return '\n'.join(tags)
def compressed_css(ctx, name):
package = settings.PIPELINE_CSS.get(name, {})
if package:
package = {name: package}
packager = Packager(css_packages=package, js_packages={})
try:
package = packager.package_for('css', name)
except PackageNotFound:
return ""
def _render_css(path):
template_name = package.template_name or "pipeline/css.jinja"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/css'),
'url': staticfiles_storage.url(path)
})
template = ctx.environment.get_template(template_name)
return template.render(context)
if settings.PIPELINE_ENABLED:
return _render_css(package.output_filename)
else:
default_collector.collect()
paths = packager.compile(package.paths)
tags = [_render_css(path) for path in paths]
return '\n'.join(tags)
class CompressedCSSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_CSS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages=package, js_packages={})
try:
package = self.packager.package_for('css', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
compressed_path = self.packager.pack_stylesheets(package)
return self.render_css(package, compressed_path)
else:
package['paths'] = self.packager.compile(package['paths'])
return self.render_individual(package)
def render_css(self, package, path):
context = {}
if not 'template' in package:
package['template'] = "pipeline/css.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_individual(self, package):
tags = [self.render_css(package, path) for path in package['paths']]
return '\n'.join(tags)
class CompressedCSSNode(template.Node):
def __init__(self, name):
self.name = name
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
package = settings.PIPELINE_CSS.get(package_name, {})
if package:
package = {package_name: package}
self.packager = Packager(css_packages=package, js_packages={})
try:
package = self.packager.package_for('css', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
return self.render_css(package, package.output_filename)
else:
paths = self.packager.compile(package.paths)
return self.render_individual(package, paths)
def render_css(self, package, path):
template_name = package.template_name or "pipeline/css.html"
context = package.extra_context
context.update({
'type': guess_type(path, 'text/css'),
'url': staticfiles_storage.url(path)
})
return render_to_string(template_name, context)
def render_individual(self, package, paths):
tags = [self.render_css(package, path) for path in paths]
return '\n'.join(tags)
class CompressedCSSNode(template.Node):
def __init__(self, name):
self.name = name
self.packager = Packager()
def render(self, context):
package_name = template.Variable(self.name).resolve(context)
try:
package = self.packager.package_for('css', package_name)
except PackageNotFound:
return '' # fail silently, do not return anything if an invalid group is specified
if settings.PIPELINE:
compressed_path = self.packager.pack_stylesheets(package)
return self.render_css(package, compressed_path)
else:
package['paths'] = self.packager.compile(package['paths'])
return self.render_individual(package)
def render_css(self, package, path):
context = {}
if not 'template' in package:
package['template'] = "pipeline/css.html"
if not 'context' in package:
context = package['context']
context.update({
'url': self.packager.individual_url(path)
})
return render_to_string(package['template'], context)
def render_individual(self, package):
tags = [self.render_css(package, path) for path in package['paths']]
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 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 install_media(site):
"""Install static media.
Args:
site (reviewboard.cmdline.rbsite.Site):
The site to install media for.
This will be the site corresponding to the current working
directory.
"""
from pipeline.collector import default_collector
from pipeline.packager import Packager
page = ui.page('Setting up static media files')
media_path = os.path.join('htdocs', 'media')
uploaded_path = os.path.join(site.install_dir, media_path, 'uploaded')
ext_media_path = os.path.join(site.install_dir, media_path, 'ext')
site.mkdir(uploaded_path)
site.mkdir(os.path.join(uploaded_path, 'images'))
site.mkdir(ext_media_path)
# Run Pipeline on all the files, so we can prime the static media
# directory. This cuts down on the very long initial load times, in
# exchange for a somewhat long up-front time. Pipeline will at least
# compile files within each bundle in parallel.
default_collector.collect()
packager = Packager()
package_types = (
('css', 'CSS'),
('js', 'JavaScript'),
)
total_packages = sum(
len(packager.packages[package_type])
for package_type, package_type_desc in package_types
)
i = 1
for package_type, package_type_desc in package_types:
packages = packager.packages[package_type]
for package_name, package in sorted(six.iteritems(packages),
key=lambda pair: pair[0]):
ui.step(page,
'Compiling %s bundle %s' % (package_type_desc,
package.output_filename),
step_num=i,
total_steps=total_packages,
func=lambda: packager.compile(package.paths))
i += 1
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 tabzilla_css_redirect(r):
packer = Packager()
tabzilla_package = packer.package_for('css', 'tabzilla')
if not settings.DEBUG:
file_path = tabzilla_package.output_filename
else:
default_collector.collect()
paths = packer.compile(tabzilla_package.paths)
file_path = paths[0]
return static(file_path)
def tabzilla_css_redirect(r):
packer = Packager()
tabzilla_package = packer.package_for('css', 'tabzilla')
if not settings.DEBUG:
file_path = tabzilla_package.output_filename
else:
default_collector.collect()
paths = packer.compile(tabzilla_package.paths)
file_path = paths[0]
return static(file_path)
def compressed_css(package_name, raw=False):
package = settings.STYLESHEETS.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages=package, js_packages={})
package = packager.package_for('css', package_name)
if settings.PIPELINE_ENABLED:
return render_css(package, package.output_filename, raw=raw)
else:
paths = packager.compile(package.paths)
return render_individual_css(package, paths, raw=raw)
def compressed_css(package_name, raw=False):
package = settings.PIPELINE_CSS.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages=package, js_packages={})
package = packager.package_for('css', package_name)
if settings.PIPELINE_ENABLED:
return render_css(package, package.output_filename, raw=raw)
else:
paths = packager.compile(package.paths)
return render_individual_css(package, paths, raw=raw)
def compressed_css(package_name, raw=False): # lint-amnesty, pylint: disable=missing-function-docstring
package = settings.STYLESHEETS.get(package_name, {})
if package:
package = {package_name: package}
packager = Packager(css_packages=package, js_packages={})
package = packager.package_for('css', package_name)
if settings.PIPELINE_ENABLED:
return render_css(package, package.output_filename, raw=raw)
else:
paths = packager.compile(package.paths)
return render_individual_css(package, paths, raw=raw)
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)
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)
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finders = get_finders()
self.package_files = []
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package.manifest:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package.manifest:
packages.append(package)
return packages
def cache(self):
if settings.PIPELINE_ENABLED:
for package in self.packages:
path = package.output_filename
self.package_files.append(path)
yield staticfiles_storage.url(path)
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
self.package_files.append(path)
yield staticfiles_storage.url(path)
ignore_patterns = getattr(django_settings,
"STATICFILES_IGNORE_PATTERNS", None)
for finder in self.finders:
for path, storage in finder.list(ignore_patterns):
# Prefix the relative path if the source storage contains it
if getattr(storage, 'prefix', None):
prefixed_path = os.path.join(storage.prefix, path)
else:
prefixed_path = path
# Dont add any doubles
if prefixed_path not in self.package_files:
self.package_files.append(prefixed_path)
yield staticfiles_storage.url(prefixed_path)
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package['manifest']:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package['manifest']:
packages.append(package)
return packages
def cache(self):
if settings.PIPELINE:
for package in self.packages:
filename_base, filename = os.path.split(package['output'])
version = self.packager.versioning.version_from_file(
filename_base, filename)
output_filename = self.packager.versioning.output_filename(
package['output'], version)
yield str(self.packager.individual_url(output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package['paths']):
yield str(self.packager.individual_url(path))
def revision(self):
versions = []
if settings.PIPELINE:
for package in self.packages:
filename_base, filename = os.path.split(package['output'])
version = self.packager.versioning.version_from_file(
filename_base, filename)
versions.append(str(version))
else:
for package in self.packages:
version = self.packager.versioning.version(package['paths'])
versions.append(str(version))
versions.sort()
return versions[-1]
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)
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)
class PipelineManifest(Manifest):
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
def collect_packages(self):
packages = []
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
if package['manifest']:
packages.append(package)
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
if package['manifest']:
packages.append(package)
return packages
def cache(self):
if settings.PIPELINE:
for package in self.packages:
filename_base, filename = os.path.split(package['output'])
version = self.packager.versioning.version_from_file(filename_base, filename)
output_filename = self.packager.versioning.output_filename(package['output'], version)
yield str(self.packager.individual_url(output_filename))
else:
for package in self.packages:
for path in self.packager.compile(package['paths']):
yield str(self.packager.individual_url(path))
def revision(self):
versions = []
if settings.PIPELINE:
for package in self.packages:
filename_base, filename = os.path.split(package['output'])
version = self.packager.versioning.version_from_file(filename_base, filename)
versions.append(str(version))
else:
for package in self.packages:
version = self.packager.versioning.version(package['paths'])
versions.append(str(version))
versions.sort()
return versions[-1]
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)
