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 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)
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 post_process(self, paths, dry_run=False, **options):
"""
This post_process hook is used to package all themed assets.
"""
if dry_run:
return
themes = get_themes()
for theme in themes:
css_packages = self.get_themed_packages(theme.theme_dir_name, settings.PIPELINE_CSS)
from pipeline.packager import Packager
packager = Packager(storage=self, css_packages=css_packages)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
yield output_file, output_file, True
super_class = super(ThemePipelineMixin, self)
if hasattr(super_class, 'post_process'):
for name, hashed_name, processed in super_class.post_process(paths.copy(), dry_run, **options):
yield name, hashed_name, processed
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(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)
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 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(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 test_individual_url(self):
"""Check that individual URL is correctly generated"""
packager = Packager()
filename = os.path.join(settings.PIPELINE_ROOT, u'js/application.js')
individual_url = packager.individual_url(filename)
self.assertEqual(individual_url,
"http://localhost/static/js/application.js")
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)
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 test_individual_url(self):
"""Check that individual URL is correctly generated"""
packager = Packager()
filename = os.path.join(settings.PIPELINE_ROOT, u'js/application.js')
individual_url = packager.individual_url(filename)
self.assertEqual(individual_url,
"http://localhost/static/js/application.js")
def post_process(self, paths, dry_run=False, **options):
if dry_run:
return []
from pipeline.packager import Packager
packager = Packager(storage=self)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
if self.packing:
paths_written = packager.pack_stylesheets(package)
for path in paths_written:
paths[path] = (self, path)
else:
# TODO: bcooksey 5/15/13. Not sure why we pretend we packed if packing is false...will this mess up source maps
output_file = package.output_filename
paths[output_file] = (self, output_file)
for package_name in packager.packages['js']:
package = packager.package_for('js', package_name)
if self.packing:
paths_written = packager.pack_javascripts(package)
for path in paths_written:
paths[path] = (self, path)
else:
# TODO: bcooksey 5/15/13. Not sure why we pretend we packed if packing is false...will this mess up source maps
output_file = package.output_filename
paths[output_file] = (self, output_file)
super_class = super(PipelineMixin, self)
if hasattr(super_class, 'post_process'):
return super_class.post_process(paths, dry_run, **options)
return [
(path, path, True)
for path in paths
]
def post_process(self, paths, dry_run=False, **options):
"""
This post_process hook is used to package all themed assets.
"""
if dry_run:
return
themes = get_themes()
for theme in themes:
css_packages = self.get_themed_packages(
theme.theme_dir_name, settings.PIPELINE['STYLESHEETS'])
from pipeline.packager import Packager
packager = Packager(storage=self, css_packages=css_packages)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
yield output_file, output_file, True
super_class = super(ThemePipelineMixin, self)
if hasattr(super_class, 'post_process'):
for name, hashed_name, processed in super_class.post_process(
paths.copy(), dry_run, **options):
yield name, hashed_name, processed
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 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 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 test_periods_safe_individual_url(self):
"""Check that the periods in file names do not get replaced by individual_url when
PIPELINE_ROOT/STATIC_ROOT is not set, such as in development
"""
settings.PIPELINE_ROOT = settings.STATIC_ROOT = settings.MEDIA_ROOT = ""
packager = Packager()
filename = os.path.join(settings.PIPELINE_ROOT, u"js/application.js")
individual_url = packager.individual_url(filename)
self.assertEqual(individual_url, "http://localhost/static/js/application.js")
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 test_templates(self):
packager = Packager()
packages = packager.create_packages({
'templates': {
'source_filenames': (_('pipeline/templates/photo/list.jst'), ),
'output_filename': 'templates.js',
}
})
self.assertEqual(packages['templates'].templates,
[_('pipeline/templates/photo/list.jst')])
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 test_periods_safe_individual_url(self):
"""Check that the periods in file names do not get replaced by individual_url when
PIPELINE_ROOT/STATIC_ROOT is not set, such as in development
"""
settings.PIPELINE_ROOT = settings.STATIC_ROOT = settings.MEDIA_ROOT = ""
packager = Packager()
filename = os.path.join(settings.PIPELINE_ROOT, u'js/application.js')
individual_url = packager.individual_url(filename)
self.assertEqual(individual_url,
"http://localhost/static/js/application.js")
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 test_templates(self):
packager = Packager()
packages = packager.create_packages({
'templates': {
'source_filenames': (
'templates/photo/list.jst',
),
'output_filename': 'templates.js',
}
})
self.assertEqual(packages['templates'].templates, ['templates/photo/list.jst'])
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_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 handle(self, *args, **options):
from pipeline.packager import Packager
force = options.get('force', False)
verbose = int(options.get('verbosity', 1)) >= 2
sync = options.get('dry_run', True)
packager = Packager(verbose=verbose)
for package_name in packager.packages['css']:
if args and package_name not in args:
continue
package = packager.package_for('css', package_name)
if verbose:
print
message = "CSS Group '%s'" % package_name
print message
print len(message) * '-'
packager.pack_stylesheets(package, sync=sync, force=force)
for package_name in packager.packages['js']:
if args and package_name not in args:
continue
package = packager.package_for('js', package_name)
if verbose:
print
message = "JS Group '%s'" % package_name
print message
print len(message) * '-'
packager.pack_javascripts(package, sync=sync, force=force)
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 post_process(self, paths, dry_run=False, **options):
if dry_run:
return []
from pipeline.packager import Packager
packager = Packager(storage=self)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
for package_name in packager.packages['js']:
package = packager.package_for('js', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_javascripts(package)
paths[output_file] = (self, output_file)
super_class = super(PipelineMixin, self)
if hasattr(super_class, 'post_process'):
return super_class.post_process(paths, dry_run, **options)
return [
(path, path, True)
for path in paths
]
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 post_process(self, paths, dry_run=False, **options):
if dry_run:
return
from pipeline.packager import Packager
packager = Packager(storage=self)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
yield output_file, output_file, True
for package_name in packager.packages['js']:
package = packager.package_for('js', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_javascripts(package)
paths[output_file] = (self, output_file)
yield output_file, output_file, True
super_class = super(PipelineMixin, self)
if hasattr(super_class, 'post_process'):
for name, hashed_name, processed in super_class.post_process(paths.copy(), dry_run, **options):
yield name, hashed_name, processed
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 package_for(self, package_name, package_type):
package = {
'js': getattr(settings, 'PIPELINE_JS', {}).get(package_name, {}),
'css': getattr(settings, 'PIPELINE_CSS', {}).get(package_name, {}),
}[package_type]
if package:
package = {package_name: package}
packager = {
'js': Packager(css_packages={}, js_packages=package),
'css': Packager(css_packages=package, js_packages={}),
}[package_type]
return packager.package_for(package_type, package_name)
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 CustomPipelineManifest(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):
ignore_patterns = getattr(settings, "STATICFILES_IGNORE_PATTERNS", None)
packaged_files = []
if settings.PIPELINE_ENABLED:
for package in self.packages:
self.package_files.append(package.output_filename)
self.package_files += package.paths
yield staticfiles_storage.url(package.output_filename)
else:
for package in self.packages:
for path in self.packager.compile(package.paths):
self.package_files.append(path)
yield staticfiles_storage.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:
self.package_files.append(prefixed_path)
yield staticfiles_storage.url(prefixed_path)
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 test_templates(self):
packager = Packager()
packages = packager.create_packages(
{"templates": {"source_filenames": ("templates/photo/list.jst",), "output_filename": "templates.r?.js"}}
)
self.assertEqual(
packages,
{
"templates": {
"templates": ["templates/photo/list.jst"],
"manifest": True,
"paths": [],
"context": {},
"output": "templates.r?.js",
}
},
)
def post_process(self, paths, dry_run=False, **options):
if dry_run:
return
packager = Packager(storage=self)
for _abs_path, rel_path in paths:
files_to_process = OrderedDict()
files_to_process[rel_path] = (self, rel_path)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if rel_path in package.paths:
if self.packing:
packager.pack_stylesheets(package)
files_to_process[output_file] = (self, output_file)
yield output_file, output_file, True
for package_name in packager.packages['js']:
package = packager.package_for('js', package_name)
output_file = package.output_filename
if rel_path in package.paths:
if self.packing:
packager.pack_javascripts(package)
files_to_process[output_file] = (self, output_file)
yield output_file, output_file, True
super_class = super(PipelineMixin, self)
if hasattr(super_class, 'post_process'):
for name, hashed_name, processed in super_class.post_process(
files_to_process.copy(), dry_run, **options):
yield name, hashed_name, processed
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 handle(self, *args, **options):
from pipeline.packager import Packager
force = options.get('force', False)
verbose = int(options.get('verbosity', 1)) >= 2
sync = options.get('dry_run', True)
packager = Packager(verbose=verbose)
for package_name in packager.packages['css']:
if args and package_name not in args:
continue
package = packager.package_for('css', package_name)
if verbose:
print
message = "CSS Group '%s'" % package_name
print message
print len(message) * '-'
packager.pack_stylesheets(package, sync=sync, force=force)
for package_name in packager.packages['js']:
if args and package_name not in args:
continue
package = packager.package_for('js', package_name)
if verbose:
print
message = "JS Group '%s'" % package_name
print message
print len(message) * '-'
packager.pack_javascripts(package, sync=sync, force=force)
def post_process(self, paths, dry_run=False, **options):
if dry_run:
return []
from pipeline.packager import Packager
packager = Packager(storage=self)
for package_name in packager.packages['css']:
package = packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_stylesheets(package)
paths[output_file] = (self, output_file)
for package_name in packager.packages['js']:
package = packager.package_for('js', package_name)
output_file = package.output_filename
if self.packing:
packager.pack_javascripts(package)
paths[output_file] = (self, output_file)
super_class = super(PipelineMixin, self)
if hasattr(super_class, 'post_process'):
return super_class.post_process(paths, dry_run, **options)
return [
(path, path, True)
for path in paths
]
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 test_templates(self):
packager = Packager()
packages = packager.create_packages({
'templates': {
'source_filenames': (
'templates/photo/list.jst',
),
'output_filename': 'templates.r?.js',
}
})
self.assertEqual(packages, {
'templates': {
'templates': ['templates/photo/list.jst'],
'paths': [],
'context': {},
'output': 'templates.r?.js'
}
})
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 test_templates(self):
packager = Packager()
packages = packager.create_packages({
'templates': {
'source_filenames': (
'templates/photo/list.jst',
),
'output_filename': 'templates.r?.js',
}
})
self.assertEqual(packages, {
'templates': {
'templates': ['templates/photo/list.jst'],
'manifest': True,
'paths': [],
'context': {},
'output': 'templates.r?.js'
}
})
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 test_external_urls(self):
packager = Packager()
packages = packager.create_packages(
{
"jquery": {"external_urls": ("//ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js",)},
"application": {"source_filenames": ("js/application.js",), "output_filename": "application.r?.js"},
}
)
self.assertEqual(
packages,
{
"jquery": {"externals": ("//ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js",)},
"application": {
"context": {},
"manifest": True,
"output": "application.r?.js",
"paths": ["js/application.js"],
"templates": [],
},
},
)
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))
def test_external_urls(self):
packager = Packager()
packages = packager.create_packages({
'jquery': {
'external_urls': ('//ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js',)
},
'application': {
'source_filenames': ('js/application.js',),
'output_filename': 'application.r?.js'
}
})
self.assertEqual(packages, {
'jquery': {
'externals': ('//ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js',)
},
'application': {
'context': {},
'output': 'application.r?.js',
'paths': ['js/application.js'],
'templates': []
}
})
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)