Implemented delete functionality in nb browser.

* Dialog confirms the notebook delete.
* Notebook element is removed from list upon deletion.

IPython/frontend/html/notebook/notebookmanager.py

@@ -1,199 +1,198
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import datetime
 import os
 import uuid
 
 from tornado import web
 
 from IPython.config.configurable import Configurable
 from IPython.nbformat import current
 from IPython.utils.traitlets import Unicode, List, Dict
 
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class NotebookManager(Configurable):
 
     notebook_dir = Unicode(os.getcwd())
     filename_ext = Unicode(u'.ipynb')
     allowed_formats = List([u'json',u'xml',u'py'])
 
     # Map notebook_ids to notebook names
     mapping = Dict()
     # Map notebook names to notebook_ids
     rev_mapping = Dict()
 
     def list_notebooks(self):
         """List all notebooks in the notebook dir.
 
         This returns a list of dicts of the form::
 
             dict(notebook_id=notebook,name=name)
         """
         names = os.listdir(self.notebook_dir)
         names = [name.split(u'.')[0] \
             for name in names if name.endswith(self.filename_ext)]
-        print names
         data = []
         for name in names:
             if name not in self.rev_mapping:
                 notebook_id = self.new_notebook_id(name)
             else:
                 notebook_id = self.rev_mapping[name]
             data.append(dict(notebook_id=notebook_id,name=name))
         data = sorted(data, key=lambda item: item['name'])
         return data
 
     def new_notebook_id(self, name):
         """Generate a new notebook_id for a name and store its mappings."""
         notebook_id = unicode(uuid.uuid4())
         self.mapping[notebook_id] = name
         self.rev_mapping[name] = notebook_id
         return notebook_id
 
     def delete_notebook_id(self, notebook_id):
         """Delete a notebook's id only. This doesn't delete the actual notebook."""
         name = self.mapping[notebook_id]
         del self.mapping[notebook_id]
         del self.rev_mapping[name]
 
     def notebook_exists(self, notebook_id):
         """Does a notebook exist?"""
         if notebook_id not in self.mapping:
             return False
         path = self.get_path_by_name(self.mapping[notebook_id])
         if not os.path.isfile(path):
             return False
         return True        
 
     def find_path(self, notebook_id):
         """Return a full path to a notebook given its notebook_id."""
         try:
             name = self.mapping[notebook_id]
         except KeyError:
             raise web.HTTPError(404)
         return self.get_path_by_name(name)
 
     def get_path_by_name(self, name):
         """Return a full path to a notebook given its name."""
         filename = name + self.filename_ext
         path = os.path.join(self.notebook_dir, filename)
         return path       
 
     def get_notebook(self, notebook_id, format=u'json'):
         """Get the representation of a notebook in format by notebook_id."""
         format = unicode(format)
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
         last_modified, nb = self.get_notebook_object(notebook_id)
         data = current.writes(nb, format)
         name = nb.get('name','notebook')
         return last_modified, name, data
 
     def get_notebook_object(self, notebook_id):
         """Get the NotebookNode representation of a notebook by notebook_id."""
         path = self.find_path(notebook_id)
         if not os.path.isfile(path):
             raise web.HTTPError(404)
         info = os.stat(path)
         last_modified = datetime.datetime.utcfromtimestamp(info.st_mtime)
         try:
             with open(path,'r') as f:
                 s = f.read()
                 try:
                     # v2 and later have xml in the .ipynb files.
                     nb = current.reads(s, 'xml')
                 except:
                     # v1 had json in the .ipynb files.
                     nb = current.reads(s, 'json')
                     # v1 notebooks don't have a name field, so use the filename.
                     nb.name = os.path.split(path)[-1].split(u'.')[0]
         except:
             raise web.HTTPError(404)
         return last_modified, nb
 
     def save_new_notebook(self, data, format=u'json'):
         """Save a new notebook and return its notebook_id."""
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
         try:
             nb = current.reads(data, format)
         except:
             raise web.HTTPError(400)
         try:
             name = nb.name
         except AttributeError:
             raise web.HTTPError(400)
         notebook_id = self.new_notebook_id(name)
         self.save_notebook_object(notebook_id, nb)
         return notebook_id
 
     def save_notebook(self, notebook_id, data, format=u'json'):
         """Save an existing notebook by notebook_id."""
         if format not in self.allowed_formats:
             raise web.HTTPError(415)
         try:
             nb = current.reads(data, format)
         except:
             raise web.HTTPError(400)
         self.save_notebook_object(notebook_id, nb)
 
     def save_notebook_object(self, notebook_id, nb):
         """Save an existing notebook object by notebook_id."""
         if notebook_id not in self.mapping:
             raise web.HTTPError(404)
         old_name = self.mapping[notebook_id]
         try:
             new_name = nb.name
         except AttributeError:
             raise web.HTTPError(400)
         path = self.get_path_by_name(new_name)
         try:
             with open(path,'w') as f:
                 current.write(nb, f, u'xml')
         except:
             raise web.HTTPError(400)
         if old_name != new_name:
             old_path = self.get_path_by_name(old_name)
             if os.path.isfile(old_path):
                 os.unlink(old_path)
             self.mapping[notebook_id] = new_name
             self.rev_mapping[new_name] = notebook_id
 
     def delete_notebook(self, notebook_id):
         """Delete notebook by notebook_id."""
         path = self.find_path(notebook_id)
         if not os.path.isfile(path):
             raise web.HTTPError(404)
         os.unlink(path)
         self.delete_notebook_id(notebook_id)
 
     def new_notebook(self):
         """Create a new notebook and returns its notebook_id."""
         i = 0
         while True:
             name = u'Untitled%i' % i
             path = self.get_path_by_name(name)
             if not os.path.isfile(path):
                 break
             else:
                 i = i+1
         notebook_id = self.new_notebook_id(name)
         nb = current.new_notebook(name=name, id=notebook_id)
         with open(path,'w') as f:
             current.write(nb, f, u'xml')
         return notebook_id
 

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

