Translation of UI (german and english)

Bugfix for feeds
    - removed categories related and up
    - load new books now working
    - category random now working
login page is free of non accessible elements
boolean custom column is vivible in UI
books with only with certain languages can be shown
book shelfs can be deleted from UI
Anonymous user view is more resticted
Added browse of series in sidebar
Dependencys in vendor folder are updated to newer versions (licencs files are now present)
Bugfix editing Authors names
Made upload on windows working

vendor/werkzeug/debug/__init__.py

@@ -5,24 +5,103 @@
 
     WSGI application traceback debugger.
 
-    :copyright: (c) 2013 by the Werkzeug Team, see AUTHORS for more details.
+    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
     :license: BSD, see LICENSE for more details.
 """
+import os
+import re
+import sys
+import uuid
 import json
+import time
+import getpass
+import hashlib
 import mimetypes
+from itertools import chain
 from os.path import join, dirname, basename, isfile
 from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response
+from werkzeug.http import parse_cookie
 from werkzeug.debug.tbtools import get_current_traceback, render_console_html
 from werkzeug.debug.console import Console
 from werkzeug.security import gen_salt
+from werkzeug._internal import _log
+from werkzeug._compat import text_type
 
 
+# DEPRECATED
 #: import this here because it once was documented as being available
 #: from this module.  In case there are users left ...
-from werkzeug.debug.repr import debug_repr
+from werkzeug.debug.repr import debug_repr  # noqa
+
+
+# A week
+PIN_TIME = 60 * 60 * 24 * 7
+
+
+def hash_pin(pin):
+    if isinstance(pin, text_type):
+        pin = pin.encode('utf-8', 'replace')
+    return hashlib.md5(pin + b'shittysalt').hexdigest()[:12]
+
+
+_machine_id = None
+
+
+def get_machine_id():
+    global _machine_id
+    rv = _machine_id
+    if rv is not None:
+        return rv
+
+    def _generate():
+        # Potential sources of secret information on linux.  The machine-id
+        # is stable across boots, the boot id is not
+        for filename in '/etc/machine-id', '/proc/sys/kernel/random/boot_id':
+            try:
+                with open(filename, 'rb') as f:
+                    return f.readline().strip()
+            except IOError:
+                continue
+
+        # On OS X we can use the computer's serial number assuming that
+        # ioreg exists and can spit out that information.
+        try:
+            # Also catch import errors: subprocess may not be available, e.g.
+            # Google App Engine
+            # See https://github.com/pallets/werkzeug/issues/925
+            from subprocess import Popen, PIPE
+            dump = Popen(['ioreg', '-c', 'IOPlatformExpertDevice', '-d', '2'],
+                         stdout=PIPE).communicate()[0]
+            match = re.search(b'"serial-number" = <([^>]+)', dump)
+            if match is not None:
+                return match.group(1)
+        except (OSError, ImportError):
+            pass
+
+        # On Windows we can use winreg to get the machine guid
+        wr = None
+        try:
+            import winreg as wr
+        except ImportError:
+            try:
+                import _winreg as wr
+            except ImportError:
+                pass
+        if wr is not None:
+            try:
+                with wr.OpenKey(wr.HKEY_LOCAL_MACHINE,
+                                'SOFTWARE\\Microsoft\\Cryptography', 0,
+                                wr.KEY_READ | wr.KEY_WOW64_64KEY) as rk:
+                    return wr.QueryValueEx(rk, 'MachineGuid')[0]
+            except WindowsError:
+                pass
+
+    _machine_id = rv = _generate()
+    return rv
 
 
 class _ConsoleFrame(object):
+
     """Helper class so that we can reuse the frame console code for the
     standalone console.
     """
@@ -32,6 +111,90 @@ class _ConsoleFrame(object):
         self.id = 0
 
 
+def get_pin_and_cookie_name(app):
+    """Given an application object this returns a semi-stable 9 digit pin
+    code and a random key.  The hope is that this is stable between
+    restarts to not make debugging particularly frustrating.  If the pin
+    was forcefully disabled this returns `None`.
+
+    Second item in the resulting tuple is the cookie name for remembering.
+    """
+    pin = os.environ.get('WERKZEUG_DEBUG_PIN')
+    rv = None
+    num = None
+
+    # Pin was explicitly disabled
+    if pin == 'off':
+        return None, None
+
+    # Pin was provided explicitly
+    if pin is not None and pin.replace('-', '').isdigit():
+        # If there are separators in the pin, return it directly
+        if '-' in pin:
+            rv = pin
+        else:
+            num = pin
+
+    modname = getattr(app, '__module__',
+                      getattr(app.__class__, '__module__'))
+
+    try:
+        # `getpass.getuser()` imports the `pwd` module,
+        # which does not exist in the Google App Engine sandbox.
+        username = getpass.getuser()
+    except ImportError:
+        username = None
+
+    mod = sys.modules.get(modname)
+
+    # This information only exists to make the cookie unique on the
+    # computer, not as a security feature.
+    probably_public_bits = [
+        username,
+        modname,
+        getattr(app, '__name__', getattr(app.__class__, '__name__')),
+        getattr(mod, '__file__', None),
+    ]
+
+    # This information is here to make it harder for an attacker to
+    # guess the cookie name.  They are unlikely to be contained anywhere
+    # within the unauthenticated debug page.
+    private_bits = [
+        str(uuid.getnode()),
+        get_machine_id(),
+    ]
+
+    h = hashlib.md5()
+    for bit in chain(probably_public_bits, private_bits):
+        if not bit:
+            continue
+        if isinstance(bit, text_type):
+            bit = bit.encode('utf-8')
+        h.update(bit)
+    h.update(b'cookiesalt')
+
+    cookie_name = '__wzd' + h.hexdigest()[:20]
+
+    # If we need to generate a pin we salt it a bit more so that we don't
+    # end up with the same value and generate out 9 digits
+    if num is None:
+        h.update(b'pinsalt')
+        num = ('%09d' % int(h.hexdigest(), 16))[:9]
+
+    # Format the pincode in groups of digits for easier remembering if
+    # we don't have a result yet.
+    if rv is None:
+        for group_size in 5, 4, 3:
+            if len(num) % group_size == 0:
+                rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
+                              for x in range(0, len(num), group_size))
+                break
+        else:
+            rv = num
+
+    return rv, cookie_name
+
+
 class DebuggedApplication(object):
     """Enables debugging support for a given application::
 
