File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib/python2.7/site-packages/paste/debug

opt / alt / python27 / lib / python2.7 / site-packages / paste / debug /

📁 ..
📄 __init__.py(221 B)
📄 __init__.pyc(224 B)
📄 __init__.pyo(224 B)
📄 debugapp.py(2.76 KB)
📄 debugapp.pyc(3.12 KB)
📄 debugapp.pyo(3.12 KB)
📄 doctest_webapp.py(14.55 KB)
📄 doctest_webapp.py.stdlib(14.66 KB)
📄 doctest_webapp.pyc(14.97 KB)
📄 doctest_webapp.pyo(14.81 KB)
📄 fsdiff.py(12.77 KB)
📄 fsdiff.py.stdlib(12.7 KB)
📄 fsdiff.pyc(14.25 KB)
📄 fsdiff.pyo(14.21 KB)
📄 prints.py(5.43 KB)
📄 prints.pyc(5.45 KB)
📄 prints.pyo(5.45 KB)
📄 profile.py(7.45 KB)
📄 profile.pyc(8.53 KB)
📄 profile.pyo(8.53 KB)
📄 testserver.py(3.31 KB)
📄 testserver.pyc(4.21 KB)
📄 testserver.pyo(4.04 KB)
📄 watchthreads.py(10.61 KB)
📄 watchthreads.pyc(11.47 KB)
📄 watchthreads.pyo(11.47 KB)
📄 wdg_validate.py(4.17 KB)
📄 wdg_validate.py.stdlib(4.25 KB)
📄 wdg_validate.pyc(4.51 KB)
📄 wdg_validate.pyo(4.51 KB)

Editing: wdg_validate.py.stdlib

# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
"""
Middleware that tests the validity of all generated HTML using the
`WDG HTML Validator <http://www.htmlhelp.com/tools/validator/>`_
"""

from cStringIO import StringIO
try:
    import subprocess
except ImportError:
    from paste.util import subprocess24 as subprocess
from paste.response import header_value
import re
import cgi

__all__ = ['WDGValidateMiddleware']

class WDGValidateMiddleware(object):

"""
    Middleware that checks HTML and appends messages about the validity of
    the HTML.  Uses: http://www.htmlhelp.com/tools/validator/ -- interacts
    with the command line client.  Use the configuration ``wdg_path`` to
    override the path (default: looks for ``validate`` in $PATH).

To install, in your web context's __init__.py::

def urlparser_wrap(environ, start_response, app):
            return wdg_validate.WDGValidateMiddleware(app)(
                environ, start_response)

Or in your configuration::

middleware.append('paste.wdg_validate.WDGValidateMiddleware')
    """

_end_body_regex = re.compile(r'</body>', re.I)

def __init__(self, app, global_conf=None, wdg_path='validate'):
        self.app = app
        self.wdg_path = wdg_path

def __call__(self, environ, start_response):
        output = StringIO()
        response = []

def writer_start_response(status, headers, exc_info=None):
            response.extend((status, headers))
            start_response(status, headers, exc_info)
            return output.write

app_iter = self.app(environ, writer_start_response)
        try:
            for s in app_iter:
                output.write(s)
        finally:
            if hasattr(app_iter, 'close'):
                app_iter.close()
        page = output.getvalue()
        status, headers = response
        v = header_value(headers, 'content-type') or ''
        if (not v.startswith('text/html')
            and not v.startswith('text/xhtml')
            and not v.startswith('application/xhtml')):
            # Can't validate
            # @@: Should validate CSS too... but using what?
            return [page]
        ops = []
        if v.startswith('text/xhtml+xml'):
            ops.append('--xml')
        # @@: Should capture encoding too
        html_errors = self.call_wdg_validate(
            self.wdg_path, ops, page)
        if html_errors:
            page = self.add_error(page, html_errors)[0]
            headers.remove(
                     ('Content-Length',
                      str(header_value(headers, 'content-length'))))
            headers.append(('Content-Length', str(len(page))))
        return [page]

def call_wdg_validate(self, wdg_path, ops, page):
        if subprocess is None:
            raise ValueError(
                "This middleware requires the subprocess module from "
                "Python 2.4")
        proc = subprocess.Popen([wdg_path] + ops,
                                shell=False,
                                close_fds=True,
                                stdout=subprocess.PIPE,
                                stdin=subprocess.PIPE,
                                stderr=subprocess.STDOUT)
        stdout = proc.communicate(page)[0]
        proc.wait()
        return stdout

def add_error(self, html_page, html_errors):
        add_text = ('<pre style="background-color: #ffd; color: #600; '
                    'border: 1px solid #000;">%s</pre>'
                    % cgi.escape(html_errors))
        match = self._end_body_regex.search(html_page)
        if match:
            return [html_page[:match.start()]
                    + add_text
                    + html_page[match.start():]]
        else:
            return [html_page + add_text]

def make_wdg_validate_middleware(
    app, global_conf, wdg_path='validate'):
    """
    Wraps the application in the WDG validator from
    http://www.htmlhelp.com/tools/validator/

Validation errors are appended to the text of each page.
    You can configure this by giving the path to the validate
    executable (by default picked up from $PATH)
    """
    return WDGValidateMiddleware(
        app, global_conf, wdg_path=wdg_path)

Hackfut Security File Manager

Editing: wdg_validate.py.stdlib

Upload File

Create Folder