http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/helium/helium.service.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/helium/helium.service.js 
b/zeppelin-web/src/app/helium/helium.service.js
index d2054b3..7501fae 100644
--- a/zeppelin-web/src/app/helium/helium.service.js
+++ b/zeppelin-web/src/app/helium/helium.service.js
@@ -12,290 +12,294 @@
  * limitations under the License.
  */
 
-import { HeliumType, } from './helium-type'
+import {HeliumType} from './helium-type';
 import {
   createAllPackageConfigs,
   createPersistableConfig,
   mergePersistedConfWithSpec,
-} from './helium-conf'
+} from './helium-conf';
 import {
   createDefaultPackages,
-} from './helium-package'
+} from './helium-package';
 
-angular.module('zeppelinWebApp').service('heliumService', HeliumService)
+angular.module('zeppelinWebApp').service('heliumService', HeliumService);
 
 export default function HeliumService($http, $sce, baseUrlSrv) {
-  'ngInject'
+  'ngInject';
 
-  let visualizationBundles = []
-  let visualizationPackageOrder = []
+  let visualizationBundles = [];
+  let visualizationPackageOrder = [];
   // name `heliumBundles` should be same as 
`HeliumBundleFactory.HELIUM_BUNDLES_VAR`
-  let heliumBundles = []
+  let heliumBundles = [];
   // map for `{ magic: interpreter }`
-  let spellPerMagic = {}
+  let spellPerMagic = {};
   // map for `{ magic: package-name }`
-  let pkgNamePerMagic = {}
+  let pkgNamePerMagic = {};
 
   /**
    * @param magic {string} e.g `%flowchart`
    * @returns {SpellBase} undefined if magic is not registered
    */
-  this.getSpellByMagic = function (magic) {
-    return spellPerMagic[magic]
-  }
+  this.getSpellByMagic = function(magic) {
+    return spellPerMagic[magic];
+  };
 
-  this.executeSpell = function (magic, textWithoutMagic) {
+  this.executeSpell = function(magic, textWithoutMagic) {
     const promisedConf = this.getSinglePackageConfigUsingMagic(magic)
-      .then(confs => createPersistableConfig(confs))
+      .then((confs) => createPersistableConfig(confs));
 
-    return promisedConf.then(conf => {
-      const spell = this.getSpellByMagic(magic)
-      const spellResult = spell.interpret(textWithoutMagic, conf)
+    return promisedConf.then((conf) => {
+      const spell = this.getSpellByMagic(magic);
+      const spellResult = spell.interpret(textWithoutMagic, conf);
       const parsed = spellResult.getAllParsedDataWithTypes(
-        spellPerMagic, magic, textWithoutMagic)
+        spellPerMagic, magic, textWithoutMagic);
 
-      return parsed
-    })
-  }
+      return parsed;
+    });
+  };
 
-  this.executeSpellAsDisplaySystem = function (magic, textWithoutMagic) {
+  this.executeSpellAsDisplaySystem = function(magic, textWithoutMagic) {
     const promisedConf = this.getSinglePackageConfigUsingMagic(magic)
-      .then(confs => createPersistableConfig(confs))
+      .then((confs) => createPersistableConfig(confs));
 
-    return promisedConf.then(conf => {
-      const spell = this.getSpellByMagic(magic)
-      const spellResult = spell.interpret(textWithoutMagic.trim(), conf)
-      const parsed = spellResult.getAllParsedDataWithTypes(spellPerMagic)
+    return promisedConf.then((conf) => {
+      const spell = this.getSpellByMagic(magic);
+      const spellResult = spell.interpret(textWithoutMagic.trim(), conf);
+      const parsed = spellResult.getAllParsedDataWithTypes(spellPerMagic);
 
-      return parsed
-    })
-  }
+      return parsed;
+    });
+  };
 
-  this.getVisualizationCachedPackages = function () {
-    return visualizationBundles
-  }
+  this.getVisualizationCachedPackages = function() {
+    return visualizationBundles;
+  };
 
-  this.getVisualizationCachedPackageOrder = function () {
-    return visualizationPackageOrder
-  }
+  this.getVisualizationCachedPackageOrder = function() {
+    return visualizationPackageOrder;
+  };
 
   /**
    * @returns {Promise} which returns bundleOrder and cache it in 
`visualizationPackageOrder`
    */
-  this.getVisualizationPackageOrder = function () {
+  this.getVisualizationPackageOrder = function() {
     return $http.get(baseUrlSrv.getRestApiBase() + 
'/helium/order/visualization')
-      .then(function (response, status) {
-        const order = response.data.body
-        visualizationPackageOrder = order
-        return order
-      })
-      .catch(function (error) {
-        console.error('Can not get bundle order', error)
+      .then(function(response, status) {
+        const order = response.data.body;
+        visualizationPackageOrder = order;
+        return order;
       })
-  }
+      .catch(function(error) {
+        console.error('Can not get bundle order', error);
+      });
+  };
 
-  this.setVisualizationPackageOrder = function (list) {
-    return $http.post(baseUrlSrv.getRestApiBase() + 
'/helium/order/visualization', list)
-  }
+  this.setVisualizationPackageOrder = function(list) {
+    return $http.post(baseUrlSrv.getRestApiBase() + 
'/helium/order/visualization', list);
+  };
 
-  this.enable = function (name, artifact) {
-    return $http.post(baseUrlSrv.getRestApiBase() + '/helium/enable/' + name, 
artifact)
-  }
+  this.enable = function(name, artifact) {
+    return $http.post(baseUrlSrv.getRestApiBase() + '/helium/enable/' + name, 
artifact);
+  };
 
-  this.disable = function (name) {
-    return $http.post(baseUrlSrv.getRestApiBase() + '/helium/disable/' + name)
-  }
+  this.disable = function(name) {
+    return $http.post(baseUrlSrv.getRestApiBase() + '/helium/disable/' + name);
+  };
 
-  this.saveConfig = function (pkg, defaultPackageConfig, 
closeConfigPanelCallback) {
+  this.saveConfig = function(pkg, defaultPackageConfig, 
closeConfigPanelCallback) {
     // in case of local package, it will include `/`
-    const pkgArtifact = encodeURIComponent(pkg.artifact)
-    const pkgName = pkg.name
-    const filtered = createPersistableConfig(defaultPackageConfig)
+    const pkgArtifact = encodeURIComponent(pkg.artifact);
+    const pkgName = pkg.name;
+    const filtered = createPersistableConfig(defaultPackageConfig);
 
     if (!pkgName || !pkgArtifact || !filtered) {
       console.error(
-        `Can't save config for helium package '${pkgArtifact}'`, filtered)
-      return
+        `Can't save config for helium package '${pkgArtifact}'`, filtered);
+      return;
     }
 
-    const url = 
`${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgArtifact}`
+    const url = 
`${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgArtifact}`;
     return $http.post(url, filtered)
       .then(() => {
-        if (closeConfigPanelCallback) { closeConfigPanelCallback() }
+        if (closeConfigPanelCallback) {
+          closeConfigPanelCallback();
+        }
       }).catch((error) => {
-        console.error(`Failed to save config for ${pkgArtifact}`, error)
-      })
-  }
+        console.error(`Failed to save config for ${pkgArtifact}`, error);
+      });
+  };
 
   /**
    * @returns {Promise<Object>} which including {name, Array<package info for 
artifact>}
    */