@@ -58,19 +221,19 @@ class DebuggedApplication(object):
     :param show_hidden_frames: by default hidden traceback frames are skipped.
                                You can show them by setting this parameter
                                to `True`.
+    :param pin_security: can be used to disable the pin based security system.
+    :param pin_logging: enables the logging of the pin system.
     """
 
-    # this class is public
-    __module__ = 'werkzeug'
-
     def __init__(self, app, evalex=False, request_key='werkzeug.request',
                  console_path='/console', console_init_func=None,
-                 show_hidden_frames=False, lodgeit_url=None):
+                 show_hidden_frames=False, lodgeit_url=None,
+                 pin_security=True, pin_logging=True):
         if lodgeit_url is not None:
             from warnings import warn
             warn(DeprecationWarning('Werkzeug now pastes into gists.'))
         if not console_init_func:
-            console_init_func = dict
+            console_init_func = None
         self.app = app
         self.evalex = evalex
         self.frames = {}
@@ -80,6 +243,39 @@ class DebuggedApplication(object):
         self.console_init_func = console_init_func
         self.show_hidden_frames = show_hidden_frames
         self.secret = gen_salt(20)
+        self._failed_pin_auth = 0
+
+        self.pin_logging = pin_logging
+        if pin_security:
+            # Print out the pin for the debugger on standard out.
+            if os.environ.get('WERKZEUG_RUN_MAIN') == 'true' and \
+               pin_logging:
+                _log('warning', ' * Debugger is active!')
+                if self.pin is None:
+                    _log('warning', ' * Debugger pin disabled.  '
+                         'DEBUGGER UNSECURED!')
+                else:
+                    _log('info', ' * Debugger pin code: %s' % self.pin)
+        else:
+            self.pin = None
+
+    def _get_pin(self):
+        if not hasattr(self, '_pin'):
+            self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
+        return self._pin
+
+    def _set_pin(self, value):
+        self._pin = value
+
+    pin = property(_get_pin, _set_pin)
+    del _get_pin, _set_pin
+
+    @property
+    def pin_cookie_name(self):
+        """The name of the pin cookie."""
+        if not hasattr(self, '_pin_cookie'):
+            self._pin, self._pin_cookie = get_pin_and_cookie_name(self.app)
+        return self._pin_cookie
 
     def debug_application(self, environ, start_response):
         """Run the application and conserve the traceback frames."""
@@ -93,9 +289,9 @@ class DebuggedApplication(object):
         except Exception:
             if hasattr(app_iter, 'close'):
                 app_iter.close()
-            traceback = get_current_traceback(skip=1, show_hidden_frames=
-                                              self.show_hidden_frames,
-                                              ignore_system_exceptions=True)
+            traceback = get_current_traceback(
+                skip=1, show_hidden_frames=self.show_hidden_frames,
+                ignore_system_exceptions=True)
             for frame in traceback.frames:
                 self.frames[frame.id] = frame
             self.tracebacks[traceback.id] = traceback
@@ -117,9 +313,11 @@ class DebuggedApplication(object):
                     'response at a point where response headers were already '
                     'sent.\n')
             else:
+                is_trusted = bool(self.check_pin_trust(environ))
                 yield traceback.render_full(evalex=self.evalex,
+                                            evalex_trusted=is_trusted,
                                             secret=self.secret) \
-                               .encode('utf-8', 'replace')
+                    .encode('utf-8', 'replace')
 
             traceback.log(environ['wsgi.errors'])
 
@@ -130,8 +328,15 @@ class DebuggedApplication(object):
     def display_console(self, request):
         """Display a standalone shell."""
         if 0 not in self.frames:
-            self.frames[0] = _ConsoleFrame(self.console_init_func())
-        return Response(render_console_html(secret=self.secret),
+            if self.console_init_func is None:
+                ns = {}
+            else:
+                ns = dict(self.console_init_func())
+            ns.setdefault('app', self.app)
+            self.frames[0] = _ConsoleFrame(ns)
+        is_trusted = bool(self.check_pin_trust(request.environ))
+        return Response(render_console_html(secret=self.secret,
+                                            evalex_trusted=is_trusted),
                         mimetype='text/html')
 
     def paste_traceback(self, request, traceback):
@@ -139,10 +344,6 @@ class DebuggedApplication(object):
         rv = traceback.paste()
         return Response(json.dumps(rv), mimetype='application/json')
 
-    def get_source(self, request, frame):
-        """Render the source viewer."""
-        return Response(frame.render_source(), mimetype='text/html')
-
     def get_resource(self, request, filename):
         """Return a static resource from the shared folder."""
         filename = join(dirname(__file__), 'shared', basename(filename))
@@ -156,6 +357,83 @@ class DebuggedApplication(object):
                 f.close()
         return Response('Not Found', status=404)
 
+    def check_pin_trust(self, environ):
+        """Checks if the request passed the pin test.  This returns `True` if the
+        request is trusted on a pin/cookie basis and returns `False` if not.
+        Additionally if the cookie's stored pin hash is wrong it will return
+        `None` so that appropriate action can be taken.
+        """
+        if self.pin is None:
+            return True
+        val = parse_cookie(environ).get(self.pin_cookie_name)
+        if not val or '|' not in val:
+            return False
+        ts, pin_hash = val.split('|', 1)
+        if not ts.isdigit():
+            return False
+        if pin_hash != hash_pin(self.pin):
+            return None
+        return (time.time() - PIN_TIME) < int(ts)
+
+    def _fail_pin_auth(self):
+        time.sleep(self._failed_pin_auth > 5 and 5.0 or 0.5)
+        self._failed_pin_auth += 1
+
+    def pin_auth(self, request):
+        """Authenticates with the pin."""
+        exhausted = False
+        auth = False
+        trust = self.check_pin_trust(request.environ)
+
+        # If the trust return value is `None` it means that the cookie is
+        # set but the stored pin hash value is bad.  This means that the
+        # pin was changed.  In this case we count a bad auth and unset the
+        # cookie.  This way it becomes harder to guess the cookie name
+        # instead of the pin as we still count up failures.
+        bad_cookie = False
+        if trust is None:
+            self._fail_pin_auth()
+            bad_cookie = True
+
+        # If we're trusted, we're authenticated.
+        elif trust:
+            auth = True
+
+        # If we failed too many times, then we're locked out.
+        elif self._failed_pin_auth > 10:
+            exhausted = True
+
+        # Otherwise go through pin based authentication
+        else:
+            entered_pin = request.args.get('pin')
+            if entered_pin.strip().replace('-', '') == \
+               self.pin.replace('-', ''):
+                self._failed_pin_auth = 0
+                auth = True
+            else:
+                self._fail_pin_auth()
+
+        rv = Response(json.dumps({
+            'auth': auth,
+            'exhausted': exhausted,
+        }), mimetype='application/json')
+        if auth:
+            rv.set_cookie(self.pin_cookie_name, '%s|%s' % (
+                int(time.time()),
+                hash_pin(self.pin)
+            ), httponly=True)
+        elif bad_cookie:
+            rv.delete_cookie(self.pin_cookie_name)
+        return rv
+
+    def log_pin_request(self):
+        """Log the pin if needed."""
+        if self.pin_logging and self.pin is not None:
+            _log('info', ' * To enable the debugger you need to '
+                 'enter the security pin:')
+            _log('info', ' * Debugger pin code: %s' % self.pin)
+        return Response('')
+
     def __call__(self, environ, start_response):
         """Dispatch the requests."""
         # important: don't ever access a function here that reads the incoming
@@ -172,14 +450,17 @@ class DebuggedApplication(object):
             if cmd == 'resource' and arg:
                 response = self.get_resource(request, arg)
             elif cmd == 'paste' and traceback is not None and \
-                 secret == self.secret:
+                    secret == self.secret:
                 response = self.paste_traceback(request, traceback)
-            elif cmd == 'source' and frame and self.secret == secret:
-                response = self.get_source(request, frame)
-            elif self.evalex and cmd is not None and frame is not None and \
-                 self.secret == secret:
+            elif cmd == 'pinauth' and secret == self.secret:
+                response = self.pin_auth(request)
+            elif cmd == 'printpin' and secret == self.secret:
+                response = self.log_pin_request()
+            elif self.evalex and cmd is not None and frame is not None \
+                    and self.secret == secret and \
+                    self.check_pin_trust(environ):
                 response = self.execute_command(request, cmd, frame)
         elif self.evalex and self.console_path is not None and \
-           request.path == self.console_path:
+                request.path == self.console_path:
             response = self.display_console(request)
         return response(environ, start_response)

vendor/werkzeug/debug/console.py

@@ -5,7 +5,7 @@
 
     Interactive console support.
 
-    :copyright: (c) 2013 by the Werkzeug Team, see AUTHORS for more details.
+    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
     :license: BSD.
 """
 import sys
