Updated to ES6 syntax

Author: JamesMessinger

.eslintrc.yml

@@ -9,7 +9,7 @@ extends:
   - modular/style
   - modular/browser
   - modular/node
-  - modular/es5
+  - modular/es6
 
 globals:
   Promise: false

lib/bundle.js

@@ -1,8 +1,8 @@
 "use strict";
 
-var $Ref = require("./ref"),
-    Pointer = require("./pointer"),
-    url = require("./util/url");
+const $Ref = require("./ref");
+const Pointer = require("./pointer");
+const url = require("./util/url");
 
 module.exports = bundle;
 
@@ -18,7 +18,7 @@ function bundle (parser, options) {
   // console.log('Bundling $ref pointers in %s', parser.$refs._root$Ref.path);
 
   // Build an inventory of all $ref pointers in the JSON Schema
-  var inventory = [];
+  let inventory = [];
   crawl(parser, "schema", parser.$refs._root$Ref.path + "#", "#", 0, inventory, parser.$refs, options);
 
   // Remap all $ref pointers
@@ -37,7 +37,7 @@ function bundle (parser, options) {
  * @param {$RefParserOptions} options
  */
 function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs, options) {
-  var obj = key === null ? parent : parent[key];
+  let obj = key === null ? parent : parent[key];
 
   if (obj && typeof obj === "object") {
     if ($Ref.isAllowed$Ref(obj)) {
@@ -47,8 +47,8 @@ function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs,
       // Crawl the object in a specific order that's optimized for bundling.
       // This is important because it determines how `pathFromRoot` gets built,
       // which later determines which keys get dereferenced and which ones get remapped
-      var keys = Object.keys(obj)
-        .sort(function (a, b) {
+      let keys = Object.keys(obj)
+        .sort((a, b) => {
           // Most people will expect references to be bundled into the the "definitions" property,
           // so we always crawl that property first, if it exists.
           if (a === "definitions") {
@@ -64,10 +64,10 @@ function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs,
           }
         });
 
-      keys.forEach(function (key) {
-        var keyPath = Pointer.join(path, key);
-        var keyPathFromRoot = Pointer.join(pathFromRoot, key);
-        var value = obj[key];
+      keys.forEach((key) => {
+        let keyPath = Pointer.join(path, key);
+        let keyPathFromRoot = Pointer.join(pathFromRoot, key);
+        let value = obj[key];
 
         if ($Ref.isAllowed$Ref(value)) {
           inventory$Ref(obj, key, path, keyPathFromRoot, indirections, inventory, $refs, options);
@@ -93,17 +93,17 @@ function crawl (parent, key, path, pathFromRoot, indirections, inventory, $refs,
  * @param {$RefParserOptions} options
  */
 function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, inventory, $refs, options) {
-  var $ref = $refKey === null ? $refParent : $refParent[$refKey];
-  var $refPath = url.resolve(path, $ref.$ref);
-  var pointer = $refs._resolve($refPath, options);
-  var depth = Pointer.parse(pathFromRoot).length;
-  var file = url.stripHash(pointer.path);
-  var hash = url.getHash(pointer.path);
-  var external = file !== $refs._root$Ref.path;
-  var extended = $Ref.isExtended$Ref($ref);
+  let $ref = $refKey === null ? $refParent : $refParent[$refKey];
+  let $refPath = url.resolve(path, $ref.$ref);
+  let pointer = $refs._resolve($refPath, options);
+  let depth = Pointer.parse(pathFromRoot).length;
+  let file = url.stripHash(pointer.path);
+  let hash = url.getHash(pointer.path);
+  let external = file !== $refs._root$Ref.path;
+  let extended = $Ref.isExtended$Ref($ref);
   indirections += pointer.indirections;
 
-  var existingEntry = findInInventory(inventory, $refParent, $refKey);
+  let existingEntry = findInInventory(inventory, $refParent, $refKey);
   if (existingEntry) {
     // This $Ref has already been inventoried, so we don't need to process it again
     if (depth < existingEntry.depth || indirections < existingEntry.indirections) {
@@ -115,18 +115,18 @@ function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, i
   }
 
   inventory.push({
-    $ref: $ref,                   // The JSON Reference (e.g. {$ref: string})
+    $ref,                   // The JSON Reference (e.g. {$ref: string})
     parent: $refParent,           // The object that contains this $ref pointer
     key: $refKey,                 // The key in `parent` that is the $ref pointer
-    pathFromRoot: pathFromRoot,   // The path to the $ref pointer, from the JSON Schema root
-    depth: depth,                 // How far from the JSON Schema root is this $ref pointer?
-    file: file,                   // The file that the $ref pointer resolves to
-    hash: hash,                   // The hash within `file` that the $ref pointer resolves to
+    pathFromRoot,   // The path to the $ref pointer, from the JSON Schema root
+    depth,                 // How far from the JSON Schema root is this $ref pointer?
+    file,                   // The file that the $ref pointer resolves to
+    hash,                   // The hash within `file` that the $ref pointer resolves to
     value: pointer.value,         // The resolved value of the $ref pointer
     circular: pointer.circular,   // Is this $ref pointer DIRECTLY circular? (i.e. it references itself)
-    extended: extended,           // Does this $ref extend its resolved value? (i.e. it has extra properties, in addition to "$ref")
-    external: external,           // Does this $ref pointer point to a file other than the main JSON Schema file?
-    indirections: indirections,   // The number of indirect references that were traversed to resolve the value
+    extended,           // Does this $ref extend its resolved value? (i.e. it has extra properties, in addition to "$ref")
+    external,           // Does this $ref pointer point to a file other than the main JSON Schema file?
+    indirections,   // The number of indirect references that were traversed to resolve the value
   });
 
   // Recursively crawl the resolved value
@@ -158,7 +158,7 @@ function inventory$Ref ($refParent, $refKey, path, pathFromRoot, indirections, i
  */
 function remap (inventory) {
   // Group & sort all the $ref pointers, so they're in the order that we need to dereference/remap them
-  inventory.sort(function (a, b) {
+  inventory.sort((a, b) => {
     if (a.file !== b.file) {
       // Group all the $refs that point to the same file
       return a.file < b.file ? -1 : +1;
@@ -186,8 +186,8 @@ function remap (inventory) {
     else {
       // Determine how far each $ref is from the "definitions" property.
       // Most people will expect references to be bundled into the the "definitions" property if possible.
-      var aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
-      var bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
+      let aDefinitionsIndex = a.pathFromRoot.lastIndexOf("/definitions");
+      let bDefinitionsIndex = b.pathFromRoot.lastIndexOf("/definitions");
 
       if (aDefinitionsIndex !== bDefinitionsIndex) {
         // Give higher priority to the $ref that's closer to the "definitions" property
@@ -200,8 +200,8 @@ function remap (inventory) {
     }
   });
 
-  var file, hash, pathFromRoot;
-  inventory.forEach(function (entry) {
+  let file, hash, pathFromRoot;
+  inventory.forEach((entry) => {
     // console.log('Re-mapping $ref pointer "%s" at %s', entry.$ref.$ref, entry.pathFromRoot);
 
     if (!entry.external) {
@@ -240,15 +240,15 @@ function remap (inventory) {
  * TODO
  */
 function findInInventory (inventory, $refParent, $refKey) {
-  for (var i = 0; i < inventory.length; i++) {
-    var existingEntry = inventory[i];
+  for (let i = 0; i < inventory.length; i++) {
+    let existingEntry = inventory[i];
     if (existingEntry.parent === $refParent && existingEntry.key === $refKey) {
       return existingEntry;
     }
   }
 }
 
 function removeFromInventory (inventory, entry) {
-  var index = inventory.indexOf(entry);
+  let index = inventory.indexOf(entry);
   inventory.splice(index, 1);
 }