-  this.getAllPackageInfo = function () {
+  this.getAllPackageInfo = function() {
     return $http.get(`${baseUrlSrv.getRestApiBase()}/helium/package`)
-      .then(function (response, status) {
-        return response.data.body
-      })
-      .catch(function (error) {
-        console.error('Failed to get all package infos', error)
+      .then(function(response, status) {
+        return response.data.body;
       })
-  }
+      .catch(function(error) {
+        console.error('Failed to get all package infos', error);
+      });
+  };
 
-  this.getAllEnabledPackages = function () {
+  this.getAllEnabledPackages = function() {
     return $http.get(`${baseUrlSrv.getRestApiBase()}/helium/enabledPackage`)
-      .then(function (response, status) {
-        return response.data.body
+      .then(function(response, status) {
+        return response.data.body;
       })
-      .catch(function (error) {
-        console.error('Failed to get all enabled package infos', error)
-      })
-  }
+      .catch(function(error) {
+        console.error('Failed to get all enabled package infos', error);
+      });
+  };
 
-  this.getSingleBundle = function (pkgName) {
-    let url = `${baseUrlSrv.getRestApiBase()}/helium/bundle/load/${pkgName}`
+  this.getSingleBundle = function(pkgName) {
+    let url = `${baseUrlSrv.getRestApiBase()}/helium/bundle/load/${pkgName}`;
     if (process.env.HELIUM_BUNDLE_DEV) {
-      url = url + '?refresh=true'
+      url = url + '?refresh=true';
     }
 
     return $http.get(url)
-      .then(function (response, status) {
-        const bundle = response.data
+      .then(function(response, status) {
+        const bundle = response.data;
         if (bundle.substring(0, 'ERROR:'.length) === 'ERROR:') {
-          console.error(`Failed to get bundle: ${pkgName}`, bundle)
-          return '' // empty bundle will be filtered later
+          console.error(`Failed to get bundle: ${pkgName}`, bundle);
+          return ''; // empty bundle will be filtered later
         }
 
-        return bundle
-      })
-      .catch(function (error) {
-        console.error(`Failed to get single bundle: ${pkgName}`, error)
+        return bundle;
       })
-  }
+      .catch(function(error) {
+        console.error(`Failed to get single bundle: ${pkgName}`, error);
+      });
+  };
 
-  this.getDefaultPackages = function () {
+  this.getDefaultPackages = function() {
     return this.getAllPackageInfo()
-      .then(pkgSearchResults => {
-        return createDefaultPackages(pkgSearchResults, $sce)
-      })
-  }
+      .then((pkgSearchResults) => {
+        return createDefaultPackages(pkgSearchResults, $sce);
+      });
+  };
 
-  this.getAllPackageInfoAndDefaultPackages = function () {
+  this.getAllPackageInfoAndDefaultPackages = function() {
     return this.getAllPackageInfo()
-      .then(pkgSearchResults => {
+      .then((pkgSearchResults) => {
         return {
           pkgSearchResults: pkgSearchResults,
           defaultPackages: createDefaultPackages(pkgSearchResults, $sce),
-        }
-      })
-  }
+        };
+      });
+  };
 
   /**
    * get all package configs.
    * @return { Promise<{name, Array<Object>}> }
    */
-  this.getAllPackageConfigs = function () {
-    const promisedDefaultPackages = this.getDefaultPackages()
+  this.getAllPackageConfigs = function() {
+    const promisedDefaultPackages = this.getDefaultPackages();
     const promisedPersistedConfs =
       $http.get(`${baseUrlSrv.getRestApiBase()}/helium/config`)
-      .then(function (response, status) {
-        return response.data.body
-      })
+      .then(function(response, status) {
+        return response.data.body;
+      });
 
     return Promise.all([promisedDefaultPackages, promisedPersistedConfs])
-      .then(values => {
-        const defaultPackages = values[0]
-        const persistedConfs = values[1]
+      .then((values) => {
+        const defaultPackages = values[0];
+        const persistedConfs = values[1];
 
-        return createAllPackageConfigs(defaultPackages, persistedConfs)
-      })
-      .catch(function (error) {
-        console.error('Failed to get all package configs', error)
+        return createAllPackageConfigs(defaultPackages, persistedConfs);
       })
-  }
+      .catch(function(error) {
+        console.error('Failed to get all package configs', error);
+      });
+  };
 
   /**
    * get the package config which is persisted in server.
    * @return { Promise<Array<Object>> }
    */
-  this.getSinglePackageConfigs = function (pkg) {
-    const pkgName = pkg.name
+  this.getSinglePackageConfigs = function(pkg) {
+    const pkgName = pkg.name;
     // in case of local package, it will include `/`
-    const pkgArtifact = encodeURIComponent(pkg.artifact)
+    const pkgArtifact = encodeURIComponent(pkg.artifact);
 
     if (!pkgName || !pkgArtifact) {
-      console.error('Failed to fetch config for\n', pkg)
-      return Promise.resolve([])
+      console.error('Failed to fetch config for\n', pkg);
+      return Promise.resolve([]);
     }
 
-    const confUrl = 
`${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgArtifact}`
+    const confUrl = 
`${baseUrlSrv.getRestApiBase()}/helium/config/${pkgName}/${pkgArtifact}`;
     const promisedConf = $http.get(confUrl)
-      .then(function (response, status) {
-        return response.data.body
-      })
+      .then(function(response, status) {
+        return response.data.body;
+      });
 
     return promisedConf.then(({confSpec, confPersisted}) => {
-      const merged = mergePersistedConfWithSpec(confPersisted, confSpec)
-      return merged
-    })
-  }
+      const merged = mergePersistedConfWithSpec(confPersisted, confSpec);
+      return merged;
+    });
+  };
 
-  this.getSinglePackageConfigUsingMagic = function (magic) {
-    const pkgName = pkgNamePerMagic[magic]
+  this.getSinglePackageConfigUsingMagic = function(magic) {
+    const pkgName = pkgNamePerMagic[magic];
 
-    const confUrl = 
`${baseUrlSrv.getRestApiBase()}/helium/spell/config/${pkgName}`
+    const confUrl = 
`${baseUrlSrv.getRestApiBase()}/helium/spell/config/${pkgName}`;
     const promisedConf = $http.get(confUrl)
-      .then(function (response, status) {
-        return response.data.body
-      })
+      .then(function(response, status) {
+        return response.data.body;
+      });
 
     return promisedConf.then(({confSpec, confPersisted}) => {
-      const merged = mergePersistedConfWithSpec(confPersisted, confSpec)
-      return merged
-    })
-  }
+      const merged = mergePersistedConfWithSpec(confPersisted, confSpec);
+      return merged;
+    });
+  };
 
   const p = this.getAllEnabledPackages()
-    .then(enabledPackageSearchResults => {
-      const promises = enabledPackageSearchResults.map(packageSearchResult => {
-        const pkgName = packageSearchResult.pkg.name
-        return this.getSingleBundle(pkgName)
-      })
+    .then((enabledPackageSearchResults) => {
+      const promises = enabledPackageSearchResults.map((packageSearchResult) 
=> {
+        const pkgName = packageSearchResult.pkg.name;
+        return this.getSingleBundle(pkgName);
+      });
 
-      return Promise.all(promises)
+      return Promise.all(promises);
     })
-    .then(bundles => {
+    .then((bundles) => {
       return bundles.reduce((acc, b) => {
         // filter out empty bundle
-        if (b === '') { return acc }
-        acc.push(b)
-        return acc
-      }, [])
-    })
+        if (b === '') {
+          return acc;
+        }
+        acc.push(b);
+        return acc;
+      }, []);
+    });
 
   // load should be promise
-  this.load = p.then(availableBundles => {
+  this.load = p.then((availableBundles) => {
     // evaluate bundles
-    availableBundles.map(b => {
+    availableBundles.map((b) => {
       // eslint-disable-next-line no-eval
-      eval(b)
-    })
+      eval(b);
+    });
 
     // extract bundles by type
-    heliumBundles.map(b => {
+    heliumBundles.map((b) => {
       if (b.type === HeliumType.SPELL) {
-        const spell = new b.class() // eslint-disable-line new-cap
-        const pkgName = b.id
-        spellPerMagic[spell.getMagic()] = spell
-        pkgNamePerMagic[spell.getMagic()] = pkgName
+        const spell = new b.class(); // eslint-disable-line new-cap
+        const pkgName = b.id;
+        spellPerMagic[spell.getMagic()] = spell;
+        pkgNamePerMagic[spell.getMagic()] = pkgName;
       } else if (b.type === HeliumType.VISUALIZATION) {
-        visualizationBundles.push(b)
+        visualizationBundles.push(b);
       }
-    })
-  })
+    });
+  });
 
   this.init = function() {
-    this.getVisualizationPackageOrder()
-  }
+    this.getVisualizationPackageOrder();
+  };
 
   // init
-  this.init()
+  this.init();
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/helium/index.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/helium/index.js 
b/zeppelin-web/src/app/helium/index.js
index 2b27d60..754c949 100644
--- a/zeppelin-web/src/app/helium/index.js
+++ b/zeppelin-web/src/app/helium/index.js
@@ -12,7 +12,7 @@
  * limitations under the License.
  */
 
-import HeliumController from './helium.controller'
+import HeliumController from './helium.controller';
 
 angular.module('zeppelinWebApp')
-  .controller('HeliumCtrl', HeliumController)
+  .controller('HeliumCtrl', HeliumController);

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/home/home.controller.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/home/home.controller.js 
b/zeppelin-web/src/app/home/home.controller.js
index d2823dd..7ae5e44 100644
--- a/zeppelin-web/src/app/home/home.controller.js
+++ b/zeppelin-web/src/app/home/home.controller.js
@@ -12,145 +12,145 @@
  * limitations under the License.
  */
 
-angular.module('zeppelinWebApp').controller('HomeCtrl', HomeCtrl)
+angular.module('zeppelinWebApp').controller('HomeCtrl', HomeCtrl);
 
-function HomeCtrl ($scope, noteListFactory, websocketMsgSrv, $rootScope, 
arrayOrderingSrv,
+function HomeCtrl($scope, noteListFactory, websocketMsgSrv, $rootScope, 
arrayOrderingSrv,
                   ngToast, noteActionService, TRASH_FOLDER_ID) {
-  'ngInject'
-
-  ngToast.dismiss()
-  let vm = this
-  vm.notes = noteListFactory
-  vm.websocketMsgSrv = websocketMsgSrv
-  vm.arrayOrderingSrv = arrayOrderingSrv
-  vm.noteActionService = noteActionService
-  vm.numberOfNotesDisplayed = window.innerHeight / 20
-
-  vm.notebookHome = false
-  vm.noteCustomHome = true
+  'ngInject';
+
+  ngToast.dismiss();
+  let vm = this;
+  vm.notes = noteListFactory;
+  vm.websocketMsgSrv = websocketMsgSrv;
+  vm.arrayOrderingSrv = arrayOrderingSrv;
+  vm.noteActionService = noteActionService;
+  vm.numberOfNotesDisplayed = window.innerHeight / 20;
+
+  vm.notebookHome = false;
+  vm.noteCustomHome = true;
   if ($rootScope.ticket !== undefined) {
-    vm.staticHome = false
+    vm.staticHome = false;
   } else {
-    vm.staticHome = true
+    vm.staticHome = true;
   }
 
-  $scope.isReloading = false
-  $scope.TRASH_FOLDER_ID = TRASH_FOLDER_ID
-  $scope.query = {q: ''}
+  $scope.isReloading = false;
+  $scope.TRASH_FOLDER_ID = TRASH_FOLDER_ID;
+  $scope.query = {q: ''};
 
-  $scope.initHome = function () {
-    websocketMsgSrv.getHomeNote()
-    vm.noteCustomHome = false
-  }
+  $scope.initHome = function() {
+    websocketMsgSrv.getHomeNote();
+    vm.noteCustomHome = false;
+  };
 
-  $scope.reloadNoteList = function () {
-    websocketMsgSrv.reloadAllNotesFromRepo()
-    $scope.isReloadingNotes = true
-  }
+  $scope.reloadNoteList = function() {
+    websocketMsgSrv.reloadAllNotesFromRepo();
+    $scope.isReloadingNotes = true;
+  };
 
-  $scope.toggleFolderNode = function (node) {
-    node.hidden = !node.hidden
-  }
+  $scope.toggleFolderNode = function(node) {
+    node.hidden = !node.hidden;
+  };
 
-  angular.element('#loginModal').on('hidden.bs.modal', function (e) {
-    $rootScope.$broadcast('initLoginValues')
-  })
+  angular.element('#loginModal').on('hidden.bs.modal', function(e) {
+    $rootScope.$broadcast('initLoginValues');
+  });
 
   /*
    ** $scope.$on functions below
    */
 
-  $scope.$on('setNoteMenu', function (event, notes) {
-    $scope.isReloadingNotes = false
-  })
+  $scope.$on('setNoteMenu', function(event, notes) {
+    $scope.isReloadingNotes = false;
+  });
 
-  $scope.$on('setNoteContent', function (event, note) {
+  $scope.$on('setNoteContent', function(event, note) {
     if (vm.noteCustomHome) {
-      return
+      return;
     }
 
     if (note) {
-      vm.note = note
+      vm.note = note;
 
       // initialize look And Feel
-      $rootScope.$broadcast('setLookAndFeel', 'home')
+      $rootScope.$broadcast('setLookAndFeel', 'home');
 
       // make it read only
-      vm.viewOnly = true
+      vm.viewOnly = true;
 
-      vm.notebookHome = true
-      vm.staticHome = false
+      vm.notebookHome = true;
+      vm.staticHome = false;
     } else {
-      vm.staticHome = true
-      vm.notebookHome = false
+      vm.staticHome = true;
+      vm.notebookHome = false;
     }
-  })
+  });
 
-  $scope.loadMoreNotes = function () {
-    vm.numberOfNotesDisplayed += 10
-  }
+  $scope.loadMoreNotes = function() {
+    vm.numberOfNotesDisplayed += 10;
+  };
 
-  $scope.renameNote = function (nodeId, nodePath) {
-    vm.noteActionService.renameNote(nodeId, nodePath)
-  }
+  $scope.renameNote = function(nodeId, nodePath) {
+    vm.noteActionService.renameNote(nodeId, nodePath);
+  };
 
-  $scope.moveNoteToTrash = function (noteId) {
-    vm.noteActionService.moveNoteToTrash(noteId, false)
-  }
+  $scope.moveNoteToTrash = function(noteId) {
+    vm.noteActionService.moveNoteToTrash(noteId, false);
+  };
 
-  $scope.moveFolderToTrash = function (folderId) {
-    vm.noteActionService.moveFolderToTrash(folderId)
-  }
+  $scope.moveFolderToTrash = function(folderId) {
+    vm.noteActionService.moveFolderToTrash(folderId);
+  };
 
-  $scope.restoreNote = function (noteId) {
-    websocketMsgSrv.restoreNote(noteId)
-  }
+  $scope.restoreNote = function(noteId) {
+    websocketMsgSrv.restoreNote(noteId);
+  };
 
-  $scope.restoreFolder = function (folderId) {
-    websocketMsgSrv.restoreFolder(folderId)
-  }
+  $scope.restoreFolder = function(folderId) {
+    websocketMsgSrv.restoreFolder(folderId);
+  };
 
-  $scope.restoreAll = function () {
-    vm.noteActionService.restoreAll()
-  }
+  $scope.restoreAll = function() {
+    vm.noteActionService.restoreAll();
+  };
 
-  $scope.renameFolder = function (node) {
-    vm.noteActionService.renameFolder(node.id)
-  }
+  $scope.renameFolder = function(node) {
+    vm.noteActionService.renameFolder(node.id);
+  };
 
-  $scope.removeNote = function (noteId) {
-    vm.noteActionService.removeNote(noteId, false)
-  }
+  $scope.removeNote = function(noteId) {
+    vm.noteActionService.removeNote(noteId, false);
+  };
 
-  $scope.removeFolder = function (folderId) {
-    vm.noteActionService.removeFolder(folderId)
-  }
+  $scope.removeFolder = function(folderId) {
+    vm.noteActionService.removeFolder(folderId);
+  };
 
-  $scope.emptyTrash = function () {
-    vm.noteActionService.emptyTrash()
-  }
+  $scope.emptyTrash = function() {
+    vm.noteActionService.emptyTrash();
+  };
 
-  $scope.clearAllParagraphOutput = function (noteId) {
-    vm.noteActionService.clearAllParagraphOutput(noteId)
-  }
+  $scope.clearAllParagraphOutput = function(noteId) {
+    vm.noteActionService.clearAllParagraphOutput(noteId);
+  };
 
-  $scope.isFilterNote = function (note) {
+  $scope.isFilterNote = function(note) {
     if (!$scope.query.q) {
-      return true
+      return true;
     }
 
-    let noteName = note.name
+    let noteName = note.name;
     if (noteName.toLowerCase().indexOf($scope.query.q.toLowerCase()) > -1) {
-      return true
+      return true;
     }
-    return false
-  }
+    return false;
+  };
 
-  $scope.getNoteName = function (note) {
-    return arrayOrderingSrv.getNoteName(note)
-  }
+  $scope.getNoteName = function(note) {
+    return arrayOrderingSrv.getNoteName(note);
+  };
 
-  $scope.noteComparator = function (note1, note2) {
-    return arrayOrderingSrv.noteComparator(note1, note2)
-  }
+  $scope.noteComparator = function(note1, note2) {
+    return arrayOrderingSrv.noteComparator(note1, note2);
+  };
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/interpreter/interpreter-item.directive.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/interpreter/interpreter-item.directive.js 
b/zeppelin-web/src/app/interpreter/interpreter-item.directive.js
index 4bde44d..cfb109a 100644
--- a/zeppelin-web/src/app/interpreter/interpreter-item.directive.js
+++ b/zeppelin-web/src/app/interpreter/interpreter-item.directive.js
@@ -12,20 +12,20 @@
  * limitations under the License.
  */
 
-angular.module('zeppelinWebApp').directive('interpreterItem', 
InterpreterItemDirective)
+angular.module('zeppelinWebApp').directive('interpreterItem', 
InterpreterItemDirective);
 
-function InterpreterItemDirective ($timeout) {
-  'ngInject'
+function InterpreterItemDirective($timeout) {
+  'ngInject';
 
   return {
     restrict: 'A',
-    link: function (scope, element, attr) {
+    link: function(scope, element, attr) {
       if (scope.$last === true) {
-        $timeout(function () {
-          let id = 'ngRenderFinished'
-          scope.$emit(id)
-        })
+        $timeout(function() {
+          let id = 'ngRenderFinished';
+          scope.$emit(id);
+        });
       }
-    }
-  }
+    },
+  };
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/interpreter/interpreter.controller.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/interpreter/interpreter.controller.js 
b/zeppelin-web/src/app/interpreter/interpreter.controller.js
index ef88402..060c6b6 100644
--- a/zeppelin-web/src/app/interpreter/interpreter.controller.js
+++ b/zeppelin-web/src/app/interpreter/interpreter.controller.js
@@ -12,548 +12,552 @@
  * limitations under the License.
  */
 
-import { ParagraphStatus, } from '../notebook/paragraph/paragraph.status'
+import {ParagraphStatus} from '../notebook/paragraph/paragraph.status';
 
-angular.module('zeppelinWebApp').controller('InterpreterCtrl', InterpreterCtrl)
+angular.module('zeppelinWebApp').controller('InterpreterCtrl', 
InterpreterCtrl);
 
 function InterpreterCtrl($rootScope, $scope, $http, baseUrlSrv, ngToast, 
$timeout, $route) {
-  'ngInject'
-
-  let interpreterSettingsTmp = []
-  $scope.interpreterSettings = []
-  $scope.availableInterpreters = {}
-  $scope.showAddNewSetting = false
-  $scope.showRepositoryInfo = false
-  $scope.searchInterpreter = ''
-  $scope._ = _
-  $scope.interpreterPropertyTypes = []
-  ngToast.dismiss()
-
-  $scope.openPermissions = function () {
-    $scope.showInterpreterAuth = true
-  }
-
-  $scope.closePermissions = function () {
-    $scope.showInterpreterAuth = false
-  }
-
-  let getSelectJson = function () {
+  'ngInject';
+
+  let interpreterSettingsTmp = [];
+  $scope.interpreterSettings = [];
+  $scope.availableInterpreters = {};
+  $scope.showAddNewSetting = false;
+  $scope.showRepositoryInfo = false;
+  $scope.searchInterpreter = '';
+  $scope._ = _;
+  $scope.interpreterPropertyTypes = [];
+  ngToast.dismiss();
+
+  $scope.openPermissions = function() {
+    $scope.showInterpreterAuth = true;
+  };
+
+  $scope.closePermissions = function() {
+    $scope.showInterpreterAuth = false;
+  };
+
+  let getSelectJson = function() {
     let selectJson = {
       tags: true,
       minimumInputLength: 3,
       multiple: true,
       tokenSeparators: [',', ' '],
       ajax: {
-        url: function (params) {
+        url: function(params) {
           if (!params.term) {
-            return false
+            return false;
           }
-          return baseUrlSrv.getRestApiBase() + '/security/userlist/' + 
params.term
+          return baseUrlSrv.getRestApiBase() + '/security/userlist/' + 
params.term;
         },
         delay: 250,
-        processResults: function (data, params) {
-          let results = []
+        processResults: function(data, params) {
+          let results = [];
 
           if (data.body.users.length !== 0) {
-            let users = []
+            let users = [];
             for (let len = 0; len < data.body.users.length; len++) {
               users.push({
                 'id': data.body.users[len],
-                'text': data.body.users[len]
-              })
+                'text': data.body.users[len],
+              });
             }
             results.push({
               'text': 'Users :',
-              'children': users
-            })
+              'children': users,
+            });
           }
           if (data.body.roles.length !== 0) {
-            let roles = []
+            let roles = [];
             for (let len = 0; len < data.body.roles.length; len++) {
               roles.push({
                 'id': data.body.roles[len],
-                'text': data.body.roles[len]
-              })
+                'text': data.body.roles[len],
+              });
             }
             results.push({
               'text': 'Roles :',
-              'children': roles
-            })
+              'children': roles,
+            });
           }
           return {
             results: results,
             pagination: {
-              more: false
-            }
-          }
+              more: false,
+            },
+          };
         },
-        cache: false
-      }
-    }
-    return selectJson
-  }
-
-  $scope.togglePermissions = function (intpName) {
-    angular.element('#' + intpName + 'Owners').select2(getSelectJson())
+        cache: false,
+      },
+    };
+    return selectJson;
+  };
+
+  $scope.togglePermissions = function(intpName) {
+    angular.element('#' + intpName + 'Owners').select2(getSelectJson());
     if ($scope.showInterpreterAuth) {
-      $scope.closePermissions()
+      $scope.closePermissions();
     } else {
-      $scope.openPermissions()
+      $scope.openPermissions();
     }
-  }
+  };
 
