def test_cssrewrite_change_folder(self):
     """Test the replace mode of the cssrewrite filter.
     """
     self.create_files({"in.css": """h1 { background: url(old/sub/icon.png) }"""})
     try:
         from collections import OrderedDict
     except ImportError:
         # Without OrderedDict available, use a simplified version
         # of this test.
         cssrewrite = get_filter(
             "cssrewrite",
             replace=dict((("o", "/error/"), ("old", "/new/"))),  # o does NOT match the old/ dir  # this will match
         )
     else:
         cssrewrite = get_filter(
             "cssrewrite",
             replace=OrderedDict(
                 (
                     ("o", "/error/"),  # o does NOT match the old/ dir
                     ("old", "/new/"),  # this will match
                     ("old/sub", "/error/"),  # the first match is used, so this won't be
                     ("new", "/error/"),  # neither will this one match
                 )
             ),
         )
     self.mkbundle("in.css", filters=cssrewrite, output="out.css").build()
     assert self.get("out.css") == """h1 { background: url(/new/sub/icon.png) }"""

def test_get_filter():
    """Test filter resolving.
    """
    # By name - here using one of the builtins.
    assert isinstance(get_filter('jsmin'), Filter)
    assert_raises(ValueError, get_filter, 'notafilteractually')

    # By class.
    class MyFilter(Filter): pass
    assert isinstance(get_filter(MyFilter), MyFilter)
    assert_raises(ValueError, get_filter, object())

    # Passing an instance doesn't do anything.
    f = MyFilter()
    assert id(get_filter(f)) == id(f)

    # Passing a lone callable will give us a a filter back as well.
    assert hasattr(get_filter(lambda: None), 'output')

    # Arguments passed to get_filter are used for instance creation.
    assert get_filter('sass', scss=True).use_scss == True
    # However, this is not allowed when a filter instance is passed directly,
    # or a callable object.
    assert_raises(AssertionError, get_filter, f, 'test')
    assert_raises(AssertionError, get_filter, lambda: None, 'test')

    def test_debug_info_option(self):
        # The debug_info argument to the sass filter can be configured via
        # a global SASS_DEBUG_INFO option.
        self.m.config['SASS_DEBUG_INFO'] = False
        self.mkbundle('foo.sass', filters=get_filter('sass'), output='out.css').build()
        assert not '-sass-debug-info' in self.get('out.css')

        # However, an instance-specific debug_info option takes precedence.
        self.mkbundle('foo.sass', filters=get_filter('sass', debug_info=True), output='out2.css').build()
        assert '-sass-debug-info' in self.get('out2.css')

 def test_sass_import(self):
     """Test referencing other files in sass.
     """
     sass = get_filter('sass', debug_info=False)
     self.create_files({'import-test.sass': '''@import foo.sass'''})
     self.mkbundle('import-test.sass', filters=sass, output='out.css').build()
     assert doctest_match("""/* line 1, ...foo.sass */\nh1 {\n  font-family: "Verdana";\n  color: white;\n}\n""", self.get('out.css'))

    def __init__(self, *args, **kwargs):
        ignore_filters = kwargs.pop('ignore_filters', False) or False
        kwargs['debug'] = False

        try:
            filters = list(kwargs.pop('filters'))
        except KeyError:
            filters = []

        try:
            vars = kwargs.pop('vars')
        except KeyError:
            vars = {}

        fltr = get_filter('vars', vars=vars)

        if not ignore_filters:
            filters.extend([fltr])
        else:
            filters = fltr

        kwargs.update({
            'filters': filters
        })

        Bundle.__init__(self, *args, **kwargs)

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 test_clevercss(self):
     try:
         import clevercss
     except ImportError: 
         raise SkipTest()
     clevercss = get_filter('clevercss')
     self.mkbundle('foo.clevercss', filters=clevercss, output='out.css').build()
     assert self.get('out.css') == """a {

 def test_custom_include_path(self):
     """Test a custom include_path.
     """
     sass_output = get_filter("sass", debug_info=False, as_output=True, includes_dir=self.path("includes"))
     self.create_files(
         {"includes/vars.sass": "$a_color: #FFFFFF", "base.sass": "@import vars.sass\nh1\n  color: $a_color"}
     )
     self.mkbundle("base.sass", filters=sass_output, output="out.css").build()
     assert self.get("out.css") == """/* line 2 */\nh1 {\n  color: white;\n}\n"""

 def test_as_output_filter(self):
     """The sass filter can be configured to work as on output filter,
     first merging the sources together, then applying sass.
     """
     # To test this, split a sass rules into two files.
     sass_output = get_filter('sass', debug_info=False, as_output=True)
     self.create_files({'p1': 'h1', 'p2': '\n  color: #FFFFFF'})
     self.mkbundle('p1', 'p2', filters=sass_output, output='out.css').build()
     assert self.get('out.css') == """/* line 1 */\nh1 {\n  color: white;\n}\n"""

 def test_sass_import(self):
     """Test referencing other files in sass.
     """
     sass = get_filter("sass", debug_info=False)
     self.create_files({"import-test.sass": """@import foo.sass"""})
     self.mkbundle("import-test.sass", filters=sass, output="out.css").build()
     assert (
         self.get("out.css") == """/* line 1, ./foo.sass */\nh1 {\n  font-family: "Verdana";\n  color: white;\n}\n"""
     )

 def test_custom_include_path(self):
     """Test a custom include_path.
     """
     sass_output = get_filter('sass', debug_info=False, as_output=True,
                              includes_dir=self.path('includes'))
     self.create_files({
         'includes/vars.sass': '$a_color: #FFFFFF',
         'base.sass': '@import vars.sass\nh1\n  color: $a_color'})
     self.mkbundle('base.sass', filters=sass_output, output='out.css').build()
     assert self.get('out.css') == """/* line 2 */\nh1 {\n  color: white;\n}\n"""

    def test_replace_with_cache(self):
        """[Regression] Test replace mode while cache is active.

        This used to fail due to an unhashable key being returned by
        the filter."""
        cssrewrite = get_filter("cssrewrite", replace={"old": "new"})
        self.env.cache = True
        self.create_files({"in.css": """h1 { background: url(old/sub/icon.png) }"""})
        # Does not raise an exception.
        self.mkbundle("in.css", filters=cssrewrite, output="out.css").build()

    def test_replace_with_cache(self):
        """[Regression] Test replace mode while cache is active.

        This used to fail due to an unhashable key being returned by
        the filter."""
        cssrewrite = get_filter('cssrewrite', replace={'old': 'new'})
        self.env.cache = True
        self.create_files({'in.css': '''h1 { background: url(old/sub/icon.png) }'''})
        # Does not raise an exception.
        self.mkbundle('in.css', filters=cssrewrite, output='out.css').build()

    def test_coffeescript(self):
        coffeescript = get_filter("coffeescript")
        self.mkbundle("foo.coffee", filters=coffeescript, output="out.js").build()
        assert (
            self.get("out.js")
            == """if (typeof elvis != "undefined" && elvis !== null) {
  alert("I knew it!");
}
"""
        )

    def __init__(self, flask_app):
        self.app = flask_app
        self.styles_path = os.path.join(self.app.config['ASSETS_PATH'], 'styles')
        self.scripts_path = os.path.join(self.app.config['ASSETS_PATH'], 'scripts')

        # add filters
        self.pyscss = get_filter('pyscss')
        self.pyscss.load_paths = [self.styles_path]

        self.css_filters = (self.pyscss, 'cssmin')
        self.js_filters = (Pipeline.pycoffee, 'jsmin')

def get_rules(kind):
    if kind == '.css':
        return Bunch(
            final_filter = ["yui_css", get_filter('cssrewrite', replace=proxied)],
            compilers = {".scss": "pyscss"},
            kwargs = defaultdict(dict)
        )
    elif kind == '.js':
        return Bunch(final_filter="yui_js", compilers={".coffee": "coffeescript", ".jst": "register_jst"},
                     kwargs=defaultdict(dict))
    raise RuntimeError("unknown bundle kind: %s" % (kind,))

    def test_debug_info_option(self):
        # The debug_info argument to the sass filter can be configured via
        # a global SASS_DEBUG_INFO option.
        self.env.config["SASS_DEBUG_INFO"] = False
        self.mkbundle("foo.sass", filters=get_filter("sass"), output="out.css").build(force=True)
        assert not "-sass-debug-info" in self.get("out.css")

        # However, an instance-specific debug_info option takes precedence.
        self.mkbundle("foo.sass", filters=get_filter("sass", debug_info=True), output="out.css").build(force=True)
        assert "-sass-debug-info" in self.get("out.css")

        # If the value is None (the default), then the filter will look
        # at the debug setting to determine whether to include debug info.
        self.env.config["SASS_DEBUG_INFO"] = None
        self.env.debug = True
        self.mkbundle("foo.sass", filters=get_filter("sass"), output="out.css", debug=False).build(force=True)
        assert "-sass-debug-info" in self.get("out.css")
        self.env.debug = False
        self.mkbundle("foo.sass", filters=get_filter("sass"), output="out.css").build(force=True)
        assert not "-sass-debug-info" in self.get("out.css")

    def test_template(self):
        self.create_files({
            'media/foo.html': 'Ünicôdé-Chèck: {{ num|filesizeformat }}',
        })
        self.mkbundle(
            'foo.html',
            output="out",
            filters=get_filter('template', context={'num': 23232323}),
        ).build()

        # Depending on Django version "filesizeformat" may contain a breaking space
        assert self.get('media/out') in ('Ünicôdé-Chèck: 22.2\xa0MB', 'Ünicôdé-Chèck: 22.2 MB')

  def input(self, _in, out, **kwargs):
    filepath = kwargs['source_path']
    source = kwargs.get('source')

    if not source:
      # this happens when this filters is not used as a "source" filter, i.e _in
      # is a webasset hunk instance
      source = filepath
    # output = kwargs['output']
    base_dir = os.path.dirname(filepath)
    rel_dir = os.path.dirname(source)

    self.logger.debug('process "%s"', filepath)

    for line in _in.readlines():
      import_match = self._IMPORT_RE.search(line)
      if import_match is None:
        out.write(line)
        continue

      filename = import_match.group('filename')
      abs_filename = os.path.abspath(os.path.join(base_dir, filename))
      rel_filename= os.path.normpath(os.path.join(rel_dir, filename))

      start, end = import_match.span()
      if start > 0:
        out.write(line[:start])
        out.write('\n')

      with open(abs_filename, 'r') as included:
        # rewrite url() statements
        buf = StringIO()
        url_rewriter = get_filter('cssrewrite')
        url_rewriter.set_context(self.ctx)
        url_rewriter.setup()
        url_rewriter.input(included, buf,
                           source=rel_filename,
                           source_path=abs_filename,
                           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')

 def test_change_folder(self):
     """Test the replace mode of the cssrewrite filter.
     """
     self.create_files({'in.css': '''h1 { background: url(old/sub/icon.png) }'''})
     try:
         from collections import OrderedDict
     except ImportError:
         # Without OrderedDict available, use a simplified version
         # of this test.
         cssrewrite = get_filter('cssrewrite', replace=dict((
             ('o', '/error/'),       # o does NOT match the old/ dir
             ('old', '/new/'),       # this will match
         )))
     else:
         cssrewrite = get_filter('cssrewrite', replace=OrderedDict((
             ('o', '/error/'),       # o does NOT match the old/ dir
             ('old', '/new/'),       # this will match
             ('old/sub', '/error/'), # the first match is used, so this won't be
             ('new', '/error/'),     # neither will this one match
         )))
     self.mkbundle('in.css', filters=cssrewrite, output='out.css').build()
     assert self.get('out.css') == '''h1 { background: url(/new/sub/icon.png) }'''