move url_[un]escape to utils from nbm

IPython/html/tests/test_utils.py

@@ -0,0 +1,61 b''
+"""Test HTML utils"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2013 The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import nose.tools as nt
+
+import IPython.testing.tools as tt
+from IPython.html.utils import url_escape, url_unescape
+
+#-----------------------------------------------------------------------------
+# Test functions
+#-----------------------------------------------------------------------------
+
+def test_help_output():
+    """ipython notebook --help-all works"""
+    tt.help_all_output_test('notebook')
+
+
+def test_url_escape():
+
+    # changes path or notebook name with special characters to url encoding
+    # these tests specifically encode paths with spaces
+    path = url_escape('/this is a test/for spaces/')
+    nt.assert_equal(path, '/this%20is%20a%20test/for%20spaces/')
+
+    path = url_escape('notebook with space.ipynb')
+    nt.assert_equal(path, 'notebook%20with%20space.ipynb')
+
+    path = url_escape('/path with a/notebook and space.ipynb')
+    nt.assert_equal(path, '/path%20with%20a/notebook%20and%20space.ipynb')
+    
+    path = url_escape('/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
+    nt.assert_equal(path,
+        '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
+
+def test_url_unescape():
+
+    # decodes a url string to a plain string
+    # these tests decode paths with spaces
+    path = url_unescape('/this%20is%20a%20test/for%20spaces/')
+    nt.assert_equal(path, '/this is a test/for spaces/')
+
+    path = url_unescape('notebook%20with%20space.ipynb')
+    nt.assert_equal(path, 'notebook with space.ipynb')
+
+    path = url_unescape('/path%20with%20a/notebook%20and%20space.ipynb')
+    nt.assert_equal(path, '/path with a/notebook and space.ipynb')
+
+    path = url_unescape(
+        '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
+    nt.assert_equal(path, '/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
+

IPython/html/notebook/handlers.py

@@ -1,103 +1,103 b''
 """Tornado handlers for the live notebook view.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 from tornado import web
 HTTPError = web.HTTPError
 from zmq.utils import jsonapi
 
 
 from ..base.handlers import IPythonHandler
 from ..services.notebooks.handlers import _notebook_path_regex, _path_regex
-from ..utils import url_path_join
+from ..utils import url_path_join, url_escape, url_unescape
 from urllib import quote
 
 #-----------------------------------------------------------------------------
 # Handlers
 #-----------------------------------------------------------------------------
 
 
 class NotebookHandler(IPythonHandler):
 
     @web.authenticated
     def post(self):
         """post either creates a new notebook if no json data is
         sent to the server, or copies the data and returns a 
         copied notebook."""
         nbm = self.notebook_manager
         data=self.request.body
         if data:
             data = jsonapi.loads(data)
             notebook_name = nbm.copy_notebook(data['name'])
         else:
             notebook_name = nbm.new_notebook()
         self.finish(jsonapi.dumps({"name": notebook_name}))
 
 
 class NamedNotebookHandler(IPythonHandler):
 
     @web.authenticated
     def get(self, path='', name=None):
         """get renders the notebook template if a name is given, or 
         redirects to the '/files/' handler if the name is not given."""
         nbm = self.notebook_manager
         if name is None:
             url = url_path_join(self.base_project_url, 'files', path)
             self.redirect(url)
             return
             
         # a .ipynb filename was given
         if not nbm.notebook_exists(name, path):
             raise web.HTTPError(404, u'Notebook does not exist: %s/%s' % (path, name))
-        name = nbm.url_encode(name)
-        path = nbm.url_encode(path)
+        name = url_escape(name)
+        path = url_escape(path)
         self.write(self.render_template('notebook.html',
             project=self.project_dir,
             notebook_path=path,
             notebook_name=name,
             kill_kernel=False,
             mathjax_url=self.mathjax_url,
             )
         )
 
     @web.authenticated
     def post(self, path='', name=None):
         """post either creates a new notebook if no json data is
         sent to the server, or copies the data and returns a 
         copied notebook in the location given by 'notebook_path."""
         nbm = self.notebook_manager
         data = self.request.body
         if data:
             data = jsonapi.loads(data)
             notebook_name = nbm.copy_notebook(data['name'], notebook_path)
         else:
             notebook_name = nbm.new_notebook(notebook_path)
         self.finish(jsonapi.dumps({"name": notebook_name}))
 
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings
 #-----------------------------------------------------------------------------
 
 
 default_handlers = [
     (r"/notebooks/?%s" % _notebook_path_regex, NamedNotebookHandler),
     (r"/notebooks/?%s" % _path_regex, NamedNotebookHandler),
     (r"/notebooks/?", NotebookHandler),
 ]
 