-  $scope.$on('ngRenderFinished', function (event, data) {
+  $scope.$on('ngRenderFinished', function(event, data) {
     for (let setting = 0; setting < $scope.interpreterSettings.length; 
setting++) {
-      angular.element('#' + $scope.interpreterSettings[setting].name + 
'Owners').select2(getSelectJson())
+      angular.element('#' + $scope.interpreterSettings[setting].name + 
'Owners').select2(getSelectJson());
     }
-  })
+  });
 
-  let getInterpreterSettings = function () {
+  let getInterpreterSettings = function() {
     $http.get(baseUrlSrv.getRestApiBase() + '/interpreter/setting')
-      .then(function (res) {
-        $scope.interpreterSettings = res.data.body
-        checkDownloadingDependencies()
-      }).catch(function (res) {
+      .then(function(res) {
+        $scope.interpreterSettings = res.data.body;
+        checkDownloadingDependencies();
+      }).catch(function(res) {
         if (res.status === 401) {
           ngToast.danger({
             content: 'You don\'t have permission on this page',
             verticalPosition: 'bottom',
-            timeout: '3000'
-          })
-          setTimeout(function () {
-            window.location = baseUrlSrv.getBase()
-          }, 3000)
+            timeout: '3000',
+          });
+          setTimeout(function() {
+            window.location = baseUrlSrv.getBase();
+          }, 3000);
         }
-        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'')
-      })
-  }
+        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'');
+      });
+  };
 
