Python slimmer.js_slimmer函数代码示例

    def test_registerJSFiles__both_slimmed(self):
        """ test the registerJSFiles() with slim_if_possible=True """
        if js_slimmer is None:
            return

        class MyProduct:
            pass

        # test setting a bunch of files
        files = ["large.js", "test.js"]
        files.append(tuple(files))
        registerJSFiles(
            MyProduct, files, rel_path="tests", set_expiry_header=True, slim_if_possible=True, gzip_if_possible=False
        )

        instance = MyProduct()
        for filename in files:
            if isinstance(filename, tuple):
                filename = ",".join(filename)
            static = getattr(instance, filename)
            self.assertTrue(isinstance(static, BetterImageFile))
            rendered = str(static)
            # expect this to be slimmed
            if len(filename.split(",")) > 1:
                content_parts = [open(right_here(x)).read() for x in filename.split(",")]
                expected_content = js_slimmer("\n".join(content_parts))
            else:
                expected_content = js_slimmer(open(right_here(filename)).read())
            self.assertEqual(rendered.strip(), expected_content.strip())

    def test_registerJSFiles__one_slimmed(self):
        """ test the registerJSFiles() with slim_if_possible=True but one
        of the files shouldn't be slimmed because its filename indicates
        that it's already been slimmed/packed/minified. 

        In this test, the big challange is when two js files are combined 
        and one of them should be slimmed, the other one not slimmed.
        """

        class MyProduct:
            pass

        files = ["test.min.js", "test.js"]
        files.append(tuple(files))
        registerJSFiles(
            MyProduct, files, rel_path="tests", set_expiry_header=True, slim_if_possible=True, gzip_if_possible=False
        )

        instance = MyProduct()
        for filename in files:
            if isinstance(filename, tuple):
                filename = ",".join(filename)
            static = getattr(instance, filename)
            self.assertTrue(isinstance(static, BetterImageFile))
            rendered = str(static).strip()
            # expect this to be slimmed
            if len(filename.split(",")) > 1:

                content_parts = []
                for filename in filename.split(","):
                    content = open(right_here(filename)).read()
                    if filename.find("min") > -1 or js_slimmer is None:
                        content_parts.append(content)
                    else:
                        content_parts.append(js_slimmer(content))

                expected_content = "\n".join(content_parts)
                expected_content = expected_content.strip()

            else:
                content = open(right_here(filename)).read()
                if filename.find("min") > -1 or js_slimmer is None:
                    expected_content = content
                else:
                    expected_content = js_slimmer(content)
                expected_content = expected_content.strip()

            self.assertEqual(rendered, expected_content)

    def test_registerJSFiles__both_slimmed_and_gzipped(self):
        """ test the registerJSFiles() with slim_if_possible=True """
        if js_slimmer is None:
            return

        class MyProduct:
            pass

        # test setting a bunch of files
        files = ["large.js", "test.js"]
        files.append(tuple(files))
        registerJSFiles(
            MyProduct, files, rel_path="tests", set_expiry_header=True, slim_if_possible=True, gzip_if_possible=True
        )

        instance = MyProduct()

        REQUEST = self.app.REQUEST
        RESPONSE = REQUEST.RESPONSE

        for filename in files:
            if isinstance(filename, tuple):
                filename = ",".join(filename)
            static = getattr(instance, filename)
            self.assertTrue(isinstance(static, BetterImageFile))

            # if you just call static.__str__() you're not calling it
            # with a REQUEST that accepts gzip encoding
            REQUEST.set("HTTP_ACCEPT_ENCODING", "gzip")
            bin_rendered = static.index_html(REQUEST, RESPONSE)
            # expect this to be slimmed
            if len(filename.split(",")) > 1:
                content_parts = [open(right_here(x)).read() for x in filename.split(",")]
                expected_content = js_slimmer("\n".join(content_parts))
            else:
                content = open(right_here(filename)).read()
                expected_content = js_slimmer(content)

            rendered = _gzip2ascii(bin_rendered)

            self.assertEqual(rendered.strip(), expected_content.strip())

 def get_code(self):
     import slimmer
     f = codecs.open(self.path, 'r', 'utf-8')
     code = f.read()
     f.close()
     if self.filetype == '.css':
         return slimmer.css_slimmer(code)
     if self.filetype == '.js':
         return slimmer.js_slimmer(code)
     if self.filetype == '.html':
         return slimmer.xhtml_slimmer(code)
     return code

 def _get_code(self):
     import slimmer
     f = open(self.path)
     code = f.read()
     f.close()
     if self.filetype == '.css':
         return slimmer.css_slimmer(code)
     if self.filetype == '.js':
         return slimmer.js_slimmer(code)
     if self.filetype == '.html':
         return slimmer.xhtml_slimmer(code)
     return code

