def test_register_filter():
    """Test registration of custom filters.
    """
    # Needs to be a ``Filter`` subclass.
    assert_raises(ValueError, register_filter, object)

    # A name is required.
    class MyFilter(Filter):
        name = None

        def output(self, *a, **kw):
            pass

    assert_raises(ValueError, register_filter, MyFilter)

    # The same filter cannot be registered under multiple names.
    MyFilter.name = "foo"
    register_filter(MyFilter)
    MyFilter.name = "bar"
    register_filter(MyFilter)

    # But the same name cannot be registered multiple times.
    assert_raises(KeyError, register_filter, MyFilter)

    # A filter needs to have at least one of the input or output methods.
    class BrokenFilter(Filter):
        name = "broken"

    assert_raises(TypeError, register_filter, BrokenFilter)

def test_register_filter():
    """Test registration of custom filters.
    """
    # Needs to be a ``Filter`` subclass.
    assert_raises(ValueError, register_filter, object)

    # A name is required.
    class MyFilter(Filter):
        name = None

        def output(self, *a, **kw):
            pass

    assert_raises(ValueError, register_filter, MyFilter)

    # We should be able to register a filter with a name.
    MyFilter.name = "foo"
    register_filter(MyFilter)

    # A filter should be able to override a pre-registered filter of the same
    # name.
    class OverrideMyFilter(Filter):
        name = "foo"

        def output(self, *a, **kw):
            pass

    register_filter(OverrideMyFilter)
    assert_true(isinstance(get_filter("foo"), OverrideMyFilter))

def register_scss_bundle(scss,
        assets=None,
        output=None,
        prefix='',
        compile_to='',
        name=''):
    """
    Function to automate registartion
    SCSS bundles
    """
    SCSSFilter.base_assets_dir = assets.directory
    SCSSFilter.base_scss_dir = os.path.join(
        SCSSFilter.base_assets_dir,
        prefix
    )

    register_filter(SCSSFilter)

    widget_scss = SCSSBundle(
        *scss,
        compile_dir=compile_to,
        filters='scssfilter',
        output=output,
        prefix=prefix
    )

    assets.register(name, widget_scss)

    return widget_scss

    def initialize(self):
        loader = FileSystemLoader([
            self.settings['template_path'],
            self.settings['snippet_path']])
        assets_env = AssetsEnvironment(self.settings['static_path'], self.static_url(''))
        register_filter(LibSass)
        self.template_env = JinjaEnvironment(
            loader=loader, extensions=[AssetsExtension])
        self.template_env.assets_environment = assets_env
        self.template_env.filters['stylesheet_tag'] = self.stylesheet_tag
        self.template_env.filters['javascript_tag'] = self.javascript_tag
        self.template_env.filters['theme_image_url'] = self.theme_image_url

        self.template_env.globals = self.get_globals()
        self.site = self.settings['site']

def test_register_filter():
    """Test registration of custom filters.
    """
    # Needs to be a ``Filter`` subclass.
    assert_raises(ValueError, register_filter, object)

    # A name is required.
    class MyFilter(Filter):
        name = None
        def output(self, *a, **kw): pass
    assert_raises(ValueError, register_filter, MyFilter)

    # The same filter cannot be registered under multiple names.
    MyFilter.name = 'foo'
    register_filter(MyFilter)
    MyFilter.name = 'bar'
    register_filter(MyFilter)

    # But the same name cannot be registered multiple times.
    assert_raises(KeyError, register_filter, MyFilter)