-  const checkDownloadingDependencies = function () {
-    let isDownloading = false
+  const checkDownloadingDependencies = function() {
+    let isDownloading = false;
     for (let index = 0; index < $scope.interpreterSettings.length; index++) {
-      let setting = $scope.interpreterSettings[index]
+      let setting = $scope.interpreterSettings[index];
       if (setting.status === 'DOWNLOADING_DEPENDENCIES') {
-        isDownloading = true
+        isDownloading = true;
       }
 
       if (setting.status === ParagraphStatus.ERROR || setting.errorReason) {
         ngToast.danger({content: 'Error setting properties for interpreter \'' 
+
         setting.group + '.' + setting.name + '\': ' + setting.errorReason,
           verticalPosition: 'top',
-          dismissOnTimeout: false
-        })
+          dismissOnTimeout: false,
+        });
       }
     }
 
     if (isDownloading) {
-      $timeout(function () {
+      $timeout(function() {
         if ($route.current.$$route.originalPath === '/interpreter') {
-          getInterpreterSettings()
+          getInterpreterSettings();
         }
-      }, 2000)
+      }, 2000);
     }
-  }
+  };
 
-  let getAvailableInterpreters = function () {
-    $http.get(baseUrlSrv.getRestApiBase() + '/interpreter').then(function 
(res) {
-      $scope.availableInterpreters = res.data.body
-    }).catch(function (res) {
-      console.log('Error %o %o', res.status, res.data ? res.data.message : '')
-    })
-  }
+  let getAvailableInterpreters = function() {
+    $http.get(baseUrlSrv.getRestApiBase() + '/interpreter').then(function(res) 
{
+      $scope.availableInterpreters = res.data.body;
+    }).catch(function(res) {
+      console.log('Error %o %o', res.status, res.data ? res.data.message : '');
+    });
+  };
 
-  let getAvailableInterpreterPropertyWidgets = function () {
+  let getAvailableInterpreterPropertyWidgets = function() {
     $http.get(baseUrlSrv.getRestApiBase() + '/interpreter/property/types')
-      .then(function (res) {
-        $scope.interpreterPropertyTypes = res.data.body
-      }).catch(function (res) {
-        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'')
-      })
-  }
+      .then(function(res) {
+        $scope.interpreterPropertyTypes = res.data.body;
+      }).catch(function(res) {
+        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'');
+      });
+  };
 
   let emptyNewProperty = function(object) {
-    angular.extend(object, {propertyValue: '', propertyKey: '', propertyType: 
$scope.interpreterPropertyTypes[0]})
-  }
+    angular.extend(object, {propertyValue: '', propertyKey: '', propertyType: 
$scope.interpreterPropertyTypes[0]});
+  };
 
-  let emptyNewDependency = function (object) {
-    angular.extend(object, {depArtifact: '', depExclude: ''})
-  }
+  let emptyNewDependency = function(object) {
+    angular.extend(object, {depArtifact: '', depExclude: ''});
+  };
 
-  let removeTMPSettings = function (index) {
-    interpreterSettingsTmp.splice(index, 1)
-  }
+  let removeTMPSettings = function(index) {
+    interpreterSettingsTmp.splice(index, 1);
+  };
 
-  $scope.copyOriginInterpreterSettingProperties = function (settingId) {
-    let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-    interpreterSettingsTmp[index] = 
angular.copy($scope.interpreterSettings[index])
-  }
+  $scope.copyOriginInterpreterSettingProperties = function(settingId) {
+    let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+    interpreterSettingsTmp[index] = 
angular.copy($scope.interpreterSettings[index]);
+  };
 
-  $scope.setPerNoteOption = function (settingId, sessionOption) {
-    let option
+  $scope.setPerNoteOption = function(settingId, sessionOption) {
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
 
     if (sessionOption === 'isolated') {
-      option.perNote = sessionOption
-      option.session = false
-      option.process = true
+      option.perNote = sessionOption;
+      option.session = false;
+      option.process = true;
     } else if (sessionOption === 'scoped') {
-      option.perNote = sessionOption
-      option.session = true
-      option.process = false
+      option.perNote = sessionOption;
+      option.session = true;
+      option.process = false;
     } else {
-      option.perNote = 'shared'
-      option.session = false
-      option.process = false
+      option.perNote = 'shared';
+      option.session = false;
+      option.process = false;
     }
-  }
+  };
 
-  $scope.defaultValueByType = function (setting) {
+  $scope.defaultValueByType = function(setting) {
     if (setting.propertyType === 'checkbox') {
-      setting.propertyValue = false
-      return
+      setting.propertyValue = false;
+      return;
     }
 
-    setting.propertyValue = ''
-  }
+    setting.propertyValue = '';
+  };
 
-  $scope.setPerUserOption = function (settingId, sessionOption) {
-    let option
+  $scope.setPerUserOption = function(settingId, sessionOption) {
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
 
     if (sessionOption === 'isolated') {
-      option.perUser = sessionOption
-      option.session = false
-      option.process = true
+      option.perUser = sessionOption;
+      option.session = false;
+      option.process = true;
     } else if (sessionOption === 'scoped') {
-      option.perUser = sessionOption
-      option.session = true
-      option.process = false
+      option.perUser = sessionOption;
+      option.session = true;
+      option.process = false;
     } else {
-      option.perUser = 'shared'
-      option.session = false
-      option.process = false
+      option.perUser = 'shared';
+      option.session = false;
+      option.process = false;
     }
-  }
+  };
 
-  $scope.getPerNoteOption = function (settingId) {
-    let option
+  $scope.getPerNoteOption = function(settingId) {
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
 
     if (option.perNote === 'scoped') {
-      return 'scoped'
+      return 'scoped';
     } else if (option.perNote === 'isolated') {
-      return 'isolated'
+      return 'isolated';
     } else {
-      return 'shared'
+      return 'shared';
     }
-  }
+  };
 
-  $scope.getPerUserOption = function (settingId) {
-    let option
+  $scope.getPerUserOption = function(settingId) {
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
 
     if (option.perUser === 'scoped') {
-      return 'scoped'
+      return 'scoped';
     } else if (option.perUser === 'isolated') {
-      return 'isolated'
+      return 'isolated';
     } else {
-      return 'shared'
+      return 'shared';
     }
-  }
+  };
 
-  $scope.getInterpreterRunningOption = function (settingId) {
-    let sharedModeName = 'shared'
+  $scope.getInterpreterRunningOption = function(settingId) {
+    let sharedModeName = 'shared';
 
-    let globallyModeName = 'Globally'
-    let perNoteModeName = 'Per Note'
-    let perUserModeName = 'Per User'
+    let globallyModeName = 'Globally';
+    let perNoteModeName = 'Per Note';
+    let perUserModeName = 'Per User';
 
-    let option
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
 
-    let perNote = option.perNote
-    let perUser = option.perUser
+    let perNote = option.perNote;
+    let perUser = option.perUser;
 
     // Globally == shared_perNote + shared_perUser
     if (perNote === sharedModeName && perUser === sharedModeName) {
-      return globallyModeName
+      return globallyModeName;
     }
 
     if ($rootScope.ticket.ticket === 'anonymous' && $rootScope.ticket.roles 
=== '[]') {
       if (perNote !== undefined && typeof perNote === 'string' && perNote !== 
'') {
-        return perNoteModeName
+        return perNoteModeName;
       }
     } else if ($rootScope.ticket.ticket !== 'anonymous') {
       if (perNote !== undefined && typeof perNote === 'string' && perNote !== 
'') {
         if (perUser !== undefined && typeof perUser === 'string' && perUser 
!== '') {
-          return perUserModeName
+          return perUserModeName;
         }
-        return perNoteModeName
+        return perNoteModeName;
       }
     }
 
-    option.perNote = sharedModeName
-    option.perUser = sharedModeName
-    return globallyModeName
-  }
+    option.perNote = sharedModeName;
+    option.perUser = sharedModeName;
+    return globallyModeName;
+  };
 