@@ -1,63 +1,108
 
 //============================================================================
 // Cell
 //============================================================================
 
 var IPython = (function (IPython) {
 
     var NotebookList = function (selector) {
         this.selector = selector;
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
     };
 
     NotebookList.prototype.style = function () {
         this.element.addClass('ui-widget ui-widget-content');
         $('div#project_name').addClass('ui-widget ui-widget-header');
     };
 
 
     NotebookList.prototype.bind_events = function () {
 
     };
 
 
     NotebookList.prototype.load_list = function () {
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : $.proxy(this.list_loaded,this)
         };
         $.ajax("/notebooks", settings);
     };
 
 
     NotebookList.prototype.list_loaded = function (data, status, xhr) {
         var len = data.length;
         for (var i=0; i<len; i++) {
-            var div = $('<div/>').addClass('notebook_item ui-widget ui-widget-content ui-helper-clearfix');
-            var nbname = $('<span/>').addClass('item_name').append(
-                $('<a/>').attr('href','/'+data[i].notebook_id).
+            var notebook_id = data[i].notebook_id;
+            var nbname = data[i].name;
+
+            var item = $('<div/>');
+            item.addClass('notebook_item ui-widget ui-widget-content ui-helper-clearfix');
+            var item_name = $('<span/>').addClass('item_name').append(
+                $('<a/>').attr('href','/'+notebook_id).
                 attr('target','_blank').
-                text(data[i].name)
+                text(nbname)
             );
-            var buttons = $('<span/>').addClass('item_buttons').append(
-                $('<button>Delete</button>').button()
-            )
-            div.append(nbname).append(buttons);
-            this.element.append(div);
+            // Store the nbname and notebook_id on the item for later usage. We have to do this
+            // because the loop over elements changes the values of the local nbname and notebook_id
+            // variables.
+            item.data('notebook_id',notebook_id);
+            item.data('nbname',nbname);
+
+            var buttons = $('<span/>').addClass('item_buttons');
+            var delete_button = $('<button>Delete</button>').button().
+                click(function (e) {
+                    // $(this) is the button that was clicked.
+                    var that = $(this);
+                    // We use the nbname and notebook_id from the parent notebook_item element's
+                    // data because the outer scopes values change as we iterate through the loop.
+                    var parent_item = that.parents('div.notebook_item');
+                    var nbname = parent_item.data('nbname');
+                    var notebook_id = parent_item.data('notebook_id');
+                    var dialog = $('<div/>');
+                    dialog.html('Are you sure you want to permanently delete the notebook: ' + nbname + '?');
+                    parent_item.append(dialog);
+                    dialog.dialog({
+                        resizable: false,
+                        modal: true,
+                        title: "Delete notebook",
+                        buttons : {
+                            "Delete": function () {
+                                var settings = {
+                                    processData : false,
+                                    cache : false,
+                                    type : "DELETE",
+                                    dataType : "json",
+                                    success : function (data, status, xhr) {
+                                        parent_item.remove();
+                                    }
+                                };
+                                $.ajax("/notebooks/" + notebook_id, settings);
+                                $(this).dialog('close');
+                            },
+                            "Cancel": function () {
+                                $(this).dialog('close');
+                            }
+                        }
+                    });
+                });
+            buttons.append(delete_button);
+            item.append(item_name).append(buttons);
+            this.element.append(item);
         }
     };
 
 
     IPython.NotebookList = NotebookList;
 
     return IPython;
 
 }(IPython));