.then(() => {
   // Open the link with the default rendered widget factory,
   // if applicable.
   const factory = docManager.registry.defaultRenderedWidgetFactory(
     path
   );
   const widget = docManager.openOrReveal(path, factory.name);
   if (!widget) {
     return;
   }
   return widget.revealed.then(() => {
     // Once the widget is ready, attempt to scroll the hash into view
     // if one has been provided.
     if (!id) {
       return;
     }
     // Look for the an element with the hash id in the document.
     // This id is set automatically for headers tags when
     // we render markdown.
     const element = widget.node.querySelector(id);
     if (element) {
       element.scrollIntoView();
     }
     return;
   });
 });

 execute: () => {
   if (!isEnabled()) {
     return;
   }
   const context = docManager.contextForWidget(shell.currentWidget);
   return context.listCheckpoints().then(checkpoints => {
     if (checkpoints.length < 1) {
       return;
     }
     const lastCheckpoint = checkpoints[checkpoints.length - 1];
     if (!lastCheckpoint) {
       return;
     }
     return showDialog({
       title: 'Revert notebook to checkpoint',
       body: new RevertConfirmWidget(lastCheckpoint),
       buttons: [
         Dialog.cancelButton(),
         Dialog.warnButton({ label: 'Revert' })
       ]
     }).then(result => {
       if (context.isDisposed) {
         return;
       }
       if (result.button.accept) {
         if (context.model.readOnly) {
           return context.revert();
         }
         return context.restoreCheckpoint().then(() => context.revert());
       }
     });
   });
 }

 each(shell.widgets('main'), widget => {
   const context = docManager.contextForWidget(widget);
   if (context && !context.model.readOnly && !paths.has(context.path)) {
     paths.add(context.path);
     promises.push(context.save());
   }
 });

 execute: () => {
   if (isEnabled()) {
     let context = docManager.contextForWidget(app.shell.currentWidget);
     return context.saveAs().then(() => {
       return context.createCheckpoint();
     });
   }
 }

 beforeEach(() => {
   state.clear();
   model = new FileBrowserModel({ manager, state });
   return manager.newUntitled({ type: 'file' }).then(contents => {
     name = contents.name;
     return model.cd();
   });
 });

 execute: () => {
   if (isEnabled()) {
     let context = docManager.contextForWidget(app.shell.currentWidget);
     if (context.model.readOnly) {
       return context.revert();
     }
     return context.restoreCheckpoint().then(() => context.revert());
   }
 }

 isVisible: () => {
   const widget = app.shell.currentWidget;
   if (!widget) {
     return;
   }
   // Find the context for the widget.
   let context = docManager.contextForWidget(widget);
   return context !== null;
 },

    execute: () => {
      let context = docManager.contextForWidget(app.shell.currentWidget);
      if (!context) {
        return;
      }

      // 'activate-main' is needed if this command is selected in the "open tabs" sidebar
      commands.execute('filebrowser:activate-main');
      commands.execute('filebrowser:navigate-main', {path: context.path});
    }

    execute: args => {
      const path = typeof args['path'] === 'undefined' ? ''
        : args['path'] as string;

      if (!path) {
        const command = CommandIDs.deleteFile;
        throw new Error(`A non-empty path is required for ${command}.`);
      }
      return docManager.deleteFile(path);
    }

 it('should be emitted when a file is created', (done) => {
   model.fileChanged.connect((sender, args) => {
     expect(sender).to.be(model);
     expect(args.type).to.be('new');
     expect(args.oldValue).to.be(null);
     expect(args.newValue.type).to.be('file');
     done();
   });
   manager.newUntitled({ type: 'file' }).catch(done);
 });