@@ -21,6 +21,7 @@ _local = Local()
 
 
 class HTMLStringO(object):
+
     """A StringO version that HTML escapes on write."""
 
     def __init__(self):
@@ -63,6 +64,7 @@ class HTMLStringO(object):
 
 
 class ThreadedStream(object):
+
     """Thread-local wrapper for sys.stdout for the interactive console."""
 
     def push():
@@ -136,6 +138,7 @@ class _ConsoleLoader(object):
 
 def _wrap_compiler(console):
     compile = console.compile
+
     def func(source, filename, symbol):
         code = compile(source, filename, symbol)
         console.loader.register(code, source)
@@ -162,7 +165,7 @@ class _InteractiveConsole(code.InteractiveInterpreter):
         try:
             source_to_eval = ''.join(self.buffer + [source])
             if code.InteractiveInterpreter.runsource(self,
-               source_to_eval, '<debugger>', 'single'):
+                                                     source_to_eval, '<debugger>', 'single'):
                 self.more = True
                 self.buffer.append(source)
             else:
@@ -193,6 +196,7 @@ class _InteractiveConsole(code.InteractiveInterpreter):
 
 
 class Console(object):
+
     """An interactive console."""
 
     def __init__(self, globals=None, locals=None):

vendor/werkzeug/debug/repr.py