-  $scope.setInterpreterRunningOption = function (settingId, isPerNoteMode, 
isPerUserMode) {
-    let option
+  $scope.setInterpreterRunningOption = function(settingId, isPerNoteMode, 
isPerUserMode) {
+    let option;
     if (settingId === undefined) {
-      option = $scope.newInterpreterSetting.option
+      option = $scope.newInterpreterSetting.option;
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
-      option = setting.option
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
+      option = setting.option;
     }
-    option.perNote = isPerNoteMode
-    option.perUser = isPerUserMode
-  }
+    option.perNote = isPerNoteMode;
+    option.perUser = isPerUserMode;
+  };
 
-  $scope.updateInterpreterSetting = function (form, settingId) {
+  $scope.updateInterpreterSetting = function(form, settingId) {
     const thisConfirm = BootstrapDialog.confirm({
       closable: false,
       closeByBackdrop: false,
       closeByKeyboard: false,
       title: '',
       message: 'Do you want to update this interpreter and restart with new 
settings?',
-      callback: function (result) {
+      callback: function(result) {
         if (result) {
-          let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId})
-          let setting = $scope.interpreterSettings[index]
+          let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId});
+          let setting = $scope.interpreterSettings[index];
           if (setting.propertyKey !== '' || setting.propertyKey) {
-            $scope.addNewInterpreterProperty(settingId)
+            $scope.addNewInterpreterProperty(settingId);
           }
           if (setting.depArtifact !== '' || setting.depArtifact) {
-            $scope.addNewInterpreterDependency(settingId)
+            $scope.addNewInterpreterDependency(settingId);
           }
           // add missing field of option
           if (!setting.option) {
-            setting.option = {}
+            setting.option = {};
           }
           if (setting.option.isExistingProcess === undefined) {
-            setting.option.isExistingProcess = false
+            setting.option.isExistingProcess = false;
           }
           if (setting.option.setPermission === undefined) {
-            setting.option.setPermission = false
+            setting.option.setPermission = false;
           }
           if (setting.option.isUserImpersonate === undefined) {
-            setting.option.isUserImpersonate = false
+            setting.option.isUserImpersonate = false;
           }
           if (!($scope.getInterpreterRunningOption(settingId) === 'Per User' &&
             $scope.getPerUserOption(settingId) === 'isolated')) {
-            setting.option.isUserImpersonate = false
+            setting.option.isUserImpersonate = false;
           }
           if (setting.option.remote === undefined) {
             // remote always true for now
-            setting.option.remote = true
+            setting.option.remote = true;
           }
-          setting.option.owners = angular.element('#' + setting.name + 
'Owners').val()
+          setting.option.owners = angular.element('#' + setting.name + 
'Owners').val();
 
           let request = {
             option: angular.copy(setting.option),
             properties: angular.copy(setting.properties),
-            dependencies: angular.copy(setting.dependencies)
-          }
+            dependencies: angular.copy(setting.dependencies),
+          };
 
-          thisConfirm.$modalFooter.find('button').addClass('disabled')
+          thisConfirm.$modalFooter.find('button').addClass('disabled');
           thisConfirm.$modalFooter.find('button:contains("OK")')
-            .html('<i class="fa fa-circle-o-notch fa-spin"></i> Saving 
Setting')
+            .html('<i class="fa fa-circle-o-notch fa-spin"></i> Saving 
Setting');
 
           $http.put(baseUrlSrv.getRestApiBase() + '/interpreter/setting/' + 
settingId, request)
-            .then(function (res) {
-              $scope.interpreterSettings[index] = res.data.body
-              removeTMPSettings(index)
-              checkDownloadingDependencies()
-              thisConfirm.close()
-            })
-            .catch(function (res) {
-              const message = res.data ? res.data.message : 'Could not connect 
to server.'
-              console.log('Error %o %o', res.status, message)
-              ngToast.danger({content: message, verticalPosition: 'bottom'})
-              form.$show()
-              thisConfirm.close()
+            .then(function(res) {
+              $scope.interpreterSettings[index] = res.data.body;
+              removeTMPSettings(index);
+              checkDownloadingDependencies();
+              thisConfirm.close();
             })
-          return false
+            .catch(function(res) {
+              const message = res.data ? res.data.message : 'Could not connect 
to server.';
+              console.log('Error %o %o', res.status, message);
+              ngToast.danger({content: message, verticalPosition: 'bottom'});
+              form.$show();
+              thisConfirm.close();
+            });
+          return false;
         } else {
-          form.$show()
+          form.$show();
         }
-      }
-    })
-  }
+      },
+    });
+  };
 
-  $scope.resetInterpreterSetting = function (settingId) {
-    let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
+  $scope.resetInterpreterSetting = function(settingId) {
+    let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
 
     // Set the old settings back
-    $scope.interpreterSettings[index] = 
angular.copy(interpreterSettingsTmp[index])
-    removeTMPSettings(index)
-  }
+    $scope.interpreterSettings[index] = 
angular.copy(interpreterSettingsTmp[index]);
+    removeTMPSettings(index);
+  };
 
-  $scope.removeInterpreterSetting = function (settingId) {
+  $scope.removeInterpreterSetting = function(settingId) {
     BootstrapDialog.confirm({
       closable: true,
       title: '',
       message: 'Do you want to delete this interpreter setting?',
-      callback: function (result) {
+      callback: function(result) {
         if (result) {
           $http.delete(baseUrlSrv.getRestApiBase() + '/interpreter/setting/' + 
settingId)
-            .then(function (res) {
-              let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId})
-              $scope.interpreterSettings.splice(index, 1)
-            }).catch(function (res) {
-              console.log('Error %o %o', res.status, res.data ? 
res.data.message : '')
-            })
+            .then(function(res) {
+              let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId});
+              $scope.interpreterSettings.splice(index, 1);
+            }).catch(function(res) {
+              console.log('Error %o %o', res.status, res.data ? 
res.data.message : '');
+            });
         }
-      }
-    })
-  }
+      },
+    });
+  };
 
-  $scope.newInterpreterGroupChange = function () {
+  $scope.newInterpreterGroupChange = function() {
     let el = _.pluck(_.filter($scope.availableInterpreters, {'name': 
$scope.newInterpreterSetting.group}),
-      'properties')
-    let properties = {}
+      'properties');
+    let properties = {};
     for (let i = 0; i < el.length; i++) {
-      let intpInfo = el[i]
+      let intpInfo = el[i];
       for (let key in intpInfo) {
-        properties[key] = {
-          value: intpInfo[key].defaultValue,
-          description: intpInfo[key].description,
-          type: intpInfo[key].type
+        if (intpInfo.hasOwnProperty(key)) {
+          properties[key] = {
+            value: intpInfo[key].defaultValue,
+            description: intpInfo[key].description,
+            type: intpInfo[key].type,
+          };
         }
       }
     }
-    $scope.newInterpreterSetting.properties = properties
-  }
+    $scope.newInterpreterSetting.properties = properties;
+  };
 
-  $scope.restartInterpreterSetting = function (settingId) {
+  $scope.restartInterpreterSetting = function(settingId) {
     BootstrapDialog.confirm({
       closable: true,
       title: '',
       message: 'Do you want to restart this interpreter?',
-      callback: function (result) {
+      callback: function(result) {
         if (result) {
           $http.put(baseUrlSrv.getRestApiBase() + 
'/interpreter/setting/restart/' + settingId)
-            .then(function (res) {
-              let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId})
-              $scope.interpreterSettings[index] = res.data.body
-              ngToast.info('Interpreter stopped. Will be lazily started on 
next run.')
-            }).catch(function (res) {
-              let errorMsg = (res.data !== null) ? res.data.message : 'Could 
not connect to server.'
-              console.log('Error %o %o', res.status, errorMsg)
-              ngToast.danger(errorMsg)
-            })
+            .then(function(res) {
+              let index = _.findIndex($scope.interpreterSettings, {'id': 
settingId});
+              $scope.interpreterSettings[index] = res.data.body;
+              ngToast.info('Interpreter stopped. Will be lazily started on 
next run.');
+            }).catch(function(res) {
+              let errorMsg = (res.data !== null) ? res.data.message : 'Could 
not connect to server.';
+              console.log('Error %o %o', res.status, errorMsg);
+              ngToast.danger(errorMsg);
+            });
         }
-      }
-    })
-  }
+      },
+    });
+  };
 
-  $scope.addNewInterpreterSetting = function () {
+  $scope.addNewInterpreterSetting = function() {
     // user input validation on interpreter creation
     if (!$scope.newInterpreterSetting.name ||
       !$scope.newInterpreterSetting.name.trim() || 
!$scope.newInterpreterSetting.group) {
       BootstrapDialog.alert({
         closable: true,
         title: 'Add interpreter',
-        message: 'Please fill in interpreter name and choose a group'
-      })
-      return
+        message: 'Please fill in interpreter name and choose a group',
+      });
+      return;
     }
 
     if ($scope.newInterpreterSetting.name.indexOf('.') >= 0) {
       BootstrapDialog.alert({
         closable: true,
         title: 'Add interpreter',
-        message: '\'.\' is invalid for interpreter name'
-      })
-      return
+        message: '\'.\' is invalid for interpreter name',
+      });
+      return;
     }
 
     if (_.findIndex($scope.interpreterSettings, {'name': 
$scope.newInterpreterSetting.name}) >= 0) {
       BootstrapDialog.alert({
         closable: true,
         title: 'Add interpreter',
-        message: 'Name ' + $scope.newInterpreterSetting.name + ' already 
exists'
-      })
-      return
+        message: 'Name ' + $scope.newInterpreterSetting.name + ' already 
exists',
+      });
+      return;
     }
 
