Make Contents.new more generic

IPython/html/static/notebook/js/menubar.js

@@ -1,373 +1,373
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'notebook/js/tour',
     'bootstrap',
     'moment',
 ], function(IPython, $, utils, tour, bootstrap, moment) {
     "use strict";
     
     var MenuBar = function (selector, options) {
         // Constructor
         //
         // A MenuBar Class to generate the menubar of IPython notebook
         //
         // Parameters:
         //  selector: string
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          notebook: Notebook instance
         //          contents: ContentManager instance
         //          layout_manager: LayoutManager instance
         //          events: $(Events) instance
         //          save_widget: SaveWidget instance
         //          quick_help: QuickHelp instance
         //          base_url : string
         //          notebook_path : string
         //          notebook_name : string
         options = options || {};
         this.base_url = options.base_url || utils.get_body_data("baseUrl");
         this.selector = selector;
         this.notebook = options.notebook;
         this.contents = options.contents;
         this.layout_manager = options.layout_manager;
         this.events = options.events;
         this.save_widget = options.save_widget;
         this.quick_help = options.quick_help;
 
         try {
             this.tour = new tour.Tour(this.notebook, this.events);
         } catch (e) {
             this.tour = undefined;
             console.log("Failed to instantiate Notebook Tour", e);
         }
 
         if (this.selector !== undefined) {
             this.element = $(selector);
             this.style();
             this.bind_events();
         }
     };
 
     // TODO: This has definitively nothing to do with style ...
     MenuBar.prototype.style = function () {
         var that = this;
         this.element.find("li").click(function (event, ui) {
                 // The selected cell loses focus when the menu is entered, so we
                 // re-select it upon selection.
                 var i = that.notebook.get_selected_index();
                 that.notebook.select(i);
             }
         );
     };
 
     MenuBar.prototype._nbconvert = function (format, download) {
         download = download || false;
         var notebook_path = this.notebook.notebook_path;
         var notebook_name = this.notebook.notebook_name;
         if (this.notebook.dirty) {
             this.notebook.save_notebook({async : false});
         }
         var url = utils.url_join_encode(
             this.base_url,
             'nbconvert',
             format,
             notebook_path,
             notebook_name
         ) + "?download=" + download.toString();
 
         window.open(url);
     };
 
     MenuBar.prototype.bind_events = function () {
         //  File
         var that = this;
         this.element.find('#new_notebook').click(function () {
             // Create a new notebook in the same path as the current
             // notebook's path.
-            that.contents.new_notebook(that.notebook.notebook_path,
-                {
+            that.contents.new(that.notebook.notebook_path, null, {
+                    ext: ".ipynb",
                     success: function (data) {
                         window.open(
                             utils.url_join_encode(
                                 that.base_url, 'notebooks',
                                 data.path, data.name
                             ), '_blank');
                         },
                     error: function(error) {
                         dialog.modal({
                             title : 'Creating Notebook Failed',
                             body : "The error was: " + error.message,
                             buttons : {'OK' : {'class' : 'btn-primary'}}
                         });
                     }
                 });
         });
         this.element.find('#open_notebook').click(function () {
             window.open(utils.url_join_encode(
                 that.notebook.base_url,
                 'tree',
                 that.notebook.notebook_path
             ));
         });
         this.element.find('#copy_notebook').click(function () {
             that.notebook.copy_notebook();
             return false;
         });
         this.element.find('#download_ipynb').click(function () {
             var base_url = that.notebook.base_url;
             var notebook_path = that.notebook.notebook_path;
             var notebook_name = that.notebook.notebook_name;
             if (that.notebook.dirty) {
                 that.notebook.save_notebook({async : false});
             }
             
             var url = utils.url_join_encode(
                 base_url,
                 'files',
                 notebook_path,
                 notebook_name
             );
             window.open(url + '?download=1');
         });
         
         this.element.find('#print_preview').click(function () {
             that._nbconvert('html', false);
         });
 
         this.element.find('#download_py').click(function () {
             that._nbconvert('python', true);
         });
 
         this.element.find('#download_html').click(function () {
             that._nbconvert('html', true);
         });
 
         this.element.find('#download_rst').click(function () {
             that._nbconvert('rst', true);
         });
 
         this.element.find('#download_pdf').click(function () {
             that._nbconvert('pdf', true);
         });
 
         this.element.find('#rename_notebook').click(function () {
             that.save_widget.rename_notebook({notebook: that.notebook});
         });
         this.element.find('#save_checkpoint').click(function () {
             that.notebook.save_checkpoint();
         });
         this.element.find('#restore_checkpoint').click(function () {
         });
         this.element.find('#trust_notebook').click(function () {
             that.notebook.trust_notebook();
         });
         this.events.on('trust_changed.Notebook', function (event, trusted) {
             if (trusted) {
                 that.element.find('#trust_notebook')
                     .addClass("disabled")
                     .find("a").text("Trusted Notebook");
             } else {
                 that.element.find('#trust_notebook')
                     .removeClass("disabled")
                     .find("a").text("Trust Notebook");
             }
         });
         this.element.find('#kill_and_exit').click(function () {
             var close_window = function () {
                 // allow closing of new tabs in Chromium, impossible in FF
                 window.open('', '_self', '');
                 window.close();
             };
             // finish with close on success or failure
             that.notebook.session.delete(close_window, close_window);
         });
         // Edit
         this.element.find('#cut_cell').click(function () {
             that.notebook.cut_cell();
         });
         this.element.find('#copy_cell').click(function () {
             that.notebook.copy_cell();
         });
         this.element.find('#delete_cell').click(function () {
             that.notebook.delete_cell();
         });
         this.element.find('#undelete_cell').click(function () {
             that.notebook.undelete_cell();
         });
         this.element.find('#split_cell').click(function () {
             that.notebook.split_cell();
         });
         this.element.find('#merge_cell_above').click(function () {
             that.notebook.merge_cell_above();
         });
         this.element.find('#merge_cell_below').click(function () {
             that.notebook.merge_cell_below();
         });
         this.element.find('#move_cell_up').click(function () {
             that.notebook.move_cell_up();
         });
         this.element.find('#move_cell_down').click(function () {
             that.notebook.move_cell_down();
         });
         this.element.find('#edit_nb_metadata').click(function () {
             that.notebook.edit_metadata({
                 notebook: that.notebook,
                 keyboard_manager: that.notebook.keyboard_manager});
         });
         
         // View
         this.element.find('#toggle_header').click(function () {
             $('div#header').toggle();
             that.layout_manager.do_resize();
         });
         this.element.find('#toggle_toolbar').click(function () {
             $('div#maintoolbar').toggle();
             that.layout_manager.do_resize();
         });
         // Insert
         this.element.find('#insert_cell_above').click(function () {
             that.notebook.insert_cell_above('code');
             that.notebook.select_prev();
         });
         this.element.find('#insert_cell_below').click(function () {
             that.notebook.insert_cell_below('code');
             that.notebook.select_next();
         });
         // Cell
         this.element.find('#run_cell').click(function () {
             that.notebook.execute_cell();
         });
         this.element.find('#run_cell_select_below').click(function () {
             that.notebook.execute_cell_and_select_below();
         });
         this.element.find('#run_cell_insert_below').click(function () {
             that.notebook.execute_cell_and_insert_below();
         });
         this.element.find('#run_all_cells').click(function () {
             that.notebook.execute_all_cells();
         });
         this.element.find('#run_all_cells_above').click(function () {
             that.notebook.execute_cells_above();
         });
         this.element.find('#run_all_cells_below').click(function () {
             that.notebook.execute_cells_below();
         });
         this.element.find('#to_code').click(function () {
             that.notebook.to_code();
         });
         this.element.find('#to_markdown').click(function () {
             that.notebook.to_markdown();
         });
         this.element.find('#to_raw').click(function () {
             that.notebook.to_raw();
         });
         this.element.find('#to_heading1').click(function () {
             that.notebook.to_heading(undefined, 1);
         });
         this.element.find('#to_heading2').click(function () {
             that.notebook.to_heading(undefined, 2);
         });
         this.element.find('#to_heading3').click(function () {
             that.notebook.to_heading(undefined, 3);
         });
         this.element.find('#to_heading4').click(function () {
             that.notebook.to_heading(undefined, 4);
         });
         this.element.find('#to_heading5').click(function () {
             that.notebook.to_heading(undefined, 5);
         });
         this.element.find('#to_heading6').click(function () {
             that.notebook.to_heading(undefined, 6);
         });
         
         this.element.find('#toggle_current_output').click(function () {
             that.notebook.toggle_output();
         });
         this.element.find('#toggle_current_output_scroll').click(function () {
             that.notebook.toggle_output_scroll();
         });
         this.element.find('#clear_current_output').click(function () {
             that.notebook.clear_output();
         });
         
         this.element.find('#toggle_all_output').click(function () {
             that.notebook.toggle_all_output();
         });
         this.element.find('#toggle_all_output_scroll').click(function () {
             that.notebook.toggle_all_output_scroll();
         });
         this.element.find('#clear_all_output').click(function () {
             that.notebook.clear_all_output();
         });
         
         // Kernel
         this.element.find('#int_kernel').click(function () {
             that.notebook.kernel.interrupt();
         });
         this.element.find('#restart_kernel').click(function () {
             that.notebook.restart_kernel();
         });
         // Help
         if (this.tour) {
             this.element.find('#notebook_tour').click(function () {
                 that.tour.start();
             });
         } else {
             this.element.find('#notebook_tour').addClass("disabled");
         }
         this.element.find('#keyboard_shortcuts').click(function () {
             that.quick_help.show_keyboard_shortcuts();
         });
         
         this.update_restore_checkpoint(null);
         
         this.events.on('checkpoints_listed.Notebook', function (event, data) {
             that.update_restore_checkpoint(that.notebook.checkpoints);
         });
         
         this.events.on('checkpoint_created.Notebook', function (event, data) {
             that.update_restore_checkpoint(that.notebook.checkpoints);
         });
     };
 
     MenuBar.prototype.update_restore_checkpoint = function(checkpoints) {
         var ul = this.element.find("#restore_checkpoint").find("ul");
         ul.empty();
         if (!checkpoints || checkpoints.length === 0) {
             ul.append(
                 $("<li/>")
                 .addClass("disabled")
                 .append(
                     $("<a/>")
                     .text("No checkpoints")
                 )
             );
             return;
         }
         
         var that = this;
         checkpoints.map(function (checkpoint) {
             var d = new Date(checkpoint.last_modified);
             ul.append(
                 $("<li/>").append(
                     $("<a/>")
                     .attr("href", "#")
                     .text(moment(d).format("LLLL"))
                     .click(function () {
                         that.notebook.restore_checkpoint_dialog(checkpoint);
                     })
                 )
             );
         });
     };
 
     // Backwards compatability.
     IPython.MenuBar = MenuBar;
 
     return {'MenuBar': MenuBar};
 });

IPython/html/static/services/contents.js

@@ -1,271 +1,282
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     'base/js/namespace',
     'jquery',
     'base/js/utils',
     'base/js/dialog',
 ], function(IPython, $, utils, dialog) {
     var Contents = function(options) {
         // Constructor
         //
         // A contents handles passing file operations
         // to the back-end.  This includes checkpointing
         // with the normal file operations.
         //
         // Parameters:
         //  options: dictionary
         //      Dictionary of keyword arguments.
         //          base_url: string
         this.base_url = options.base_url;
     };
 
     /** Error type */
     Contents.DIRECTORY_NOT_EMPTY_ERROR = 'DirectoryNotEmptyError';
 
     Contents.DirectoryNotEmptyError = function() {
         // Constructor
         //
         // An error representing the result of attempting to delete a non-empty
         // directory.
         this.message = 'A directory must be empty before being deleted.';
     }
     Contents.DirectoryNotEmptyError.prototype = new Error;
     Contents.DirectoryNotEmptyError.prototype.name =
         Contents.DIRECTORY_NOT_EMPTY_ERROR;
 
 
     Contents.prototype.api_url = function() {
         var url_parts = [this.base_url, 'api/contents'].concat(
                                 Array.prototype.slice.apply(arguments));
         return utils.url_join_encode.apply(null, url_parts);
     };
 
     /**
      * Creates a basic error handler that wraps a jqXHR error as an Error.
      *
      * Takes a callback that accepts an Error, and returns a callback that can
      * be passed directly to $.ajax, which will wrap the error from jQuery
      * as an Error, and pass that to the original callback.
      *
      * @method create_basic_error_handler
      * @param{Function} callback
      * @return{Function}
      */
     Contents.prototype.create_basic_error_handler = function(callback) {
         if (!callback) {
             return function(xhr, status, error) { };
         }
         return function(xhr, status, error) {
             callback(utils.wrap_ajax_error(xhr, status, error));
         };
     }
 
     /**
      * File Functions (including notebook operations)
      */
 
     /**
      * Load a file.
      *
      * Calls success with file JSON model, or error with error.
      *
      * @method load_notebook
      * @param {String} path
      * @param {String} name
      * @param {Function} success
      * @param {Function} error
      */
     Contents.prototype.load_file = function (path, name, options) {
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : options.success,
             error : this.create_basic_error_handler(options.error)
         };
         var url = this.api_url(path, name);
         $.ajax(url, settings);
     };
 
 
     /**
      * Creates a new notebook file at the specified directory path.
      *
      * @method scroll_to_cell
      * @param {String} path The path to create the new notebook at
+     * @param {String} name Name for new file. Chosen by server if unspecified.
+     * @param {Object} options:
+     *      ext: file extension to use if name unspecified
      */
