Merge branch 'master' of https://github.com/abakan/ipython

IPython/frontend/html/notebook/static/less/highlight.less

@@ -0,0 +1,157 b''
+/*
+
+Original style from softwaremaniacs.org (c) Ivan Sagalaev <[e-mail]>
+Adapted from GitHub theme
+
+*/
+
+pre code {
+  display: block;
+  padding: 0.5em;
+}
+
+.highlight-base,
+pre code,
+pre .subst,
+pre .tag .title,
+pre .lisp .title,
+pre .clojure .built_in,
+pre .nginx .title {
+  color: black;
+}
+
+.highlight-string,
+pre .string,
+pre .constant,
+pre .parent,
+pre .tag .value,
+pre .rules .value,
+pre .rules .value .number,
+pre .preprocessor,
+pre .ruby .symbol,
+pre .ruby .symbol .string,
+pre .aggregate,
+pre .template_tag,
+pre .django .variable,
+pre .smalltalk .class,
+pre .addition,
+pre .flow,
+pre .stream,
+pre .bash .variable,
+pre .apache .tag,
+pre .apache .cbracket,
+pre .tex .command,
+pre .tex .special,
+pre .erlang_repl .function_or_atom,
+pre .markdown .header {
+  color: #BA2121;
+}
+
+.highlight-comment,
+pre .comment,
+pre .annotation,
+pre .template_comment,
+pre .diff .header,
+pre .chunk,
+pre .markdown .blockquote {
+  color: #408080;
+  font-style: italic;
+}
+
+.highlight-number,
+pre .number,
+pre .date,
+pre .regexp,
+pre .literal,
+pre .smalltalk .symbol,
+pre .smalltalk .char,
+pre .go .constant,
+pre .change,
+pre .markdown .bullet,
+pre .markdown .link_url {
+  color: #080;
+}
+
+pre .label,
+pre .javadoc,
+pre .ruby .string,
+pre .decorator,
+pre .filter .argument,
+pre .localvars,
+pre .array,
+pre .attr_selector,
+pre .important,
+pre .pseudo,
+pre .pi,
+pre .doctype,
+pre .deletion,
+pre .envvar,
+pre .shebang,
+pre .apache .sqbracket,
+pre .nginx .built_in,
+pre .tex .formula,
+pre .erlang_repl .reserved,
+pre .prompt,
+pre .markdown .link_label,
+pre .vhdl .attribute,
+pre .clojure .attribute,
+pre .coffeescript .property {
+  color: #88F
+}
+
+.highlight-keyword,
+pre .keyword,
+pre .id,
+pre .phpdoc,
+pre .aggregate,
+pre .css .tag,
+pre .javadoctag,
+pre .phpdoc,
+pre .yardoctag,
+pre .smalltalk .class,
+pre .winutils,
+pre .bash .variable,
+pre .apache .tag,
+pre .go .typename,
+pre .tex .command,
+pre .markdown .strong,
+pre .request,
+pre .status {
+  color: #008000;
+  font-weight: bold;
+}
+
+.highlight-builtin,
+pre .built_in {
+  color: #008000;
+}
+
+pre .markdown .emphasis {
+  font-style: italic;
+}
+
+pre .nginx .built_in {
+  font-weight: normal;
+}
+
+pre .coffeescript .javascript,
+pre .javascript .xml,
+pre .tex .formula,
+pre .xml .javascript,
+pre .xml .vbscript,
+pre .xml .css,
+pre .xml .cdata {
+  opacity: 0.5;
+}
+
+/* apply the same style to codemirror */
+
+.cm-s-ipython span.cm-variable { .highlight-base()}
+.cm-s-ipython span.cm-keyword { .highlight-keyword() }
+.cm-s-ipython span.cm-number { .highlight-number() }
+.cm-s-ipython span.cm-comment { .highlight-comment() }
+.cm-s-ipython span.cm-string { .highlight-string()}
+.cm-s-ipython span.cm-builtin { .highlight-builtin() }
+.cm-s-ipython span.cm-error { color: #f00; }
+.cm-s-ipython span.cm-operator {color: #AA22FF; font-weight: bold;}
+.cm-s-ipython span.cm-meta {color: #AA22FF;}

.gitmodules

@@ -1,3 +1,3 b''
 [submodule "components"]
 	path = IPython/frontend/html/notebook/static/components
-	url = git://github.com/ipython/ipython-components.git
+	url = https://github.com/ipython/ipython-components.git

IPython/core/application.py

@@ -144,8 +144,17 b' class BaseIPythonApplication(Application):'
     # The class to use as the crash handler.
     crash_handler_class = Type(crashhandler.CrashHandler)
 
+    @catch_config_error
     def __init__(self, **kwargs):
         super(BaseIPythonApplication, self).__init__(**kwargs)
+        # ensure current working directory exists
+        try:
+            directory = os.getcwdu()
+        except:
+            # raise exception
+            self.log.error("Current working directory doesn't exist.")
+            raise
+
         # ensure even default IPYTHONDIR exists
         if not os.path.exists(self.ipython_dir):
             self._ipython_dir_changed('ipython_dir', self.ipython_dir, self.ipython_dir)

IPython/core/magics/execution.py

@@ -77,8 +77,7 b' python-profiler package from non-free.""")'
 
     @skip_doctest
     @line_cell_magic
-    def prun(self, parameter_s='', cell=None, user_mode=True,
-                   opts=None,arg_lst=None,prog_ns=None):
+    def prun(self, parameter_s='', cell=None):
 
         """Run a statement through the python code profiler.
 
@@ -178,38 +177,33 b' python-profiler package from non-free.""")'
 
           In [1]: import profile; profile.help()
         """
+        opts, arg_str = self.parse_options(parameter_s, 'D:l:rs:T:q',
+                                           list_all=True, posix=False)
+        if cell is not None:
+            arg_str += '\n' + cell
+        return self._run_with_profiler(arg_str, opts, self.shell.user_ns)
 
-        opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
+    def _run_with_profiler(self, code, opts, namespace):
+        """
+        Run `code` with profiler.  Used by ``%prun`` and ``%run -p``.
 
-        if user_mode:  # regular user call
-            opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:q',
-                                              list_all=True, posix=False)
-            namespace = self.shell.user_ns
-            if cell is not None:
-                arg_str += '\n' + cell
-        else:  # called to run a program by %run -p
-            try:
-                filename = get_py_filename(arg_lst[0])
-            except IOError as e:
-                try:
-                    msg = str(e)
-                except UnicodeError:
-                    msg = e.message
-                error(msg)
-                return
+        Parameters
+        ----------
+        code : str
+            Code to be executed.
+        opts : Struct
+            Options parsed by `self.parse_options`.
+        namespace : dict
+            A dictionary for Python namespace (e.g., `self.shell.user_ns`).
 
-            arg_str = 'execfile(filename,prog_ns)'
-            namespace = {
-                'execfile': self.shell.safe_execfile,
-                'prog_ns': prog_ns,
-                'filename': filename
-                }
+        """
 
-        opts.merge(opts_def)
+        # Fill default values for unspecified options:
+        opts.merge(Struct(D=[''], l=[], s=['time'], T=['']))
 
         prof = profile.Profile()
         try:
-            prof = prof.runctx(arg_str,namespace,namespace)
+            prof = prof.runctx(code, namespace, namespace)
             sys_exit = ''
         except SystemExit:
             sys_exit = """*** SystemExit exception caught in code being profiled."""
@@ -327,8 +321,10 b' python-profiler package from non-free.""")'
                   file_finder=get_py_filename):
         """Run the named file inside IPython as a program.
 
-        Usage:\\
-          %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options] -G] file [args]
+        Usage:
+          %run [-n -i -e -G]
+               [( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]
+               ( -m mod | file ) [args]
 
         Parameters after the filename are passed as command-line arguments to
         the program (put in sys.argv). Then, control returns to IPython's
@@ -541,62 +537,45 b' python-profiler package from non-free.""")'
         # every single object ever created.
         sys.modules[main_mod_name] = main_mod
 
+        if 'p' in opts or 'd' in opts:
+            if 'm' in opts:
+                code = 'run_module(modulename, prog_ns)'
+                code_ns = {
+                    'run_module': self.shell.safe_run_module,
+                    'prog_ns': prog_ns,
+                    'modulename': modulename,
+                }
+            else:
+                code = 'execfile(filename, prog_ns)'
+                code_ns = {
+                    'execfile': self.shell.safe_execfile,
+                    'prog_ns': prog_ns,
+                    'filename': get_py_filename(filename),
+                }
+
         try:
             stats = None
             with self.shell.readline_no_record:
                 if 'p' in opts:
-                    stats = self.prun('', None, False, opts, arg_lst, prog_ns)
+                    stats = self._run_with_profiler(code, opts, code_ns)
                 else:
                     if 'd' in opts:
-                        deb = debugger.Pdb(self.shell.colors)
-                        # reset Breakpoint state, which is moronically kept
-                        # in a class
-                        bdb.Breakpoint.next = 1
-                        bdb.Breakpoint.bplist = {}
-                        bdb.Breakpoint.bpbynumber = [None]
-                        # Set an initial breakpoint to stop execution
-                        maxtries = 10
-                        bp_file, bp_line = parse_breakpoint(opts.get('b', ['1'])[0], filename)
-                        checkline = deb.checkline(bp_file, bp_line)
-                        if not checkline:
-                            for bp in range(bp_line + 1, bp_line + maxtries + 1):
-                                if deb.checkline(bp_file, bp):
-                                    break
-                            else:
-                                msg = ("\nI failed to find a valid line to set "
-                                       "a breakpoint\n"
-                                       "after trying up to line: %s.\n"
-                                       "Please set a valid breakpoint manually "
-                                       "with the -b option." % bp)
-                                error(msg)
-                                return
-                        # if we find a good linenumber, set the breakpoint
-                        deb.do_break('%s:%s' % (bp_file, bp_line))
-
-                        # Mimic Pdb._runscript(...)
-                        deb._wait_for_mainpyfile = True
-                        deb.mainpyfile = deb.canonic(filename)
-
-                        # Start file run
-                        print "NOTE: Enter 'c' at the",
-                        print "%s prompt to start your script." % deb.prompt
-                        ns = {'execfile': py3compat.execfile, 'prog_ns': prog_ns}
-                        try:
-                            #save filename so it can be used by methods on the deb object
-                            deb._exec_filename = filename
-                            deb.run('execfile("%s", prog_ns)' % filename, ns)
-
-                        except:
-                            etype, value, tb = sys.exc_info()
-                            # Skip three frames in the traceback: the %run one,
-                            # one inside bdb.py, and the command-line typed by the
-                            # user (run by exec in pdb itself).
-                            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
+                        self._run_with_debugger(
+                            code, code_ns, opts.get('b', ['1'])[0], filename)
                     else:
-                        if runner is None:
-                            runner = self.default_runner
-                        if runner is None:
-                            runner = self.shell.safe_execfile
+                        if 'm' in opts:
+                            def run():
+                                self.shell.safe_run_module(modulename, prog_ns)
+                        else:
+                            if runner is None:
+                                runner = self.default_runner
+                            if runner is None:
+                                runner = self.shell.safe_execfile
+
+                            def run():
+                                runner(filename, prog_ns, prog_ns,
+                                       exit_ignore=exit_ignore)
+
                         if 't' in opts:
                             # timed execution
                             try:
@@ -606,37 +585,10 b' python-profiler package from non-free.""")'
                                     return
                             except (KeyError):
                                 nruns = 1
-                            twall0 = time.time()
-                            if nruns == 1:
-                                t0 = clock2()
-                                runner(filename, prog_ns, prog_ns,
-                                       exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0] - t0[0]
-                                t_sys = t1[1] - t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "  User   : %10.2f s." % t_usr
-                                print "  System : %10.2f s." % t_sys
-                            else:
-                                runs = range(nruns)
-                                t0 = clock2()
-                                for nr in runs:
-                                    runner(filename, prog_ns, prog_ns,
-                                           exit_ignore=exit_ignore)
-                                t1 = clock2()
-                                t_usr = t1[0] - t0[0]
-                                t_sys = t1[1] - t0[1]
-                                print "\nIPython CPU timings (estimated):"
-                                print "Total runs performed:", nruns
-                                print "  Times  : %10s   %10s" % ('Total', 'Per run')
-                                print "  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
-                                print "  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
-                            twall1 = time.time()
-                            print "Wall time: %10.2f s." % (twall1 - twall0)
-
+                            self._run_with_timing(run, nruns)
                         else:
                             # regular execution
-                            runner(filename, prog_ns, prog_ns, exit_ignore=exit_ignore)
+                            run()
 
                 if 'i' in opts:
                     self.shell.user_ns['__name__'] = __name__save
@@ -676,7 +628,114 b' python-profiler package from non-free.""")'
                 del sys.modules[main_mod_name]
 
         return stats
-    
+
+    def _run_with_debugger(self, code, code_ns, break_point, filename):
+        """
+        Run `code` in debugger with a break point.
+
+        Parameters
+        ----------
+        code : str
+            Code to execute.
+        code_ns : dict
+            A namespace in which `code` is executed.
+        break_point : str
+            Line number in the file specified by `filename` argument
+            or a string in the format ``file:line``.  In the latter
+            case, `filename` is ignored.
+            See also :func:`.parse_breakpoint`.
+        filename : str
+            Path to the file in which break point is specified.
+
+        Raises
+        ------
+        UsageError
+            If no meaningful break point is given by `break_point` and
+            `filename`.
+
+        """
+        deb = debugger.Pdb(self.shell.colors)
+        # reset Breakpoint state, which is moronically kept
+        # in a class
+        bdb.Breakpoint.next = 1
+        bdb.Breakpoint.bplist = {}
+        bdb.Breakpoint.bpbynumber = [None]
+        # Set an initial breakpoint to stop execution
+        maxtries = 10
+        bp_file, bp_line = parse_breakpoint(break_point, filename)
+        checkline = deb.checkline(bp_file, bp_line)
+        if not checkline:
+            for bp in range(bp_line + 1, bp_line + maxtries + 1):
+                if deb.checkline(bp_file, bp):
+                    break
+            else:
+                msg = ("\nI failed to find a valid line to set "
+                       "a breakpoint\n"
+                       "after trying up to line: %s.\n"
+                       "Please set a valid breakpoint manually "
+                       "with the -b option." % bp)
+                raise UsageError(msg)
+        # if we find a good linenumber, set the breakpoint
+        deb.do_break('%s:%s' % (bp_file, bp_line))
+
+        # Mimic Pdb._runscript(...)
+        deb._wait_for_mainpyfile = True
+        deb.mainpyfile = deb.canonic(filename)
+
+        # Start file run
+        print "NOTE: Enter 'c' at the",
+        print "%s prompt to start your script." % deb.prompt
+        try:
+            #save filename so it can be used by methods on the deb object
+            deb._exec_filename = filename
+            deb.run(code, code_ns)
+
+        except:
+            etype, value, tb = sys.exc_info()
+            # Skip three frames in the traceback: the %run one,
+            # one inside bdb.py, and the command-line typed by the
+            # user (run by exec in pdb itself).
+            self.shell.InteractiveTB(etype, value, tb, tb_offset=3)
+
+    @staticmethod
+    def _run_with_timing(run, nruns):
+        """
+        Run function `run` and print timing information.
+
+        Parameters
+        ----------
+        run : callable
+            Any callable object which takes no argument.
+        nruns : int
+            Number of times to execute `run`.
+
+        """
+        twall0 = time.time()
+        if nruns == 1:
+            t0 = clock2()
+            run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print "\nIPython CPU timings (estimated):"
+            print "  User   : %10.2f s." % t_usr
+            print "  System : %10.2f s." % t_sys
+        else:
+            runs = range(nruns)
+            t0 = clock2()
+            for nr in runs:
+                run()
+            t1 = clock2()
+            t_usr = t1[0] - t0[0]
+            t_sys = t1[1] - t0[1]
+            print "\nIPython CPU timings (estimated):"
+            print "Total runs performed:", nruns
+            print "  Times  : %10s   %10s" % ('Total', 'Per run')
+            print "  User   : %10.2f s, %10.2f s." % (t_usr, t_usr / nruns)
+            print "  System : %10.2f s, %10.2f s." % (t_sys, t_sys / nruns)
+        twall1 = time.time()
+        print "Wall time: %10.2f s." % (twall1 - twall0)
+
     @skip_doctest
     @line_cell_magic
     def timeit(self, line='', cell=None):

IPython/core/tests/test_run.py

@@ -13,9 +13,13 b' from __future__ import absolute_import'
 # Imports
 #-----------------------------------------------------------------------------
 
+import functools
 import os
+import random
 import sys
 import tempfile
+import textwrap
+import unittest
 
 import nose.tools as nt
 from nose import SkipTest
@@ -23,6 +27,8 b' from nose import SkipTest'
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils import py3compat
+from IPython.utils.tempdir import TemporaryDirectory
+from IPython.core import debugger
 
 #-----------------------------------------------------------------------------
 # Test functions begin
@@ -337,3 +343,74 b' tclass.py: deleting object: C-third'
         self.mktmp(src)
         _ip.magic('run -t -N 1 %s' % self.fname)
         _ip.magic('run -t -N 10 %s' % self.fname)
+
+
+class TestMagicRunWithPackage(unittest.TestCase):
+
+    def writefile(self, name, content):
+        path = os.path.join(self.tempdir.name, name)
+        d = os.path.dirname(path)
+        if not os.path.isdir(d):
+            os.makedirs(d)
+        with open(path, 'w') as f:
+            f.write(textwrap.dedent(content))
+
+    def setUp(self):
+        self.package = package = 'tmp{0}'.format(repr(random.random())[2:])
+        """Temporary valid python package name."""
+
+        self.value = int(random.random() * 10000)
+
+        self.tempdir = TemporaryDirectory()
+        self.__orig_cwd = os.getcwdu()
+        sys.path.insert(0, self.tempdir.name)
+
+        self.writefile(os.path.join(package, '__init__.py'), '')
+        self.writefile(os.path.join(package, 'sub.py'), """
+        x = {0!r}
+        """.format(self.value))
+        self.writefile(os.path.join(package, 'relative.py'), """
+        from .sub import x
+        """)
+        self.writefile(os.path.join(package, 'absolute.py'), """
+        from {0}.sub import x
+        """.format(package))
+
+    def tearDown(self):
+        os.chdir(self.__orig_cwd)
+        sys.path[:] = [p for p in sys.path if p != self.tempdir.name]
+        self.tempdir.cleanup()
+
+    def check_run_submodule(self, submodule, opts=''):
+        _ip.magic('run {2} -m {0}.{1}'.format(self.package, submodule, opts))
+        self.assertEqual(_ip.user_ns['x'], self.value,
+                         'Variable `x` is not loaded from module `{0}`.'
+                         .format(submodule))
+
+    def test_run_submodule_with_absolute_import(self):
+        self.check_run_submodule('absolute')
+
+    def test_run_submodule_with_relative_import(self):
+        """Run submodule that has a relative import statement (#2727)."""
+        self.check_run_submodule('relative')
+
+    def test_prun_submodule_with_absolute_import(self):
+        self.check_run_submodule('absolute', '-p')
+
+    def test_prun_submodule_with_relative_import(self):
+        self.check_run_submodule('relative', '-p')
+
+    def with_fake_debugger(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwds):
+            with tt.monkeypatch(debugger.Pdb, 'run', staticmethod(eval)):
+                return func(*args, **kwds)
+        return wrapper
+
+    @with_fake_debugger
+    def test_debug_run_submodule_with_absolute_import(self):
+        self.check_run_submodule('absolute', '-d')
+
+    @with_fake_debugger
+    def test_debug_run_submodule_with_relative_import(self):
+        self.check_run_submodule('relative', '-d')

IPython/frontend/html/notebook/static/components

@@ -1,1 +1,1 b''
-Subproject commit f7467391a9f9d4868f0bbf0d088fd572625862a4
+Subproject commit 945dfca396a1a7ca66d36ee758c7d8dca2b11287

IPython/frontend/html/notebook/static/css/style.min.css