-    let newSetting = $scope.newInterpreterSetting
+    let newSetting = $scope.newInterpreterSetting;
     if (newSetting.propertyKey !== '' || newSetting.propertyKey) {
-      $scope.addNewInterpreterProperty()
+      $scope.addNewInterpreterProperty();
     }
     if (newSetting.depArtifact !== '' || newSetting.depArtifact) {
-      $scope.addNewInterpreterDependency()
+      $scope.addNewInterpreterDependency();
     }
     if (newSetting.option.setPermission === undefined) {
-      newSetting.option.setPermission = false
+      newSetting.option.setPermission = false;
     }
-    newSetting.option.owners = angular.element('#newInterpreterOwners').val()
+    newSetting.option.owners = angular.element('#newInterpreterOwners').val();
 
-    let request = angular.copy($scope.newInterpreterSetting)
+    let request = angular.copy($scope.newInterpreterSetting);
 
     // Change properties to proper request format
-    let newProperties = {}
+    let newProperties = {};
 
     for (let p in newSetting.properties) {
-      newProperties[p] = {
-        value: newSetting.properties[p].value,
-        type: newSetting.properties[p].type,
-        name: p
+      if (newSetting.properties.hasOwnProperty(p)) {
+        newProperties[p] = {
+          value: newSetting.properties[p].value,
+          type: newSetting.properties[p].type,
+          name: p,
+        };
       }
     }
 
-    request.properties = newProperties
+    request.properties = newProperties;
 
     $http.post(baseUrlSrv.getRestApiBase() + '/interpreter/setting', request)
-      .then(function (res) {
-        $scope.resetNewInterpreterSetting()
-        getInterpreterSettings()
-        $scope.showAddNewSetting = false
-        checkDownloadingDependencies()
-      }).catch(function (res) {
-        const errorMsg = res.data ? res.data.message : 'Could not connect to 
server.'
-        console.log('Error %o %o', res.status, errorMsg)
-        ngToast.danger({content: errorMsg, verticalPosition: 'bottom'})
-      })
-  }
-
-  $scope.cancelInterpreterSetting = function () {
-    $scope.showAddNewSetting = false
-    $scope.resetNewInterpreterSetting()
-  }
-
-  $scope.resetNewInterpreterSetting = function () {
+      .then(function(res) {
+        $scope.resetNewInterpreterSetting();
+        getInterpreterSettings();
+        $scope.showAddNewSetting = false;
+        checkDownloadingDependencies();
+      }).catch(function(res) {
+        const errorMsg = res.data ? res.data.message : 'Could not connect to 
server.';
+        console.log('Error %o %o', res.status, errorMsg);
+        ngToast.danger({content: errorMsg, verticalPosition: 'bottom'});
+      });
+  };
+
+  $scope.cancelInterpreterSetting = function() {
+    $scope.showAddNewSetting = false;
+    $scope.resetNewInterpreterSetting();
+  };
+
+  $scope.resetNewInterpreterSetting = function() {
     $scope.newInterpreterSetting = {
       name: undefined,
       group: undefined,
@@ -564,94 +568,94 @@ function InterpreterCtrl($rootScope, $scope, $http, 
baseUrlSrv, ngToast, $timeou
         isExistingProcess: false,
         setPermission: false,
         session: false,
-        process: false
+        process: false,
 
-      }
-    }
-    emptyNewProperty($scope.newInterpreterSetting)
-  }
+      },
+    };
+    emptyNewProperty($scope.newInterpreterSetting);
+  };
 
-  $scope.removeInterpreterProperty = function (key, settingId) {
+  $scope.removeInterpreterProperty = function(key, settingId) {
     if (settingId === undefined) {
-      delete $scope.newInterpreterSetting.properties[key]
+      delete $scope.newInterpreterSetting.properties[key];
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      delete $scope.interpreterSettings[index].properties[key]
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      delete $scope.interpreterSettings[index].properties[key];
     }
-  }
+  };
 
-  $scope.removeInterpreterDependency = function (artifact, settingId) {
+  $scope.removeInterpreterDependency = function(artifact, settingId) {
     if (settingId === undefined) {
       $scope.newInterpreterSetting.dependencies = 
_.reject($scope.newInterpreterSetting.dependencies,
-        function (el) {
-          return el.groupArtifactVersion === artifact
-        })
+        function(el) {
+          return el.groupArtifactVersion === artifact;
+        });
     } else {
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
       $scope.interpreterSettings[index].dependencies = 
_.reject($scope.interpreterSettings[index].dependencies,
-        function (el) {
-          return el.groupArtifactVersion === artifact
-        })
+        function(el) {
+          return el.groupArtifactVersion === artifact;
+        });
     }
-  }
+  };
 
-  $scope.addNewInterpreterProperty = function (settingId) {
+  $scope.addNewInterpreterProperty = function(settingId) {
     if (settingId === undefined) {
       // Add new property from create form
       if (!$scope.newInterpreterSetting.propertyKey || 
$scope.newInterpreterSetting.propertyKey === '') {
-        return
+        return;
       }
       
$scope.newInterpreterSetting.properties[$scope.newInterpreterSetting.propertyKey]
 = {
         value: $scope.newInterpreterSetting.propertyValue,
-        type: $scope.newInterpreterSetting.propertyType
-      }
-      emptyNewProperty($scope.newInterpreterSetting)
+        type: $scope.newInterpreterSetting.propertyType,
+      };
+      emptyNewProperty($scope.newInterpreterSetting);
     } else {
       // Add new property from edit form
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
 
       if (!setting.propertyKey || setting.propertyKey === '') {
-        return
+        return;
       }
 
       setting.properties[setting.propertyKey] =
-        {value: setting.propertyValue, type: setting.propertyType}
+        {value: setting.propertyValue, type: setting.propertyType};
 
-      emptyNewProperty(setting)
+      emptyNewProperty(setting);
     }
-  }
+  };
 
-  $scope.addNewInterpreterDependency = function (settingId) {
+  $scope.addNewInterpreterDependency = function(settingId) {
     if (settingId === undefined) {
       // Add new dependency from create form
       if (!$scope.newInterpreterSetting.depArtifact || 
$scope.newInterpreterSetting.depArtifact === '') {
-        return
+        return;
       }
 
       // overwrite if artifact already exists
-      let newSetting = $scope.newInterpreterSetting
+      let newSetting = $scope.newInterpreterSetting;
       for (let d in newSetting.dependencies) {
         if (newSetting.dependencies[d].groupArtifactVersion === 
newSetting.depArtifact) {
           newSetting.dependencies[d] = {
             'groupArtifactVersion': newSetting.depArtifact,
-            'exclusions': newSetting.depExclude
-          }
-          newSetting.dependencies.splice(d, 1)
+            'exclusions': newSetting.depExclude,
+          };
+          newSetting.dependencies.splice(d, 1);
         }
       }
 
       newSetting.dependencies.push({
         'groupArtifactVersion': newSetting.depArtifact,
-        'exclusions': (newSetting.depExclude === '') ? [] : 
newSetting.depExclude
-      })
-      emptyNewDependency(newSetting)
+        'exclusions': (newSetting.depExclude === '') ? [] : 
newSetting.depExclude,
+      });
+      emptyNewDependency(newSetting);
     } else {
       // Add new dependency from edit form
-      let index = _.findIndex($scope.interpreterSettings, {'id': settingId})
-      let setting = $scope.interpreterSettings[index]
+      let index = _.findIndex($scope.interpreterSettings, {'id': settingId});
+      let setting = $scope.interpreterSettings[index];
       if (!setting.depArtifact || setting.depArtifact === '') {
-        return
+        return;
       }
 
       // overwrite if artifact already exists
@@ -659,21 +663,21 @@ function InterpreterCtrl($rootScope, $scope, $http, 
baseUrlSrv, ngToast, $timeou
         if (setting.dependencies[dep].groupArtifactVersion === 
setting.depArtifact) {
           setting.dependencies[dep] = {
             'groupArtifactVersion': setting.depArtifact,
-            'exclusions': setting.depExclude
-          }
-          setting.dependencies.splice(dep, 1)
+            'exclusions': setting.depExclude,
+          };
+          setting.dependencies.splice(dep, 1);
         }
       }
 
       setting.dependencies.push({
         'groupArtifactVersion': setting.depArtifact,
-        'exclusions': (setting.depExclude === '') ? [] : setting.depExclude
-      })
-      emptyNewDependency(setting)
+        'exclusions': (setting.depExclude === '') ? [] : setting.depExclude,
+      });
+      emptyNewDependency(setting);
     }
-  }
+  };
 
-  $scope.resetNewRepositorySetting = function () {
+  $scope.resetNewRepositorySetting = function() {
     $scope.newRepoSetting = {
       id: '',
       url: '',
@@ -684,102 +688,102 @@ function InterpreterCtrl($rootScope, $scope, $http, 
baseUrlSrv, ngToast, $timeou
       proxyHost: '',
       proxyPort: null,
       proxyLogin: '',
-      proxyPassword: ''
-    }
-  }
+      proxyPassword: '',
+    };
+  };
 
