Remove separate 'path', 'name' in Contents API

- path is full path (including name)
- name is only used for read-only convenience, and plays no role in any API
- remove 'untitled upload' (POST with content and no path)

IPython/html/base/handlers.py

@@ -298,7 +298,7 b' class AuthenticatedFileHandler(IPythonHandler, web.StaticFileHandler):'
     @web.authenticated
     def get(self, path):
         if os.path.splitext(path)[1] == '.ipynb':
-            name = os.path.basename(path)
+            name = path.rsplit('/', 1)[-1]
             self.set_header('Content-Type', 'application/json')
             self.set_header('Content-Disposition','attachment; filename="%s"' % name)
         
@@ -418,43 +418,42 b' class ApiVersionHandler(IPythonHandler):'
         # not authenticated, so give as few info as possible
         self.finish(json.dumps({"version":IPython.__version__}))
 
+
 class TrailingSlashHandler(web.RequestHandler):
     """Simple redirect handler that strips trailing slashes
     
     This should be the first, highest priority handler.
     """
     
-    SUPPORTED_METHODS = ['GET']
-    
     def get(self):
         self.redirect(self.request.uri.rstrip('/'))
+    
+    post = put = get
 
 
 class FilesRedirectHandler(IPythonHandler):
     """Handler for redirecting relative URLs to the /files/ handler"""
     def get(self, path=''):
         cm = self.contents_manager
-        if cm.path_exists(path):
+        if cm.dir_exists(path):
             # it's a *directory*, redirect to /tree
             url = url_path_join(self.base_url, 'tree', path)
         else:
             orig_path = path
             # otherwise, redirect to /files
             parts = path.split('/')
-            path = '/'.join(parts[:-1])
-            name = parts[-1]
 
-            if not cm.file_exists(name=name, path=path) and 'files' in parts:
+            if not cm.file_exists(path=path) and 'files' in parts:
                 # redirect without files/ iff it would 404
                 # this preserves pre-2.0-style 'files/' links
                 self.log.warn("Deprecated files/ URL: %s", orig_path)
                 parts.remove('files')
-                path = '/'.join(parts[:-1])
+                path = '/'.join(parts)
 
-            if not cm.file_exists(name=name, path=path):
+            if not cm.file_exists(path=path):
                 raise web.HTTPError(404)
 
-            url = url_path_join(self.base_url, 'files', path, name)
+            url = url_path_join(self.base_url, 'files', path)
         url = url_escape(url)
         self.log.debug("Redirecting %s to %s", self.request.path, url)
         self.redirect(url)
@@ -464,11 +463,8 b' class FilesRedirectHandler(IPythonHandler):'
 # URL pattern fragments for re-use
 #-----------------------------------------------------------------------------
 
-path_regex = r"(?P<path>(?:/.*)*)"
-notebook_name_regex = r"(?P<name>[^/]+\.ipynb)"
-notebook_path_regex = "%s/%s" % (path_regex, notebook_name_regex)
-file_name_regex = r"(?P<name>[^/]+)"
-file_path_regex = "%s/%s" % (path_regex, file_name_regex)
+path_regex = r"(?P<path>.*)"
+notebook_path_regex = r"(?P<path>.+\.ipynb)"
 
 #-----------------------------------------------------------------------------
 # URL to handler mappings

IPython/html/files/handlers.py

@@ -17,13 +17,18 b' class FilesHandler(IPythonHandler):'
 
     @web.authenticated
     def get(self, path):
-        cm = self.settings['contents_manager']
+        cm = self.contents_manager
         if cm.is_hidden(path):
             self.log.info("Refusing to serve hidden file, via 404 Error")
             raise web.HTTPError(404)
-
-        path, name = os.path.split(path)
-        model = cm.get_model(name, path)
+        
+        path = path.strip('/')
+        if '/' in path:
+            _, name = path.rsplit('/', 1)
+        else:
+            name = path
+        
+        model = cm.get_model(path)
         
         if self.get_argument("download", False):
             self.set_header('Content-Disposition','attachment; filename="%s"' % name)

IPython/html/nbconvert/handlers.py

@@ -76,12 +76,13 b' class NbconvertFileHandler(IPythonHandler):'
     SUPPORTED_METHODS = ('GET',)
     
     @web.authenticated
-    def get(self, format, path='', name=None):
+    def get(self, format, path):
         
         exporter = get_exporter(format, config=self.config, log=self.log)
         
         path = path.strip('/')
-        model = self.contents_manager.get_model(name=name, path=path)
+        model = self.contents_manager.get_model(path=path)
+        name = model['name']
 
         self.set_header('Last-Modified', model['last_modified'])
         
@@ -109,7 +110,7 b' class NbconvertFileHandler(IPythonHandler):'
 class NbconvertPostHandler(IPythonHandler):
     SUPPORTED_METHODS = ('POST',)
 
-    @web.authenticated 
+    @web.authenticated
     def post(self, format):
         exporter = get_exporter(format, config=self.config)
         

IPython/html/notebook/handlers.py

@@ -17,18 +17,16 b' from ..utils import url_escape'
 class NotebookHandler(IPythonHandler):
 
     @web.authenticated
-    def get(self, path='', name=None):
+    def get(self, path=''):
         """get renders the notebook template if a name is given, or 
         redirects to the '/files/' handler if the name is not given."""
         path = path.strip('/')
         cm = self.contents_manager
-        if name is None:
-            raise web.HTTPError(500, "This shouldn't be accessible: %s" % self.request.uri)
         
         # a .ipynb filename was given
-        if not cm.file_exists(name, path):
-            raise web.HTTPError(404, u'Notebook does not exist: %s/%s' % (path, name))
-        name = url_escape(name)
+        if not cm.file_exists(path):
+            raise web.HTTPError(404, u'Notebook does not exist: %s' % path)
+        name = url_escape(path.rsplit('/', 1)[-1])
         path = url_escape(path)
         self.write(self.render_template('notebook.html',
             notebook_path=path,

IPython/html/notebookapp.py

@@ -189,7 +189,6 b' class NotebookWebApplication(web.Application):'
     def init_handlers(self, settings):
         # Load the (URL pattern, handler) tuples for each component.
         handlers = []
-        handlers.extend(load_handlers('base.handlers'))
         handlers.extend(load_handlers('tree.handlers'))
         handlers.extend(load_handlers('auth.login'))
         handlers.extend(load_handlers('auth.logout'))
@@ -206,6 +205,7 b' class NotebookWebApplication(web.Application):'
         handlers.append(
             (r"/nbextensions/(.*)", FileFindHandler, {'path' : settings['nbextensions_path']}),
         )
+        handlers.extend(load_handlers('base.handlers'))
         # set the URL that will be redirected from `/`
         handlers.append(
             (r'/?', web.RedirectHandler, {

IPython/html/services/contents/filemanager.py

@@ -61,27 +61,23 b' class FileContentsManager(ContentsManager):'
         except OSError as e:
             self.log.debug("copystat on %s failed", dest, exc_info=True)
 
-    def _get_os_path(self, name=None, path=''):
+    def _get_os_path(self, path=''):
         """Given a filename and API path, return its file system
         path.
 
         Parameters
         ----------
-        name : string
-            A filename
         path : string
             The relative API path to the named file.
 
         Returns
         -------
         path : string
-            API path to be evaluated relative to root_dir.
+            Native, absolute OS path to for a file.
         """
-        if name is not None:
-            path = url_path_join(path, name)
         return to_os_path(path, self.root_dir)
 
-    def path_exists(self, path):
+    def dir_exists(self, path):
         """Does the API-style path refer to an extant directory?
 
         API-style wrapper for os.path.isdir
@@ -112,25 +108,22 b' class FileContentsManager(ContentsManager):'
 
         Returns
         -------
-        exists : bool
-            Whether the path is hidden.
-
+        hidden : bool
+            Whether the path exists and is hidden.
         """
         path = path.strip('/')
         os_path = self._get_os_path(path=path)
         return is_hidden(os_path, self.root_dir)
 
-    def file_exists(self, name, path=''):
+    def file_exists(self, path):
         """Returns True if the file exists, else returns False.
 
         API-style wrapper for os.path.isfile
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
-            The relative path to the file's directory (with '/' as separator)
+            The relative path to the file (with '/' as separator)
 
         Returns
         -------
@@ -138,20 +131,18 b' class FileContentsManager(ContentsManager):'
             Whether the file exists.
         """
         path = path.strip('/')
-        nbpath = self._get_os_path(name, path=path)
+        nbpath = self._get_os_path(path)
         return os.path.isfile(nbpath)
 
-    def exists(self, name=None, path=''):
-        """Returns True if the path [and name] exists, else returns False.
+    def exists(self, path):
+        """Returns True if the path exists, else returns False.
 
         API-style wrapper for os.path.exists
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
-            The relative path to the file's directory (with '/' as separator)
+            The API path to the file (with '/' as separator)
 
         Returns
         -------
@@ -159,18 +150,18 b' class FileContentsManager(ContentsManager):'
             Whether the target exists.
         """
         path = path.strip('/')
-        os_path = self._get_os_path(name, path=path)
+        os_path = self._get_os_path(path=path)
         return os.path.exists(os_path)
 
-    def _base_model(self, name, path=''):
+    def _base_model(self, path):
         """Build the common base of a contents model"""
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         info = os.stat(os_path)
         last_modified = tz.utcfromtimestamp(info.st_mtime)
         created = tz.utcfromtimestamp(info.st_ctime)
         # Create the base model.
         model = {}
-        model['name'] = name
+        model['name'] = path.rsplit('/', 1)[-1]
         model['path'] = path
         model['last_modified'] = last_modified
         model['created'] = created
@@ -179,12 +170,12 b' class FileContentsManager(ContentsManager):'
         model['message'] = None
         return model
 
-    def _dir_model(self, name, path='', content=True):
+    def _dir_model(self, path, content=True):
         """Build a model for a directory
 
         if content is requested, will include a listing of the directory
         """
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
 
         four_o_four = u'directory does not exist: %r' % os_path
 
@@ -196,39 +187,36 b' class FileContentsManager(ContentsManager):'
             )
             raise web.HTTPError(404, four_o_four)
 
-        if name is None:
-            if '/' in path:
-                path, name = path.rsplit('/', 1)
-            else:
-                name = ''
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'directory'
-        dir_path = u'{}/{}'.format(path, name)
         if content:
             model['content'] = contents = []
-            for os_path in glob.glob(self._get_os_path('*', dir_path)):
+            for os_path in glob.glob(self._get_os_path('%s/*' % path)):
                 name = os.path.basename(os_path)
                 # skip over broken symlinks in listing
                 if not os.path.exists(os_path):
                     self.log.warn("%s doesn't exist", os_path)
                     continue
                 if self.should_list(name) and not is_hidden(os_path, self.root_dir):
-                    contents.append(self.get_model(name=name, path=dir_path, content=False))
+                    contents.append(self.get_model(
+                        path='%s/%s' % (path, name),
+                        content=False)
+                    )
 
             model['format'] = 'json'
 
         return model
 
-    def _file_model(self, name, path='', content=True):
+    def _file_model(self, path, content=True):
         """Build a model for a file
 
         if content is requested, include the file contents.
         UTF-8 text files will be unicode, binary files will be base64-encoded.
         """
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'file'
         if content:
-            os_path = self._get_os_path(name, path)
+            os_path = self._get_os_path(path)
             with io.open(os_path, 'rb') as f:
                 bcontent = f.read()
             try:
@@ -241,34 +229,32 b' class FileContentsManager(ContentsManager):'
         return model
 
 
-    def _notebook_model(self, name, path='', content=True):
+    def _notebook_model(self, path, content=True):
         """Build a notebook model
 
         if content is requested, the notebook content will be populated
         as a JSON structure (not double-serialized)
         """
-        model = self._base_model(name, path)
+        model = self._base_model(path)
         model['type'] = 'notebook'
         if content:
-            os_path = self._get_os_path(name, path)
+            os_path = self._get_os_path(path)
             with io.open(os_path, 'r', encoding='utf-8') as f:
                 try:
                     nb = nbformat.read(f, as_version=4)
                 except Exception as e:
                     raise web.HTTPError(400, u"Unreadable Notebook: %s %r" % (os_path, e))
-            self.mark_trusted_cells(nb, name, path)
+            self.mark_trusted_cells(nb, path)
             model['content'] = nb
             model['format'] = 'json'
             self.validate_notebook_model(model)
         return model
 
-    def get_model(self, name, path='', content=True):
-        """ Takes a path and name for an entity and returns its model
+    def get_model(self, path, content=True):
+        """ Takes a path for an entity and returns its model
 
         Parameters
         ----------
-        name : str
-            the name of the target
         path : str
             the API path that describes the relative path for the target
 
@@ -280,32 +266,29 b' class FileContentsManager(ContentsManager):'
         """
         path = path.strip('/')
 
-        if not self.exists(name=name, path=path):
-            raise web.HTTPError(404, u'No such file or directory: %s/%s' % (path, name))
+        if not self.exists(path):
+            raise web.HTTPError(404, u'No such file or directory: %s' % path)
 
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         if os.path.isdir(os_path):
-            model = self._dir_model(name, path, content)
-        elif name.endswith('.ipynb'):
-            model = self._notebook_model(name, path, content)
+            model = self._dir_model(path, content=content)
+        elif path.endswith('.ipynb'):
+            model = self._notebook_model(path, content=content)
         else:
-            model = self._file_model(name, path, content)
+            model = self._file_model(path, content=content)
         return model
 
-    def _save_notebook(self, os_path, model, name='', path=''):
+    def _save_notebook(self, os_path, model, path=''):
         """save a notebook file"""
         # Save the notebook file
         nb = nbformat.from_dict(model['content'])
 
-        self.check_and_sign(nb, name, path)
-
-        if 'name' in nb['metadata']:
-            nb['metadata']['name'] = u''
+        self.check_and_sign(nb, path)
 
         with atomic_writing(os_path, encoding='utf-8') as f:
             nbformat.write(nb, f, version=nbformat.NO_CONVERT)
 
-    def _save_file(self, os_path, model, name='', path=''):
+    def _save_file(self, os_path, model, path=''):
         """save a non-notebook file"""
         fmt = model.get('format', None)
         if fmt not in {'text', 'base64'}:
@@ -322,7 +305,7 b' class FileContentsManager(ContentsManager):'
         with atomic_writing(os_path, text=False) as f:
             f.write(bcontent)
 
-    def _save_directory(self, os_path, model, name='', path=''):
+    def _save_directory(self, os_path, model, path=''):
         """create a directory"""
         if is_hidden(os_path, self.root_dir):
             raise web.HTTPError(400, u'Cannot create hidden directory %r' % os_path)
@@ -333,7 +316,7 b' class FileContentsManager(ContentsManager):'
         else:
             self.log.debug("Directory %r already exists", os_path)
 
-    def save(self, model, name='', path=''):
+    def save(self, model, path=''):
         """Save the file model and return the model with no content."""
         path = path.strip('/')
 
@@ -343,24 +326,18 b' class FileContentsManager(ContentsManager):'
             raise web.HTTPError(400, u'No file content provided')
 
         # One checkpoint should always exist
-        if self.file_exists(name, path) and not self.list_checkpoints(name, path):
-            self.create_checkpoint(name, path)
+        if self.file_exists(path) and not self.list_checkpoints(path):
+            self.create_checkpoint(path)
 
-        new_path = model.get('path', path).strip('/')
-        new_name = model.get('name', name)
-
-        if path != new_path or name != new_name:
-            self.rename(name, path, new_name, new_path)
-
-        os_path = self._get_os_path(new_name, new_path)
+        os_path = self._get_os_path(path)
         self.log.debug("Saving %s", os_path)
         try:
             if model['type'] == 'notebook':
-                self._save_notebook(os_path, model, new_name, new_path)
+                self._save_notebook(os_path, model, path)
             elif model['type'] == 'file':
-                self._save_file(os_path, model, new_name, new_path)
+                self._save_file(os_path, model, path)
             elif model['type'] == 'directory':
-                self._save_directory(os_path, model, new_name, new_path)
+                self._save_directory(os_path, model, path)
             else:
                 raise web.HTTPError(400, "Unhandled contents type: %s" % model['type'])
         except web.HTTPError:
@@ -373,29 +350,28 b' class FileContentsManager(ContentsManager):'
             self.validate_notebook_model(model)
             validation_message = model.get('message', None)
 
-        model = self.get_model(new_name, new_path, content=False)
+        model = self.get_model(path, content=False)
         if validation_message:
             model['message'] = validation_message
         return model
 
-    def update(self, model, name, path=''):
-        """Update the file's path and/or name
+    def update(self, model, path):
+        """Update the file's path
 
         For use in PATCH requests, to enable renaming a file without
         re-uploading its contents. Only used for renaming at the moment.
         """
         path = path.strip('/')
-        new_name = model.get('name', name)
         new_path = model.get('path', path).strip('/')
-        if path != new_path or name != new_name:
-            self.rename(name, path, new_name, new_path)
-        model = self.get_model(new_name, new_path, content=False)
+        if path != new_path:
+            self.rename(path, new_path)
+        model = self.get_model(new_path, content=False)
         return model
 
-    def delete(self, name, path=''):
-        """Delete file by name and path."""
+    def delete(self, path):
+        """Delete file at path."""
         path = path.strip('/')
-        os_path = self._get_os_path(name, path)
+        os_path = self._get_os_path(path)
         rm = os.unlink
         if os.path.isdir(os_path):
             listing = os.listdir(os_path)
@@ -406,9 +382,9 b' class FileContentsManager(ContentsManager):'
             raise web.HTTPError(404, u'File does not exist: %s' % os_path)
 
         # clear checkpoints
-        for checkpoint in self.list_checkpoints(name, path):
+        for checkpoint in self.list_checkpoints(path):
             checkpoint_id = checkpoint['id']
-            cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+            cp_path = self.get_checkpoint_path(checkpoint_id, path)
             if os.path.isfile(cp_path):
                 self.log.debug("Unlinking checkpoint %s", cp_path)
                 os.unlink(cp_path)
@@ -420,19 +396,19 b' class FileContentsManager(ContentsManager):'
             self.log.debug("Unlinking file %s", os_path)
             rm(os_path)
 
-    def rename(self, old_name, old_path, new_name, new_path):
+    def rename(self, old_path, new_path):
         """Rename a file."""
         old_path = old_path.strip('/')
         new_path = new_path.strip('/')
-        if new_name == old_name and new_path == old_path:
+        if new_path == old_path:
             return
 
-        new_os_path = self._get_os_path(new_name, new_path)
-        old_os_path = self._get_os_path(old_name, old_path)
+        new_os_path = self._get_os_path(new_path)
+        old_os_path = self._get_os_path(old_path)
 
         # Should we proceed with the move?
         if os.path.isfile(new_os_path):
-            raise web.HTTPError(409, u'File with name already exists: %s' % new_os_path)
+            raise web.HTTPError(409, u'File already exists: %s' % new_os_path)
 
         # Move the file
         try:
@@ -441,36 +417,38 b' class FileContentsManager(ContentsManager):'
             raise web.HTTPError(500, u'Unknown error renaming file: %s %s' % (old_os_path, e))
 
         # Move the checkpoints
-        old_checkpoints = self.list_checkpoints(old_name, old_path)
+        old_checkpoints = self.list_checkpoints(old_path)
         for cp in old_checkpoints:
             checkpoint_id = cp['id']
-            old_cp_path = self.get_checkpoint_path(checkpoint_id, old_name, old_path)
-            new_cp_path = self.get_checkpoint_path(checkpoint_id, new_name, new_path)
+            old_cp_path = self.get_checkpoint_path(checkpoint_id, old_path)
+            new_cp_path = self.get_checkpoint_path(checkpoint_id, new_path)
             if os.path.isfile(old_cp_path):
                 self.log.debug("Renaming checkpoint %s -> %s", old_cp_path, new_cp_path)
                 shutil.move(old_cp_path, new_cp_path)
 
     # Checkpoint-related utilities
 
-    def get_checkpoint_path(self, checkpoint_id, name, path=''):
+    def get_checkpoint_path(self, checkpoint_id, path):
         """find the path to a checkpoint"""
         path = path.strip('/')
+        parent, name = ('/' + path).rsplit('/', 1)
+        parent = parent.strip('/')
         basename, ext = os.path.splitext(name)
         filename = u"{name}-{checkpoint_id}{ext}".format(
             name=basename,
             checkpoint_id=checkpoint_id,
             ext=ext,
         )
-        os_path = self._get_os_path(path=path)
+        os_path = self._get_os_path(path=parent)
         cp_dir = os.path.join(os_path, self.checkpoint_dir)
         ensure_dir_exists(cp_dir)
         cp_path = os.path.join(cp_dir, filename)
         return cp_path
 
-    def get_checkpoint_model(self, checkpoint_id, name, path=''):
+    def get_checkpoint_model(self, checkpoint_id, path):
         """construct the info dict for a given checkpoint"""
         path = path.strip('/')
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         stats = os.stat(cp_path)
         last_modified = tz.utcfromtimestamp(stats.st_mtime)
         info = dict(
@@ -481,43 +459,43 b' class FileContentsManager(ContentsManager):'
 
     # public checkpoint API
 
-    def create_checkpoint(self, name, path=''):
+    def create_checkpoint(self, path):
         """Create a checkpoint from the current state of a file"""
         path = path.strip('/')
-        src_path = self._get_os_path(name, path)
+        src_path = self._get_os_path(path)
         # only the one checkpoint ID:
         checkpoint_id = u"checkpoint"
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
-        self.log.debug("creating checkpoint for %s", name)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
+        self.log.debug("creating checkpoint for %s", path)
         self._copy(src_path, cp_path)
 
         # return the checkpoint info
-        return self.get_checkpoint_model(checkpoint_id, name, path)
+        return self.get_checkpoint_model(checkpoint_id, path)
 
-    def list_checkpoints(self, name, path=''):
+    def list_checkpoints(self, path):
         """list the checkpoints for a given file
 
         This contents manager currently only supports one checkpoint per file.
         """
         path = path.strip('/')
         checkpoint_id = "checkpoint"
-        os_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        os_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.exists(os_path):
             return []
         else:
-            return [self.get_checkpoint_model(checkpoint_id, name, path)]
+            return [self.get_checkpoint_model(checkpoint_id, path)]
 
 
-    def restore_checkpoint(self, checkpoint_id, name, path=''):
+    def restore_checkpoint(self, checkpoint_id, path):
         """restore a file to a checkpointed state"""
         path = path.strip('/')
-        self.log.info("restoring %s from checkpoint %s", name, checkpoint_id)
-        nb_path = self._get_os_path(name, path)
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        self.log.info("restoring %s from checkpoint %s", path, checkpoint_id)
+        nb_path = self._get_os_path(path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(cp_path):
             self.log.debug("checkpoint file does not exist: %s", cp_path)
             raise web.HTTPError(404,
-                u'checkpoint does not exist: %s-%s' % (name, checkpoint_id)
+                u'checkpoint does not exist: %s@%s' % (path, checkpoint_id)
             )
         # ensure notebook is readable (never restore from an unreadable notebook)
         if cp_path.endswith('.ipynb'):
@@ -526,13 +504,13 b' class FileContentsManager(ContentsManager):'
         self._copy(cp_path, nb_path)
         self.log.debug("copying %s -> %s", cp_path, nb_path)
 
-    def delete_checkpoint(self, checkpoint_id, name, path=''):
+    def delete_checkpoint(self, checkpoint_id, path):
         """delete a file's checkpoint"""
         path = path.strip('/')
-        cp_path = self.get_checkpoint_path(checkpoint_id, name, path)
+        cp_path = self.get_checkpoint_path(checkpoint_id, path)
         if not os.path.isfile(cp_path):
             raise web.HTTPError(404,
-                u'Checkpoint does not exist: %s%s-%s' % (path, name, checkpoint_id)
+                u'Checkpoint does not exist: %s@%s' % (path, checkpoint_id)
             )
         self.log.debug("unlinking %s", cp_path)
         os.unlink(cp_path)
@@ -540,6 +518,10 b' class FileContentsManager(ContentsManager):'
     def info_string(self):
         return "Serving notebooks from local directory: %s" % self.root_dir
 
-    def get_kernel_path(self, name, path='', model=None):
+    def get_kernel_path(self, path, model=None):
         """Return the initial working dir a kernel associated with a given notebook"""
-        return os.path.join(self.root_dir, path)
+        if '/' in path:
+            os_dir = path.rsplit('/', 1)[0]
+        else:
+            os_dir = ''
+        return self._get_os_path(os_dir)

IPython/html/services/contents/handlers.py

@@ -10,9 +10,9 b' from tornado import web'
 from IPython.html.utils import url_path_join, url_escape
 from IPython.utils.jsonutil import date_default
 
-from IPython.html.base.handlers import (IPythonHandler, json_errors,
-                                    file_path_regex, path_regex,
-                                    file_name_regex)
+from IPython.html.base.handlers import (
+    IPythonHandler, json_errors, path_regex,
+)
 
 
 def sort_key(model):
@@ -29,38 +29,36 b' class ContentsHandler(IPythonHandler):'
 
     SUPPORTED_METHODS = (u'GET', u'PUT', u'PATCH', u'POST', u'DELETE')
 
-    def location_url(self, name, path):
+    def location_url(self, path):
         """Return the full URL location of a file.
 
         Parameters
         ----------
-        name : unicode
-            The base name of the file, such as "foo.ipynb".
         path : unicode
-            The API path of the file, such as "foo/bar".
+            The API path of the file, such as "foo/bar.txt".
         """
         return url_escape(url_path_join(
-            self.base_url, 'api', 'contents', path, name
+            self.base_url, 'api', 'contents', path
         ))
 
     def _finish_model(self, model, location=True):
         """Finish a JSON request with a model, setting relevant headers, etc."""
         if location:
-            location = self.location_url(model['name'], model['path'])
+            location = self.location_url(model['path'])
             self.set_header('Location', location)
         self.set_header('Last-Modified', model['last_modified'])
         self.finish(json.dumps(model, default=date_default))
 
     @web.authenticated
     @json_errors
-    def get(self, path='', name=None):
+    def get(self, path=''):
         """Return a model for a file or directory.
 
         A directory model contains a list of models (without content)
         of the files and directories it contains.
         """
         path = path or ''
-        model = self.contents_manager.get_model(name=name, path=path)
+        model = self.contents_manager.get_model(path=path)
         if model['type'] == 'directory':
             # group listing by type, then by name (case-insensitive)
             # FIXME: sorting should be done in the frontends
@@ -69,91 +67,71 b' class ContentsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def patch(self, path='', name=None):
-        """PATCH renames a notebook without re-uploading content."""
+    def patch(self, path=''):
+        """PATCH renames a file or directory without re-uploading content."""
         cm = self.contents_manager
-        if name is None:
-            raise web.HTTPError(400, u'Filename missing')
         model = self.get_json_body()
         if model is None:
             raise web.HTTPError(400, u'JSON body missing')
-        model = cm.update(model, name, path)
+        print('before', model)
+        model = cm.update(model, path)
+        print('after', model)
         self._finish_model(model)
 
-    def _copy(self, copy_from, path, copy_to=None):
-        """Copy a file, optionally specifying the new name.
+    def _copy(self, copy_from, copy_to=None):
+        """Copy a file, optionally specifying the new path.
         """
-        self.log.info(u"Copying {copy_from} to {path}/{copy_to}".format(
+        self.log.info(u"Copying {copy_from} to {copy_to}".format(
             copy_from=copy_from,
-            path=path,
             copy_to=copy_to or '',
         ))
-        model = self.contents_manager.copy(copy_from, copy_to, path)
+        model = self.contents_manager.copy(copy_from, copy_to)
         self.set_status(201)
         self._finish_model(model)
 
-    def _upload(self, model, path, name=None):
-        """Handle upload of a new file
-
-        If name specified, create it in path/name,
-        otherwise create a new untitled file in path.
-        """
-        self.log.info(u"Uploading file to %s/%s", path, name or '')
-        if name:
-            model['name'] = name
-
+    def _upload(self, model, path):
+        """Handle upload of a new file to path"""
+        self.log.info(u"Uploading file to %s", path)
         model = self.contents_manager.create_file(model, path)
         self.set_status(201)
         self._finish_model(model)
 
-    def _create_empty_file(self, path, name=None, ext='.ipynb'):
+    def _create_empty_file(self, path, ext='.ipynb'):
         """Create an empty file in path
 
-        If name specified, create it in path/name.
+        If name specified, create it in path.
         """
-        self.log.info(u"Creating new file in %s/%s", path, name or '')
-        model = {}
-        if name:
-            model['name'] = name
-        model = self.contents_manager.create_file(model, path=path, ext=ext)
+        self.log.info(u"Creating new file in %s", path)
+        model = self.contents_manager.create_file(path=path, ext=ext)
         self.set_status(201)
         self._finish_model(model)
 
-    def _save(self, model, path, name):
+    def _save(self, model, path):
         """Save an existing file."""
-        self.log.info(u"Saving file at %s/%s", path, name)
-        model = self.contents_manager.save(model, name, path)
-        if model['path'] != path.strip('/') or model['name'] != name:
-            # a rename happened, set Location header
-            location = True
-        else:
-            location = False
-        self._finish_model(model, location)
+        self.log.info(u"Saving file at %s", path)
+        model = self.contents_manager.save(model, path)
+        self._finish_model(model)
 
     @web.authenticated
     @json_errors
-    def post(self, path='', name=None):
+    def post(self, path=''):
         """Create a new file or directory in the specified path.
 
         POST creates new files or directories. The server always decides on the name.
 
         POST /api/contents/path
-          New untitled notebook in path. If content specified, upload a
-          notebook, otherwise start empty.
+          New untitled, empty file or directory.
         POST /api/contents/path
-          with body {"copy_from" : "OtherNotebook.ipynb"}
+          with body {"copy_from" : "/path/to/OtherNotebook.ipynb"}
           New copy of OtherNotebook in path
         """
 
-        if name is not None:
-            path = u'{}/{}'.format(path, name)
-
         cm = self.contents_manager
 
         if cm.file_exists(path):
             raise web.HTTPError(400, "Cannot POST to existing files, use PUT instead.")
 
-        if not cm.path_exists(path):
+        if not cm.dir_exists(path):
             raise web.HTTPError(404, "No such directory: %s" % path)
 
         model = self.get_json_body()
@@ -161,11 +139,7 b' class ContentsHandler(IPythonHandler):'
         if model is not None:
             copy_from = model.get('copy_from')
             ext = model.get('ext', '.ipynb')
-            if model.get('content') is not None:
-                if copy_from:
-                    raise web.HTTPError(400, "Can't upload and copy at the same time.")
-                self._upload(model, path)
-            elif copy_from:
+            if copy_from:
                 self._copy(copy_from, path)
             else:
                 self._create_empty_file(path, ext=ext)
@@ -174,7 +148,7 b' class ContentsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def put(self, path='', name=None):
+    def put(self, path=''):
         """Saves the file in the location specified by name and path.
 
         PUT is very similar to POST, but the requester specifies the name,
@@ -193,30 +167,27 b' class ContentsHandler(IPythonHandler):'
 
           Copy OtherNotebook to Name
         """
-        if name is None:
-            raise web.HTTPError(400, "name must be specified with PUT.")
-
         model = self.get_json_body()
         if model:
             copy_from = model.get('copy_from')
             if copy_from:
                 if model.get('content'):
                     raise web.HTTPError(400, "Can't upload and copy at the same time.")
-                self._copy(copy_from, path, name)
-            elif self.contents_manager.file_exists(name, path):
-                self._save(model, path, name)
+                self._copy(copy_from, path)
+            elif self.contents_manager.file_exists(path):
+                self._save(model, path)
             else:
-                self._upload(model, path, name)
+                self._upload(model, path)
         else:
-            self._create_empty_file(path, name)
+            self._create_empty_file(path)
 
     @web.authenticated
     @json_errors
-    def delete(self, path='', name=None):
+    def delete(self, path=''):
         """delete a file in the given path"""
         cm = self.contents_manager
-        self.log.warn('delete %s:%s', path, name)
-        cm.delete(name, path)
+        self.log.warn('delete %s', path)
+        cm.delete(path)
         self.set_status(204)
         self.finish()
 
@@ -227,22 +198,22 b' class CheckpointsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def get(self, path='', name=None):
+    def get(self, path=''):
         """get lists checkpoints for a file"""
         cm = self.contents_manager
-        checkpoints = cm.list_checkpoints(name, path)
+        checkpoints = cm.list_checkpoints(path)
         data = json.dumps(checkpoints, default=date_default)
         self.finish(data)
 
     @web.authenticated
     @json_errors
-    def post(self, path='', name=None):
+    def post(self, path=''):
         """post creates a new checkpoint"""
         cm = self.contents_manager
-        checkpoint = cm.create_checkpoint(name, path)
+        checkpoint = cm.create_checkpoint(path)
         data = json.dumps(checkpoint, default=date_default)
         location = url_path_join(self.base_url, 'api/contents',
-            path, name, 'checkpoints', checkpoint['id'])
+            path, 'checkpoints', checkpoint['id'])
         self.set_header('Location', url_escape(location))
         self.set_status(201)
         self.finish(data)
@@ -254,19 +225,19 b' class ModifyCheckpointsHandler(IPythonHandler):'
 
     @web.authenticated
     @json_errors
-    def post(self, path, name, checkpoint_id):
+    def post(self, path, checkpoint_id):
         """post restores a file from a checkpoint"""
         cm = self.contents_manager
-        cm.restore_checkpoint(checkpoint_id, name, path)
+        cm.restore_checkpoint(checkpoint_id, path)
         self.set_status(204)
         self.finish()
 
     @web.authenticated
     @json_errors
-    def delete(self, path, name, checkpoint_id):
+    def delete(self, path, checkpoint_id):
         """delete clears a checkpoint for a given file"""
         cm = self.contents_manager
-        cm.delete_checkpoint(checkpoint_id, name, path)
+        cm.delete_checkpoint(checkpoint_id, path)
         self.set_status(204)
         self.finish()
 
@@ -294,10 +265,9 b' class NotebooksRedirectHandler(IPythonHandler):'
 _checkpoint_id_regex = r"(?P<checkpoint_id>[\w-]+)"
 
 default_handlers = [
-    (r"/api/contents%s/checkpoints" % file_path_regex, CheckpointsHandler),
-    (r"/api/contents%s/checkpoints/%s" % (file_path_regex, _checkpoint_id_regex),
+    (r"/api/contents%s/checkpoints" % path_regex, CheckpointsHandler),
+    (r"/api/contents%s/checkpoints/%s" % (path_regex, _checkpoint_id_regex),
         ModifyCheckpointsHandler),
-    (r"/api/contents%s" % file_path_regex, ContentsHandler),
     (r"/api/contents%s" % path_regex, ContentsHandler),
     (r"/api/notebooks/?(.*)", NotebooksRedirectHandler),
 ]

IPython/html/services/contents/manager.py

@@ -33,14 +33,6 b' class ContentsManager(LoggingConfigurable):'
     - if unspecified, path defaults to '',
       indicating the root path.
 
-    name is also unicode, and refers to a specfic target:
-
-    - unicode, not url-escaped
-    - must not contain '/'
-    - It refers to an individual filename
-    - It may refer to a directory name,
-      in the case of listing or creating directories.
-
     """
 
     notary = Instance(sign.NotebookNotary)
@@ -69,7 +61,7 b' class ContentsManager(LoggingConfigurable):'
     # ContentsManager API part 1: methods that must be
     # implemented in subclasses.
 
-    def path_exists(self, path):
+    def dir_exists(self, path):
         """Does the API-style path (directory) actually exist?
 
         Like os.path.isdir
@@ -105,8 +97,8 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError
 
-    def file_exists(self, name, path=''):
-        """Does a file exist at the given name and path?
+    def file_exists(self, path=''):
+        """Does a file exist at the given path?
 
         Like os.path.isfile
 
@@ -126,15 +118,13 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError('must be implemented in a subclass')
 
-    def exists(self, name, path=''):
+    def exists(self, path):
         """Does a file or directory exist at the given name and path?
 
         Like os.path.exists
 
         Parameters
         ----------
-        name : string
-            The name of the file you are checking.
         path : string
             The relative path to the file's directory (with '/' as separator)
 
@@ -143,17 +133,17 b' class ContentsManager(LoggingConfigurable):'
         exists : bool
             Whether the target exists.
         """
-        return self.file_exists(name, path) or self.path_exists("%s/%s" % (path, name))
+        return self.file_exists(path) or self.dir_exists(path)
 
-    def get_model(self, name, path='', content=True):
+    def get_model(self, path, content=True):
         """Get the model of a file or directory with or without content."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def save(self, model, name, path=''):
+    def save(self, model, path):
         """Save the file or directory and return the model with no content."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def update(self, model, name, path=''):
+    def update(self, model, path):
         """Update the file or directory and return the model with no content.
 
         For use in PATCH requests, to enable renaming a file without
@@ -161,26 +151,26 b' class ContentsManager(LoggingConfigurable):'
         """
         raise NotImplementedError('must be implemented in a subclass')
 
-    def delete(self, name, path=''):
-        """Delete file or directory by name and path."""
+    def delete(self, path):
+        """Delete file or directory by path."""
         raise NotImplementedError('must be implemented in a subclass')
 
-    def create_checkpoint(self, name, path=''):
+    def create_checkpoint(self, path):
         """Create a checkpoint of the current state of a file
 
         Returns a checkpoint_id for the new checkpoint.
         """
         raise NotImplementedError("must be implemented in a subclass")
 
-    def list_checkpoints(self, name, path=''):
+    def list_checkpoints(self, path):
         """Return a list of checkpoints for a given file"""
         return []
 
-    def restore_checkpoint(self, checkpoint_id, name, path=''):
+    def restore_checkpoint(self, checkpoint_id, path):
         """Restore a file from one of its checkpoints"""
         raise NotImplementedError("must be implemented in a subclass")
 
-    def delete_checkpoint(self, checkpoint_id, name, path=''):
+    def delete_checkpoint(self, checkpoint_id, path):
         """delete a checkpoint for a file"""
         raise NotImplementedError("must be implemented in a subclass")
 
@@ -190,7 +180,7 b' class ContentsManager(LoggingConfigurable):'
     def info_string(self):
         return "Serving contents"
 
-    def get_kernel_path(self, name, path='', model=None):
+    def get_kernel_path(self, path, model=None):
         """ Return the path to start kernel in """
         return path
 
@@ -214,7 +204,7 b' class ContentsManager(LoggingConfigurable):'
         for i in itertools.count():
             name = u'{basename}{i}{ext}'.format(basename=basename, i=i,
                                                 ext=ext)
-            if not self.file_exists(name, path):
+            if not self.file_exists('{}/{}'.format(path, name)):
                 break
         return name
 
@@ -233,6 +223,8 b' class ContentsManager(LoggingConfigurable):'
         path = path.strip('/')
         if model is None:
             model = {}
+        else:
+            model.pop('path', None)
         if 'content' not in model and model.get('type', None) != 'directory':
             if ext == '.ipynb':
                 model['content'] = new_notebook()
@@ -242,7 +234,7 b' class ContentsManager(LoggingConfigurable):'
                 model['content'] = ''
                 model['type'] = 'file'
                 model['format'] = 'text'
-        if 'name' not in model:
+        if self.dir_exists(path):
             if model['type'] == 'directory':
                 untitled = self.untitled_directory
             elif model['type'] == 'notebook':
@@ -251,13 +243,13 b' class ContentsManager(LoggingConfigurable):'
                 untitled = self.untitled_file
             else:
                 raise HTTPError(400, "Unexpected model type: %r" % model['type'])
-            model['name'] = self.increment_filename(untitled + ext, path)
-
-        model['path'] = path
-        model = self.save(model, model['name'], model['path'])
+            
+            name = self.increment_filename(untitled + ext, path)
+            path = '{0}/{1}'.format(path, name)
+        model = self.save(model, path)
         return model
 
-    def copy(self, from_name, to_name=None, path=''):
+    def copy(self, from_path, to_path=None):
         """Copy an existing file and return its new model.
 
         If to_name not specified, increment `from_name-Copy#.ext`.
@@ -265,43 +257,48 b' class ContentsManager(LoggingConfigurable):'
         copy_from can be a full path to a file,
         or just a base name. If a base name, `path` is used.
         """
-        path = path.strip('/')
-        if '/' in from_name:
-            from_path, from_name = from_name.rsplit('/', 1)
+        path = from_path.strip('/')
+        if '/' in path:
+            from_dir, from_name = path.rsplit('/', 1)
         else:
-            from_path = path
-        model = self.get_model(from_name, from_path)
+            from_dir = ''
+            from_name = path
+        
+        model = self.get_model(path)
+        model.pop('path', None)
+        model.pop('name', None)
         if model['type'] == 'directory':
             raise HTTPError(400, "Can't copy directories")
-        if not to_name:
+        
+        if not to_path:
+            to_path = from_dir
+        if self.dir_exists(to_path):
             base, ext = os.path.splitext(from_name)
             copy_name = u'{0}-Copy{1}'.format(base, ext)
-            to_name = self.increment_filename(copy_name, path)
-        model['name'] = to_name
-        model['path'] = path
-        model = self.save(model, to_name, path)
+            to_name = self.increment_filename(copy_name, to_path)
+            to_path = '{0}/{1}'.format(to_path, to_name)
+        
+        model = self.save(model, to_path)
         return model
 
     def log_info(self):
         self.log.info(self.info_string())
 
-    def trust_notebook(self, name, path=''):
+    def trust_notebook(self, path):
         """Explicitly trust a notebook
 
         Parameters
         ----------
-        name : string
-            The filename of the notebook
         path : string
-            The notebook's directory
+            The path of a notebook
         """
-        model = self.get_model(name, path)
+        model = self.get_model(path)
         nb = model['content']
-        self.log.warn("Trusting notebook %s/%s", path, name)
+        self.log.warn("Trusting notebook %s", path)
         self.notary.mark_cells(nb, True)
-        self.save(model, name, path)
+        self.save(model, path)
 
-    def check_and_sign(self, nb, name='', path=''):
+    def check_and_sign(self, nb, path=''):
         """Check for trusted cells, and sign the notebook.
 
         Called as a part of saving notebooks.
@@ -310,17 +307,15 b' class ContentsManager(LoggingConfigurable):'
         ----------
         nb : dict
             The notebook dict
-        name : string
-            The filename of the notebook (for logging)
         path : string
-            The notebook's directory (for logging)
+            The notebook's path (for logging)
         """
         if self.notary.check_cells(nb):
             self.notary.sign(nb)
         else:
-            self.log.warn("Saving untrusted notebook %s/%s", path, name)
+            self.log.warn("Saving untrusted notebook %s", path)
 
-    def mark_trusted_cells(self, nb, name='', path=''):
+    def mark_trusted_cells(self, nb, path=''):
         """Mark cells as trusted if the notebook signature matches.
 
         Called as a part of loading notebooks.
@@ -329,14 +324,12 b' class ContentsManager(LoggingConfigurable):'
         ----------
         nb : dict
             The notebook object (in current nbformat)
-        name : string
-            The filename of the notebook (for logging)
         path : string
             The notebook's directory (for logging)
         """
         trusted = self.notary.check_signature(nb)
         if not trusted:
-            self.log.warn("Notebook %s/%s is not trusted", path, name)
+            self.log.warn("Notebook %s is not trusted", path)
         self.notary.mark_cells(nb, trusted)
 
     def should_list(self, name):

IPython/html/services/contents/tests/test_contents_api.py

@@ -46,8 +46,8 b' class API(object):'
     def list(self, path='/'):
         return self._req('GET', path)
 
-    def read(self, name, path='/'):
-        return self._req('GET', url_path_join(path, name))
+    def read(self, path):
+        return self._req('GET', path)
 
     def create_untitled(self, path='/', ext=None):
         body = None
@@ -55,47 +55,44 b' class API(object):'
             body = json.dumps({'ext': ext})
         return self._req('POST', path, body)
 
-    def upload_untitled(self, body, path='/'):
-        return self._req('POST', path, body)
-
     def copy_untitled(self, copy_from, path='/'):
         body = json.dumps({'copy_from':copy_from})
         return self._req('POST', path, body)
 
-    def create(self, name, path='/'):
-        return self._req('PUT', url_path_join(path, name))
+    def create(self, path='/'):
+        return self._req('PUT', path)
 
-    def upload(self, name, body, path='/'):
-        return self._req('PUT', url_path_join(path, name), body)
+    def upload(self, path, body):
+        return self._req('PUT', path, body)
 
-    def mkdir(self, name, path='/'):
-        return self._req('PUT', url_path_join(path, name), json.dumps({'type': 'directory'}))
+    def mkdir(self, path='/'):
+        return self._req('PUT', path, json.dumps({'type': 'directory'}))
 
-    def copy(self, copy_from, copy_to, path='/'):
+    def copy(self, copy_from, path):
         body = json.dumps({'copy_from':copy_from})
-        return self._req('PUT', url_path_join(path, copy_to), body)
+        return self._req('PUT', path, body)
 
-    def save(self, name, body, path='/'):
-        return self._req('PUT', url_path_join(path, name), body)
+    def save(self, path, body):
+        return self._req('PUT', path, body)
 
-    def delete(self, name, path='/'):
-        return self._req('DELETE', url_path_join(path, name))
+    def delete(self, path='/'):
+        return self._req('DELETE', path)
 
-    def rename(self, name, path, new_name):
-        body = json.dumps({'name': new_name})
-        return self._req('PATCH', url_path_join(path, name), body)
+    def rename(self, path, new_path):
+        body = json.dumps({'path': new_path})
+        return self._req('PATCH', path, body)
 
-    def get_checkpoints(self, name, path):
-        return self._req('GET', url_path_join(path, name, 'checkpoints'))
+    def get_checkpoints(self,  path):
+        return self._req('GET', url_path_join(path, 'checkpoints'))
 
-    def new_checkpoint(self, name, path):
-        return self._req('POST', url_path_join(path, name, 'checkpoints'))
+    def new_checkpoint(self,  path):
+        return self._req('POST', url_path_join(path, 'checkpoints'))
 
-    def restore_checkpoint(self, name, path, checkpoint_id):
-        return self._req('POST', url_path_join(path, name, 'checkpoints', checkpoint_id))
+    def restore_checkpoint(self, path, checkpoint_id):
+        return self._req('POST', url_path_join(path, 'checkpoints', checkpoint_id))
 
-    def delete_checkpoint(self, name, path, checkpoint_id):
-        return self._req('DELETE', url_path_join(path, name, 'checkpoints', checkpoint_id))
+    def delete_checkpoint(self, path, checkpoint_id):
+        return self._req('DELETE', url_path_join(path, 'checkpoints', checkpoint_id))
 
 class APITest(NotebookTestBase):
     """Test the kernels web service API"""
@@ -131,8 +128,6 b' class APITest(NotebookTestBase):'
         self.blob = os.urandom(100)
         self.b64_blob = base64.encodestring(self.blob).decode('ascii')
 
-
-
         for d in (self.dirs + self.hidden_dirs):
             d.replace('/', os.sep)
             if not os.path.isdir(pjoin(nbdir, d)):
@@ -178,12 +173,12 b' class APITest(NotebookTestBase):'
         nbs = notebooks_only(self.api.list(u'/unicodé/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'innonascii.ipynb')
-        self.assertEqual(nbs[0]['path'], u'unicodé')
+        self.assertEqual(nbs[0]['path'], u'unicodé/innonascii.ipynb')
 
         nbs = notebooks_only(self.api.list('/foo/bar/').json())
         self.assertEqual(len(nbs), 1)
         self.assertEqual(nbs[0]['name'], 'baz.ipynb')
-        self.assertEqual(nbs[0]['path'], 'foo/bar')
+        self.assertEqual(nbs[0]['path'], 'foo/bar/baz.ipynb')
 
         nbs = notebooks_only(self.api.list('foo').json())
         self.assertEqual(len(nbs), 4)
@@ -208,8 +203,10 b' class APITest(NotebookTestBase):'
 
     def test_get_nb_contents(self):
         for d, name in self.dirs_nbs:
-            nb = self.api.read('%s.ipynb' % name, d+'/').json()
+            path = url_path_join(d, name + '.ipynb')
+            nb = self.api.read(path).json()
             self.assertEqual(nb['name'], u'%s.ipynb' % name)
+            self.assertEqual(nb['path'], path)
             self.assertEqual(nb['type'], 'notebook')
             self.assertIn('content', nb)
             self.assertEqual(nb['format'], 'json')
@@ -220,12 +217,14 b' class APITest(NotebookTestBase):'
     def test_get_contents_no_such_file(self):
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.ipynb', 'foo')
+            self.api.read('foo/q.ipynb')
 
     def test_get_text_file_contents(self):
         for d, name in self.dirs_nbs:
-            model = self.api.read(u'%s.txt' % name, d+'/').json()
+            path = url_path_join(d, name + '.txt')
+            model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.txt' % name)
+            self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'text')
             self.assertEqual(model['type'], 'file')
@@ -233,12 +232,14 b' class APITest(NotebookTestBase):'
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.txt', 'foo')
+            self.api.read('foo/q.txt')
 
     def test_get_binary_file_contents(self):
         for d, name in self.dirs_nbs:
-            model = self.api.read(u'%s.blob' % name, d+'/').json()
+            path = url_path_join(d, name + '.blob')
+            model = self.api.read(path).json()
             self.assertEqual(model['name'], u'%s.blob' % name)
+            self.assertEqual(model['path'], path)
             self.assertIn('content', model)
             self.assertEqual(model['format'], 'base64')
             self.assertEqual(model['type'], 'file')
@@ -247,66 +248,59 b' class APITest(NotebookTestBase):'
 
         # Name that doesn't exist - should be a 404
         with assert_http_error(404):
-            self.api.read('q.txt', 'foo')
+            self.api.read('foo/q.txt')
 
-    def _check_created(self, resp, name, path, type='notebook'):
+    def _check_created(self, resp, path, type='notebook'):
         self.assertEqual(resp.status_code, 201)
         location_header = py3compat.str_to_unicode(resp.headers['Location'])
-        self.assertEqual(location_header, url_escape(url_path_join(u'/api/contents', path, name)))
+        self.assertEqual(location_header, url_escape(url_path_join(u'/api/contents', path)))
         rjson = resp.json()
-        self.assertEqual(rjson['name'], name)
+        self.assertEqual(rjson['name'], path.rsplit('/', 1)[-1])
         self.assertEqual(rjson['path'], path)
         self.assertEqual(rjson['type'], type)
         isright = os.path.isdir if type == 'directory' else os.path.isfile
         assert isright(pjoin(
             self.notebook_dir.name,
             path.replace('/', os.sep),
-            name,
         ))
 
     def test_create_untitled(self):
         resp = self.api.create_untitled(path=u'å b')
-        self._check_created(resp, 'Untitled0.ipynb', u'å b')
+        self._check_created(resp, u'å b/Untitled0.ipynb')
 
         # Second time
         resp = self.api.create_untitled(path=u'å b')
-        self._check_created(resp, 'Untitled1.ipynb', u'å b')
+        self._check_created(resp, u'å b/Untitled1.ipynb')
 
         # And two directories down
         resp = self.api.create_untitled(path='foo/bar')
-        self._check_created(resp, 'Untitled0.ipynb', 'foo/bar')
+        self._check_created(resp, 'foo/bar/Untitled0.ipynb')
 
     def test_create_untitled_txt(self):
         resp = self.api.create_untitled(path='foo/bar', ext='.txt')
-        self._check_created(resp, 'untitled0.txt', 'foo/bar', type='file')
+        self._check_created(resp, 'foo/bar/untitled0.txt', type='file')
 
-        resp = self.api.read(path='foo/bar', name='untitled0.txt')
+        resp = self.api.read(path='foo/bar/untitled0.txt')
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
         self.assertEqual(model['content'], '')
 
-    def test_upload_untitled(self):
-        nb = new_notebook()
-        nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload_untitled(path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, 'Untitled0.ipynb', u'å b')
-
     def test_upload(self):
         nb = new_notebook()
         nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload(u'Upload tést.ipynb', path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, u'Upload tést.ipynb', u'å b')
+        path = u'å b/Upload tést.ipynb'
+        resp = self.api.upload(path, body=json.dumps(nbmodel))
+        self._check_created(resp, path)
 
     def test_mkdir(self):
-        resp = self.api.mkdir(u'New ∂ir', path=u'å b')
-        self._check_created(resp, u'New ∂ir', u'å b', type='directory')
+        path = u'å b/New ∂ir'
+        resp = self.api.mkdir(path)
+        self._check_created(resp, path, type='directory')
 
     def test_mkdir_hidden_400(self):
         with assert_http_error(400):
-            resp = self.api.mkdir(u'.hidden', path=u'å b')
+            resp = self.api.mkdir(u'å b/.hidden')
 
     def test_upload_txt(self):
         body = u'ünicode téxt'
@@ -315,11 +309,11 b' class APITest(NotebookTestBase):'
             'format'  : 'text',
             'type'    : 'file',
         }
-        resp = self.api.upload(u'Upload tést.txt', path=u'å b',
-                                              body=json.dumps(model))
+        path = u'å b/Upload tést.txt'
+        resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
-        resp = self.api.read(path=u'å b', name=u'Upload tést.txt')
+        resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
         self.assertEqual(model['format'], 'text')
@@ -333,13 +327,14 b' class APITest(NotebookTestBase):'
             'format'  : 'base64',
             'type'    : 'file',
         }
-        resp = self.api.upload(u'Upload tést.blob', path=u'å b',
-                                              body=json.dumps(model))
+        path = u'å b/Upload tést.blob'
+        resp = self.api.upload(path, body=json.dumps(model))
 
         # check roundtrip
-        resp = self.api.read(path=u'å b', name=u'Upload tést.blob')
+        resp = self.api.read(path)
         model = resp.json()
         self.assertEqual(model['type'], 'file')
+        self.assertEqual(model['path'], path)
         self.assertEqual(model['format'], 'base64')
         decoded = base64.decodestring(model['content'].encode('ascii'))
         self.assertEqual(decoded, body)
@@ -350,24 +345,27 b' class APITest(NotebookTestBase):'
         nb.worksheets.append(ws)
         ws.cells.append(v2.new_code_cell(input='print("hi")'))
         nbmodel = {'content': nb, 'type': 'notebook'}
-        resp = self.api.upload(u'Upload tést.ipynb', path=u'å b',
-                                              body=json.dumps(nbmodel))
-        self._check_created(resp, u'Upload tést.ipynb', u'å b')
-        resp = self.api.read(u'Upload tést.ipynb', u'å b')
+        path = u'å b/Upload tést.ipynb'
+        resp = self.api.upload(path, body=json.dumps(nbmodel))
+        self._check_created(resp, path)
+        resp = self.api.read(path)
         data = resp.json()
         self.assertEqual(data['content']['nbformat'], 4)
 
     def test_copy_untitled(self):
-        resp = self.api.copy_untitled(u'ç d.ipynb', path=u'å b')
-        self._check_created(resp, u'ç d-Copy0.ipynb', u'å b')
+        resp = self.api.copy_untitled(u'å b/ç d.ipynb', u'unicodé')
+        self._check_created(resp, u'unicodé/ç d-Copy0.ipynb')
+        
+        resp = self.api.copy_untitled(u'å b/ç d.ipynb', u'å b')
+        self._check_created(resp, u'å b/ç d-Copy0.ipynb')
 
     def test_copy(self):
-        resp = self.api.copy(u'ç d.ipynb', u'cøpy.ipynb', path=u'å b')
-        self._check_created(resp, u'cøpy.ipynb', u'å b')
+        resp = self.api.copy(u'å b/ç d.ipynb', u'å b/cøpy.ipynb')
+        self._check_created(resp, u'å b/cøpy.ipynb')
 
     def test_copy_path(self):
-        resp = self.api.copy(u'foo/a.ipynb', u'cøpyfoo.ipynb', path=u'å b')
-        self._check_created(resp, u'cøpyfoo.ipynb', u'å b')
+        resp = self.api.copy(u'foo/a.ipynb', u'å b/cøpyfoo.ipynb')
+        self._check_created(resp, u'å b/cøpyfoo.ipynb')
 
     def test_copy_dir_400(self):
         # can't copy directories
@@ -376,19 +374,23 b' class APITest(NotebookTestBase):'
 
     def test_delete(self):
         for d, name in self.dirs_nbs:
-            resp = self.api.delete('%s.ipynb' % name, d)
+            print('%r, %r' % (d, name))
+            resp = self.api.delete(url_path_join(d, name + '.ipynb'))
             self.assertEqual(resp.status_code, 204)
 
         for d in self.dirs + ['/']:
             nbs = notebooks_only(self.api.list(d).json())
-            self.assertEqual(len(nbs), 0)
+            print('------')
+            print(d)
+            print(nbs)
+            self.assertEqual(nbs, [])
 
     def test_delete_dirs(self):
         # depth-first delete everything, so we don't try to delete empty directories
         for name in sorted(self.dirs + ['/'], key=len, reverse=True):
             listing = self.api.list(name).json()['content']
             for model in listing:
-                self.api.delete(model['name'], model['path'])
+                self.api.delete(model['path'])
         listing = self.api.list('/').json()['content']
         self.assertEqual(listing, [])
 
@@ -398,9 +400,10 b' class APITest(NotebookTestBase):'
             self.api.delete(u'å b')
 
     def test_rename(self):
-        resp = self.api.rename('a.ipynb', 'foo', 'z.ipynb')
+        resp = self.api.rename('foo/a.ipynb', 'foo/z.ipynb')
         self.assertEqual(resp.headers['Location'].split('/')[-1], 'z.ipynb')
         self.assertEqual(resp.json()['name'], 'z.ipynb')
+        self.assertEqual(resp.json()['path'], 'foo/z.ipynb')
         assert os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'z.ipynb'))
 
         nbs = notebooks_only(self.api.list('foo').json())
@@ -410,41 +413,31 b' class APITest(NotebookTestBase):'
 
     def test_rename_existing(self):
         with assert_http_error(409):
-            self.api.rename('a.ipynb', 'foo', 'b.ipynb')
+            self.api.rename('foo/a.ipynb', 'foo/b.ipynb')
 
     def test_save(self):
-        resp = self.api.read('a.ipynb', 'foo')
+        resp = self.api.read('foo/a.ipynb')
         nbcontent = json.loads(resp.text)['content']
         nb = from_dict(nbcontent)
         nb.cells.append(new_markdown_cell(u'Created by test ³'))
 
-        nbmodel= {'name': 'a.ipynb', 'path':'foo', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
+        nbmodel= {'content': nb, 'type': 'notebook'}
+        resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         nbfile = pjoin(self.notebook_dir.name, 'foo', 'a.ipynb')
         with io.open(nbfile, 'r', encoding='utf-8') as f:
             newnb = read(f, as_version=4)
         self.assertEqual(newnb.cells[0].source,
                          u'Created by test ³')
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
         newnb = from_dict(nbcontent)
         self.assertEqual(newnb.cells[0].source,
                          u'Created by test ³')
 
-        # Save and rename
-        nbmodel= {'name': 'a2.ipynb', 'path':'foo/bar', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
-        saved = resp.json()
-        self.assertEqual(saved['name'], 'a2.ipynb')
-        self.assertEqual(saved['path'], 'foo/bar')
-        assert os.path.isfile(pjoin(self.notebook_dir.name,'foo','bar','a2.ipynb'))
-        assert not os.path.isfile(pjoin(self.notebook_dir.name, 'foo', 'a.ipynb'))
-        with assert_http_error(404):
-            self.api.read('a.ipynb', 'foo')
 
     def test_checkpoints(self):
-        resp = self.api.read('a.ipynb', 'foo')
-        r = self.api.new_checkpoint('a.ipynb', 'foo')
+        resp = self.api.read('foo/a.ipynb')
+        r = self.api.new_checkpoint('foo/a.ipynb')
         self.assertEqual(r.status_code, 201)
         cp1 = r.json()
         self.assertEqual(set(cp1), {'id', 'last_modified'})
@@ -456,26 +449,26 b' class APITest(NotebookTestBase):'
         hcell = new_markdown_cell('Created by test')
         nb.cells.append(hcell)
         # Save
-        nbmodel= {'name': 'a.ipynb', 'path':'foo', 'content': nb, 'type': 'notebook'}
-        resp = self.api.save('a.ipynb', path='foo', body=json.dumps(nbmodel))
+        nbmodel= {'content': nb, 'type': 'notebook'}
+        resp = self.api.save('foo/a.ipynb', body=json.dumps(nbmodel))
 
         # List checkpoints
-        cps = self.api.get_checkpoints('a.ipynb', 'foo').json()
+        cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [cp1])
 
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
         nb = from_dict(nbcontent)
         self.assertEqual(nb.cells[0].source, 'Created by test')
 
         # Restore cp1
-        r = self.api.restore_checkpoint('a.ipynb', 'foo', cp1['id'])
+        r = self.api.restore_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
-        nbcontent = self.api.read('a.ipynb', 'foo').json()['content']
+        nbcontent = self.api.read('foo/a.ipynb').json()['content']
         nb = from_dict(nbcontent)
         self.assertEqual(nb.cells, [])
 
         # Delete cp1
-        r = self.api.delete_checkpoint('a.ipynb', 'foo', cp1['id'])
+        r = self.api.delete_checkpoint('foo/a.ipynb', cp1['id'])
         self.assertEqual(r.status_code, 204)
-        cps = self.api.get_checkpoints('a.ipynb', 'foo').json()
+        cps = self.api.get_checkpoints('foo/a.ipynb').json()
         self.assertEqual(cps, [])

IPython/html/services/contents/tests/test_manager.py

@@ -42,7 +42,7 b' class TestFileContentsManager(TestCase):'
         with TemporaryDirectory() as td:
             root = td
             fm = FileContentsManager(root_dir=root)
-            path = fm._get_os_path('test.ipynb', '/path/to/notebook/')
+            path = fm._get_os_path('/path/to/notebook/test.ipynb')
             rel_path_list =  '/path/to/notebook/test.ipynb'.split('/')
             fs_path = os.path.join(fm.root_dir, *rel_path_list)
             self.assertEqual(path, fs_path)
@@ -53,7 +53,7 b' class TestFileContentsManager(TestCase):'
             self.assertEqual(path, fs_path)
 
             fm = FileContentsManager(root_dir=root)
-            path = fm._get_os_path('test.ipynb', '////')
+            path = fm._get_os_path('////test.ipynb')
             fs_path = os.path.join(fm.root_dir, 'test.ipynb')
             self.assertEqual(path, fs_path)
 
@@ -64,8 +64,8 b' class TestFileContentsManager(TestCase):'
             root = td
             os.mkdir(os.path.join(td, subd))
             fm = FileContentsManager(root_dir=root)
-            cp_dir = fm.get_checkpoint_path('cp', 'test.ipynb', '/')
-            cp_subdir = fm.get_checkpoint_path('cp', 'test.ipynb', '/%s/' % subd)
+            cp_dir = fm.get_checkpoint_path('cp', 'test.ipynb')
+            cp_subdir = fm.get_checkpoint_path('cp', '/%s/test.ipynb' % subd)
         self.assertNotEqual(cp_dir, cp_subdir)
         self.assertEqual(cp_dir, os.path.join(root, fm.checkpoint_dir, cp_name))
         self.assertEqual(cp_subdir, os.path.join(root, subd, fm.checkpoint_dir, cp_name))
@@ -105,11 +105,11 b' class TestContentsManager(TestCase):'
         name = model['name']
         path = model['path']
 
-        full_model = cm.get_model(name, path)
+        full_model = cm.get_model(path)
         nb = full_model['content']
         self.add_code_cell(nb)
 
-        cm.save(full_model, name, path)
+        cm.save(full_model, path)
         return nb, name, path
 
     def test_create_file(self):
@@ -120,17 +120,17 b' class TestContentsManager(TestCase):'
         self.assertIn('name', model)
         self.assertIn('path', model)
         self.assertEqual(model['name'], 'Untitled0.ipynb')
-        self.assertEqual(model['path'], '')
+        self.assertEqual(model['path'], 'Untitled0.ipynb')
 
         # Test in sub-directory
         sub_dir = '/foo/'
         self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
+        model = cm.create_file(path=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.strip('/'))
+        self.assertEqual(model['path'], 'foo/Untitled0.ipynb')
 
     def test_get(self):
         cm = self.contents_manager
@@ -140,7 +140,7 b' class TestContentsManager(TestCase):'
         path = model['path']
 
         # Check that we 'get' on the notebook we just created
-        model2 = cm.get_model(name, path)
+        model2 = cm.get_model(path)
         assert isinstance(model2, dict)
         self.assertIn('name', model2)
         self.assertIn('path', model2)
@@ -150,14 +150,14 b' class TestContentsManager(TestCase):'
         # Test in sub-directory
         sub_dir = '/foo/'
         self.make_dir(cm.root_dir, 'foo')
-        model = cm.create_file(None, sub_dir)
-        model2 = cm.get_model(name, sub_dir)
+        model = cm.create_file(path=sub_dir, ext='.ipynb')
+        model2 = cm.get_model(sub_dir + name)
         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.strip('/'))
+        self.assertEqual(model2['path'], '{0}/{1}'.format(sub_dir.strip('/'), name))
     
     @dec.skip_win32
     def test_bad_symlink(self):
@@ -175,16 +175,18 b' class TestContentsManager(TestCase):'
     @dec.skip_win32
     def test_good_symlink(self):
         cm = self.contents_manager
-        path = 'test good symlink'
-        os_path = self.make_dir(cm.root_dir, path)
+        parent = 'test good symlink'
+        name = 'good symlink'
+        path = '{0}/{1}'.format(parent, name)
+        os_path = self.make_dir(cm.root_dir, parent)
         
-        file_model = cm.create_file(path=path, ext='.txt')
+        file_model = cm.create_file(path=parent, ext='.txt')
         
         # create a good symlink
-        os.symlink(file_model['name'], os.path.join(os_path, "good symlink"))
-        symlink_model = cm.get_model(name="good symlink", path=path, content=False)
+        os.symlink(file_model['name'], os.path.join(os_path, name))
+        symlink_model = cm.get_model(path, content=False)
         
-        dir_model = cm.get_model(path)
+        dir_model = cm.get_model(parent)
         self.assertEqual(
             sorted(dir_model['content'], key=lambda x: x['name']),
             [symlink_model, file_model],
@@ -198,15 +200,15 b' class TestContentsManager(TestCase):'
         path = model['path']
 
         # Change the name in the model for rename
-        model['name'] = 'test.ipynb'
-        model = cm.update(model, name, path)
+        model['path'] = 'test.ipynb'
+        model = cm.update(model, 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, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get_model, path)
 
         # Test in sub-directory
         # Create a directory and notebook in that directory
@@ -217,16 +219,17 b' class TestContentsManager(TestCase):'
         path = model['path']
 
         # Change the name in the model for rename
-        model['name'] = 'test_in_sub.ipynb'
-        model = cm.update(model, name, path)
+        d = path.rsplit('/', 1)[0]
+        new_path = model['path'] = d + '/test_in_sub.ipynb'
+        model = cm.update(model, 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.strip('/'))
+        self.assertEqual(model['path'], new_path)
 
         # Make sure the old name is gone
-        self.assertRaises(HTTPError, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get_model, path)
 
     def test_save(self):
         cm = self.contents_manager
@@ -236,10 +239,10 b' class TestContentsManager(TestCase):'
         path = model['path']
 
         # Get the model with 'content'
-        full_model = cm.get_model(name, path)
+        full_model = cm.get_model(path)
 
         # Save the notebook
-        model = cm.save(full_model, name, path)
+        model = cm.save(full_model, path)
         assert isinstance(model, dict)
         self.assertIn('name', model)
         self.assertIn('path', model)
@@ -253,15 +256,15 b' class TestContentsManager(TestCase):'
         model = cm.create_file(None, sub_dir)
         name = model['name']
         path = model['path']
-        model = cm.get_model(name, path)
+        model = cm.get_model(path)
 
         # Change the name in the model for rename
-        model = cm.save(model, name, path)
+        model = cm.save(model, 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.strip('/'))
+        self.assertEqual(model['path'], 'foo/Untitled0.ipynb')
 
     def test_delete(self):
         cm = self.contents_manager
@@ -269,36 +272,38 b' class TestContentsManager(TestCase):'
         nb, name, path = self.new_notebook()
 
         # Delete the notebook
-        cm.delete(name, path)
+        cm.delete(path)
 
         # Check that a 'get' on the deleted notebook raises and error
-        self.assertRaises(HTTPError, cm.get_model, name, path)
+        self.assertRaises(HTTPError, cm.get_model, path)
 
     def test_copy(self):
         cm = self.contents_manager
-        path = u'å b'
+        parent = u'å b'
         name = u'nb √.ipynb'
-        os.mkdir(os.path.join(cm.root_dir, path))
-        orig = cm.create_file({'name' : name}, path=path)
+        path = u'{0}/{1}'.format(parent, name)
+        os.mkdir(os.path.join(cm.root_dir, parent))
+        orig = cm.create_file(path=path)
 
         # copy with unspecified name
-        copy = cm.copy(name, path=path)
+        copy = cm.copy(path)
         self.assertEqual(copy['name'], orig['name'].replace('.ipynb', '-Copy0.ipynb'))
 
         # copy with specified name
-        copy2 = cm.copy(name, u'copy 2.ipynb', path=path)
+        copy2 = cm.copy(path, u'å b/copy 2.ipynb')
         self.assertEqual(copy2['name'], u'copy 2.ipynb')
+        self.assertEqual(copy2['path'], u'å b/copy 2.ipynb')
 
     def test_trust_notebook(self):
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        untrusted = cm.get_model(name, path)['content']
+        untrusted = cm.get_model(path)['content']
         assert not cm.notary.check_cells(untrusted)
 
         # print(untrusted)
-        cm.trust_notebook(name, path)
-        trusted = cm.get_model(name, path)['content']
+        cm.trust_notebook(path)
+        trusted = cm.get_model(path)['content']
         # print(trusted)
         assert cm.notary.check_cells(trusted)
 
@@ -306,13 +311,13 b' class TestContentsManager(TestCase):'
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        cm.mark_trusted_cells(nb, name, path)
+        cm.mark_trusted_cells(nb, path)
         for cell in nb.cells:
             if cell.cell_type == 'code':
                 assert not cell.metadata.trusted
 
-        cm.trust_notebook(name, path)
-        nb = cm.get_model(name, path)['content']
+        cm.trust_notebook(path)
+        nb = cm.get_model(path)['content']
         for cell in nb.cells:
             if cell.cell_type == 'code':
                 assert cell.metadata.trusted
@@ -321,12 +326,12 b' class TestContentsManager(TestCase):'
         cm = self.contents_manager
         nb, name, path = self.new_notebook()
 
-        cm.mark_trusted_cells(nb, name, path)
-        cm.check_and_sign(nb, name, path)
+        cm.mark_trusted_cells(nb, path)
+        cm.check_and_sign(nb, path)
         assert not cm.notary.check_signature(nb)
 
-        cm.trust_notebook(name, path)
-        nb = cm.get_model(name, path)['content']
-        cm.mark_trusted_cells(nb, name, path)
-        cm.check_and_sign(nb, name, path)
+        cm.trust_notebook(path)
+        nb = cm.get_model(path)['content']
+        cm.mark_trusted_cells(nb, path)
+        cm.check_and_sign(nb, path)
         assert cm.notary.check_signature(nb)

IPython/html/tests/test_nbextensions.py

@@ -75,22 +75,22 b' class TestInstallNBExtension(TestCase):'
             td.cleanup()
         nbextensions.get_ipython_dir = self.save_get_ipython_dir
     
-    def assert_path_exists(self, path):
+    def assert_dir_exists(self, path):
         if not os.path.exists(path):
             do_exist = os.listdir(os.path.dirname(path))
             self.fail(u"%s should exist (found %s)" % (path, do_exist))
     
-    def assert_not_path_exists(self, path):
+    def assert_not_dir_exists(self, path):
         if os.path.exists(path):
             self.fail(u"%s should not exist" % path)
     
     def assert_installed(self, relative_path, ipdir=None):
-        self.assert_path_exists(
+        self.assert_dir_exists(
             pjoin(ipdir or self.ipdir, u'nbextensions', relative_path)
         )
     
     def assert_not_installed(self, relative_path, ipdir=None):
-        self.assert_not_path_exists(
+        self.assert_not_dir_exists(
             pjoin(ipdir or self.ipdir, u'nbextensions', relative_path)
         )
     
@@ -99,7 +99,7 b' class TestInstallNBExtension(TestCase):'
         with TemporaryDirectory() as td:
             ipdir = pjoin(td, u'ipython')
             install_nbextension(self.src, ipython_dir=ipdir)
-            self.assert_path_exists(ipdir)
+            self.assert_dir_exists(ipdir)
             for file in self.files:
                 self.assert_installed(
                     pjoin(basename(self.src), file),

IPython/html/tree/handlers.py

@@ -4,7 +4,7 b''
 # Distributed under the terms of the Modified BSD License.
 
 from tornado import web
-from ..base.handlers import IPythonHandler, notebook_path_regex, path_regex
+from ..base.handlers import IPythonHandler, path_regex
 from ..utils import url_path_join, url_escape
 
 
@@ -33,18 +33,18 b' class TreeHandler(IPythonHandler):'
             return 'Home'
 
     @web.authenticated
-    def get(self, path='', name=None):
+    def get(self, path=''):
         path = path.strip('/')
         cm = self.contents_manager
-        if name is not None:
+        if cm.file_exists(path):
             # is a notebook, redirect to notebook handler
             url = url_escape(url_path_join(
-                self.base_url, 'notebooks', path, name
+                self.base_url, 'notebooks', path,
             ))
             self.log.debug("Redirecting %s to %s", self.request.path, url)
             self.redirect(url)
         else:
-            if not cm.path_exists(path=path):
+            if not cm.dir_exists(path=path):
                 # Directory is hidden or does not exist.
                 raise web.HTTPError(404)
             elif cm.is_hidden(path):
@@ -66,7 +66,6 b' class TreeHandler(IPythonHandler):'
 
 
 default_handlers = [
-    (r"/tree%s" % notebook_path_regex, TreeHandler),
     (r"/tree%s" % path_regex, TreeHandler),
     (r"/tree", TreeHandler),
     ]