def optimize(content, type_):
    if type_ == CSS:
        if getattr(settings, 'DJANGO_STATIC_YUI_COMPRESSOR', None):
            return _run_yui_compressor(content, type_)
        return css_slimmer(content)
    elif type_ == JS:
        if getattr(settings, 'DJANGO_STATIC_CLOSURE_COMPILER', None):
            return _run_closure_compiler(content)
        if getattr(settings, 'DJANGO_STATIC_YUI_COMPRESSOR', None):
            return _run_yui_compressor(content, type_)
        return js_slimmer(content)
    else:
        raise ValueError("Invalid type %r" % type_)

def geniAnki(self):
    if (web.ctx.environ['HTTP_USER_AGENT'].lower().find('iphone') < 0) and (web.ctx.environ['HTTP_USER_AGENT'].lower().find('ipod') < 0):
        iPhone = False
    else:
        iPhone = True

    # css
    f = open(iankiPath+'/static/base.css')
    css = f.read()
    f.close()
    if True: #iPhone
        f = open(iankiPath+'/static/iphone.css')
        css += f.read()
        f.close()

    if iPhone:
        f = open(iankiPath+'/static/anki-logo.png', 'rb')
        touchicon = '<link rel="apple-touch-icon" href="data:image/png;base64,%s"/>' % base64.b64encode(f.read())
        f.close()
        favicon = ""
        joose = ""
        orm = ""
    else:
        touchicon = ""
        # favicon
        f = open(iankiPath+'/static/favicon.ico', 'rb')
        favicon = '<link rel="shorcut icon" href="data:image/ico;base64,%s"/>' % base64.b64encode(f.read())
        f.close()
        f = open(iankiPath+'/static/joose.mini.js')
        joose = f.read()
        f.close()
        f = open(iankiPath+'/static/orm_async.js')
        orm = f.read()
        f.close()
    f = open(iankiPath+'/static/mootools-1.2.1-core.js')
    s1 = f.read()
    f.close()
    f = open(iankiPath+'/static/ianki.js')
    s2 = f.read()
    f.close()
    f = open(iankiPath+'/templates/ianki.html')
    iankiHTML = f.read()
    f.close()

    if makeSlim:
        s2 = slimmer.js_slimmer(s2)

    iankiHTML = iankiHTML % {'version':ui.__version__, 'favicon':favicon, 'touchicon':touchicon, 'css':css, 'joose':joose, 'orm':orm, 'mootools':s1, 'ianki':s2, 'location':web.input(loc='').loc}
        
    return iankiHTML

def registerJS(filename, path='js', slim_if_possible=True):
    product = OFS.misc_.misc_.IssueTrackerMassContainer
    objectid = filename
    setattr(product,
            objectid, 
            BetterImageFile(os.path.join(path, filename), globals())
            )            
    obj = getattr(product, objectid)
    if js_slimmer is not None and OPTIMIZE:
        if slim_if_possible:
            slimmed = js_slimmer(open(obj.path,'rb').read())
            new_path = obj.path + '-slimmed'
            open(new_path, 'wb').write(slimmed)
            setattr(obj, 'path', new_path)

 def render(self, context):
     code = self.nodelist.render(context)
     if self.format == 'css':
         return css_slimmer(code)
     elif self.format in ('js', 'javascript'):
         return js_slimmer(code)
     elif self.format == 'html':
         return html_slimmer(code)
     else:
         format = guessSyntax(code)
         if format:
             self.format = format
             return self.render(context)
         
     return code