-  let getRepositories = function () {
+  let getRepositories = function() {
     $http.get(baseUrlSrv.getRestApiBase() + '/interpreter/repository')
-      .success(function (data, status, headers, config) {
-        $scope.repositories = data.body
-      }).error(function (data, status, headers, config) {
-        console.log('Error %o %o', status, data.message)
-      })
-  }
+      .success(function(data, status, headers, config) {
+        $scope.repositories = data.body;
+      }).error(function(data, status, headers, config) {
+        console.log('Error %o %o', status, data.message);
+      });
+  };
 
-  $scope.addNewRepository = function () {
-    let request = angular.copy($scope.newRepoSetting)
+  $scope.addNewRepository = function() {
+    let request = angular.copy($scope.newRepoSetting);
 
     $http.post(baseUrlSrv.getRestApiBase() + '/interpreter/repository', 
request)
-      .then(function (res) {
-        getRepositories()
-        $scope.resetNewRepositorySetting()
-        angular.element('#repoModal').modal('hide')
-      }).catch(function (res) {
-        console.log('Error %o %o', res.headers, res.config)
-      })
-  }
-
-  $scope.removeRepository = function (repoId) {
+      .then(function(res) {
+        getRepositories();
+        $scope.resetNewRepositorySetting();
+        angular.element('#repoModal').modal('hide');
+      }).catch(function(res) {
+        console.log('Error %o %o', res.headers, res.config);
+      });
+  };
+
+  $scope.removeRepository = function(repoId) {
     BootstrapDialog.confirm({
       closable: true,
       title: '',
       message: 'Do you want to delete this repository?',
-      callback: function (result) {
+      callback: function(result) {
         if (result) {
           $http.delete(baseUrlSrv.getRestApiBase() + 
'/interpreter/repository/' + repoId)
-            .then(function (res) {
-              let index = _.findIndex($scope.repositories, {'id': repoId})
-              $scope.repositories.splice(index, 1)
-            }).catch(function (res) {
-              console.log('Error %o %o', res.status, res.data ? 
res.data.message : '')
-            })
+            .then(function(res) {
+              let index = _.findIndex($scope.repositories, {'id': repoId});
+              $scope.repositories.splice(index, 1);
+            }).catch(function(res) {
+              console.log('Error %o %o', res.status, res.data ? 
res.data.message : '');
+            });
         }
-      }
-    })
-  }
+      },
+    });
+  };
 
-  $scope.isDefaultRepository = function (repoId) {
+  $scope.isDefaultRepository = function(repoId) {
     if (repoId === 'central' || repoId === 'local') {
-      return true
+      return true;
     } else {
-      return false
+      return false;
     }
-  }
+  };
 
-  $scope.showErrorMessage = function (setting) {
+  $scope.showErrorMessage = function(setting) {
     BootstrapDialog.show({
       title: 'Error downloading dependencies',
-      message: setting.errorReason
-    })
-  }
+      message: setting.errorReason,
+    });
+  };
 
   let init = function() {
-    getAvailableInterpreterPropertyWidgets()
+    getAvailableInterpreterPropertyWidgets();
 
-    $scope.resetNewInterpreterSetting()
-    $scope.resetNewRepositorySetting()
+    $scope.resetNewInterpreterSetting();
+    $scope.resetNewRepositorySetting();
 
-    getInterpreterSettings()
-    getAvailableInterpreters()
-    getRepositories()
-  }
+    getInterpreterSettings();
+    getAvailableInterpreters();
+    getRepositories();
+  };
 
-  $scope.showSparkUI = function (settingId) {
+  $scope.showSparkUI = function(settingId) {
     $http.get(baseUrlSrv.getRestApiBase() + '/interpreter/metadata/' + 
settingId)
-      .then(function (res) {
+      .then(function(res) {
         if (res.data.body === undefined) {
           BootstrapDialog.alert({
-            message: 'No spark application running'
-          })
-          return
+            message: 'No spark application running',
+          });
+          return;
         }
         if (res.data.body.url) {
-          window.open(res.data.body.url, '_blank')
+          window.open(res.data.body.url, '_blank');
         } else {
           BootstrapDialog.alert({
-            message: res.data.body.message
-          })
+            message: res.data.body.message,
+          });
         }
-      }).catch(function (res) {
-        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'')
-      })
-  }
+      }).catch(function(res) {
+        console.log('Error %o %o', res.status, res.data ? res.data.message : 
'');
+      });
+  };
 
   $scope.getInterpreterBindingModeDocsLink = function() {
-    const currentVersion = $rootScope.zeppelinVersion
-    return 
`https://zeppelin.apache.org/docs/${currentVersion}/usage/interpreter/interpreter_binding_mode.html`
-  }
+    const currentVersion = $rootScope.zeppelinVersion;
+    return 
`https://zeppelin.apache.org/docs/${currentVersion}/usage/interpreter/interpreter_binding_mode.html`;
+  };
 
-  init()
+  init();
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/interpreter/interpreter.filter.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/interpreter/interpreter.filter.js 
b/zeppelin-web/src/app/interpreter/interpreter.filter.js
index 3f42572..7b5ace0 100644
--- a/zeppelin-web/src/app/interpreter/interpreter.filter.js
+++ b/zeppelin-web/src/app/interpreter/interpreter.filter.js
@@ -12,11 +12,11 @@
  * limitations under the License.
  */
 
-angular.module('zeppelinWebApp').filter('sortByKey', sortByKey)
+angular.module('zeppelinWebApp').filter('sortByKey', sortByKey);
 
