Python htmltalparser.HTMLTALParser类代码示例

 def __call__(self, value, *args, **kw):
     gen = TALGenerator(getEngine(), xml=1, source_file=None)
     parser = HTMLTALParser(gen)
     try:
         parser.parseString(value)
     except Exception, err:
         return ("Validation Failed(%s): \n %s" % (self.name, err))

def compilefile(file, mode=None):
    assert mode in ("html", "xml", None)
    if mode is None:
        ext = os.path.splitext(file)[1]
        if ext.lower() in (".html", ".htm"):
            mode = "html"
        else:
            mode = "xml"
    # make sure we can find the file
    prefix = os.path.dirname(os.path.abspath(__file__)) + os.path.sep
    if (not os.path.exists(file)
        and os.path.exists(os.path.join(prefix, file))):
        file = os.path.join(prefix, file)
    # normalize filenames for test output
    filename = os.path.abspath(file)
    if filename.startswith(prefix):
        filename = filename[len(prefix):]
    filename = filename.replace(os.sep, '/') # test files expect slashes
    # parse
    from zope.tal.talgenerator import TALGenerator
    if mode == "html":
        from zope.tal.htmltalparser import HTMLTALParser
        p = HTMLTALParser(gen=TALGenerator(source_file=filename, xml=0))
    else:
        from zope.tal.talparser import TALParser
        p = TALParser(gen=TALGenerator(source_file=filename))
    p.parseFile(file)
    return p.getCode()

def talEval(expression, context, extra=None):
    """
    Perform a TAL eval on the expression.
    """
    # First, account for the possibility that it is merely TALES; if there are
    # no <tal> in it at all (nor the ${python:} you can do with this function),
    # just send it to talesEval
    isTales = '<tal' not in expression and '${python:' not in expression
    if isTales:
        return talesEvalStr(expression, context, extra)

    # Next, as a convenience, replace all ${} blocks that aren't inside a <tal>
    # with <tal:block content="..."/> equivalent
    chunks = TAG.split(expression)
    modified = []
    for chunk in chunks:
        if chunk.startswith('<tal'):
            modified.append(chunk)
        else:
            modified.append(TPLBLOCK.sub(_chunk_repl, chunk))
    expression = ''.join(modified)

    # Finally, compile the expression and apply context
    gen = TALGenerator(Engine, xml=0)
    parser = HTMLTALParser(gen)
    parser.parseString(expression)
    program, macros = parser.getCode()
    output = cStringIO.StringIO()
    context = Engine.getContext(context)
    TALInterpreter(program, macros, context, output, tal=True)()
    return output.getvalue()

 def test_dynamic_msgids(self):
     sample_source = """
         <p i18n:translate="">
           Some
           <span tal:replace="string:strange">dynamic</span>
           text.
         </p>
         <p i18n:translate="">
           A <a tal:attributes="href path:dynamic">link</a>.
         </p>
     """
     p = HTMLTALParser()
     p.parseString(sample_source)
     program, macros = p.getCode()
     engine = POEngine()
     engine.file = 'sample_source'
     POTALInterpreter(program, macros, engine, stream=StringIO(),
                      metal=False)()
     msgids = []
     for domain in engine.catalog.values():
         msgids += list(domain)
     msgids.sort()
     self.assertEqual(msgids,
         ['A <a href="${DYNAMIC_CONTENT}">link</a>.',
         'Some ${DYNAMIC_CONTENT} text.'])

 def insertHTMLStructure(self, text, repldict):
     from zope.tal.htmltalparser import HTMLTALParser
     gen = AltTALGenerator(repldict, self.engine._engine, 0)
     p = HTMLTALParser(gen) # Raises an exception if text is invalid
     p.parseString(text)
     program, macros = p.getCode()
     self.interpret(program)

def time_tal(fn, count):
    p = HTMLTALParser()
    p.parseFile(fn)
    program, macros = p.getCode()
    engine = DummyEngine(macros)
    engine.globals = data
    tal = TALInterpreter(program, macros, engine, StringIO(), wrap=0,
                         tal=1, strictinsert=0)
    return time_apply(tal, (), {}, count)

    def cook(cls, source_file, text, engine, content_type):
        if content_type == 'text/html':
            gen = TALGenerator(engine, xml=0, source_file=source_file)
            parser = HTMLTALParser(gen)
        else:
            gen = TALGenerator(engine, source_file=source_file)
            parser = TALParser(gen)

        parser.parseString(text)
        program, macros = parser.getCode()

        return cls(program), macros

def profile_tal(fn, count, profiler):
    p = HTMLTALParser()
    p.parseFile(fn)
    program, macros = p.getCode()
    engine = DummyEngine(macros)
    engine.globals = data
    tal = TALInterpreter(program, macros, engine, StringIO(), wrap=0,
                         tal=1, strictinsert=0)
    for i in range(4):
        tal()
    r = [None] * count
    for i in r:
        profiler.runcall(tal)