@@ -10,7 +10,7 @@
     Together with the CSS and JavaScript files of the debugger this gives
     a colorful and more compact output.
 
-    :copyright: (c) 2013 by the Werkzeug Team, see AUTHORS for more details.
+    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
     :license: BSD.
 """
 import sys
@@ -19,7 +19,7 @@ import codecs
 from traceback import format_exception_only
 try:
     from collections import deque
-except ImportError: # pragma: no cover
+except ImportError:  # pragma: no cover
     deque = None
 from werkzeug.utils import escape
 from werkzeug._compat import iteritems, PY2, text_type, integer_types, \
@@ -64,6 +64,7 @@ def dump(obj=missing):
 
 
 class _Helper(object):
+
     """Displays an HTML version of the normal help, for the interactive
     debugger only because it requires a patched sys.stdout.
     """
@@ -84,7 +85,7 @@ class _Helper(object):
         if len(paragraphs) > 1:
             title = paragraphs[0]
             text = '\n\n'.join(paragraphs[1:])
-        else: # pragma: no cover
+        else:  # pragma: no cover
             title = 'Help'
             text = paragraphs[0]
         sys.stdout._write(HELP_HTML % {'title': title, 'text': text})
@@ -218,7 +219,7 @@ class DebugReprGenerator(object):
     def fallback_repr(self):
         try:
             info = ''.join(format_exception_only(*sys.exc_info()[:2]))
-        except Exception: # pragma: no cover
+        except Exception:  # pragma: no cover
             info = '?'
         if PY2:
             info = info.decode('utf-8', 'ignore')

vendor/werkzeug/debug/shared/debugger.js

@@ -1,5 +1,7 @@
 $(function() {
-  var sourceView = null;
+  if (!EVALEX_TRUSTED) {
+    initPinBox();
+  }
 
   /**
    * if we are in console mode, show the console.
@@ -10,17 +12,18 @@ $(function() {
 
   $('div.traceback div.frame').each(function() {
     var
-      target = $('pre', this)
-        .click(function() {
-          sourceButton.click();
-        }),
-      consoleNode = null, source = null,
+      target = $('pre', this),
+      consoleNode = null,
       frameID = this.id.substring(6);
 
+    target.click(function() {
+      $(this).parent().toggleClass('expanded');
+    });
+
     /**
      * Add an interactive console to the frames
      */
-    if (EVALEX)
+    if (EVALEX && target.is('.current')) {
       $('<img src="?__debugger__=yes&cmd=resource&f=console.png">')
         .attr('title', 'Open an interactive python shell in this frame')
         .click(function() {
@@ -28,36 +31,7 @@ $(function() {
           return false;
         })
         .prependTo(target);
-
-    /**
-     * Show sourcecode
-     */
-    var sourceButton = $('<img src="?__debugger__=yes&cmd=resource&f=source.png">')
-      .attr('title', 'Display the sourcecode for this frame')
-      .click(function() {
-        if (!sourceView)
-          $('h2', sourceView =
-            $('<div class="box"><h2>View Source</h2><div class="sourceview">' +
-              '<table></table></div>')
-              .insertBefore('div.explanation'))
-            .css('cursor', 'pointer')
-            .click(function() {
-              sourceView.slideUp('fast');
-            });
-        $.get('', {__debugger__: 'yes', cmd:
-            'source', frm: frameID, s: SECRET}, function(data) {
-          $('table', sourceView)
-            .replaceWith(data);
-          if (!sourceView.is(':visible'))
-            sourceView.slideDown('fast', function() {
-              focusSourceBlock();
-            });
-          else
-            focusSourceBlock();
-        });
-        return false;
-      })
-      .prependTo(target);
+    }
   });
 
   /**
@@ -118,11 +92,57 @@ $(function() {
   plainTraceback.replaceWith($('<pre>').text(plainTraceback.text()));
 });
 
+function initPinBox() {
+  $('.pin-prompt form').submit(function(evt) {
+    evt.preventDefault();
+    var pin = this.pin.value;
+    var btn = this.btn;
+    btn.disabled = true;
+    $.ajax({
+      dataType: 'json',
+      url: document.location.pathname,
+      data: {__debugger__: 'yes', cmd: 'pinauth', pin: pin,
+             s: SECRET},
+      success: function(data) {
+        btn.disabled = false;
+        if (data.auth) {
+          EVALEX_TRUSTED = true;
+          $('.pin-prompt').fadeOut();
+        } else {
+          if (data.exhausted) {
+            alert('Error: too many attempts.  Restart server to retry.');
+          } else {
+            alert('Error: incorrect pin');
+          }
+        }
+        console.log(data);
+      },
+      error: function() {
+        btn.disabled = false;
+        alert('Error: Could not verify PIN.  Network error?');
+      }
+    });
+  });
+}
+
+function promptForPin() {
+  if (!EVALEX_TRUSTED) {
+    $.ajax({
+      url: document.location.pathname,
+      data: {__debugger__: 'yes', cmd: 'printpin', s: SECRET}
+    });
+    $('.pin-prompt').fadeIn(function() {
+      $('.pin-prompt input[name="pin"]').focus();
+    });
+  }
+}
+
 
 /**
  * Helper function for shell initialization
  */
 function openShell(consoleNode, target, frameID) {
+  promptForPin();
   if (consoleNode)
     return consoleNode.slideToggle('fast');
   consoleNode = $('<pre class="console">')
@@ -183,19 +203,3 @@ function openShell(consoleNode, target, frameID) {
     command.focus();
   });
 }
-
-/**
- * Focus the current block in the source view.
- */
-function focusSourceBlock() {
-  var tmp, line = $('table.source tr.current');
-  for (var i = 0; i < 7; i++) {
-    tmp = line.prev();
-    if (!(tmp && tmp.is('.in-frame')))
-      break
-    line = tmp;
-  }
-  var container = $('div.sourceview');
-
-  container.scrollTop(line.offset().top - container.offset().top + container.scrollTop());
-}

vendor/werkzeug/debug/shared/style.css

@@ -14,9 +14,10 @@ h1, h2, h3   { font-family: 'Ubuntu', 'Lucida Grande', 'Lucida Sans Unicode',
 
 input        { background-color: #fff; margin: 0; text-align: left;
                outline: none !important; }
+input[type="submit"] { padding: 3px 6px; }
 a            { color: #11557C; }
 a:hover      { color: #177199; }
-pre, code, table.source,
+pre, code,
 textarea     { font-family: 'Consolas', 'Monaco', 'Bitstream Vera Sans Mono',
                monospace; font-size: 14px; }
 
@@ -43,15 +44,20 @@ div.traceback ul { list-style: none; margin: 0; padding: 0 0 0 1em; }
 div.traceback h4 { font-size: 13px; font-weight: normal; margin: 0.7em 0 0.1em 0; }
 div.traceback pre { margin: 0; padding: 5px 0 3px 15px;
                     background-color: #E8EFF0; border: 1px solid #D3E7E9; }
-div.traceback pre,
-div.box table.source { white-space: pre-wrap;       /* css-3 should we be so lucky... */
-                       white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
-                       white-space: -pre-wrap;      /* Opera 4-6 ?? */
-                       white-space: -o-pre-wrap;    /* Opera 7 ?? */
-                       word-wrap: break-word;       /* Internet Explorer 5.5+ */
-                       _white-space: pre;           /* IE only hack to re-specify in
-                                                    addition to word-wrap  */ }
 div.traceback pre:hover { background-color: #DDECEE; color: black; cursor: pointer; }
+div.traceback div.source.expanded pre + pre { border-top: none; }
+
+div.traceback span.ws { display: none; }
+div.traceback pre.before, div.traceback pre.after { display: none; background: white; }
+div.traceback div.source.expanded pre.before,
+div.traceback div.source.expanded pre.after {
+    display: block;
+}
+
+div.traceback div.source.expanded span.ws {
+    display: inline;
+}
+
 div.traceback blockquote { margin: 1em 0 0 0; padding: 0; }
 div.traceback img { float: right; padding: 2px; margin: -3px 2px 0 0; display: none; }
 div.traceback img:hover { background-color: #ddd; cursor: pointer;
@@ -105,9 +111,32 @@ pre.console div.box pre.help:hover { cursor: default; }
 pre.console table tr { vertical-align: top; }
 div.console { border: 1px solid #ccc; padding: 4px; background-color: #fafafa; }
 
-div.box table.source { border-collapse: collapse; width: 100%; background: #E8EFF0 }
-div.box table.source td { border-top: 1px solid #E8EFF0; padding: 4px 0 4px 10px; }
-div.box table.source td.lineno { color: #999; padding-right: 10px; width: 1px; }
-div.box table.source tr.in-frame { background-color: white; }
-div.box table.source tr.current { background-color: #EEF7F8; color: #23707E; }
-div.sourceview { max-height: 400px; overflow: auto; border: 1px solid #ccc; }
+div.traceback pre, div.console pre {
+    white-space: pre-wrap;       /* css-3 should we be so lucky... */
+    white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+    white-space: -pre-wrap;      /* Opera 4-6 ?? */
+    white-space: -o-pre-wrap;    /* Opera 7 ?? */
+    word-wrap: break-word;       /* Internet Explorer 5.5+ */
+    _white-space: pre;           /* IE only hack to re-specify in
+                                 addition to word-wrap  */
+}
+
+
+div.pin-prompt {
+    position: absolute;
+    display: none;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: rgba(255, 255, 255, 0.8);
+}
+
+div.pin-prompt .inner {
+    background: #eee;
+    padding: 10px 50px;
+    width: 350px;
+    margin: 10% auto 0 auto;
+    border: 1px solid #ccc;
+    border-radius: 2px;
+}

vendor/werkzeug/debug/tbtools.py

@@ -5,7 +5,7 @@
 
     This module provides various traceback related utility functions.
 
-    :copyright: (c) 2013 by the Werkzeug Team, see AUTHORS for more details.
+    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
     :license: BSD.
 """
 import re
