Updated all docs examples to use ES6 syntax

Author: JamesMessinger

README.md

@@ -58,7 +58,7 @@ Example
 --------------------------
 
 ```javascript
-$RefParser.dereference(mySchema, function(err, schema) {
+$RefParser.dereference(mySchema, (err, schema) => {
   if (err) {
     console.error(err);
   }
@@ -67,19 +67,19 @@ $RefParser.dereference(mySchema, function(err, schema) {
     // including referenced files, combined into a single object
     console.log(schema.definitions.person.properties.firstName);
   }
-});
+}
 ```
 
-Or use [Promises syntax](http://javascriptplayground.com/blog/2015/02/promises/) instead. The following example is the same as above:
+Or use `async`/`await` syntax instead. The following example is the same as above:
 
 ```javascript
-$RefParser.dereference(mySchema)
-  .then(function(schema) {
-    console.log(schema.definitions.person.properties.firstName);
-  })
-  .catch(function(err) {
-    console.error(err);
-  });
+try {
+  let schema = await $RefParser.dereference(mySchema);
+  console.log(schema.definitions.person.properties.firstName);
+}
+catch(err) {
+  console.error(err);
+}
 ```
 
 For more detailed examples, please see the [API Documentation](https://apidevtools.org/json-schema-ref-parser/docs/)

docs/README.md

@@ -44,23 +44,23 @@ $RefParser.bundle("my-schema.json");
 ... is the same as this:
 
 ```javascript
-var parser = new $RefParser();
+let parser = new $RefParser();
 parser.bundle("my-schema.json");
 ```
 
 The difference is that in the second example you now have a reference to `parser`, which means you can access the results ([`parser.schema`](ref-parser.md#schema) and [`parser.$refs`](ref-parser.md#refs)) anytime you want, rather than just in the callback function.
 
 
 ### Callbacks vs. Promises
-Many people prefer [ES6 Promise syntax](http://javascriptplayground.com/blog/2015/02/promises/) instead of callbacks.  JSON Schema $Ref Parser allows you to use whichever one you prefer.
+Many people prefer [Promise syntax](http://javascriptplayground.com/blog/2015/02/promises/) or `async`/`awiat` instead of callbacks.  JSON Schema $Ref Parser allows you to use whichever one you prefer.
 
-If you pass a callback function to any method, then the method will call the callback using the Node.js error-first convention.  If you do _not_ pass a callback function, then the method will return an ES6 Promise.
+If you pass a callback function to any method, then the method will call the callback using the Node.js error-first convention.  If you do _not_ pass a callback function, then the method will return a Promise.
 
 The following two examples are equivalent:
 
 ```javascript
 // Callback syntax
-$RefParser.dereference(mySchema, function(err, api) {
+$RefParser.dereference(mySchema, (err, api) => {
     if (err) {
         // Error
     }
@@ -71,14 +71,15 @@ $RefParser.dereference(mySchema, function(err, api) {
 ```
 
 ```javascript
-// ES6 Promise syntax
-$RefParser.dereference(mySchema)
-    .then(function(api) {
-        // Success
-    })
-    .catch(function(err) {
-        // Error
-    });
+try {
+    // async/await syntax
+    let api = await $RefParser.dereference(mySchema);
+
+    // Success
+}
+catch (err) {
+    // Error
+}
 ```
 
 

docs/plugins/parsers.md

@@ -9,14 +9,14 @@ You can see the source code for any of the built-in parsers [right here](../../l
 The fastest way to learn is by example, so let's do that.  Here's a simplistic parser that parses CSV files (comma-separated values):
 
 ```javascript
-var myParser = {
+let myParser = {
   order: 1,
 
   canParse: ".csv",
 
-  parse: function(file) {
-    var lines = file.data.toString().split("\n");
-    return lines.map(function(line) {
+  parse(file) {
+    let lines = file.data.toString().split("\n");
+    return lines.map((line) => {
       return line.split(",");
     });
   }
@@ -37,55 +37,60 @@ If _none_ of the parsers match the file, then _all_ of them are tried, in order,
 The `canParse` property tells JSON Schema $Ref Parser what kind of files your parser can handle. In this example, we've simply specified a file extension, but we could have used a simple boolean, an array of file extensions, a regular expression, or even a function with custom logic to determine which files to parse.  Here are examples of each approach:
 
 ```javascript
-// Parse ALL file types
-canParse: true
+let myParser = {
+  // Parse ALL file types
+  canParse: true
 
-// An array of file extensions (lowercased)
-canParse: [".txt", ".csv"]
+  // An array of file extensions (lowercased)
+  canParse: [".txt", ".csv"]
 
-// A regular expression (matched against the FULL file path)
-canParse: /\.(txt|csv)$/i
+  // A regular expression (matched against the FULL file path)
+  canParse: /\.(txt|csv)$/i
 
-// A function that returns a truthy/falsy value
-canParse: function(file) {
-  return file.extension === ".csv" || file.extension === ".txt";
-}
+  // A function that returns a truthy/falsy value
+  canParse(file) {
+    return file.extension === ".csv" || file.extension === ".txt";
+  }
+};
 ```
 
 When using the function form, the `file` parameter is a [file info object](file-info-object.md), which contains information about the file being parsed.
 
 #### The `parse` method
 Obviously, this is where the real work of a parser happens.  The `parse` method accepts the same [file info object](file-info-object.md) as the `canParse` function, but rather than returning a boolean value, the `parse` method should return a JavaScript representation of the file contents.  For our CSV parser, that is a two-dimensional array of lines and values.  For your parser, it might be an object, a string, a custom class, or anything else.
 
-Unlike the `canParse` function, the `parse` method can also be asynchronous. This might be important if your parser needs to retrieve data from a database or if it relies on an external HTTP service to return the parsed value.  You can return your asynchronous value using either an [ES6 Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Here are examples of both approaches:
+Unlike the `canParse` function, the `parse` method can also be asynchronous. This might be important if your parser needs to retrieve data from a database or if it relies on an external HTTP service to return the parsed value.  You can return your asynchronous value via a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Here are examples of both approaches:
 
 ```javascript
-// Return the value in a callback function
-parse: function(file, callback) {
-  doSomethingAsync(file.data, function(data) {
-    if (data) {
-      // Success !
-      callback(null, data);
-    }
-    else {
-      // Error !
-      callback(new Error("No data!"));
-    }
-  });
-}
-
-// Return the value in an ES6 Promise
-parse: function(file) {
-  doSomethingAsync(file.data)
-    .then(function(data) {
+let myCallbackParser = {
+  // Return the value in a callback function
+  parse(file, callback) {
+    doSomethingAsync(file.data, (data) => {
       if (data) {
         // Success !
-        return data;
+        callback(null, data);
       }
       else {
         // Error !
-        throw new Error("No data!");
+        callback(new Error("No data!"));
       }
     });
-}
+  }
+};
+
+let myPromiseParser = {
+  // Return the value in an ES6 Promise
+  async parse(file) {
+    let data = await doSomethingAsync(file.data);
+
+    if (data) {
+      // Success !
+      return data;
+    }
+    else {
+      // Error !
+      throw new Error("No data!");
+    }
+  }
+};
 ```

docs/plugins/resolvers.md

@@ -9,18 +9,18 @@ You can see the source code for any of the built-in resolvers [right here](../..
 The fastest way to learn is by example, so let's do that.  Here's a simplistic resolver that reads data from a MongoDB database:
 
 ```javascript
-var myResolver = {
+let myResolver = {
   order: 1,
 
   canRead: /^mongodb:/i,
 
-  read: function(file, callback) {
-    MongoClient.connect(file.url, function(err, db) {
+  read(file, callback) {
+    MongoClient.connect(file.url, (err, db) => {
       if (err) {
         callback(err);
       }
       else {
-        db.find({}).toArray(function(err, document) {
+        db.find({}).toArray((err, document) => {
           callback(null, document);
         });
       }
@@ -41,16 +41,18 @@ The `order` property and `canRead` property are related to each other. For each
 The `canRead` property tells JSON Schema $Ref Parser what kind of files your resolver can read. In this example, we've simply specified a regular expression that matches "mogodb://" URLs, but we could have used a simple boolean, or even a function with custom logic to determine which files to resolve.  Here are examples of each approach:
 
 ```javascript
-// Read ALL files
-canRead: true
+let myResolver = {
+  // Read ALL files
+  canRead: true
 
-// Read all files on localhost
-canRead: /localhost/i
+  // Read all files on localhost
+  canRead: /localhost/i
 
-// A function that returns a truthy/falsy value
-canRead: function(file) {
-  return file.url.indexOf("127.0.0.1") !== -1;
-}
+  // A function that returns a truthy/falsy value
+  canRead(file) {
+    return file.url.indexOf("127.0.0.1") !== -1;
+  }
+};
 ```
 
 When using the function form, the `file` parameter is a [file info object](file-info-object.md), which contains information about the file being resolved.
@@ -59,40 +61,43 @@ When using the function form, the `file` parameter is a [file info object](file-
 #### The `read` method
 This is where the real work of a resolver happens.  The `read` method accepts the same [file info object](file-info-object.md) as the `canRead` function, but rather than returning a boolean value, the `read` method should return the contents of the file.  The file contents should be returned in as raw a form as possible, such as a string or a byte array.  Any further parsing or processing should be done by [parsers](parsers.md).
 
-Unlike the `canRead` function, the `read` method can also be asynchronous. This might be important if your resolver needs to read data from a database or some other external source.  You can return your asynchronous value using either an [ES6 Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Of course, if your resolver has the ability to return its data synchronously, then that's fine too.  Here are examples of all three approaches:
+Unlike the `canRead` function, the `read` method can also be asynchronous. This might be important if your resolver needs to read data from a database or some other external source.  You can return your asynchronous value via a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Of course, if your resolver has the ability to return its data synchronously, then that's fine too.  Here are examples of all three approaches:
 
 ```javascript
-// Return the value synchronously
-read: function(file) {
-  return fs.readFileSync(file.url);
-}
-
-// Return the value in a callback function
-read: function(file, callback) {
-  doSomethingAsync(file.url, function(data) {
-    if (data) {
-      // Success !
-      callback(null, data);
-    }
-    else {
-      // Error !
-      callback(new Error("No data!"));
-    }
-  });
-}
+let myCallbackResolver = {
+  // Return the value synchronously
+  read(file) {
+    return fs.readFileSync(file.url);
+  }
 
-// Return the value in an ES6 Promise
-read: function(file) {
-  return doSomethingAsync(file.url)
-    .then(function(data) {
+  // Return the value in a callback function
+  read(file, callback) {
+    doSomethingAsync(file.url, (data) => {
       if (data) {
         // Success !
-        return data;
+        callback(null, data);
       }
       else {
         // Error !
-        throw new Error("No data!");
+        callback(new Error("No data!"));
       }
     });
-}
+  }
+};
+
+let myPromiseResolver = {
+  // Return the value in an ES6 Promise
+  async read(file) {
+    let data = await doSomethingAsync(file.url);
+
+    if (data) {
+      // Success !
+      return data;
+    }
+    else {
+      // Error !
+      throw new Error("No data!");
+    }
+  }
+};
 ```