def _registerJS(product, filename,
                path='js', slim_if_possible=True):
    objectid = filename
    setattr(product,
            objectid,
            BetterImageFile(os.path.join(path, filename), globals())
            )
    obj = getattr(product, objectid)
    if js_slimmer is not None and OPTIMIZE:
        if slim_if_possible:
            slimmed = js_slimmer(open(obj.path,'rb').read())
            new_path = obj.path + '-slimmed.js'
            new_path = _get_autogenerated_file_path(new_path)
            open(new_path, 'wb').write(slimmed)
            setattr(obj, 'path', new_path)

    def test_registering_with_slimming_basic(self):
        try:
            from slimmer import js_slimmer, css_slimmer
        except ImportError:
            # not possible to test this
            return

        class MyProduct:
            pass

        instance = MyProduct()

        registerJSFile(MyProduct, "test.js", rel_path="tests", set_expiry_header=True, slim_if_possible=True)

        static = getattr(instance, "test.js")
        self.assertEqual(str(static), js_slimmer(open(right_here("test.js")).read()))

        # this will have created a file called 'test.js-slimmed.js' whose content
        # is the same as str(static)
        copy_test_js = os.path.join(_get_autogenerated_dir(), "test.js-slimmed.js")
        self.assertTrue(os.path.isfile(copy_test_js))
        self.assertEqual(open(copy_test_js).read(), str(static))
        # and it that directory there should not be any other files
        for f in os.listdir(os.path.dirname(copy_test_js)):
            self.assertEqual(f, os.path.basename(copy_test_js))

        registerCSSFile(MyProduct, "test.css", rel_path="tests", set_expiry_header=True, slim_if_possible=True)
        static = getattr(instance, "test.css")
        self.assertEqual(str(static), css_slimmer(open(right_here("test.css")).read()))

        # this will have created a file called 'test.css-slimmed.css' whose content
        # is the same as str(static)
        copy_test_css = os.path.join(_get_autogenerated_dir(), "test.css-slimmed.css")
        self.assertTrue(os.path.isfile(copy_test_css))
        self.assertEqual(open(copy_test_css).read(), str(static))
        # and it that directory there should not be any other files other
        # than the one we made before called test.js-slimmed.js
        for f in os.listdir(os.path.dirname(copy_test_css)):
            self.assertTrue(f == os.path.basename(copy_test_js) or f == os.path.basename(copy_test_css))

        # if you don it again it should just overwrite the old one
        registerCSSFile(MyProduct, "test.css", rel_path="tests", set_expiry_header=True, slim_if_possible=True)

        static = getattr(instance, "test.css")
        # there should still only be two files in the autogenerated directory
        self.assertEqual(len(os.listdir(_get_autogenerated_dir())), 2)

def optimize(content, type_):
    if type_ == CSS:
        if cssmin is not None:
            return _run_cssmin(content)
        elif getattr(settings, "DJANGO_STATIC_YUI_COMPRESSOR", None):
            return _run_yui_compressor(content, type_)
        return slimmer.css_slimmer(content)
    elif type_ == JS:
        if getattr(settings, "DJANGO_STATIC_CLOSURE_COMPILER", None):
            return _run_closure_compiler(content)
        if getattr(settings, "DJANGO_STATIC_YUI_COMPRESSOR", None):
            return _run_yui_compressor(content, type_)
        if getattr(settings, "DJANGO_STATIC_JSMIN", None):
            return _run_jsmin(content)
        return slimmer.js_slimmer(content)
    else:
        raise ValueError("Invalid type %r" % type_)

 def render(self, context):
     code = self.nodelist.render(context)
     if slimmer is None:
         return code
     
     if self.format not in ('css','js','html','xhtml'):
         self.format = guessSyntax(code)
         
     if self.format == 'css':
         return css_slimmer(code)
     elif self.format in ('js', 'javascript'):
         return js_slimmer(code)
     elif self.format == 'xhtml':
         return xhtml_slimmer(code)
     elif self.format == 'html':
         return html_slimmer(code)
         
     return code

    def render(self, context):
        code = self.nodelist.render(context)
        if slimmer is None:
            return code

        if self.format not in ('css','js','html','xhtml'):
            self.format = slimmer.guessSyntax(code)

        if self.format == 'css':
            return slimmer.css_slimmer(code)
        elif self.format in ('js', 'javascript'):
            return slimmer.js_slimmer(code)
        elif self.format == 'xhtml':
            return slimmer.xhtml_slimmer(code)
        elif self.format == 'html':
            return slimmer.html_slimmer(code)
        else:
            raise TemplateSyntaxError("Unrecognized format for slimming content")

        return code

    def render(self, context):
        code = self.nodelist.render(context)
        if slimmer is None:
            return code

        if self.format not in ("css", "js", "html", "xhtml"):
            self.format = slimmer.guessSyntax(code)

        if self.format == "css":
            return slimmer.css_slimmer(code)
        elif self.format in ("js", "javascript"):
            return slimmer.js_slimmer(code)
        elif self.format == "xhtml":
            return slimmer.xhtml_slimmer(code)
        elif self.format == "html":
            return slimmer.html_slimmer(code)
        else:
            raise TemplateSyntaxError("Unrecognized format for slimming content")

        return code