@@ -20,13 +20,15 @@ from tokenize import TokenError
 
 from werkzeug.utils import cached_property, escape
 from werkzeug.debug.console import Console
-from werkzeug._compat import range_type, PY2, text_type, string_types
+from werkzeug._compat import range_type, PY2, text_type, string_types, \
+    to_native, to_unicode
+from werkzeug.filesystem import get_filesystem_encoding
 
 
-_coding_re = re.compile(r'coding[:=]\s*([-\w.]+)')
-_line_re = re.compile(r'^(.*?)$(?m)')
+_coding_re = re.compile(br'coding[:=]\s*([-\w.]+)')
+_line_re = re.compile(br'^(.*?)$(?m)')
 _funcdef_re = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
-UTF8_COOKIE = '\xef\xbb\xbf'
+UTF8_COOKIE = b'\xef\xbb\xbf'
 
 system_exceptions = (SystemExit, KeyboardInterrupt)
 try:
@@ -41,17 +43,20 @@ HEADER = u'''\
 <html>
   <head>
     <title>%(title)s // Werkzeug Debugger</title>
-    <link rel="stylesheet" href="?__debugger__=yes&amp;cmd=resource&amp;f=style.css" type="text/css">
-    <!-- We need to make sure this has a favicon so that the debugger does not by
-         accident trigger a request to /favicon.ico which might change the application
-         state. -->
-    <link rel="shortcut icon" href="?__debugger__=yes&amp;cmd=resource&amp;f=console.png">
-    <script type="text/javascript" src="?__debugger__=yes&amp;cmd=resource&amp;f=jquery.js"></script>
-    <script type="text/javascript" src="?__debugger__=yes&amp;cmd=resource&amp;f=debugger.js"></script>
+    <link rel="stylesheet" href="?__debugger__=yes&amp;cmd=resource&amp;f=style.css"
+        type="text/css">
+    <!-- We need to make sure this has a favicon so that the debugger does
+         not by accident trigger a request to /favicon.ico which might
+         change the application state. -->
+    <link rel="shortcut icon"
+        href="?__debugger__=yes&amp;cmd=resource&amp;f=console.png">
+    <script src="?__debugger__=yes&amp;cmd=resource&amp;f=jquery.js"></script>
+    <script src="?__debugger__=yes&amp;cmd=resource&amp;f=debugger.js"></script>
     <script type="text/javascript">
       var TRACEBACK = %(traceback_id)d,
           CONSOLE_MODE = %(console)s,
           EVALEX = %(evalex)s,
+          EVALEX_TRUSTED = %(evalex_trusted)s,
           SECRET = "%(secret)s";
     </script>
   </head>
@@ -64,6 +69,21 @@ FOOTER = u'''\
         friendly Werkzeug powered traceback interpreter.
       </div>
     </div>
