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)
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')
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 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):
"""
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 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 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 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 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_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 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 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 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 get_package(self, name):
"""Get the js or css package."""
package = {
'js': self.settings.PIPELINE_JS.get(name, {}),
'css': self.settings.PIPELINE_CSS.get(name, {}),
}[self.package_type]
if package:
package = {name: package}
self.packager = {
'js': Packager(css_packages={}, js_packages=package),
'css': Packager(css_packages=package, js_packages={}),
}[self.package_type]
try:
self.package = self.packager.package_for(self.package_type, name)
except PackageNotFound:
self.package = None
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): # 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):
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)
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_package_for(self):
packager = Packager()
packager.packages['js'] = packager.create_packages({
'application': {
'source_filenames': (_('pipeline/js/application.js'), ),
'output_filename': 'application.js'
}
})
try:
packager.package_for('js', 'application')
except PackageNotFound:
self.fail()
try:
packager.package_for('js', 'broken')
self.fail()
except PackageNotFound:
pass
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 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 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
from pipeline.packager import Packager
self.packager = Packager(storage=self)
for package_name in self.packager.packages['css']:
package = self.packager.package_for('css', package_name)
output_file = package.output_filename
if self.packing and self._is_outdated(package_name, package):
print('COMPRESSING {} package...'.format(package_name))
self.packager.pack_stylesheets(package)
self.compressed_packages.append(package_name)
else:
self.unchanged_packages.append(package_name)
paths[output_file] = (self, output_file)
yield output_file, output_file, True
for package_name in self.packager.packages['js']:
package = self.packager.package_for('js', package_name)
output_file = package.output_filename
if self.packing and self._is_outdated(package_name, package):
print('COMPRESSING {} package...'.format(package_name))
self.packager.pack_javascripts(package)
self.compressed_packages.append(package_name)
else:
self.unchanged_packages.append(package_name)
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
self._finalize()
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': []
}
})
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 __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finders = get_finders()
self.package_files = []
def __init__(self):
self.packager = Packager()
self.packages = self.collect_packages()
self.finder = DefaultStorageFinder()
