Rename pathHandler -> linkHandler

src/renderers/widget.ts

@@ -160,7 +160,7 @@ class RenderedHTML extends RenderedHTMLCommon {
     appendHtml(this.node, source);
     if (options.resolver) {
       this._urlResolved = handleUrls(this.node, options.resolver,
-                                      options.pathHandler);
+                                      options.linkHandler);
     }
   }
 
@@ -200,7 +200,7 @@ class RenderedMarkdown extends RenderedHTMLCommon {
       appendHtml(this.node, content);
       if (options.resolver) {
         this._urlResolved = handleUrls(this.node, options.resolver,
-                                        options.pathHandler);
+                                        options.linkHandler);
       }
       this.fit();
       this._rendered = true;
@@ -300,7 +300,7 @@ class RenderedSVG extends Widget {
     }
     if (options.resolver) {
       this._urlResolved = handleUrls(this.node, options.resolver,
-                                      options.pathHandler);
+                                      options.linkHandler);
     }
     this.addClass(SVG_CLASS);
   }
@@ -331,12 +331,12 @@ class RenderedPDF extends Widget {
  *
  * @param resolver - A url resolver.
  *
- * @param pathHandler - An optional url path handler.
+ * @param linkHandler - An optional url path handler.
  *
  * @returns a promise fulfilled when the relative urls have been resolved.
  */
 export
-function handleUrls(node: HTMLElement, resolver: RenderMime.IResolver, pathHandler: RenderMime.IPathHandler | null): Promise<void> {
+function handleUrls(node: HTMLElement, resolver: RenderMime.IResolver, linkHandler: RenderMime.ILinkHandler | null): Promise<void> {
   let promises: Promise<void>[] = [];
   // Handle HTML Elements with src attributes.
   let nodes = node.querySelectorAll('*[src]');
@@ -345,7 +345,7 @@ function handleUrls(node: HTMLElement, resolver: RenderMime.IResolver, pathHandl
   }
   let anchors = node.getElementsByTagName('a');
   for (let i = 0; i < anchors.length; i++) {
-    promises.push(handleAnchor(anchors[i], resolver, pathHandler));
+    promises.push(handleAnchor(anchors[i], resolver, linkHandler));
   }
   let links = node.getElementsByTagName('link');
   for (let i = 0; i < links.length; i++) {
@@ -375,15 +375,15 @@ function handleAttr(node: HTMLElement, name: 'src' | 'href', resolver: RenderMim
 /**
  * Handle an anchor node.
  */
-function handleAnchor(anchor: HTMLAnchorElement, resolver: RenderMime.IResolver, pathHandler: RenderMime.IPathHandler): Promise<void> {
+function handleAnchor(anchor: HTMLAnchorElement, resolver: RenderMime.IResolver, linkHandler: RenderMime.ILinkHandler): Promise<void> {
   anchor.target = '_blank';
   let href = anchor.getAttribute('href');
   if (!href) {
     return Promise.resolve(void 0);
   }
   return resolver.resolveUrl(href).then(path => {
-    if (pathHandler) {
-      pathHandler.handlePath(anchor, path);
+    if (linkHandler) {
+      linkHandler.handleLink(anchor, path);
     }
     return resolver.getDownloadUrl(path);
   }).then(url => {

src/rendermime/index.ts

@@ -83,7 +83,7 @@ class RenderMime {
     this._order = new Vector(options.order);
     this._sanitizer = options.sanitizer;
     this._resolver = options.resolver || null;
-    this._handler = options.pathHandler || null;
+    this._handler = options.linkHandler || null;
   }
 
   /**
@@ -99,10 +99,10 @@ class RenderMime {
   /**
    * The object used to handle path opening links.
    */
-  get pathHandler(): RenderMime.IPathHandler {
+  get linkHandler(): RenderMime.ILinkHandler {
     return this._handler;
   }
-  set pathHandler(value: RenderMime.IPathHandler) {
+  set linkHandler(value: RenderMime.ILinkHandler) {
     this._handler = value;
   }
 
@@ -141,7 +141,7 @@ class RenderMime {
       injector,
       resolver: this._resolver,
       sanitizer: trusted ? null : this._sanitizer,
-      pathHandler: this._handler
+      linkHandler: this._handler
     };
     return this._renderers[mimetype].render(rendererOptions);
   }
@@ -177,7 +177,7 @@ class RenderMime {
       renderers: this._renderers,
       order: this._order.iter(),
       sanitizer: this._sanitizer,
-      pathHandler: this._handler
+      linkHandler: this._handler
     });
   }
 
@@ -223,7 +223,7 @@ class RenderMime {
   private _order: Vector<string>;
   private _sanitizer: ISanitizer = null;
   private _resolver: RenderMime.IResolver | null;
-  private _handler: RenderMime.IPathHandler | null;
+  private _handler: RenderMime.ILinkHandler | null;
 }
 
 
@@ -262,7 +262,7 @@ namespace RenderMime {
     /**
      * An optional path handler.
      */
-    pathHandler?: IPathHandler;
+    linkHandler?: ILinkHandler;
   }
 
   /**
@@ -387,20 +387,20 @@ namespace RenderMime {
     sanitizer?: ISanitizer;
 
     /**
-     * An optional path handler.
+     * An optional link handler.
      */
-    pathHandler?: IPathHandler;
+    linkHandler?: ILinkHandler;
   }
 
   /**
-   * An object that handles path open on click for a node.
+   * An object that handles links on a node.
    */
   export
-  interface IPathHandler {
+  interface ILinkHandler {
     /**
-     * Add the path open handler to the node.
+     * Add the link handler to the node.
      */
-    handlePath(node: HTMLElement, path: string): void;
+    handleLink(node: HTMLElement, url: string): void;
   }
 
   /**

src/rendermime/plugin.ts

@@ -57,8 +57,8 @@ function activate(app: JupyterLab, linker: ICommandLinker): IRenderMime {
       order.push(m);
     }
   }
-  let pathHandler = {
-    handlePath: (node: HTMLElement, path: string) => {
+  let linkHandler = {
+    handleLink: (node: HTMLElement, path: string) => {
       if (!utils.urlParse(path).protocol && path.indexOf('//') !== 0) {
         linker.connectNode(node, CommandIDs.open, { path });
       }
@@ -68,6 +68,6 @@ function activate(app: JupyterLab, linker: ICommandLinker): IRenderMime {
     renderers,
     order,
     sanitizer,
-    pathHandler
+    linkHandler
   });
 };

test/src/rendermime/rendermime.spec.ts

@@ -63,15 +63,15 @@ describe('rendermime/index', () => {
 
     });
 
-    describe('#pathHandler', () => {
+    describe('#linkHandler', () => {
 
-      it('should be the path handler used by the rendermime', () => {
-        expect(r.pathHandler).to.be(null);
+      it('should be the link handler used by the rendermime', () => {
+        expect(r.linkHandler).to.be(null);
         let handler = {
-          handlePath: () => { /* no-op */ }
+          handleLink: () => { /* no-op */ }
         };
-        r.pathHandler = handler;
-        expect(r.pathHandler).to.be(handler);
+        r.linkHandler = handler;
+        expect(r.linkHandler).to.be(handler);
       });
 
     });
@@ -181,14 +181,14 @@ describe('rendermime/index', () => {
         r.render({ bundle, trusted: true });
       });
 
-      it('should send a path handler', (done) => {
+      it('should send a link handler', (done) => {
         let bundle: RenderMime.MimeMap<string> = {
           'text/html': '<a href="./foo/bar.txt">foo</a>'
         };
         r.resolver = RESOLVER;
-        r.pathHandler = {
-          handlePath: (node: HTMLElement, path: string) => {
-            expect(path).to.be('foo/bar.txt');
+        r.linkHandler = {
+          handleLink: (node: HTMLElement, url: string) => {
+            expect(url).to.be('foo/bar.txt');
             done();
           }
         };