+
+    <div class="pin-prompt">
+      <div class="inner">
+        <h3>Console Locked</h3>
+        <p>
+          The console is locked and needs to be unlocked by entering the PIN.
+          You can find the PIN printed out on the standard output of your
+          shell that runs the server.
+        <form>
+          <p>PIN:
+            <input type=text name=pin size=14>
+            <input type=submit name=btn value="Confirm Pin">
+        </form>
+      </div>
+    </div>
   </body>
 </html>
 '''
@@ -124,12 +144,10 @@ FRAME_HTML = u'''\
   <h4>File <cite class="filename">"%(filename)s"</cite>,
       line <em class="line">%(lineno)s</em>,
       in <code class="function">%(function_name)s</code></h4>
-  <pre>%(current_line)s</pre>
+  <div class="source">%(lines)s</div>
 </div>
 '''
 
-SOURCE_TABLE_HTML = u'<table class=source>%s</table>'
-
 SOURCE_LINE_HTML = u'''\
 <tr class="%(classes)s">
   <td class=lineno>%(lineno)s</td>
@@ -138,13 +156,14 @@ SOURCE_LINE_HTML = u'''\
 '''
 
 
-def render_console_html(secret):
+def render_console_html(secret, evalex_trusted=True):
     return CONSOLE_HTML % {
         'evalex':           'true',
+        'evalex_trusted':   evalex_trusted and 'true' or 'false',
         'console':          'true',
         'title':            'Console',
         'secret':           secret,
-        'traceback_id':     -1
+        'traceback_id': -1
     }
 
 
