Clean up the plugins and rename

examples/lab/plugin.ts

@@ -11,7 +11,7 @@ import {
 } from 'phosphor-di';
 
 import {
-  ITerminalFactory
+  ITerminalProvider
 } from '../lib';
 
 
@@ -37,19 +37,19 @@ class DefaultHandler {
   /**
    * The dependencies required by the default plugin.
    */
-  static requires: Token<any>[] = [IAppShell, ITerminalFactory];
+  static requires: Token<any>[] = [IAppShell, ITerminalProvider];
 
   /**
    * Create a default plugin instance..
    */
-  static create(shell: IAppShell, term: ITerminalFactory): DefaultHandler {
+  static create(shell: IAppShell, term: ITerminalProvider): DefaultHandler {
     return new DefaultHandler(shell, term);
   }
 
   /**
    * Construct a new default plugin.
    */
-  constructor(shell: IAppShell, term: ITerminalFactory) {
+  constructor(shell: IAppShell, term: ITerminalProvider) {
     this._shell = shell;
     this._term = term;
   }
@@ -62,6 +62,6 @@ class DefaultHandler {
     this._shell.addToMainArea(term);
   }
 
-  private _term: ITerminalFactory = null;
+  private _term: ITerminalProvider = null;
   private _shell: IAppShell = null;
 }

src/editor/index.ts

@@ -14,53 +14,49 @@ import {
 } from 'phosphor-di';
 
 
-
 /**
- * The interface for a jupyter editor widget.
+ * A handler for creating and manipulating Jupyter editors.
  */
 export
-interface IEditor extends CodeMirrorWidget {
+interface IEditorHandler {
 
   /**
-   * A convenience property to get/set the text on the editor.
+   * Create a new IEditor instance.
    */
-  text: string;
+  createEditor(options?: CodeMirror.EditorConfiguration): CodeMirrorWidget;
 
   /**
    * Set the editor mode by name.  This will lode the mode file
    * as needed.
    */
-  setModeByName(mode: string): void;
+  setModeByName(widget: CodeMirrorWidget, mode: string): void;
 
   /**
    * Set the editor mode by file name.  This will lode the mode file
    * as needed.
    */
-  setModeByFileName(filename: string): void;
+  setModeByFileName(widget: CodeMirrorWidget, filename: string): void;
 
   /**
    * Set the editor mode by mime type.  This will lode the mode file
    * as needed.
    */
-  setModeByMIMEType(mime: string): void;
-}
+  setModeByMIMEType(widget: CodeMirrorWidget, mime: string): void;
 
-
-/**
- * A factory for creating a Jupyter editor.
- */
-export
-interface IEditorFactory {
+  /**
+   * A convenience method to get the text from the editor.
+   */
+  getText(widget: CodeMirrorWidget, text: string): string;
 
   /**
-   * Create a new IEditor instance.
+   * A convenience method to set the text on the editor.
    */
-  createEditor(options?: CodeMirror.EditorConfiguration): IEditor;
+  setText(widget: CodeMirrorWidget, text: string): void;
 }
 
 
 /**
- * The dependency token for the `IEditorFactory` interface.
+ * The dependency token for the `IEditorHandler` interface.
  */
 export
-const IEditorFactory = new Token<IEditorFactory>('jupyter-js-plugins.IEditorFactory');
+const IEditorHandler = new Token<IEditorHandler>('jupyter-js-plugins.IEditorHandler');

src/editor/plugin.ts

@@ -18,7 +18,7 @@ import {
 } from 'phosphor-di';
 
 import {
-  IEditor, IEditorFactory
+  IEditorHandler
 } from './index';
 
 import './plugin.css';
@@ -46,63 +46,56 @@ import './codemirror-ipython';
  */
 export
 function register(container: Container): void {
-  container.register(IEditorFactory, EditorFactory);
+  container.register(IEditorHandler, EditorHandler);
 }
 
 
 /**
- * An implemenation of an IEditorFactory.
+ * An implemenation of an IEditorHandler.
  */
-class EditorFactory implements IEditorFactory {
+class EditorHandler implements IEditorHandler {
 
   /**
-   * The dependencies required by the editor factory.
+   * The dependencies required by the editor handler.
    */
   static requires: Token<any>[] = [];
 
   /**
-   * Create a new editor factory instance.
+   * Create a new editor handler instance.
    */
-  static create(): IEditorFactory {
-    return new EditorFactory();
+  static create(): IEditorHandler {
+    return new EditorHandler();
   }
 
   /**
    * Create a new IEditor instance.
    */
-  createEditor(options?: CodeMirror.EditorConfiguration): IEditor {
-    return new Editor(options);
+  createEditor(options?: CodeMirror.EditorConfiguration): CodeMirrorWidget {
+    return new CodeMirrorWidget(options);
   }
-}
-
-
-/**
- * A default implementation of the jupyter editor widget.
- */
-class Editor extends CodeMirrorWidget {
 
   /**
-   * Get the text from the editor.
+   * A convenience method to get the text from the editor.
    */
-  get text(): string {
-    return this.editor.getDoc().getValue();
+  getText(widget: CodeMirrorWidget, text: string): string {
+    return widget.editor.getDoc().getValue();
   }
 
   /**
-   * Set the text on the editor.
+   * A convenience method to set the text on the editor.
    */
-  set text(value: string) {
-    this.editor.getDoc().setValue(value);
+  setText(widget: CodeMirrorWidget, text: string): void {
+    widget.editor.getDoc().setValue(text);
   }
 
   /**
    * Set the editor mode by name.  This will lode the mode file
    * as needed.
    */
-  setModeByName(mode: string): void {
+  setModeByName(widget: CodeMirrorWidget, mode: string): void {
     let info = CodeMirror.findModeByName(mode);
     if (info) {
-      this.loadCodeMirrorMode(info.mode, info.mime);
+      loadCodeMirrorMode(widget.editor, info.mode, info.mime);
     }
   }
 
@@ -110,10 +103,10 @@ class Editor extends CodeMirrorWidget {
    * Set the editor mode by file name.  This will lode the mode file
    * as needed.
    */
-  setModeByFileName(filename: string): void {
+  setModeByFileName(widget: CodeMirrorWidget, filename: string): void {
     let info = CodeMirror.findModeByFileName(filename);
     if (info) {
-      this.loadCodeMirrorMode(info.mode, info.mime);
+      loadCodeMirrorMode(widget.editor, info.mode, info.mime);
     }
   }
 
@@ -121,27 +114,27 @@ class Editor extends CodeMirrorWidget {
    * Set the editor mode by mime type.  This will lode the mode file
    * as needed.
    */
-  setModeByMIMEType(mime: string): void {
+  setModeByMIMEType(widget: CodeMirrorWidget, mime: string): void {
     let info = CodeMirror.findModeByMIME(mime);
     if (info) {
-      this.loadCodeMirrorMode(info.mode, info.mime);
+      loadCodeMirrorMode(widget.editor, info.mode, info.mime);
     }
   }
+}
 
-  /**
-   * Load and set a CodeMirror mode.
-   *
-   * #### Notes
-   * This assumes WebPack as the module loader.
-   */
-  protected loadCodeMirrorMode(mode: string, mime: string): void {
-    if (CodeMirror.modes.hasOwnProperty(mode)) {
-      this.editor.setOption('mode', mime);
-    } else {
-      // Load the full codemirror mode bundle.
-      require([`codemirror/mode/${mode}/${mode}.js`], () => {
-        this.editor.setOption('mode', mime);
-      });
-    }
+/**
+ * Load and set a CodeMirror mode.
+ *
+ * #### Notes
+ * This assumes WebPack as the module loader.
+ */
+function loadCodeMirrorMode(editor: CodeMirror.Editor, mode: string, mime: string): void {
+  if (CodeMirror.modes.hasOwnProperty(mode)) {
+    editor.setOption('mode', mime);
+  } else {
+    // Load the full codemirror mode bundle.
+    require([`codemirror/mode/${mode}/${mode}.js`], () => {
+      editor.setOption('mode', mime);
+    });
   }
 }

src/filebrowser/index.ts

@@ -15,7 +15,7 @@ import {
  * A singleton FileBrowser provider.
  */
 export
-interface IFileBrowser {
+interface IFileBrowserHandler {
   fileBrowser: FileBrowser;
 }
 
@@ -24,4 +24,4 @@ interface IFileBrowser {
  * The dependency token for the `IFileBrowser` interface.
  */
 export
-const IFileBrowser = new Token<IFileBrowser>('jupyter-js-plugins.IFileBrowser');
+const IFileBrowserHandler = new Token<IFileBrowserHandler>('jupyter-js-plugins.IFileBrowserHandler');

src/filebrowser/plugin.ts

@@ -15,11 +15,11 @@ import {
 } from 'phosphor-di';
 
 import {
-  IFileBrowser
+  IFileBrowserHandler
 } from './index';
 
 import {
-  IEditorFactory, IServicesFactory
+  IEditorHandler, IServicesProvider
 } from '../index';
 
 import './plugin.css';
@@ -35,37 +35,40 @@ import './plugin.css';
  */
 export
 function register(container: Container): void {
-  container.register(IFileBrowser, FileBrowserProvider);
+  container.register(IFileBrowserHandler, FileBrowserHandler);
 }
 
 
+/**
+ * Resolve the default file provider.
+ */
 export
 function resolve(container: Container): Promise<void> {
-  return container.resolve(FileBrowserProvider).then(() => { return; });
+  return container.resolve(FileBrowserHandler).then(() => { return; });
 }
 
 
 /**
- * An implementation of the IFileBrowser provider.
+ * An implementation of the FileBrowserHandler provider.
  */
-class FileBrowserProvider implements IFileBrowser {
+class FileBrowserHandler implements IFileBrowserHandler {
 
   /**
    * The dependencies required by the application shell.
    */
-  static requires: Token<any>[] = [IAppShell, IServicesFactory, IEditorFactory];
+  static requires: Token<any>[] = [IAppShell, IServicesProvider, IEditorHandler];
 
   /**
    * Create a new application shell instance.
    */
-  static create(shell: IAppShell, services: IServicesFactory, editor: IEditorFactory): IFileBrowser {
-    return new FileBrowserProvider(shell, services, editor);
+  static create(shell: IAppShell, services: IServicesProvider, editor: IEditorHandler): IFileBrowserHandler {
+    return new FileBrowserHandler(shell, services, editor);
   }
 
   /**
    * Construct a new filebrowser provider instance.
    */
-  constructor(shell: IAppShell, services: IServicesFactory, editor: IEditorFactory) {
+  constructor(shell: IAppShell, services: IServicesProvider, editor: IEditorHandler) {
     this._shell = shell;
     this._editor = editor;
     let contents = services.createContentsManager();
@@ -77,8 +80,8 @@ class FileBrowserProvider implements IFileBrowser {
     model.changed.connect((instance, change) => {
       if (change.name === 'open' && change.newValue.type === 'file') {
         let newEditor = editor.createEditor();
-        newEditor.setModeByFileName(change.newValue.name);
-        newEditor.text = change.newValue.content;
+        editor.setModeByFileName(newEditor, change.newValue.name);
+        editor.setText(newEditor, change.newValue.content);
         newEditor.title.text = change.newValue.name;
         this._shell.addToMainArea(newEditor);
       }
@@ -96,7 +99,7 @@ class FileBrowserProvider implements IFileBrowser {
   }
 
   private _shell: IAppShell = null;
-  private _editor: IEditorFactory = null;
+  private _editor: IEditorHandler = null;
   private _browser: FileBrowser = null;
 
 }

src/services/index.ts

@@ -13,10 +13,10 @@ import {
 
 
 /**
- * A factory for creating Jupyter service managers.
+ * A provider for creating Jupyter service managers.
  */
 export
-interface IServicesFactory {
+interface IServicesProvider {
 
   /**
    * Create a new kernel manager instance.
@@ -39,4 +39,4 @@ interface IServicesFactory {
  * The dependency token for the `IServicesFactory` interface.
  */
 export
-const IServicesFactory = new Token<IServicesFactory>('jupyter-js-plugins.IServicesFactory');
+const IServicesProvider = new Token<IServicesProvider>('jupyter-js-plugins.IServicesProvider');

src/services/plugin.ts

@@ -16,7 +16,7 @@ import {
 } from 'phosphor-di';
 
 import {
-  IServicesFactory
+  IServicesProvider
 } from './index';
 
 
@@ -30,26 +30,29 @@ import {
  */
 export
 function register(container: Container): void {
-  container.register(IServicesFactory, ServicesFactory);
+  container.register(IServicesProvider, ServicesProvider);
 }
 
 
-class ServicesFactory implements IServicesFactory {
+/**
+ * An implementation of a services provider.
+ */
+class ServicesProvider implements IServicesProvider {
 
   /**
-   * The dependencies required by the application shell.
+   * The dependencies required by the services provider.
    */
   static requires: Token<any>[] = [];
 
   /**
-   * Create a new application shell instance.
+   * Create a new services provider instance.
    */
-  static create(): IServicesFactory {
-    return new ServicesFactory();
+  static create(): IServicesProvider {
+    return new ServicesProvider();
   }
 
   /**
-   * Construct a new services factory.
+   * Construct a new services provider.
    */
   constructor() {
     this._baseUrl = getConfigOption('baseUrl');

src/terminal/index.ts

@@ -16,7 +16,7 @@ import {
  * A factory for creating a Jupyter editor.
  */
 export
-interface ITerminalFactory {
+interface ITerminalProvider {
 
   /**
    * Create a new Terminal instance.
@@ -26,7 +26,7 @@ interface ITerminalFactory {
 
 
 /**
- * The dependency token for the `ITerminalFactory` interface.
+ * The dependency token for the `ITerminalProvider` interface.
  */
 export
-const ITerminalFactory = new Token<ITerminalFactory>('jupyter-js-plugins.ITerminalFactory');
+const ITerminalProvider = new Token<ITerminalProvider>('jupyter-js-plugins.ITerminalProvider');

src/terminal/plugin.ts

@@ -11,7 +11,7 @@ import {
 } from 'phosphor-di';
 
 import {
-  ITerminalFactory
+  ITerminalProvider
 } from './index';
 
 import './plugin.css';
@@ -27,14 +27,14 @@ import './plugin.css';
  */
 export
 function register(container: Container): void {
-  container.register(ITerminalFactory, TerminalFactory);
+  container.register(ITerminalProvider, TerminalProvider);
 }
 
 
 /**
- * An implementation of an ITerminalFactory.
+ * An implementation of an ITerminalProvider.
  */
-class TerminalFactory implements ITerminalFactory {
+class TerminalProvider implements ITerminalProvider {
 
   /**
    * The dependencies required by the editor factory.
@@ -44,8 +44,8 @@ class TerminalFactory implements ITerminalFactory {
   /**
    * Create a new editor factory instance.
    */
-  static create(): ITerminalFactory {
-    return new TerminalFactory();
+  static create(): ITerminalProvider {
+    return new TerminalProvider();
   }
 
   /**