IPython/html/services/notebooks/nbmanager.py

@@ -1,211 +1,199 b''
 """A base class notebook manager.
 
 Authors:
 
 * Brian Granger
 * Zach Sailer
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import uuid
 from urllib import quote, unquote
 
 from tornado import web
 
 from IPython.html.utils import url_path_join
 from IPython.config.configurable import LoggingConfigurable
 from IPython.nbformat import current
 from IPython.utils.traitlets import List, Dict, Unicode, TraitError
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class NotebookManager(LoggingConfigurable):
 
     # Todo:
     # The notebook_dir attribute is used to mean a couple of different things:
     # 1. Where the notebooks are stored if FileNotebookManager is used.
     # 2. The cwd of the kernel for a project.
     # Right now we use this attribute in a number of different places and
     # we are going to have to disentangle all of this.
     notebook_dir = Unicode(os.getcwdu(), config=True, help="""
             The directory to use for notebooks.
             """)
 
     filename_ext = Unicode(u'.ipynb')
     
     def path_exists(self, path):
         """Does the API-style path (directory) actually exist?
         
         Override this method for non-filesystem-based notebooks.
         
         Parameters
         ----------
         path : string
             The 
         
         Returns
         -------
         exists : bool
             Whether the path does indeed exist.
         """
         os_path = self.get_os_path(name, path)
         return os.path.exists(os_path)
         
     
     def get_os_path(self, name=None, path=''):
         """Given a notebook name and a URL path, return its file system
         path.
 
         Parameters
         ----------
         name : string
             The name of a notebook file with the .ipynb extension
         path : string
             The relative URL path (with '/' as separator) to the named
             notebook.
 
         Returns
         -------
         path : string
             A file system path that combines notebook_dir (location where
             server started), the relative path, and the filename with the
             current operating system's url.
         """
         parts = path.strip('/').split('/')
         parts = [p for p in parts if p != ''] # remove duplicate splits
         if name is not None:
             parts.append(name)
         path = os.path.join(self.notebook_dir, *parts)
         return path
 
-    def url_encode(self, path):
-        """Takes a URL path with special characters and returns 
-        the path with all these characters URL encoded"""
-        parts = path.split('/')
-        return '/'.join([quote(p) for p in parts])
-
-    def url_decode(self, path):
-        """Takes a URL path with encoded special characters and 
-        returns the URL with special characters decoded"""
-        parts = path.split('/')
-        return '/'.join([unquote(p) for p in parts])
-
     def _notebook_dir_changed(self, name, old, new):
         """Do a bit of validation of the notebook dir."""
         if not os.path.isabs(new):
             # If we receive a non-absolute path, make it absolute.
             self.notebook_dir = os.path.abspath(new)
             return
         if os.path.exists(new) and not os.path.isdir(new):
             raise TraitError("notebook dir %r is not a directory" % new)
         if not os.path.exists(new):
             self.log.info("Creating notebook dir %s", new)
             try:
                 os.mkdir(new)
             except:
                 raise TraitError("Couldn't create notebook dir %r" % new)
 
     # Main notebook API
 
     def increment_filename(self, basename, path=''):
         """Increment a notebook filename without the .ipynb to make it unique.
         
         Parameters
         ----------
         basename : unicode
             The name of a notebook without the ``.ipynb`` file extension.
         path : unicode
             The URL path of the notebooks directory
         """
         return basename
 
     def list_notebooks(self):
         """Return a list of notebook dicts without content.
 
         This returns a list of dicts, each of the form::
 
             dict(notebook_id=notebook,name=name)
 
         This list of dicts should be sorted by name::
 
             data = sorted(data, key=lambda item: item['name'])
         """
         raise NotImplementedError('must be implemented in a subclass')
 
     def get_notebook_model(self, name, path='', content=True):
         """Get the notebook model with or without content."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def save_notebook_model(self, model, name, path=''):
         """Save the notebook model and return the model with no content."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def update_notebook_model(self, model, name, path=''):
         """Update the notebook model and return the model with no content."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def delete_notebook_model(self, name, path):
         """Delete notebook by name and path."""
         raise NotImplementedError('must be implemented in a subclass')
 
     def create_notebook_model(self, model=None, path=''):
         """Create a new untitled notebook and return its model with no content."""
         name = self.increment_filename('Untitled', path)
         if model is None:
             model = {}
             metadata = current.new_metadata(name=u'')
             nb = current.new_notebook(metadata=metadata)
             model['content'] = nb
             model['name'] = name
             model['path'] = path
         model = self.save_notebook_model(model, name, path)
         return model
 
     def copy_notebook(self, name, path='/', content=False):
         """Copy an existing notebook and return its new model."""
         model = self.get_notebook_model(name, path)
         name = os.path.splitext(name)[0] + '-Copy'
         name = self.increment_filename(name, path) + self.filename_ext
         model['name'] = name
         model = self.save_notebook_model(model, name, path, content=content)
         return model
     
     # Checkpoint-related
     
     def create_checkpoint(self, name, path='/'):
         """Create a checkpoint of the current state of a notebook
         
         Returns a checkpoint_id for the new checkpoint.
         """
         raise NotImplementedError("must be implemented in a subclass")
     
     def list_checkpoints(self, name, path='/'):
         """Return a list of checkpoints for a given notebook"""
         return []
     
     def restore_checkpoint(self, checkpoint_id, name, path='/'):
         """Restore a notebook from one of its checkpoints"""
         raise NotImplementedError("must be implemented in a subclass")
 
     def delete_checkpoint(self, checkpoint_id, name, path='/'):
         """delete a checkpoint for a notebook"""
         raise NotImplementedError("must be implemented in a subclass")
     
     def log_info(self):
         self.log.info(self.info_string())
     
     def info_string(self):
         return "Serving notebooks"

IPython/html/services/notebooks/tests/test_nbmanager.py

@@ -1,246 +1,210 b''
 """Tests for the notebook manager."""
 
 import os
 
 from tornado.web import HTTPError
 from unittest import TestCase
 from tempfile import NamedTemporaryFile
 
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.utils.traitlets import TraitError
 from IPython.html.utils import url_path_join
 
 from ..filenbmanager import FileNotebookManager
 from ..nbmanager import NotebookManager
 
 class TestFileNotebookManager(TestCase):
 
     def test_nb_dir(self):
         with TemporaryDirectory() as td:
             fm = FileNotebookManager(notebook_dir=td)
             self.assertEqual(fm.notebook_dir, td)
 
     def test_create_nb_dir(self):
         with TemporaryDirectory() as td:
             nbdir = os.path.join(td, 'notebooks')
             fm = FileNotebookManager(notebook_dir=nbdir)
             self.assertEqual(fm.notebook_dir, nbdir)
 
     def test_missing_nb_dir(self):
         with TemporaryDirectory() as td:
             nbdir = os.path.join(td, 'notebook', 'dir', 'is', 'missing')
             self.assertRaises(TraitError, FileNotebookManager, notebook_dir=nbdir)
 
     def test_invalid_nb_dir(self):
         with NamedTemporaryFile() as tf:
             self.assertRaises(TraitError, FileNotebookManager, notebook_dir=tf.name)
 
     def test_get_os_path(self):
         # full filesystem path should be returned with correct operating system
         # separators.
         with TemporaryDirectory() as td:
             nbdir = os.path.join(td, 'notebooks')
             fm = FileNotebookManager(notebook_dir=nbdir)
             path = fm.get_os_path('test.ipynb', '/path/to/notebook/')
             rel_path_list =  '/path/to/notebook/test.ipynb'.split('/')
             fs_path = os.path.join(fm.notebook_dir, *rel_path_list)
             self.assertEqual(path, fs_path)
 
             fm = FileNotebookManager(notebook_dir=nbdir)
             path = fm.get_os_path('test.ipynb')
             fs_path = os.path.join(fm.notebook_dir, 'test.ipynb')
             self.assertEqual(path, fs_path)
 
             fm = FileNotebookManager(notebook_dir=nbdir)
             path = fm.get_os_path('test.ipynb', '////')
             fs_path = os.path.join(fm.notebook_dir, 'test.ipynb')
             self.assertEqual(path, fs_path)
 
 class TestNotebookManager(TestCase):
     
     def make_dir(self, abs_path, rel_path):
         """make subdirectory, rel_path is the relative path
         to that directory from the location where the server started"""
         os_path = os.path.join(abs_path, rel_path)
         try:
             os.makedirs(os_path)
         except OSError:
             print "Directory already exists."
 
-    def test_url_encode(self):
-        nm = NotebookManager()
-
-        # changes path or notebook name with special characters to url encoding
-        # these tests specifically encode paths with spaces
-        path = nm.url_encode('/this is a test/for spaces/')
-        self.assertEqual(path, '/this%20is%20a%20test/for%20spaces/')
-
-        path = nm.url_encode('notebook with space.ipynb')
-        self.assertEqual(path, 'notebook%20with%20space.ipynb')
-
-        path = nm.url_encode('/path with a/notebook and space.ipynb')
-        self.assertEqual(path, '/path%20with%20a/notebook%20and%20space.ipynb')
-        
-        path = nm.url_encode('/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
-        self.assertEqual(path,
-            '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
-
-    def test_url_decode(self):
-        nm = NotebookManager()
-
-        # decodes a url string to a plain string
-        # these tests decode paths with spaces
-        path = nm.url_decode('/this%20is%20a%20test/for%20spaces/')
-        self.assertEqual(path, '/this is a test/for spaces/')
-
-        path = nm.url_decode('notebook%20with%20space.ipynb')
-        self.assertEqual(path, 'notebook with space.ipynb')
-
-        path = nm.url_decode('/path%20with%20a/notebook%20and%20space.ipynb')
-        self.assertEqual(path, '/path with a/notebook and space.ipynb')
-
-        path = nm.url_decode(
-            '/%20%21%40%24%23%25%5E%26%2A%20/%20test%20%25%5E%20notebook%20%40%23%24%20name.ipynb')
-        self.assertEqual(path, '/ !@$#%^&* / test %^ notebook @#$ name.ipynb')
-
     def test_create_notebook_model(self):
         with TemporaryDirectory() as td:
             # Test in root directory
             nm = FileNotebookManager(notebook_dir=td)
             model = nm.create_notebook_model()
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], 'Untitled0.ipynb')
             self.assertEqual(model['path'], '/')
 
             # Test in sub-directory
             sub_dir = '/foo/'
             self.make_dir(nm.notebook_dir, 'foo')
             model = nm.create_notebook_model(None, sub_dir)
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], 'Untitled0.ipynb')
             self.assertEqual(model['path'], sub_dir)
 
     def test_get_notebook_model(self):
         with TemporaryDirectory() as td:
             # Test in root directory
             # Create a notebook
             nm = FileNotebookManager(notebook_dir=td)
             model = nm.create_notebook_model()
             name = model['name']
             path = model['path']
 
             # Check that we 'get' on the notebook we just created
             model2 = nm.get_notebook_model(name, path)
             assert isinstance(model2, dict)
             self.assertIn('name', model2)
             self.assertIn('path', model2)
             self.assertEqual(model['name'], name)
             self.assertEqual(model['path'], path)
 
             # Test in sub-directory
             sub_dir = '/foo/'
             self.make_dir(nm.notebook_dir, 'foo')
             model = nm.create_notebook_model(None, sub_dir)
             model2 = nm.get_notebook_model(name, sub_dir)
             assert isinstance(model2, dict)
             self.assertIn('name', model2)
             self.assertIn('path', model2)
             self.assertIn('content', model2)
             self.assertEqual(model2['name'], 'Untitled0.ipynb')
             self.assertEqual(model2['path'], sub_dir)
             
     def test_update_notebook_model(self):
         with TemporaryDirectory() as td:
             # Test in root directory
             # Create a notebook
             nm = FileNotebookManager(notebook_dir=td)
             model = nm.create_notebook_model()
             name = model['name']
             path = model['path']
 
             # Change the name in the model for rename
             model['name'] = 'test.ipynb'
             model = nm.update_notebook_model(model, name, path)
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], 'test.ipynb')
 
             # Make sure the old name is gone
             self.assertRaises(HTTPError, nm.get_notebook_model, name, path)
 
             # Test in sub-directory
             # Create a directory and notebook in that directory
             sub_dir = '/foo/'
             self.make_dir(nm.notebook_dir, 'foo')
             model = nm.create_notebook_model(None, sub_dir)
             name = model['name']
             path = model['path']
             
             # Change the name in the model for rename
             model['name'] = 'test_in_sub.ipynb'
             model = nm.update_notebook_model(model, name, path)
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], 'test_in_sub.ipynb')
             self.assertEqual(model['path'], sub_dir)
             
             # Make sure the old name is gone
             self.assertRaises(HTTPError, nm.get_notebook_model, name, path)
 
     def test_save_notebook_model(self):
         with TemporaryDirectory() as td:
             # Test in the root directory
             # Create a notebook
             nm = FileNotebookManager(notebook_dir=td)
             model = nm.create_notebook_model()
             name = model['name']
             path = model['path']
 
             # Get the model with 'content'
             full_model = nm.get_notebook_model(name, path)
 
             # Save the notebook
             model = nm.save_notebook_model(full_model, name, path)
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], name)
             self.assertEqual(model['path'], path)
 
             # Test in sub-directory
             # Create a directory and notebook in that directory
             sub_dir = '/foo/'
             self.make_dir(nm.notebook_dir, 'foo')
             model = nm.create_notebook_model(None, sub_dir)
             name = model['name']
             path = model['path']
             model = nm.get_notebook_model(name, path)
 
             # Change the name in the model for rename
             model = nm.save_notebook_model(model, name, path)
             assert isinstance(model, dict)
             self.assertIn('name', model)
             self.assertIn('path', model)
             self.assertEqual(model['name'], 'Untitled0.ipynb')
             self.assertEqual(model['path'], sub_dir)          
 
     def test_delete_notebook_model(self):
         with TemporaryDirectory() as td:
             # Test in the root directory
             # Create a notebook
             nm = FileNotebookManager(notebook_dir=td)
             model = nm.create_notebook_model()
             name = model['name']
             path = model['path']
             
             # Delete the notebook
             nm.delete_notebook_model(name, path)
             
             # Check that a 'get' on the deleted notebook raises and error
             self.assertRaises(HTTPError, nm.get_notebook_model, name, path)

IPython/html/utils.py

@@ -1,51 +1,66 b''
 """Notebook related utilities
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 import os
 from urllib import quote, unquote
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 def url_path_join(*pieces):
     """Join components of url into a relative url
 
     Use to prevent double slash when joining subpath. This will leave the
     initial and final / in place
     """
     initial = pieces[0].startswith('/')
     final = pieces[-1].endswith('/')
     stripped = [s.strip('/') for s in pieces]
     result = '/'.join(s for s in stripped if s)
     if initial: result = '/' + result
     if final: result = result + '/'
     if result == '//': result = '/'
     return result
 
 def path2url(path):
     """Convert a local file path to a URL"""
     pieces = [ quote(p) for p in path.split(os.path.sep) ]
     # preserve trailing /
     if pieces[-1] == '':
         pieces[-1] = '/'
     url = url_path_join(*pieces)
     return url
 
 def url2path(url):
     """Convert a URL to a local file path"""
     pieces = [ unquote(p) for p in url.split('/') ]
     path = os.path.join(*pieces)
     return path
     
+def url_escape(path):
+    """Escape special characters in a URL path
+    
+    Turns '/foo bar/' into '/foo%20bar/'
+    """
+    parts = path.split('/')
+    return '/'.join([quote(p) for p in parts])
+
+def url_unescape(path):
+    """Unescape special characters in a URL path
+    
+    Turns '/foo%20bar/' into '/foo bar/'
+    """
+    return '/'.join([unquote(p) for p in path.split('/')])
+