@@ -269,7 +288,7 @@ class Traceback(object):
             logfile = sys.stderr
         tb = self.plaintext.rstrip() + u'\n'
         if PY2:
-            tb.encode('utf-8', 'replace')
+            tb = tb.encode('utf-8', 'replace')
         logfile.write(tb)
 
     def paste(self):
@@ -327,17 +346,19 @@ class Traceback(object):
             'description':  description_wrapper % escape(self.exception)
         }
 
-    def render_full(self, evalex=False, secret=None):
+    def render_full(self, evalex=False, secret=None,
+                    evalex_trusted=True):
         """Render the Full HTML page with the traceback info."""
         exc = escape(self.exception)
         return PAGE_HTML % {
             'evalex':           evalex and 'true' or 'false',
+            'evalex_trusted':   evalex_trusted and 'true' or 'false',
             'console':          'false',
             'title':            exc,
             'exception':        exc,
             'exception_type':   escape(self.exception_type),
             'summary':          self.render_summary(include_title=False),
-            'plaintext':        self.plaintext,
+            'plaintext':        escape(self.plaintext),
             'plaintext_cs':     re.sub('-{2,}', '-', self.plaintext),
             'traceback_id':     self.id,
             'secret':           secret
@@ -363,6 +384,7 @@ class Traceback(object):
 
 
 class Frame(object):
+
     """A single frame in a traceback."""
 
     def __init__(self, exc_type, exc_value, tb):
@@ -377,7 +399,7 @@ class Frame(object):
         # if it's a file on the file system resolve the real filename.
         if os.path.isfile(fn):
             fn = os.path.realpath(fn)
-        self.filename = fn
+        self.filename = to_unicode(fn, get_filesystem_encoding())
         self.module = self.globals.get('__name__')
         self.loader = self.globals.get('__loader__')
         self.code = tb.tb_frame.f_code
@@ -399,9 +421,29 @@ class Frame(object):
             'filename':         escape(self.filename),
             'lineno':           self.lineno,
             'function_name':    escape(self.function_name),
-            'current_line':     escape(self.current_line.strip())
+            'lines':            self.render_line_context(),
         }
 