def webassets(debug=False, expire=True, replace=False):
    # Register our custom webassets filter.
    register_filter(ConsoleLogFilter)

    #--------------------------------------------------------------------------
    # Copy fonts to webassets dir.
    print('* Copying fonts to %s' % ASSETDIR)
    fonts = [
        'tailon/assets/vendor/components-font-awesome/fonts/fontawesome-webfont.eot',
        'tailon/assets/vendor/components-font-awesome/fonts/fontawesome-webfont.svg',
        'tailon/assets/vendor/components-font-awesome/fonts/fontawesome-webfont.ttf',
        'tailon/assets/vendor/components-font-awesome/fonts/fontawesome-webfont.woff',
        'tailon/assets/vendor/components-font-awesome/fonts/fontawesome-webfont.woff2',
    ]
    run('rsync -v {} {}'.format(' '.join(fonts), ASSETDIR / 'fonts'))

    #--------------------------------------------------------------------------
    # Load webassets environment.
    env = YAMLLoader('./webassets.yaml').load_environment()
    env.debug = debug
    env.url_expire = expire

    #--------------------------------------------------------------------------
    # Generate css/js urls.
    css_urls = [env['external-css'], env['selectize-css'], env['internal-css']]
    css_urls = [url_to_link(url) for urls in css_urls for url in urls.urls()]

    js_urls = [env['external-js'], env['internal-js']]
    js_urls = [url_to_script(url) for urls in js_urls for url in urls.urls()]

    print()
    print('* URLs css:')
    print(''.join((i.lstrip() for i in css_urls)))

    print('* URLs js:')
    print(''.join((i.lstrip() for i in js_urls)))

    if replace:
        sedplaceholder('tailon/templates/base.html', '<!-- WEBASSETS CSS -->', css_urls)
        sedplaceholder('tailon/templates/base.html', '<!-- WEBASSETS JS -->',  js_urls)

def init_assets_environment(app, include_dependencies=True, auto_build=True):
    """Configure Flask webassets."""
    # Configuration must be set directly on Flask.config because Environment
    # needs to have a Flask application in the context in order to do that.
    app.config['ASSETS_AUTO_BUILD'] = auto_build
    # We need a r.js version which supports stdout (https://github.com/jrburke/r.js/pull/620).
    app.config['RJS_BIN'] = path.join(app.config['STATIC_ROOT'], 'js', 'vendor', 'r.js')
    app.config['RJS_EXTRA_ARGS'] = read_config(path.join(app.config['DATA_ROOT'], 'r.js.conf'))

    register_filter(RJS)

    # 'less' requires lessc and node.js (see package.json).
    css_layout = Bundle(path.join('css', 'less', 'layout.less'),
                        output=path.join('css', 'layout.min.css'),
                        filters='less, cssmin',
                        depends=files(path.join(app.static_folder, 'css', 'less'), '*.less'))

    css_errors = Bundle(path.join('css', 'less', 'errors.less'),
                        output=path.join('css', 'errors.min.css'),
                        filters='less, cssmin')

    # 'rjs' requires r.js and node.js.
    js_rjs = Bundle(path.join('js', 'build', 'main.js'),
                    output=path.join('js', 'main.min.js'),
                    filters='rjs',
                    depends=files(path.join(app.static_folder, 'js', 'build'), '*.js'))

    # Hack: exclude dependencies in order to enable caching (this is a webassets issue).
    if not include_dependencies:
        css_layout.depends = []
        css_errors.depends = []
        js_rjs.depends = []

    assets_env.register('css_layout', css_layout)
    assets_env.register('css_errors', css_errors)
    assets_env.register('js_rjs', js_rjs)

    assets_env.init_app(app)

def includeme(config):
    config.add_route('home', '/', use_global_views=True)
    config.add_route('embed', '/embed.js')
    config.add_route('token', '/api/token')
    config.add_route('users', '/api/u')
    config.add_route('api', '/api/*subpath')
    config.add_route('app', '/app')

    config.add_route('login', '/login')
    config.add_route('logout', '/logout')
    config.add_route('register', '/register')
    config.add_route('forgot', '/forgot')

    config.scan(__name__)
    config.include('pyramid_webassets')

    # wrap coffeescript output in a closure
    config.get_webassets_env().config['coffee_no_bare'] = True

    # register our backported cleancss filter until webassets 0.8 is released
    register_filter(CleanCSS)

    add_webassets(config)

def register_template_bundle(files,
        namespace='KHARKIVPYTPL',
        name=None, output=None, assets=None
        ):
    TemplateFilter.base_assets_dir = assets.directory
    TemplateFilter.namespace = namespace,
    TemplateFilter.base_templates_dir = os.path.join(
                                            TemplateFilter.base_assets_dir,
                                            UNDERSCORE_TEMPLATES_DIR
                                        )
    register_filter(TemplateFilter)

    filters = ['underscore_templates']

    widget_templates = AlwaysUpdatedBundle(
        *files,
        filters=filters,
        output=output

    )

    assets.register(name, widget_templates)
    return widget_templates

    def initialize(self):
        loader = FileSystemLoader([
            self.settings['template_path'],
            self.settings['snippet_path']])
        assets_env = AssetsEnvironment(
            self.settings['static_path'], self.static_url(''))
        register_filter(LibSass)

        self.template_env = JinjaEnvironment(
            loader=loader,
            extensions=[AssetsExtension],
            bytecode_cache=FileSystemBytecodeCache())

        self.template_env.assets_environment = assets_env

        self.template_env.filters['stylesheet_tag'] = self.stylesheet_tag
        self.template_env.filters['javascript_tag'] = self.javascript_tag
        self.template_env.filters['theme_image_url'] = self.theme_image_url
        self.template_env.filters['strftime'] = self.strftime

        self.template_env.globals.update(self.get_globals())

        self.site = self.settings['site']
        self.client = tornado.httpclient.AsyncHTTPClient()

#.........这里部分代码省略.........

		js_libs = [
			"js/lib/jquery/jquery.min.js",
			"js/lib/modernizr.custom.js",
			"js/lib/lodash.min.js",
			"js/lib/sprintf.min.js",
			"js/lib/knockout.js",
			"js/lib/knockout.mapping-latest.js",
			"js/lib/babel.js",
			"js/lib/avltree.js",
			"js/lib/bootstrap/bootstrap.js",
			"js/lib/bootstrap/bootstrap-modalmanager.js",
			"js/lib/bootstrap/bootstrap-modal.js",
			"js/lib/bootstrap/bootstrap-slider.js",
			"js/lib/bootstrap/bootstrap-tabdrop.js",
			"js/lib/jquery/jquery.ui.core.js",
			"js/lib/jquery/jquery.ui.widget.js",
			"js/lib/jquery/jquery.ui.mouse.js",
			"js/lib/jquery/jquery.flot.js",
			"js/lib/jquery/jquery.iframe-transport.js",
			"js/lib/jquery/jquery.fileupload.js",
			"js/lib/jquery/jquery.slimscroll.min.js",
			"js/lib/jquery/jquery.qrcode.min.js",
			"js/lib/moment-with-locales.min.js",
			"js/lib/pusher.color.min.js",
			"js/lib/detectmobilebrowser.js",
			"js/lib/md5.min.js",
			"js/lib/pnotify.min.js",
			"js/lib/bootstrap-slider-knockout-binding.js",
			"js/lib/loglevel.min.js",
			"js/lib/sockjs-0.3.4.min.js"
		]
		js_app = dynamic_assets["js"] + [
			"js/app/dataupdater.js",
			"js/app/helpers.js",
			"js/app/main.js",
		]

		css_libs = [
			"css/bootstrap.min.css",
			"css/bootstrap-modal.css",
			"css/bootstrap-slider.css",
			"css/bootstrap-tabdrop.css",
			"css/font-awesome.min.css",
			"css/jquery.fileupload-ui.css",
			"css/pnotify.min.css"
		]
		css_app = list(dynamic_assets["css"])
		if len(css_app) == 0:
			css_app = ["empty"]

		less_app = list(dynamic_assets["less"])
		if len(less_app) == 0:
			less_app = ["empty"]

		from webassets.filter import register_filter, Filter
		from webassets.filter.cssrewrite.base import PatternRewriter
		import re
		class LessImportRewrite(PatternRewriter):
			name = "less_importrewrite"

			patterns = {
				"import_rewrite": re.compile("(@import(\s+\(.*\))?\s+)\"(.*)\";")
			}

			def import_rewrite(self, m):
				import_with_options = m.group(1)
				import_url = m.group(3)

				if not import_url.startswith("http:") and not import_url.startswith("https:") and not import_url.startswith("/"):
					import_url = "../less/" + import_url

				return "{import_with_options}\"{import_url}\";".format(**locals())

		class JsDelimiterBundle(Filter):
			name = "js_delimiter_bundler"
			options = {}
			def input(self, _in, out, **kwargs):
				out.write(_in.read())
				out.write("\n;\n")

		register_filter(LessImportRewrite)
		register_filter(JsDelimiterBundle)

		js_libs_bundle = Bundle(*js_libs, output="webassets/packed_libs.js", filters="js_delimiter_bundler")
		if settings().getBoolean(["devel", "webassets", "minify"]):
			js_app_bundle = Bundle(*js_app, output="webassets/packed_app.js", filters="rjsmin, js_delimiter_bundler")
		else:
			js_app_bundle = Bundle(*js_app, output="webassets/packed_app.js", filters="js_delimiter_bundler")

		css_libs_bundle = Bundle(*css_libs, output="webassets/packed_libs.css")
		css_app_bundle = Bundle(*css_app, output="webassets/packed_app.css", filters="cssrewrite")

		all_less_bundle = Bundle(*less_app, output="webassets/packed_app.less", filters="cssrewrite, less_importrewrite")

		assets.register("js_libs", js_libs_bundle)
		assets.register("js_app", js_app_bundle)
		assets.register("css_libs", css_libs_bundle)
		assets.register("css_app", css_app_bundle)
		assets.register("less_app", all_less_bundle)

