class CompilerTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() self.old_compilers = settings.PIPELINE_COMPILERS settings.PIPELINE_COMPILERS = ['tests.tests.test_compiler.DummyCompiler'] def test_output_path(self): output_path = self.compiler.output_path("js/helpers.coffee", "js") self.assertEqual(output_path, "js/helpers.js") def test_compilers_class(self): compilers_class = self.compiler.compilers self.assertEqual(compilers_class[0], DummyCompiler) def test_compile(self): paths = self.compiler.compile([ _('pipeline/js/dummy.coffee'), _('pipeline/js/application.js'), ]) self.assertEqual([_('pipeline/js/dummy.js'), _('pipeline/js/application.js')], list(paths)) def tearDown(self): default_collector.clear() settings.PIPELINE_COMPILERS = self.old_compilers
def __init__(self, verbose=False, css_packages=None, js_packages=None): self.verbose = verbose self.compressor = Compressor(verbose) self.versioning = Versioning(verbose) self.compiler = Compiler(verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), }
class FailingCompilerTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_compile(self): with self.assertRaises(CompilerError) as cm: self.compiler.compile([_('pipeline/js/dummy.coffee')]) e = cm.exception self.assertEqual(e.command, ['/usr/bin/env', 'false']) self.assertEqual(e.error_output, '') def tearDown(self): default_collector.clear()
class CompilerStdoutTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_output_path(self): output_path = self.compiler.output_path("js/helpers.coffee", "js") self.assertEqual(output_path, "js/helpers.js") def test_compile(self): paths = self.compiler.compile([_('pipeline/js/dummy.coffee')]) self.assertEqual([_('pipeline/js/dummy.junk')], list(paths)) def tearDown(self): default_collector.clear()
class DummyCompilerTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_output_path(self): compiler_class = self.compiler.compilers[0] compiler = compiler_class(verbose=self.compiler.verbose, storage=self.compiler.storage) output_path = compiler.output_path("js/helpers.coffee", "js") self.assertEqual(output_path, "js/helpers.js") def test_compilers_class(self): compilers_class = self.compiler.compilers self.assertEqual(compilers_class[0], DummyCompiler) def test_compile(self): paths = self.compiler.compile([ _('pipeline/js/dummy.coffee'), _('pipeline/js/application.js'), ]) self.assertEqual( [_('pipeline/js/dummy.js'), _('pipeline/js/application.js')], list(paths)) def tearDown(self): default_collector.clear()
class Packager(object): def __init__(self, storage=default_storage, verbose=False, css_packages=None, js_packages=None): self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = {"css": self.create_packages(css_packages), "js": self.create_packages(js_packages)} def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound("No corresponding package for %s package name : %s" % (kind, package_name)) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack( package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs ) def compile(self, paths): return self.compiler.compile(paths) def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print "Saving: %s" % output_filename paths = self.compile(package.paths) content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
class InvalidCompilerTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_compile(self): with self.assertRaises(CompilerError) as cm: self.compiler.compile([_('pipeline/js/dummy.coffee')]) e = cm.exception self.assertEqual(e.command, [ 'this-exists-nowhere-as-a-command-and-should-fail', 'pipeline/js/dummy.coffee', 'pipeline/js/dummy.junk' ]) self.assertEqual(e.error_output, '') def tearDown(self): default_collector.clear()
class InvalidCompilerTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_compile(self): with self.assertRaises(CompilerError) as cm: self.compiler.compile([_('pipeline/js/dummy.coffee')]) e = cm.exception self.assertEqual( e.command, ['this-exists-nowhere-as-a-command-and-should-fail', 'pipeline/js/dummy.coffee', 'pipeline/js/dummy.junk']) self.assertEqual(e.error_output, '') def tearDown(self): default_collector.clear()
def __init__(self, force=False, verbose=False): self.force = force self.verbose = verbose self.compressor = Compressor(verbose) self.versioning = Versioning(verbose) self.compiler = Compiler(verbose) self.packages = { 'css': self.create_packages(settings.PIPELINE_CSS), 'js': self.create_packages(settings.PIPELINE_JS), }
def __init__(self, storage=default_storage, verbose=False, css_packages=None, js_packages=None): self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = {"css": self.create_packages(css_packages), "js": self.create_packages(js_packages)}
def __init__(self, storage=None, verbose=False, css_packages=None, js_packages=None): if storage is None: storage = staticfiles_storage self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(storage=storage, verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), }
class CompilerTest(TestCase): def setUp(self): self.compiler = Compiler() self.old_compilers = settings.PIPELINE_COMPILERS settings.PIPELINE_COMPILERS = ["tests.tests.test_compiler.DummyCompiler"] def test_output_path(self): output_path = self.compiler.output_path("js/helpers.coffee", "js") self.assertEqual(output_path, "js/helpers.js") def test_compilers_class(self): compilers_class = self.compiler.compilers self.assertEqual(compilers_class[0], DummyCompiler) def test_compile(self): paths = self.compiler.compile([_("pipeline/js/dummy.coffee"), _("pipeline/js/application.js")]) self.assertEqual([_("pipeline/js/dummy.js"), _("pipeline/js/application.js")], paths) def tearDown(self): settings.PIPELINE_COMPILERS = self.old_compilers
class CompilerWithEmptyFirstArgTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_compile(self): paths = self.compiler.compile([_('pipeline/js/dummy.coffee')]) default_collector.collect() self.assertEqual([_('pipeline/js/dummy.junk')], list(paths)) def tearDown(self): default_collector.clear()
class CompilerTest(TestCase): def setUp(self): self.compiler = Compiler() self.old_compilers = settings.PIPELINE_COMPILERS settings.PIPELINE_COMPILERS = ['tests.tests.compiler.DummyCompiler'] def test_output_path(self): output_path = self.compiler.output_path("js/helpers.coffee", "js") self.assertEquals(output_path, "js/helpers.js") def test_compilers_class(self): compilers_class = self.compiler.compilers self.assertEquals(compilers_class[0], DummyCompiler) def test_compile(self): paths = self.compiler.compile([ 'js/dummy.coffee', 'js/application.js', ]) self.assertEquals(['js/dummy.js', 'js/application.js'], paths) def tearDown(self): settings.PIPELINE_COMPILERS = self.old_compilers
def __init__(self, storage=None, verbose=False, css_packages=None, js_packages=None): if storage is None: storage = staticfiles_storage self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(storage=storage, verbose=verbose) if css_packages is None: css_packages = settings.STYLESHEETS if js_packages is None: js_packages = settings.JAVASCRIPT self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), }
class CompilerSelfWriterTest(TestCase): def setUp(self): default_collector.collect() self.compiler = Compiler() def test_output_path(self): compiler_class = self.compiler.compilers[0] compiler = compiler_class(verbose=self.compiler.verbose, storage=self.compiler.storage) output_path = compiler.output_path("js/helpers.coffee", "js") self.assertEqual(output_path, "js/helpers.js") def test_compile(self): paths = self.compiler.compile([_('pipeline/js/dummy.coffee')]) default_collector.collect() self.assertEqual([_('pipeline/js/dummy.junk')], list(paths)) def tearDown(self): default_collector.clear()
def setUp(self): default_collector.collect() self.compiler = Compiler() self.old_compilers = settings.PIPELINE_COMPILERS settings.PIPELINE_COMPILERS = ['tests.tests.test_compiler.DummyCompiler']
class Packager(object): def __init__(self, verbose=False, css_packages=None, js_packages=None): self.verbose = verbose self.compressor = Compressor(verbose) self.versioning = Versioning(verbose) self.compiler = Compiler(verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name].copy() except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % (kind, package_name)) def individual_url(self, filename): relative_path = self.compressor.relative_path(filename)[1:] return urlparse.urljoin(settings.PIPELINE_URL, filepath_to_uri(relative_path)) def pack_stylesheets(self, package, **kwargs): variant = package.get('variant', None) absolute_asset_paths = package.get('absolute_asset_paths', True) return self.pack(package, self.compressor.compress_css, css_compressed, variant=variant, absolute_asset_paths=absolute_asset_paths, **kwargs) def compile(self, paths): return self.compiler.compile(paths) def pack(self, package, compress, signal, sync=False, force=False, **kwargs): if settings.PIPELINE_AUTO or (force and sync): need_update, version = self.versioning.need_update( package['output'], package['paths']) if need_update or force: output_filename = self.versioning.output_filename( package['output'], version) self.versioning.cleanup(package['output']) if self.verbose: print "Version: %s" % version print "Saving: %s" % output_filename paths = self.compile(package['paths']) content = compress( paths, asset_url=self.individual_url(output_filename), **kwargs) self.save_file(output_filename, content) else: filename_base, filename = os.path.split(package['output']) version = self.versioning.version_from_file(filename_base, filename, force=force) signal.send(sender=self, package=package, version=version, **kwargs) return self.versioning.output_filename(package['output'], version) def pack_javascripts(self, package, **kwargs): if 'externals' in package: return return self.pack(package, self.compressor.compress_js, js_compressed, templates=package['templates'], **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package['templates']) def save_file(self, path, content): return storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = {} if 'external_urls' in config[name]: packages[name]['externals'] = config[name]['external_urls'] continue paths = [] for pattern in config[name]['source_filenames']: for path in glob(pattern): if not path in paths: paths.append(str(path)) packages[name]['paths'] = [ path for path in paths if not path.endswith(settings.PIPELINE_TEMPLATE_EXT) ] packages[name]['templates'] = [ path for path in paths if path.endswith(settings.PIPELINE_TEMPLATE_EXT) ] packages[name]['output'] = config[name]['output_filename'] packages[name]['context'] = {} packages[name]['manifest'] = True if 'absolute_asset_paths' in config[name]: packages[name]['absolute_asset_paths'] = \ config[name]['absolute_asset_paths'] if 'extra_context' in config[name]: packages[name]['context'] = config[name]['extra_context'] if 'template_name' in config[name]: packages[name]['template'] = config[name]['template_name'] if 'variant' in config[name]: packages[name]['variant'] = config[name]['variant'] if 'manifest' in config[name]: packages[name]['manifest'] = config[name]['manifest'] return packages
class Packager(object): def __init__(self, storage=default_storage, verbose=False, css_packages=None, js_packages=None): self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % (kind, package_name)) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, force=False): return self.compiler.compile(paths, force=force) def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print "Saving: %s" % output_filename paths = self.compile(package.paths, force=True) content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
def setUp(self): self.compiler = Compiler() self.old_compilers = settings.PIPELINE_COMPILERS settings.PIPELINE_COMPILERS = ['tests.tests.compiler.DummyCompiler']
class Packager(object): def __init__(self, storage=default_storage, verbose=False, css_packages=None, js_packages=None): self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % ( kind, package_name ) ) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, '/*# sourceMappingURL={} */', output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, force=False): return self.compiler.compile(paths, force=force) def pack(self, package, compress, signal, source_mapping_template, **kwargs): output_filename = package.output_filename if self.verbose: print("Saving: %s" % output_filename) paths = self.compile(package.paths, force=True) content, source_map = compress(paths, **kwargs) if source_map is not None: source_map_output_filename = output_filename + '.map' self.save_file(source_map_output_filename, source_map) content = content + '\n' + source_mapping_template.format( os.path.basename(source_map_output_filename)) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, '//# sourceMappingURL={}', templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
class Packager(object): def __init__(self, storage=None, verbose=False, css_packages=None, js_packages=None): if storage is None: storage = staticfiles_storage self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(storage=storage, verbose=verbose) if css_packages is None: css_packages = settings.STYLESHEETS if js_packages is None: js_packages = settings.JAVASCRIPT self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % (kind, package_name)) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, compiler_options={}, force=False): return self.compiler.compile( paths, compiler_options=compiler_options, force=force, ) def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print("Saving: %s" % output_filename) paths = self.compile( package.paths, compiler_options=package.compiler_options, force=True, ) output_path = self.storage.path(output_filename) output_mtime = self.storage.get_modified_time(output_path) if any([ self.storage.get_modified_time(self.storage.path(path)) >= output_mtime for path in paths ]): content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_bytes(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
class Packager(object): def __init__(self, verbose=False, css_packages=None, js_packages=None): self.verbose = verbose self.compressor = Compressor(verbose) self.versioning = Versioning(verbose) self.compiler = Compiler(verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name].copy() except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % ( kind, package_name ) ) def individual_url(self, filename): relative_path = self.compressor.relative_path(filename)[1:] return urlparse.urljoin(settings.PIPELINE_URL, filepath_to_uri(relative_path)) def pack_stylesheets(self, package, **kwargs): variant = package.get('variant', None) absolute_asset_paths = package.get('absolute_asset_paths', True) return self.pack(package, self.compressor.compress_css, css_compressed, variant=variant, absolute_asset_paths=absolute_asset_paths, **kwargs) def compile(self, paths): return self.compiler.compile(paths) def pack(self, package, compress, signal, sync=False, force=False, **kwargs): if settings.PIPELINE_AUTO or (force and sync): need_update, version = self.versioning.need_update( package['output'], package['paths']) if need_update or force: output_filename = self.versioning.output_filename( package['output'], version ) self.versioning.cleanup(package['output']) if self.verbose: print "Version: %s" % version print "Saving: %s" % output_filename paths = self.compile(package['paths']) content = compress(paths, asset_url=self.individual_url(output_filename), **kwargs) self.save_file(output_filename, content) else: filename_base, filename = os.path.split(package['output']) version = self.versioning.version_from_file(filename_base, filename, force=force) signal.send(sender=self, package=package, version=version, **kwargs) return self.versioning.output_filename(package['output'], version) def pack_javascripts(self, package, **kwargs): if 'externals' in package: return return self.pack(package, self.compressor.compress_js, js_compressed, templates=package['templates'], **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package['templates']) def save_file(self, path, content): return storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = {} if 'external_urls' in config[name]: packages[name]['externals'] = config[name]['external_urls'] continue paths = [] for pattern in config[name]['source_filenames']: for path in glob(pattern): if not path in paths: paths.append(str(path)) packages[name]['paths'] = [path for path in paths if not path.endswith(settings.PIPELINE_TEMPLATE_EXT)] packages[name]['templates'] = [path for path in paths if path.endswith(settings.PIPELINE_TEMPLATE_EXT)] packages[name]['output'] = config[name]['output_filename'] packages[name]['context'] = {} packages[name]['manifest'] = True if 'absolute_asset_paths' in config[name]: packages[name]['absolute_asset_paths'] = \ config[name]['absolute_asset_paths'] if 'extra_context' in config[name]: packages[name]['context'] = config[name]['extra_context'] if 'template_name' in config[name]: packages[name]['template'] = config[name]['template_name'] if 'variant' in config[name]: packages[name]['variant'] = config[name]['variant'] if 'manifest' in config[name]: packages[name]['manifest'] = config[name]['manifest'] return packages
def setUp(self): default_collector.collect() self.compiler = Compiler()
class Packager(object): def __init__(self, storage=default_storage, verbose=False, css_packages=None, js_packages=None): self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % ( kind, package_name ) ) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, force=False): return self.compiler.compile(paths, force=force) def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print "Saving: %s" % output_filename paths = self.compile(package.paths, force=True) content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): if settings.PIPELINE_TEMPLATE_USE_CACHE and package.templates: key_partial = hashlib.md5() key_partial.update(str(package.templates)) cache_key = "%s_%s"%(key_partial.hexdigest(), translation.get_language()) default_cache = cache.get_cache('default') cached_package = default_cache.get(cache_key) if not cached_package: cached_package = self.compressor.compile_templates(package.templates) default_cache.set(cache_key, cached_package) return cached_package else: if self.verbose: print "Generating templates without using cache .." return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_str(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
class Packager(object): def __init__(self, storage=None, verbose=False, css_packages=None, js_packages=None): if storage is None: storage = staticfiles_storage self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(storage=storage, verbose=verbose) if css_packages is None: css_packages = settings.PIPELINE_CSS if js_packages is None: js_packages = settings.PIPELINE_JS self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % ( kind, package_name ) ) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, force=False): paths = self.compiler.compile(paths, force=force) for path in paths: if not self.storage.exists(path): if self.verbose: print("Compiled file '%s' cannot be found with packager's storage. Locating it." % path) source_storage = self.find_source_storage(path) if source_storage is not None: with source_storage.open(path) as source_file: if self.verbose: print("Saving: %s" % path) self.storage.save(path, source_file) else: raise IOError("File does not exist: %s" % path) return paths def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print("Saving: %s" % output_filename) paths = self.compile(package.paths, force=True) content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_bytes(content))) def find_source_storage(self, path): for finder in get_finders(): for short_path, storage in finder.list(''): if short_path == path: if self.verbose: print("Found storage: %s" % str(self.storage)) return storage return None def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages
def setUp(self): self.compiler = Compiler() default_collector.collect(RequestFactory().get('/'))
class Packager(object): def __init__(self, storage=None, verbose=False, css_packages=None, js_packages=None): if storage is None: storage = staticfiles_storage self.storage = storage self.verbose = verbose self.compressor = Compressor(storage=storage, verbose=verbose) self.compiler = Compiler(storage=storage, verbose=verbose) if css_packages is None: css_packages = settings.STYLESHEETS if js_packages is None: js_packages = settings.JAVASCRIPT self.packages = { 'css': self.create_packages(css_packages), 'js': self.create_packages(js_packages), } def package_for(self, kind, package_name): try: return self.packages[kind][package_name] except KeyError: raise PackageNotFound( "No corresponding package for %s package name : %s" % ( kind, package_name ) ) def individual_url(self, filename): return self.storage.url(filename) def pack_stylesheets(self, package, **kwargs): return self.pack(package, self.compressor.compress_css, css_compressed, output_filename=package.output_filename, variant=package.variant, **kwargs) def compile(self, paths, compiler_options={}, force=False): return self.compiler.compile( paths, compiler_options=compiler_options, force=force, ) def pack(self, package, compress, signal, **kwargs): output_filename = package.output_filename if self.verbose: print("Saving: %s" % output_filename) paths = self.compile( package.paths, compiler_options=package.compiler_options, force=True, ) output_path = self.storage.path(output_filename) output_mtime = self.storage.get_modified_time(output_path) if any([self.storage.get_modified_time(self.storage.path(path)) >= output_mtime for path in paths]): content = compress(paths, **kwargs) self.save_file(output_filename, content) signal.send(sender=self, package=package, **kwargs) return output_filename def pack_javascripts(self, package, **kwargs): return self.pack(package, self.compressor.compress_js, js_compressed, templates=package.templates, **kwargs) def pack_templates(self, package): return self.compressor.compile_templates(package.templates) def save_file(self, path, content): return self.storage.save(path, ContentFile(smart_bytes(content))) def create_packages(self, config): packages = {} if not config: return packages for name in config: packages[name] = Package(config[name]) return packages