@@ -866,6 +866,26 b' a.label:hover,a.label:focus,a.badge:hover,a.badge:focus{color:#ffffff;text-decor'
 .end{-webkit-box-pack:end;-moz-box-pack:end;box-pack:end;}
 .center{-webkit-box-pack:center;-moz-box-pack:center;box-pack:center;}
 .corner-all{border-radius:4px;}
+pre code{display:block;padding:0.5em;}
+.highlight-base,pre code,pre .subst,pre .tag .title,pre .lisp .title,pre .clojure .built_in,pre .nginx .title{color:black;}
+.highlight-string,pre .string,pre .constant,pre .parent,pre .tag .value,pre .rules .value,pre .rules .value .number,pre .preprocessor,pre .ruby .symbol,pre .ruby .symbol .string,pre .aggregate,pre .template_tag,pre .django .variable,pre .smalltalk .class,pre .addition,pre .flow,pre .stream,pre .bash .variable,pre .apache .tag,pre .apache .cbracket,pre .tex .command,pre .tex .special,pre .erlang_repl .function_or_atom,pre .markdown .header{color:#BA2121;}
+.highlight-comment,pre .comment,pre .annotation,pre .template_comment,pre .diff .header,pre .chunk,pre .markdown .blockquote{color:#408080;font-style:italic;}
+.highlight-number,pre .number,pre .date,pre .regexp,pre .literal,pre .smalltalk .symbol,pre .smalltalk .char,pre .go .constant,pre .change,pre .markdown .bullet,pre .markdown .link_url{color:#080;}
+pre .label,pre .javadoc,pre .ruby .string,pre .decorator,pre .filter .argument,pre .localvars,pre .array,pre .attr_selector,pre .important,pre .pseudo,pre .pi,pre .doctype,pre .deletion,pre .envvar,pre .shebang,pre .apache .sqbracket,pre .nginx .built_in,pre .tex .formula,pre .erlang_repl .reserved,pre .prompt,pre .markdown .link_label,pre .vhdl .attribute,pre .clojure .attribute,pre .coffeescript .property{color:#8888ff;}
+.highlight-keyword,pre .keyword,pre .id,pre .phpdoc,pre .aggregate,pre .css .tag,pre .javadoctag,pre .phpdoc,pre .yardoctag,pre .smalltalk .class,pre .winutils,pre .bash .variable,pre .apache .tag,pre .go .typename,pre .tex .command,pre .markdown .strong,pre .request,pre .status{color:#008000;font-weight:bold;}
+.highlight-builtin,pre .built_in{color:#008000;}
+pre .markdown .emphasis{font-style:italic;}
+pre .nginx .built_in{font-weight:normal;}
+pre .coffeescript .javascript,pre .javascript .xml,pre .tex .formula,pre .xml .javascript,pre .xml .vbscript,pre .xml .css,pre .xml .cdata{opacity:0.5;}
+.cm-s-ipython span.cm-variable{color:black;}
+.cm-s-ipython span.cm-keyword{color:#008000;font-weight:bold;}
+.cm-s-ipython span.cm-number{color:#080;}
+.cm-s-ipython span.cm-comment{color:#408080;font-style:italic;}
+.cm-s-ipython span.cm-string{color:#BA2121;}
+.cm-s-ipython span.cm-builtin{color:#008000;}
+.cm-s-ipython span.cm-error{color:#f00;}
+.cm-s-ipython span.cm-operator{color:#AA22FF;font-weight:bold;}
+.cm-s-ipython span.cm-meta{color:#AA22FF;}
 body{background-color:#ffffff;}
 body.notebook_app{overflow:hidden;}
 blockquote{border-left:4px solid #DDD;padding:0 15px;color:#777;}

IPython/frontend/html/notebook/static/js/notebookmain.js

@@ -42,7 +42,6 b' $(document).ready(function () {'
     var baseProjectUrl = $('body').data('baseProjectUrl')
 
     IPython.page = new IPython.Page();
-    IPython.markdown_converter = new Markdown.Converter();
     IPython.layout_manager = new IPython.LayoutManager();
     IPython.pager = new IPython.Pager('div#pager', 'div#pager_splitter');
     IPython.quick_help = new IPython.QuickHelp('span#quick_help_area');
@@ -94,6 +93,23 b' $(document).ready(function () {'
     
     $([IPython.events]).on('notebook_loaded.Notebook', first_load);
     IPython.notebook.load_notebook($('body').data('notebookId'));
+    
+    if (marked) {
+        marked.setOptions({
+            gfm : true,
+            tables: true,
+            langPrefix: "language-",
+            highlight: function(code, lang) {
+                var highlighted;
+                try {
+                    highlighted = hljs.highlight(lang, code, false);
+                } catch(err) {
+                    highlighted = hljs.highlightAuto(code);
+                }
+                return highlighted.value;
+            }
+        })
+    }
 
 });
 

IPython/frontend/html/notebook/static/js/savewidget.js

@@ -140,6 +140,7 b' var IPython = (function (IPython) {'
     SaveWidget.prototype.set_last_checkpoint = function (checkpoint) {
         if (!checkpoint) {
             this.set_checkpoint_status("");
+            return;
         }
         var d = new Date(checkpoint.last_modified);
         this.set_checkpoint_status(

IPython/frontend/html/notebook/static/js/textcell.js

@@ -298,7 +298,7 b' var IPython = (function (IPython) {'
 
     MarkdownCell.options_default = {
         cm_config: {
-            mode: 'markdown'
+            mode: 'gfm'
         },
         placeholder: "Type *Markdown* and LaTeX: $\\alpha^2$"
     }
@@ -315,9 +315,9 b' var IPython = (function (IPython) {'
         if (this.rendered === false) {
             var text = this.get_text();
             if (text === "") { text = this.placeholder; }
-            text = IPython.mathjaxutils.remove_math(text)
-            var html = IPython.markdown_converter.makeHtml(text);
-            html = IPython.mathjaxutils.replace_math(html)
+            text = IPython.mathjaxutils.remove_math(text);
+            var html = marked.parser(marked.lexer(text));
+            html = IPython.mathjaxutils.replace_math(html);
             try {
                 this.set_rendered(html);
             } catch (e) {
@@ -329,18 +329,6 b' var IPython = (function (IPython) {'
             }
             this.element.find('div.text_cell_input').hide();
             this.element.find("div.text_cell_render").show();
-            var code_snippets = this.element.find("pre > code");
-            code_snippets.replaceWith(function () {
-                var code = $(this).html();
-                /* Substitute br for newlines and   for spaces
-                   before highlighting, since prettify doesn't
-                   preserve those on all browsers */
-                code = code.replace(/(\r\n|\n|\r)/gm, "<br/>");
-                code = code.replace(/ /gm, '&nbsp;');
-                code = prettyPrintOne(code);
-
-                return '<code class="prettyprint">' + code + '</code>';
-            });
             this.typeset()
             this.rendered = true;
         }

IPython/frontend/html/notebook/static/less/notebook.less

@@ -5,7 +5,7 b''
  */
 
 @import "variables.less";
-
+@import "highlight.less";
 
 body {
     background-color:@notebook_background;

IPython/frontend/html/notebook/templates/notebook.html

@@ -12,9 +12,6 b' window.mathjax_url = "{{mathjax_url}}";'
 </script>
 
 <link rel="stylesheet" href="{{ static_url("components/codemirror/lib/codemirror.css") }}">
-<link rel="stylesheet" href="{{ static_url("css/codemirror-ipython.css") }}">
-
-<link rel="stylesheet" href="{{ static_url("prettify/prettify.css") }}"/>
 
 <link rel="stylesheet" href="{{ static_url("css/celltoolbar.css") }}" type="text/css" />
 
@@ -198,6 +195,7 b' class="notebook_app"'
 <script src="{{ static_url("components/codemirror/lib/codemirror.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/mode/loadmode.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/addon/mode/multiplex.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("components/codemirror/addon/mode/overlay.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("js/codemirror-ipython.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/htmlmixed/htmlmixed.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/xml/xml.js") }}" charset="utf-8"></script>
@@ -205,10 +203,11 b' class="notebook_app"'
 <script src="{{ static_url("components/codemirror/mode/css/css.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/rst/rst.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("components/codemirror/mode/markdown/markdown.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("components/codemirror/mode/gfm/gfm.js") }}" charset="utf-8"></script>
 
-<script src="{{ static_url("pagedown/Markdown.Converter.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("components/marked/lib/marked.js") }}" charset="utf-8"></script>
+<script src="{{ static_url("components/highlight.js/build/highlight.pack.js") }}" charset="utf-8"></script>
 
-<script src="{{ static_url("prettify/prettify.js") }}" charset="utf-8"></script>
 <script src="{{ static_url("dateformat/date.format.js") }}" charset="utf-8"></script>
 
 <script src="{{ static_url("js/events.js") }}" type="text/javascript" charset="utf-8"></script>

IPython/parallel/controller/heartmonitor.py

@@ -24,7 +24,7 b' from zmq.eventloop import ioloop, zmqstream'
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.py3compat import str_to_bytes
-from IPython.utils.traitlets import Set, Instance, CFloat, Integer
+from IPython.utils.traitlets import Set, Instance, CFloat, Integer, Dict
 
 from IPython.parallel.util import log_errors
 
@@ -74,6 +74,9 b' class HeartMonitor(LoggingConfigurable):'
         help='The frequency at which the Hub pings the engines for heartbeats '
         '(in ms)',
     )
+    max_heartmonitor_misses = Integer(10, config=True,
+        help='Allowed consecutive missed pings from controller Hub to engine before unregistering.',
+    )
 
     pingstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
     pongstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
@@ -84,7 +87,7 b' class HeartMonitor(LoggingConfigurable):'
     # not settable:
     hearts=Set()
     responses=Set()
-    on_probation=Set()
+    on_probation=Dict()
     last_ping=CFloat(0)
     _new_handlers = Set()
     _failure_handlers = Set()
@@ -121,11 +124,12 b' class HeartMonitor(LoggingConfigurable):'
         self.log.debug("heartbeat::sending %s", self.lifetime)
         goodhearts = self.hearts.intersection(self.responses)
         missed_beats = self.hearts.difference(goodhearts)
-        heartfailures = self.on_probation.intersection(missed_beats)
         newhearts = self.responses.difference(goodhearts)
         map(self.handle_new_heart, newhearts)
+        heartfailures, on_probation = self._check_missed(missed_beats, self.on_probation,
+                                                         self.hearts)
         map(self.handle_heart_failure, heartfailures)
-        self.on_probation = missed_beats.intersection(self.hearts)
+        self.on_probation = on_probation
         self.responses = set()
         #print self.on_probation, self.hearts
         # self.log.debug("heartbeat::beat %.3f, %i beating hearts", self.lifetime, len(self.hearts))
@@ -133,6 +137,20 b' class HeartMonitor(LoggingConfigurable):'
         # flush stream to force immediate socket send
         self.pingstream.flush()
 
+    def _check_missed(self, missed_beats, on_probation, hearts):
+        """Update heartbeats on probation, identifying any that have too many misses.
+        """
+        failures = []
+        new_probation = {}
+        for cur_heart in (b for b in missed_beats if b in hearts):
+            miss_count = on_probation.get(cur_heart, 0) + 1
+            self.log.info("heartbeat::missed %s : %s" % (cur_heart, miss_count))
+            if miss_count > self.max_heartmonitor_misses:
+                failures.append(cur_heart)
+            else:
+                new_probation[cur_heart] = miss_count
+        return failures, new_probation
+
     def handle_new_heart(self, heart):
         if self._new_handlers:
             for handler in self._new_handlers:

IPython/parallel/scripts/ipcluster

@@ -11,8 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-
-
 from IPython.parallel.apps.ipclusterapp import launch_new_instance
 
 launch_new_instance()

IPython/parallel/scripts/ipcontroller

@@ -11,8 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-
-
 from IPython.parallel.apps.ipcontrollerapp import launch_new_instance
 
 launch_new_instance()

IPython/parallel/scripts/ipengine

@@ -11,10 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-
-
 from IPython.parallel.apps.ipengineapp import launch_new_instance
 
 launch_new_instance()
-
-

IPython/parallel/scripts/iplogger

@@ -11,10 +11,6 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
-
-
 from IPython.parallel.apps.iploggerapp import launch_new_instance
 
 launch_new_instance()
-
-