from subprocess import check_output
from flask import Flask
from flask.ext.assets import Environment, Bundle
from webassets.filter import Filter, register_filter

class CoffeeifyFilter(Filter):
    name = 'coffeeify'

    def input(self, _in, out, **kwargs):
        path = kwargs['source_path']
        out.write(check_output(['browserify', '-t', 'coffeeify', path]))

    def output(self, _in, out, **kwargs):
        out.write(_in.read())

register_filter(CoffeeifyFilter)


app = Flask(__name__)

assets = Environment(app)

# api = restful.Api(app)
# api.add_resource(Page, '/pages/<int:page_id>')

js = Bundle('coffee/main.coffee', filters=['coffeeify'], output='main.js')
assets.register('js_all', js)

import plant_api.views

from webassets.filter import register_filter, ExternalTool

class Buble(ExternalTool):
    name = 'buble'
    max_debug_level = None

    options = {
        'binary': 'BUBLE_BIN',
        'extra_args': 'BABEL_EXTRA_ARGS',
        'run_in_debug': 'BABEL_RUN_IN_DEBUG',
    }

    def setup(self):
        super(Buble, self).setup()
        if self.run_in_debug is False:
            # Disable running in debug mode for this instance.
            self.max_debug_level = False

    def input(self, _in, out, **kw):
        args = [self.binary or 'buble']
        if self.extra_args:
            args.extend(self.extra_args)
        return self.subprocess(args, out, _in)

register_filter(Buble)

from flask import Blueprint, Flask
from flask_assets import Bundle, Environment
from flask_cors import CORS, cross_origin
from flask_login import LoginManager
from flask_migrate import Migrate
from flask_oauthlib.client import OAuth
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy
from webassets.filter import register_filter
from webassets_browserify import Browserify

from config import Config

register_filter(Browserify)

db = SQLAlchemy()
api = Api()
assets = Environment()
login_manager = LoginManager()
oauth = OAuth()

spotify = oauth.remote_app(
    'Spotify OAuth',
    consumer_key=Config.SPOTIFY_CLIENT_ID,
    consumer_secret=Config.SPOTIFY_CLIENT_SECRET,
    request_token_params={'scope': 'user-read-email'},
    base_url='https://api.spotify.com/',
    request_token_url=None,
    access_token_method='POST',
    access_token_url='https://accounts.spotify.com/api/token',
    authorize_url='https://accounts.spotify.com/authorize',

def create_app(config=None, debug=False):
    '''
    Inicializa la aplicación Flask. Carga los siguientes módulos:
     - index: página de inicio
     - page: páginas estáticas
     - user: gestión del usuario
     - files: búsqueda y obtención de ficheros
     - status: servicio de monitorización de la aplicación

    Y además, inicializa los siguientes servicios:
     - Configuración: carga valores por defecto y modifica con el @param config
     - Web Assets: compilación y compresión de recursos estáticos
     - i18n: detección de idioma en la URL y catálogos de mensajes
     - Cache y auth: Declarados en el módulo services
     - Files: Clases para acceso a datos
    '''
    app = Flask(__name__)
    app.config.from_object(defaults)
    app.debug = debug

    # Configuración
    if config:
        app.config.from_object(config)

    # Modo de appweb
    appmode = app.config["APPWEB_MODE"]

    # Gestión centralizada de errores
    if app.config["SENTRY_DSN"]:
        sentry.init_app(app)
    logging.getLogger().setLevel(logging.DEBUG if debug else logging.INFO)

    # Configuración dependiente de la versión del código
    revision_filename_path = os.path.join(os.path.dirname(app.root_path), "revision")
    if os.path.exists(revision_filename_path):
        f = open(revision_filename_path, "r")
        data = f.read()
        f.close()
        revisions = tuple(
            tuple(i.strip() for i in line.split("#")[0].split())
            for line in data.strip().split("\n")
            if line.strip() and not line.strip().startswith("#"))
        revision_hash = md5(data).hexdigest()
        app.config.update(
            CACHE_KEY_PREFIX = "%s%s/" % (
                app.config["CACHE_KEY_PREFIX"] if "CACHE_KEY_PREFIX" in app.config else "",
                revision_hash
                ),
            REVISION_HASH = revision_hash,
            REVISION = revisions
            )
    else:
        app.config.update(
            REVISION_HASH = None,
            REVISION = ()
            )

    # Registra filtros de plantillas
    register_filters(app)

    # Registra valores/funciones para plantillas
    app.jinja_env.globals["u"] = u

    # proteccion CSRF
    csrf.init_app(app)

    # Blueprints
    if appmode == "search":
        app.register_blueprint(files)
    elif appmode == "extras":
        app.register_blueprint(extras)
    else:
        logging.error("No se ha especificado modo en la configuración. Blueprints sin cargar.")

    # Web Assets
    dir_static = app.static_folder  # shortcut
    scss.config.LOAD_PATHS = [os.path.abspath('%s/../..' % dir_static)]

    for subdir in ['%s/%s' % (dir_static, x) for x in ['gen', 'torrents/gen']]:
        if not os.path.isdir(subdir):
            os.makedirs(subdir)

    app.assets = Environment(app)
    app.assets.debug = app.debug
    app.assets.versions = "hash"

    register_filter(JsSlimmer)
    register_filter(CssSlimmer)

    app.assets.register(
        'css_torrents',
        Bundle('torrents/css/torrents.scss',
               filters='pyscss', output='torrents/gen/torrents.css', debug=False),
        filters='css_slimmer', output='torrents/gen/torrents.css')

    if appmode == "search":
        app.assets.register(
            'js_appweb',
            Bundle('prototype.js', 'event.simulate.js', 'chosen.proto.min.js','appweb.js',
                   filters='rjsmin', output='gen/appweb.js'))
#.........这里部分代码省略.........

#.........这里部分代码省略.........

		js_libs = [
			"js/lib/jquery/jquery.min.js",
			"js/lib/modernizr.custom.js",
			"js/lib/lodash.min.js",
			"js/lib/sprintf.min.js",
			"js/lib/knockout-3.4.0.js",
			"js/lib/knockout.mapping-latest.js",
			"js/lib/babel.js",
			"js/lib/avltree.js",
			"js/lib/bootstrap/bootstrap.js",
			"js/lib/bootstrap/bootstrap-modalmanager.js",
			"js/lib/bootstrap/bootstrap-modal.js",
			"js/lib/bootstrap/bootstrap-slider.js",
			"js/lib/bootstrap/bootstrap-tabdrop.js",
			"js/lib/jquery/jquery.ui.core.js",
			"js/lib/jquery/jquery.ui.widget.js",
			"js/lib/jquery/jquery.ui.mouse.js",
			"js/lib/jquery/jquery.flot.js",
			"js/lib/jquery/jquery.iframe-transport.js",
			"js/lib/jquery/jquery.fileupload.js",
			"js/lib/jquery/jquery.slimscroll.min.js",
			"js/lib/jquery/jquery.qrcode.min.js",
			"js/lib/moment-with-locales.min.js",
			"js/lib/pusher.color.min.js",
			"js/lib/detectmobilebrowser.js",
			"js/lib/md5.min.js",
			"js/lib/pnotify.min.js",
			"js/lib/bootstrap-slider-knockout-binding.js",
			"js/lib/loglevel.min.js",
			"js/lib/sockjs-0.3.4.min.js"
		]
		js_app = dynamic_assets["js"] + [
			"js/app/dataupdater.js",
			"js/app/helpers.js",
			"js/app/main.js",
		]

		css_libs = [
			"css/bootstrap.min.css",
			"css/bootstrap-modal.css",
			"css/bootstrap-slider.css",
			"css/bootstrap-tabdrop.css",
			"css/font-awesome.min.css",
			"css/jquery.fileupload-ui.css",
			"css/pnotify.min.css"
		]
		css_app = list(dynamic_assets["css"])
		if len(css_app) == 0:
			css_app = ["empty"]

		less_app = list(dynamic_assets["less"])
		if len(less_app) == 0:
			less_app = ["empty"]

		from webassets.filter import register_filter, Filter
		from webassets.filter.cssrewrite.base import PatternRewriter
		import re
		class LessImportRewrite(PatternRewriter):
			name = "less_importrewrite"

			patterns = {
				"import_rewrite": re.compile("(@import(\s+\(.*\))?\s+)\"(.*)\";")
			}

			def import_rewrite(self, m):
				import_with_options = m.group(1)
				import_url = m.group(3)

				if not import_url.startswith("http:") and not import_url.startswith("https:") and not import_url.startswith("/"):
					import_url = "../less/" + import_url

				return "{import_with_options}\"{import_url}\";".format(**locals())

		class JsDelimiterBundle(Filter):
			name = "js_delimiter_bundler"
			options = {}
			def input(self, _in, out, **kwargs):
				out.write(_in.read())
				out.write("\n;\n")

		register_filter(LessImportRewrite)
		register_filter(JsDelimiterBundle)

		js_libs_bundle = Bundle(*js_libs, output="webassets/packed_libs.js", filters="js_delimiter_bundler")
		if settings().getBoolean(["devel", "webassets", "minify"]):
			js_app_bundle = Bundle(*js_app, output="webassets/packed_app.js", filters="rjsmin, js_delimiter_bundler")
		else:
			js_app_bundle = Bundle(*js_app, output="webassets/packed_app.js", filters="js_delimiter_bundler")

		css_libs_bundle = Bundle(*css_libs, output="webassets/packed_libs.css")
		css_app_bundle = Bundle(*css_app, output="webassets/packed_app.css", filters="cssrewrite")

		all_less_bundle = Bundle(*less_app, output="webassets/packed_app.less", filters="cssrewrite, less_importrewrite")

		assets.register("js_libs", js_libs_bundle)
		assets.register("js_app", js_app_bundle)
		assets.register("css_libs", css_libs_bundle)
		assets.register("css_app", css_app_bundle)
		assets.register("less_app", all_less_bundle)

    name = 'cssversion'
    max_debug_level = 'merge'

    def replace_url(self, url):
        parsed = urlparse(url)
        if parsed.scheme:
            return url
        else:
            dirname = path.dirname(self.output_path)
            filepath = path.join(dirname, parsed.path)
            filepath = path.normpath(path.abspath(filepath))
            resolved = self.env.resolver.resolve_source_to_url(filepath, url)
            relative = urlpath.relpath(self.output_url, resolved)
            return relative

register_filter(CSSVersion)


def Uglify(*names, **kw):
    kw.setdefault('filters', 'uglifyjs')
    return Bundle(*names, **kw)


def Coffee(*names, **kw):
    kw.setdefault('filters', 'coffeescript')
    return Bundle(*names, **kw)


def SCSS(*names, **kw):
    kw.setdefault('filters', 'compass,cssrewrite,cssversion,cleancss')
    return Bundle(*names, **kw)

For those to be registered automatically, make sure the main
django_assets namespace imports this file.
"""
from django.template import Template, Context

from webassets import six
from webassets.filter import Filter, register_filter


class TemplateFilter(Filter):
    """
    Will compile all source files as Django templates.
    """
    name = 'template'
    max_debug_level = None

    def __init__(self, context=None):
        super(TemplateFilter, self).__init__()
        self.context = context

    def input(self, _in, out, source_path, output_path, **kw):
        t = Template(_in.read(), origin='django-assets', name=source_path)
        rendered = t.render(Context(self.context if self.context else {}))

        if not six.PY3:
            rendered = rendered.encode('utf-8')
        out.write(rendered)


register_filter(TemplateFilter)

                           output=source,
                           output_path=filepath)
      buf.seek(0)
      # now process '@includes' directives in included file
      self.input(buf, out,
                 source=rel_filename,
                 source_path=abs_filename,
                 output=source,
                 output_path=filepath)

      if end < len(line):
        out.write(line[end:])
      else:
        out.write('\n')

register_filter(ImportCSSFilter)


class LessImportFilter(Filter):
  """
  This filter outputs `@import` statements for listed files. This allows
  to generate a single less file for application, where abilian properties
  can be overridden by application.
  """
  name = 'less_import'
  options = {
    'run_in_debug': 'LESS_RUN_IN_DEBUG', # use same option as less filter
  }
  max_debug_level = None

  logger = logging.getLogger(__name__ + '.LessImportFilter')

            )
        elif stderr:
            print("jade filter has warnings:", stderr)

        # Add a bit of JavaScript that will place our compiled Jade function
        # into an object on the `window` object. Jade files are keyed by their
        # basename.
        key = os.path.splitext(os.path.basename(kwargs["source_path"]))[0]
        preamble = "window['%s']['%s'] = " % (self.js_var, key)

        out.write("%s%s" % (preamble, stdout.strip()))

    def output(self, _in, out, **kwargs):
        """
        Prepend Jade runtime and initialize template variable.
        """
        if self.jade_runtime:
            with open(self.jade_runtime) as file:
                runtime = "".join(file.readlines())
        else:
            runtime = ""

        # JavaScript code to initialize the window-level object that will hold
        # our compiled Jade templates as functions
        init = "if(!window['%s']) { window['%s'] = {}; }" % (self.js_var, self.js_var)

        out.write("%s\n%s\n%s" % (runtime, init, _in.read()))


register_filter(Jade)