-function sortByKey () {
-  return function (properties) {
-    let sortedKeys = properties ? Object.keys(properties) : []
-    return sortedKeys.sort()
-  }
+function sortByKey() {
+  return function(properties) {
+    let sortedKeys = properties ? Object.keys(properties) : [];
+    return sortedKeys.sort();
+  };
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/interpreter/widget/number-widget.directive.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/interpreter/widget/number-widget.directive.js 
b/zeppelin-web/src/app/interpreter/widget/number-widget.directive.js
index 2046b94..6ea129a 100644
--- a/zeppelin-web/src/app/interpreter/widget/number-widget.directive.js
+++ b/zeppelin-web/src/app/interpreter/widget/number-widget.directive.js
@@ -12,20 +12,20 @@
  * limitations under the License.
  */
 
-angular.module('zeppelinWebApp').directive('numberWidget', 
InterpreterNumberDirective)
+angular.module('zeppelinWebApp').directive('numberWidget', 
InterpreterNumberDirective);
 
 function InterpreterNumberDirective() {
   return {
     require: 'ngModel',
-    link: function (scope, element, attrs, modelCtrl) {
-      modelCtrl.$parsers.push(function (inputValue) {
-        let transformedInput = inputValue ? inputValue.replace(/[^\d.-]/g, '') 
: null
+    link: function(scope, element, attrs, modelCtrl) {
+      modelCtrl.$parsers.push(function(inputValue) {
+        let transformedInput = inputValue ? inputValue.replace(/[^\d.-]/g, '') 
: null;
         if (transformedInput !== inputValue) {
-          modelCtrl.$setViewValue(transformedInput)
-          modelCtrl.$render()
+          modelCtrl.$setViewValue(transformedInput);
+          modelCtrl.$render();
         }
-        return transformedInput
-      })
-    }
-  }
+        return transformedInput;
+      });
+    },
+  };
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/jobmanager/job-status.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/jobmanager/job-status.js 
b/zeppelin-web/src/app/jobmanager/job-status.js
index eda41b1..d918299 100644
--- a/zeppelin-web/src/app/jobmanager/job-status.js
+++ b/zeppelin-web/src/app/jobmanager/job-status.js
@@ -19,36 +19,36 @@ export const JobStatus = {
   ERROR: 'ERROR',
   PENDING: 'PENDING',
   RUNNING: 'RUNNING',
-}
+};
 
 export function getJobIconByStatus(jobStatus) {
   if (jobStatus === JobStatus.READY) {
-    return 'fa fa-circle-o'
+    return 'fa fa-circle-o';
   } else if (jobStatus === JobStatus.FINISHED) {
-    return 'fa fa-circle'
+    return 'fa fa-circle';
   } else if (jobStatus === JobStatus.ABORT) {
-    return 'fa fa-circle'
+    return 'fa fa-circle';
   } else if (jobStatus === JobStatus.ERROR) {
-    return 'fa fa-circle'
+    return 'fa fa-circle';
   } else if (jobStatus === JobStatus.PENDING) {
-    return 'fa fa-circle'
+    return 'fa fa-circle';
   } else if (jobStatus === JobStatus.RUNNING) {
-    return 'fa fa-spinner'
+    return 'fa fa-spinner';
   }
 }
 
 export function getJobColorByStatus(jobStatus) {
   if (jobStatus === JobStatus.READY) {
-    return 'green'
+    return 'green';
   } else if (jobStatus === JobStatus.FINISHED) {
-    return 'green'
+    return 'green';
   } else if (jobStatus === JobStatus.ABORT) {
-    return 'orange'
+    return 'orange';
   } else if (jobStatus === JobStatus.ERROR) {
-    return 'red'
+    return 'red';
   } else if (jobStatus === JobStatus.PENDING) {
-    return 'gray'
+    return 'gray';
   } else if (jobStatus === JobStatus.RUNNING) {
-    return 'blue'
+    return 'blue';
   }
 }

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/jobmanager/job/job.component.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/jobmanager/job/job.component.js 
b/zeppelin-web/src/app/jobmanager/job/job.component.js
index c4d4f51..e6f102f 100644
--- a/zeppelin-web/src/app/jobmanager/job/job.component.js
+++ b/zeppelin-web/src/app/jobmanager/job/job.component.js
@@ -12,35 +12,35 @@
  * limitations under the License.
  */
 
-import moment from 'moment'
+import moment from 'moment';
 
-import { ParagraphStatus, } from '../../notebook/paragraph/paragraph.status'
-import { getJobColorByStatus, getJobIconByStatus } from '../job-status'
+import {ParagraphStatus} from '../../notebook/paragraph/paragraph.status';
+import {getJobColorByStatus, getJobIconByStatus} from '../job-status';
 
-import jobTemplate from './job.html'
-import './job.css'
+import jobTemplate from './job.html';
+import './job.css';
 
 class JobController {
   constructor($http, JobManagerService) {
-    'ngInject'
-    this.$http = $http
-    this.JobManagerService = JobManagerService
+    'ngInject';
+    this.$http = $http;
+    this.JobManagerService = JobManagerService;
   }
 
   isRunning() {
-    return this.note.isRunningJob
+    return this.note.isRunningJob;
   }
 
   getParagraphs() {
-    return this.note.paragraphs
+    return this.note.paragraphs;
   }
 
   getNoteId() {
-    return this.note.noteId
+    return this.note.noteId;
   }
 
   getNoteName() {
-    return this.note.noteName
+    return this.note.noteName;
   }
 
   runJob() {
@@ -48,19 +48,21 @@ class JobController {
       closable: true,
       title: 'Job Dialog',
       message: 'Run all paragraphs?',
-      callback: clickOk => {
-        if (!clickOk) { return }
+      callback: (clickOk) => {
+        if (!clickOk) {
+          return;
+        }
 
-        const noteId = this.getNoteId()
+        const noteId = this.getNoteId();
         // if the request is handled successfully, the job page will get 
updated using websocket
         this.JobManagerService.sendRunJobRequest(noteId)
-          .catch(response => {
+          .catch((response) => {
             let message = (response.data && response.data.message)
-              ? response.data.message : 'SERVER ERROR'
-            this.showErrorDialog('Execution Failure', message)
-          })
-      }
-    })
+              ? response.data.message : 'SERVER ERROR';
+            this.showErrorDialog('Execution Failure', message);
+          });
+      },
+    });
   }
 
   stopJob() {
@@ -68,81 +70,85 @@ class JobController {
       closable: true,
       title: 'Job Dialog',
       message: 'Stop all paragraphs?',
-      callback: clickOk => {
-        if (!clickOk) { return }
+      callback: (clickOk) => {
+        if (!clickOk) {
+          return;
+        }
 
-        const noteId = this.getNoteId()
+        const noteId = this.getNoteId();
         // if the request is handled successfully, the job page will get 
updated using websocket
         this.JobManagerService.sendStopJobRequest(noteId)
-          .catch(response => {
+          .catch((response) => {
             let message = (response.data && response.data.message)
-              ? response.data.message : 'SERVER ERROR'
-            this.showErrorDialog('Stop Failure', message)
-          })
-      }
-    })
+              ? response.data.message : 'SERVER ERROR';
+            this.showErrorDialog('Stop Failure', message);
+          });
+      },
+    });
   }
 
   showErrorDialog(title, errorMessage) {
-    if (!errorMessage) { errorMessage = 'SERVER ERROR' }
+    if (!errorMessage) {
+      errorMessage = 'SERVER ERROR';
+    }
     BootstrapDialog.alert({
       closable: true,
       title: title,
-      message: errorMessage
-    })
+      message: errorMessage,
+    });
   }
 
   lastExecuteTime() {
-    const timestamp = this.note.unixTimeLastRun
-    return moment.unix(timestamp / 1000).fromNow()
+    const timestamp = this.note.unixTimeLastRun;
+    return moment.unix(timestamp / 1000).fromNow();
   }
 
   getInterpreterName() {
     return typeof this.note.interpreter === 'undefined'
-      ? 'interpreter is not set' : this.note.interpreter
+      ? 'interpreter is not set' : this.note.interpreter;
   }
 
   getInterpreterNameStyle() {
     return typeof this.note.interpreter === 'undefined'
-      ? { color: 'gray' } : { color: 'black' }
+      ? {color: 'gray'} : {color: 'black'};
   }
 
   getJobTypeIcon() {
-    const noteType = this.note.noteType
+    const noteType = this.note.noteType;
     if (noteType === 'normal') {
-      return 'icon-doc'
+      return 'icon-doc';
     } else if (noteType === 'cron') {
-      return 'icon-clock'
+      return 'icon-clock';
     } else {
-      return 'icon-question'
+      return 'icon-question';
     }
   }
 
   getJobColorByStatus(status) {
-    return getJobColorByStatus(status)
+    return getJobColorByStatus(status);
   }
 
   getJobIconByStatus(status) {
-    return getJobIconByStatus(status)
+    return getJobIconByStatus(status);
   }
 
   getProgress() {
-    const paragraphs = this.getParagraphs()
-    let paragraphStatuses = paragraphs.map(p => p.status)
-    let runningOrFinishedParagraphs = paragraphStatuses.filter(status => {
-      return status === ParagraphStatus.RUNNING || status === 
ParagraphStatus.FINISHED
-    })
+    const paragraphs = this.getParagraphs();
+    let paragraphStatuses = paragraphs.map((p) => p.status);
+    let runningOrFinishedParagraphs = paragraphStatuses.filter((status) => {
+      return status === ParagraphStatus.RUNNING || status === 
ParagraphStatus.FINISHED;
+    });
 
-    let totalCount = paragraphStatuses.length
-    let runningCount = runningOrFinishedParagraphs.length
-    let result = Math.ceil(runningCount / totalCount * 100)
-    result = isNaN(result) ? 0 : result
+    let totalCount = paragraphStatuses.length;
+    let runningCount = runningOrFinishedParagraphs.length;
+    let result = Math.ceil(runningCount / totalCount * 100);
+    result = isNaN(result) ? 0 : result;
 
-    return `${result}%`
+    return `${result}%`;
   }
 
   showPercentProgressBar() {
-    return this.getProgress() > 0 && this.getProgress() < 100
+    return this.getProgress() > 0 && this.getProgress() < 100;
   }
 }
 
@@ -152,9 +158,9 @@ export const JobComponent = {
   },
   template: jobTemplate,
   controller: JobController,
-}
+};
 
 export const JobModule = angular
   .module('zeppelinWebApp')
   .component('job', JobComponent)
-  .name
+  .name;

http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ed517a20/zeppelin-web/src/app/jobmanager/job/job.component.test.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/jobmanager/job/job.component.test.js 
b/zeppelin-web/src/app/jobmanager/job/job.component.test.js
index 6ca285c..5b6bec1 100644
--- a/zeppelin-web/src/app/jobmanager/job/job.component.test.js
+++ b/zeppelin-web/src/app/jobmanager/job/job.component.test.js
@@ -1,55 +1,55 @@
-import { ParagraphStatus } from '../../notebook/paragraph/paragraph.status'
+import {ParagraphStatus} from '../../notebook/paragraph/paragraph.status';
 
 describe('JobComponent', () => {
-  let $componentController
+  let $componentController;
 
-  beforeEach(angular.mock.module('zeppelinWebApp'))
+  beforeEach(angular.mock.module('zeppelinWebApp'));
   beforeEach(angular.mock.inject((_$componentController_) => {
-    $componentController = _$componentController_
-  }))
+    $componentController = _$componentController_;
+  }));
 
   it('should get progress when there is a finished paragraph', () => {
     const paragraphs = [
-      { status: ParagraphStatus.FINISHED },
-    ]
-    const mockNote = createMockNote(paragraphs)
-    const bindings = { note: mockNote, }
+      {status: ParagraphStatus.FINISHED},
+    ];
+    const mockNote = createMockNote(paragraphs);
+    const bindings = {note: mockNote};
 
-    const ctrl = $componentController('job', null, bindings)
-    expect(ctrl).toBeDefined()
+    const ctrl = $componentController('job', null, bindings);
+    expect(ctrl).toBeDefined();
 
-    const progress1 = ctrl.getProgress()
-    expect(progress1).toBe('100%')
-  })
+    const progress1 = ctrl.getProgress();
+    expect(progress1).toBe('100%');
+  });
 
   it('should get progress when there is pending and finished paragraphs', () 
=> {
     const paragraphs = [
-      { status: ParagraphStatus.PENDING },
-      { status: ParagraphStatus.FINISHED},
-    ]
-    const mockNote = createMockNote(paragraphs)
-    const bindings = { note: mockNote, }
+      {status: ParagraphStatus.PENDING},
+      {status: ParagraphStatus.FINISHED},
+    ];
+    const mockNote = createMockNote(paragraphs);
+    const bindings = {note: mockNote};
 
-    const ctrl = $componentController('job', null, bindings)
+    const ctrl = $componentController('job', null, bindings);
 
-    const progress1 = ctrl.getProgress()
-    expect(progress1).toBe('50%')
-  })
+    const progress1 = ctrl.getProgress();
+    expect(progress1).toBe('50%');
+  });
 
   it('should get proper job type icons', () => {
-    const paragraphs = [ { status: ParagraphStatus.PENDING }, ]
-    const mockNote = createMockNote(paragraphs)
-    const bindings = { note: mockNote, }
+    const paragraphs = [{status: ParagraphStatus.PENDING}];
+    const mockNote = createMockNote(paragraphs);
+    const bindings = {note: mockNote};
 
-    const ctrl = $componentController('job', null, bindings)
+    const ctrl = $componentController('job', null, bindings);
 
-    let icon = ctrl.getJobTypeIcon()
-    expect(icon).toBe('icon-doc')
+    let icon = ctrl.getJobTypeIcon();
+    expect(icon).toBe('icon-doc');
 
-    mockNote.noteType = 'cron'
-    icon = ctrl.getJobTypeIcon()
-    expect(icon).toBe('icon-clock')
-  })
+    mockNote.noteType = 'cron';
+    icon = ctrl.getJobTypeIcon();
+    expect(icon).toBe('icon-clock');
+  });
 
   function createMockNote(paragraphs) {
     return {
@@ -58,6 +58,6 @@ describe('JobComponent', () => {
       noteId: 'NT01',
       noteName: 'TestNote01',
       noteType: 'normal',
-    }
+    };
   }
-})
+});

Reply via email to