def tal_strings(dir, domain="zope", include_default_domain=False, exclude=()):
    """Retrieve all TAL messages from `dir` that are in the `domain`.
    """
    # We import zope.tal.talgettext here because we can't rely on the
    # right sys path until app_dir has run
    from zope.tal.talgettext import POEngine, POTALInterpreter
    from zope.tal.htmltalparser import HTMLTALParser
    from zope.tal.talparser import TALParser
    import sys
    # i18n patch if templates using special characters
    reload(sys)
    sys.setdefaultencoding('UTF8')
    engine = POEngine()

    class Devnull(object):
        def write(self, s):
            pass

    for filename in (find_files(dir, '*.*pt', exclude=tuple(exclude)) +
                     find_files(dir, '*.html', exclude=tuple(exclude)) +
                     find_files(dir, '*.kupu', exclude=tuple(exclude)) +
                     find_files(dir, '*.pox', exclude=tuple(exclude)) +
                     find_files(dir, '*.xsl', exclude=tuple(exclude))):
        try:
            engine.file = filename
            name, ext = os.path.splitext(filename)
            if ext == '.html' or ext.endswith('pt'):
                p = HTMLTALParser()
            else:
                p = TALParser()
            p.parseFile(filename)
            program, macros = p.getCode()
            POTALInterpreter(program, macros, engine, stream=Devnull(),
                             metal=False)()
        except:  # Hee hee, I love bare excepts!
            print 'There was an error processing', filename
            traceback.print_exc()

    # See whether anything in the domain was found
    if not domain in engine.catalog:
        return {}
    # We do not want column numbers.
    catalog = engine.catalog[domain].copy()
    # When the Domain is 'default', then this means that none was found;
    # Include these strings; yes or no?
    if include_default_domain:
        catalog.update(engine.catalog['default'])
    for msgid, locations in catalog.items():
        catalog[msgid] = [(l[0], l[1][0]) for l in locations]
    return catalog

    def _cook(self):
        self._v_program = None

        if not self._source:
            return

        parser = HTMLTALParser(TALGenerator(TrustedEngine))
        try:
            parser.parseString(self.source)
            self._v_program, macros = parser.getCode()
            self._v_errors = ()
        except Exception, e:
            self._v_program = None
            self._v_errors = [unicode(err) for err in sys.exc_info()[:2]]

def talToHtml(tal):
    """
    Expects TAL-string, returns interpreted HTML-string.
    Works only with string-(and python?)-expressions, not
    with path-expressions.
    """
    generator = TALGenerator(xml=0, source_file=None)
    parser = HTMLTALParser(generator)
    parser.parseString(tal)
    program, macros = parser.getCode()
    engine = DummyEngine(macros)
    result = StringIO()
    interpreter = TALInterpreter(program, {}, engine, stream=result)
    interpreter()
    tal = result.getvalue().strip()
    return tal

 def test_potalinterpreter_translate_default(self):
     sample_source = '<p i18n:translate="">text</p>'
     p = HTMLTALParser()
     p.parseString(sample_source)
     program, macros = p.getCode()
     engine = POEngine()
     engine.file = 'sample_source'
     interpreter = POTALInterpreter(
         program, macros, engine, stream=StringIO(), metal=False)
     # We simply call this, to make sure we don't get a NameError
     # for 'unicode' in python 3.
     # The return value (strangely: 'x') is not interesting here.
     interpreter.translate('text')
     msgids = []
     for domain in engine.catalog.values():
         msgids += list(domain)
     self.assertIn('text', msgids)

def cook(self):
    """Compile the TAL and METAL statments.

    Cooking must not fail due to compilation errors in templates.
    """
    engine = self.pt_getEngine()
    source_file = self.pt_source_file()
    if self.content_type == 'text/html':
        gen = TALGenerator(engine, xml=0, source_file=source_file)
        parser = HTMLTALParser(gen)
    else:
        gen = TALGenerator(engine, source_file=source_file)
        parser = TALParser(gen)

    self._v_errors = ()
    try:
        #### the patch
        text = self._text
        text = expression.sub('', text)
        text = expression2.sub('', text)
        parser.parseString(text)
        #parser.parseString(self._text)
        self._v_program, self._v_macros = parser.getCode()
    except:
        self._v_errors = ["Compilation failed",
                          "%s: %s" % sys.exc_info()[:2]]
    self._v_warnings = parser.getWarnings()
    self._v_cooked = 1

def compilefile(file, mode=None):
    assert mode in ("html", "xml", None)
    if mode is None:
        ext = os.path.splitext(file)[1]
        if ext.lower() in (".html", ".htm"):
            mode = "html"
        else:
            mode = "xml"
    from zope.tal.talgenerator import TALGenerator
    filename = os.path.abspath(file)
    prefix = os.path.dirname(os.path.abspath(__file__)) + os.path.sep
    if filename.startswith(prefix):
        filename = filename[len(prefix):]
    filename = filename.replace(os.sep, '/') # test files expect slashes
    if mode == "html":
        from zope.tal.htmltalparser import HTMLTALParser
        p = HTMLTALParser(gen=TALGenerator(source_file=filename, xml=0))
    else:
        from zope.tal.talparser import TALParser
        p = TALParser(gen=TALGenerator(source_file=filename))
    p.parseFile(file)
    return p.getCode()

    def _cook(self):
        """Compile the TAL and METAL statments.

        Cooking must not fail due to compilation errors in templates.
        """
        engine = self.pt_getEngine()
        source_file = self.pt_source_file()
        if self.content_type == 'text/html':
            gen = TALGenerator(engine, xml=0, source_file=source_file)
            parser = HTMLTALParser(gen)
        else:
            gen = TALGenerator(engine, source_file=source_file)
            parser = TALParser(gen)

        self._v_errors = ()
        try:
            parser.parseString(self._text)
            self._v_program, self._v_macros = parser.getCode()
        except:
            etype, e = sys.exc_info()[:2]
            self._v_errors = ["Compilation failed",
                              "%s.%s: %s" % (etype.__module__, etype.__name__, e)]
        self._v_cooked = 1