-    Contents.prototype.new_notebook = function(path, options) {
-        var error = options.error || function() {};
+    Contents.prototype.new = function(path, name, options) {
+        var method, data;
+        if (name) {
+            method = "PUT";
+        } else {
+            method = "POST";
+            data = JSON.stringify({ext: options.ext || ".ipynb"});
+        }
+
         var settings = {
             processData : false,
-            type : "POST",
+            type : method,
+            data: data,
             dataType : "json",
             success : options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         $.ajax(this.api_url(path), settings);
     };
 
     Contents.prototype.delete_file = function(name, path, options) {
         var error_callback = options.error || function() {};
         var that = this;
         var settings = {
             processData : false,
             type : "DELETE",
             dataType : "json",
             success : options.success || function() {},
             error : function(xhr, status, error) {
                 // TODO: update IPEP27 to specify errors more precisely, so
                 // that error types can be detected here with certainty.
                 if (xhr.status === 400) {
                     error_callback(new Contents.DirectoryNotEmptyError());
                 }
                 error_callback(utils.wrap_ajax_error(xhr, status, error));
             }
         };
         var url = this.api_url(path, name);
         $.ajax(url, settings);
     };
 
     Contents.prototype.rename_file = function(path, name, new_path, new_name, options) {
         var data = {name: new_name, path: new_path};
         var settings = {
             processData : false,
             type : "PATCH",
             data : JSON.stringify(data),
             dataType: "json",
             contentType: 'application/json',
             success : options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         var url = this.api_url(path, name);
         $.ajax(url, settings);
     };
 
     Contents.prototype.save_file = function(path, name, model, options) {
         // We do the call with settings so we can set cache to false.
         var settings = {
             processData : false,
             type : "PUT",
             data : JSON.stringify(model),
             contentType: 'application/json',
             success : options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         if (options.extra_settings) {
             $.extend(settings, options.extra_settings);
         }
         var url = this.api_url(path, name);
         $.ajax(url, settings);
     };
     
     Contents.prototype.copy_file = function(to_path, to_name, from, options) {
         var url, method;
         if (to_name) {
             url = this.api_url(to_path, to_name);
             method = "PUT";
         } else {
             url = this.api_url(to_path);
             method = "POST";
         }
         
         var settings = {
             processData : false,
             type: method,
             data: JSON.stringify({copy_from: from}),
             dataType : "json",
             success: options.success || function() {},
             error: this.create_basic_error_handler(options.error)
         };
         if (options.extra_settings) {
             $.extend(settings, options.extra_settings);
         }
         $.ajax(url, settings);
     };
 
     /**
      * Checkpointing Functions
      */
 
     Contents.prototype.create_checkpoint = function(path, name, options) {
         var url = this.api_url(path, name, 'checkpoints');
         var settings = {
             type : "POST",
             success: options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         $.ajax(url, settings);
     };
 
     Contents.prototype.list_checkpoints = function(path, name, options) {
         var url = this.api_url(path, name, 'checkpoints');
         var settings = {
             type : "GET",
             success: options.success,
             error : this.create_basic_error_handler(options.error)
         };
         $.ajax(url, settings);
     };
 
     Contents.prototype.restore_checkpoint = function(path, name, checkpoint_id, options) {
         var url = this.api_url(path, name, 'checkpoints', checkpoint_id);
         var settings = {
             type : "POST",
             success: options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         $.ajax(url, settings);
     };
 
     Contents.prototype.delete_checkpoint = function(path, name, checkpoint_id, options) {
         var url = this.api_url(path, name, 'checkpoints', checkpoint_id);
         var settings = {
             type : "DELETE",
             success: options.success || function() {},
             error : this.create_basic_error_handler(options.error)
         };
         $.ajax(url, settings);
     };
 
     /**
      * File management functions
      */
 
     /**
      * List notebooks and directories at a given path
      *
      * On success, load_callback is called with an array of dictionaries
      * representing individual files or directories.  Each dictionary has
      * the keys:
      *     type: "notebook" or "directory"
      *     name: the name of the file or directory
      *     created: created date
      *     last_modified: last modified dat
      *     path: the path
      * @method list_notebooks
      * @param {String} path The path to list notebooks in
      * @param {Function} load_callback called with list of notebooks on success
      * @param {Function} error called with ajax results on error
      */
     Contents.prototype.list_contents = function(path, options) {
         var settings = {
             processData : false,
             cache : false,
             type : "GET",
             dataType : "json",
             success : options.success,
             error : this.create_basic_error_handler(options.error)
         };
 
         $.ajax(this.api_url(path), settings);
     };
 
 
     IPython.Contents = Contents;
 
     return {'Contents': Contents};
 });

IPython/html/static/tree/js/main.js

@@ -1,143 +1,143
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 require([
     'base/js/namespace',
     'jquery',
     'base/js/events',
     'base/js/page',
     'base/js/utils',
     'contents',
     'tree/js/notebooklist',
     'tree/js/clusterlist',
     'tree/js/sessionlist',
     'tree/js/kernellist',
     'tree/js/terminallist',
     'auth/js/loginwidget',
     // only loaded, not used:
     'jqueryui',
     'bootstrap',
     'custom/custom',
 ], function(
     IPython, 
     $, 
     events,
     page, 
     utils, 
     contents,
     notebooklist, 
     clusterlist, 
     sesssionlist, 
     kernellist,
     terminallist,
     loginwidget){
 
     page = new page.Page();
     
     var common_options = {
         base_url: utils.get_body_data("baseUrl"),
         notebook_path: utils.get_body_data("notebookPath"),
     };
     session_list = new sesssionlist.SesssionList($.extend({
         events: events}, 
         common_options));
     contents = new contents.Contents($.extend({
         events: events},
         common_options));
     notebook_list = new notebooklist.NotebookList('#notebook_list', $.extend({
         contents: contents,
         session_list:  session_list}, 
         common_options));
     cluster_list = new clusterlist.ClusterList('#cluster_list', common_options);
     kernel_list = new kernellist.KernelList('#running_list',  $.extend({
         session_list:  session_list}, 
         common_options));
     
     if (utils.get_body_data("terminalsAvailable") === "True") {
         terminal_list = new terminallist.TerminalList('#terminal_list', common_options);
     }
 
     login_widget = new loginwidget.LoginWidget('#login_widget', common_options);
 
     $('#new_notebook').click(function (e) {
-        contents.new_notebook(common_options.notebook_path,
-            {
+        contents.new(common_options.notebook_path, null, {
+                ext: ".ipynb",
                 success: function (data) {
                     window.open(
                         utils.url_join_encode(
                             common_options.base_url, 'notebooks',
                             data.path, data.name
                         ), '_blank');
                     },
                 error: function(error) {
                     dialog.modal({
                         title : 'Creating Notebook Failed',
                         body : "The error was: " + error.message,
                         buttons : {'OK' : {'class' : 'btn-primary'}}
                     });
                 }
             });
     });
 
     var interval_id=0;
     // auto refresh every xx secondes, no need to be fast,
     //  update is done at least when page get focus
     var time_refresh = 60; // in sec
 
     var enable_autorefresh = function(){
         //refresh immediately , then start interval
         session_list.load_sessions();
         cluster_list.load_list();
         if (!interval_id){
             interval_id = setInterval(function(){
                     session_list.load_sessions();
                     cluster_list.load_list();
                 }, time_refresh*1000);
             }
     };
 
     var disable_autorefresh = function(){
         clearInterval(interval_id);
         interval_id = 0;
     };
 
     // stop autorefresh when page lose focus
     $(window).blur(function() {
         disable_autorefresh();
     });
 
     //re-enable when page get focus back
     $(window).focus(function() {
         enable_autorefresh();
     });
 
     // finally start it, it will refresh immediately
     enable_autorefresh();
 
     page.show();
 
     // For backwards compatability.
     IPython.page = page;
     IPython.notebook_list = notebook_list;
     IPython.cluster_list = cluster_list;
     IPython.session_list = session_list;
     IPython.kernel_list = kernel_list;
     IPython.login_widget = login_widget;
 
     events.trigger('app_initialized.DashboardApp');
     
     // bound the upload method to the on change of the file select list
     $("#alternate_upload").change(function (event){
         notebook_list.handleFilesUpload(event,'form');
     });
     
     // set hash on tab click
     $("#tabs").find("a").click(function() {
         window.location.hash = $(this).attr("href");
     });
     
     // load tab if url hash
     if (window.location.hash) {
         $("#tabs").find("a[href=" + window.location.hash + "]").click();
     }
 });