+    def render_line_context(self):
+        before, current, after = self.get_context_lines()
+        rv = []
+
+        def render_line(line, cls):
+            line = line.expandtabs().rstrip()
+            stripped_line = line.strip()
+            prefix = len(line) - len(stripped_line)
+            rv.append(
+                '<pre class="line %s"><span class="ws">%s</span>%s</pre>' % (
+                    cls, ' ' * prefix, escape(stripped_line) or ' '))
+
+        for line in before:
+            render_line(line, 'before')
+        render_line(current, 'current')
+        for line in after:
+            render_line(line, 'after')
+
+        return '\n'.join(rv)
+
     def get_annotated_lines(self):
         """Helper function that returns lines with extra information."""
         lines = [Line(idx + 1, x) for idx, x in enumerate(self.sourcelines)]
@@ -429,15 +471,10 @@ class Frame(object):
 
         return lines
 
-    def render_source(self):
-        """Render the sourcecode."""
-        return SOURCE_TABLE_HTML % u'\n'.join(line.render() for line in
-                                              self.get_annotated_lines())
-
     def eval(self, code, mode='single'):
         """Evaluate code in the context of the frame."""
         if isinstance(code, string_types):
-            if PY2 and isinstance(code, unicode):
+            if PY2 and isinstance(code, unicode):  # noqa
                 code = UTF8_COOKIE + code.encode('utf-8')
             code = compile(code, '<interactive>', mode)
         return eval(code, self.globals, self.locals)
@@ -460,7 +497,8 @@ class Frame(object):
 
         if source is None:
             try:
-                f = open(self.filename)
+                f = open(to_native(self.filename, get_filesystem_encoding()),
+                         mode='rb')
             except IOError:
                 return []
             try:
@@ -479,7 +517,7 @@ class Frame(object):
             source = source[3:]
         else:
             for idx, match in enumerate(_line_re.finditer(source)):
-                match = _line_re.search(match.group())
+                match = _coding_re.search(match.group())
                 if match is not None:
                     charset = match.group(1)
                     break
@@ -487,6 +525,7 @@ class Frame(object):
                     break
 
         # on broken cookies we fall back to utf-8 too
+        charset = to_native(charset)
         try:
             codecs.lookup(charset)
         except LookupError:
@@ -494,6 +533,15 @@ class Frame(object):
 
         return source.decode(charset, 'replace').splitlines()
 
+    def get_context_lines(self, context=5):
+        before = self.sourcelines[self.lineno - context - 1:self.lineno - 1]
+        past = self.sourcelines[self.lineno:self.lineno + context]
+        return (
+            before,
+            self.current_line,
+            past,
+        )
+
     @property
     def current_line(self):
         try: