removed semicolons. semicolons are evil

Author: Leon Strauss

README.md

@@ -18,12 +18,12 @@ The module will export a function, that you can call with an options object to
 get the middleware:
 
 ```js
-var app = require('express')();
-var basicAuth = require('express-basic-auth');
+var app = require('express')()
+var basicAuth = require('express-basic-auth')
 
 app.use(basicAuth({
     users: { 'admin': 'supersecret' }
-}));
+}))
 ```
 
 The middleware will now check incoming requests to match the credentials
@@ -50,7 +50,7 @@ app.use(basicAuth({
         'adam': 'password1234',
         'eve': 'asdfghjkl'
     }
-}));
+}))
 ```
 
 The middleware will check incoming requests to have a basic auth header matching
@@ -63,10 +63,10 @@ however you want. It will be called with a username and password and is expected
 return `true` or `false` to indicate that the credentials were approved or not:
 
 ```js
-app.use(basicAuth( { authorizer: myAuthorizer } ));
+app.use(basicAuth( { authorizer: myAuthorizer } ))
 
 function myAuthorizer(username, password) {
-    return username.startsWith('A') && password.startsWith('secret');
+    return username.startsWith('A') && password.startsWith('secret')
 }
 ```
 
@@ -87,11 +87,11 @@ Let's look at the same authorizer again, but this time asynchronous:
 app.use(basicAuth({
     authorizer: myAsyncAuthorizer,
     authorizeAsync: true
-}));
+}))
 
 function myAsyncAuthorizer(username, password, cb) {
     if(username.startsWith('A') && password.startsWith('secret'))
-        return cb(null, true);
+        return cb(null, true)
     else
         return cb(null, false)
 }
@@ -109,12 +109,12 @@ be used as-is, otherwise it will be sent as JSON:
 app.use(basicAuth({
     users: { 'Foo': 'bar' },
     unauthorizedResponse: getUnauthorizedResponse
-}));
+}))
 
 function getUnauthorizedResponse(req) {
-    return req.auth
-        ? ('Credentials ' + req.auth.user + ':' + req.auth.password + ' rejected')
-        : 'No credentials provided';
+    return req.auth ?
+        ('Credentials ' + req.auth.user + ':' + req.auth.password + ' rejected') :
+        'No credentials provided'
 }
 ```
 
@@ -129,7 +129,7 @@ on unauthorized responses:
 app.use(basicAuth({
     users: { 'someuser': 'somepassword' },
     challenge: true
-}));
+}))
 ```
 
 ## Try it

example.js

@@ -1,8 +1,8 @@
-var express = require('express');
+const express = require('express')
 
-var app = express();
+var app = express()
 
-var basicAuth = require('./index.js');
+const basicAuth = require('./index.js')
 
 /**
 * express-basic-auth
@@ -25,86 +25,86 @@ var staticUserAuth = basicAuth({
         'Admin': 'secret1234'
     },
     challenge: false
-});
+})
 
 //Uses a custom (synchronous) authorizer function
 var customAuthorizerAuth = basicAuth({
     authorizer: myAuthorizer
-});
+})
 
 //Same, but sends a basic auth challenge header when authorization fails
 var challengeAuth = basicAuth({
     authorizer: myAuthorizer,
     challenge: true
-});
+})
 
 //Uses a custom asynchronous authorizer function
 var asyncAuth = basicAuth({
     authorizer: myAsyncAuthorizer,
     authorizeAsync: true
-});
+})
 
 //Uses a custom response body function
 var customBodyAuth = basicAuth({
     users: { 'Foo': 'bar' },
     unauthorizedResponse: getUnauthorizedResponse
-});
+})
 
 //Uses a static response body
 var staticBodyAuth = basicAuth({
     unauthorizedResponse: 'Haaaaaha'
-});
+})
 
 //Uses a JSON response body
 var jsonBodyAuth = basicAuth({
     unauthorizedResponse: { foo: 'bar' }
-});
+})
 
 app.get('/static', staticUserAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/custom', customAuthorizerAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/challenge', challengeAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/async', asyncAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/custombody', customBodyAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/staticbody', staticBodyAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.get('/jsonbody', jsonBodyAuth, function(req, res) {
-    res.status(200).send('You passed');
-});
+    res.status(200).send('You passed')
+})
 
 app.listen(8080, function() {
-    console.log("Listening!");
-});
+    console.log("Listening!")
+})
 
 //Custom authorizer checking if the username starts with 'A' and the password with 'secret'
 function myAuthorizer(username, password) {
-    return username.startsWith('A') && password.startsWith('secret');
+    return username.startsWith('A') && password.startsWith('secret')
 }
 
 //Same but asynchronous
 function myAsyncAuthorizer(username, password, cb) {
     if(username.startsWith('A') && password.startsWith('secret'))
-        return cb(null, true);
+        return cb(null, true)
     else
         return cb(null, false)
 }
 
 function getUnauthorizedResponse(req) {
-    return req.auth ? ('Credentials ' + req.auth.user + ':' + req.auth.password + ' rejected') : 'No credentials provided';
+    return req.auth ? ('Credentials ' + req.auth.user + ':' + req.auth.password + ' rejected') : 'No credentials provided'
 }

index.js

@@ -1,71 +1,71 @@
-var auth = require('basic-auth');
-var assert = require('assert');
+const auth = require('basic-auth')
+const assert = require('assert')
 
 function buildMiddleware(options) {
-    var challenge = options.challenge != undefined ? !!options.challenge : false;
-    var users = options.users || {};
-    var authorizer = options.authorizer || staticUsersAuthorizer;
-    var isAsync = options.authorizeAsync != undefined ? !!options.authorizeAsync : false;
-    var getResponseBody = options.unauthorizedResponse;
+    var challenge = options.challenge != undefined ? !!options.challenge : false
+    var users = options.users || {}
+    var authorizer = options.authorizer || staticUsersAuthorizer
+    var isAsync = options.authorizeAsync != undefined ? !!options.authorizeAsync : false
+    var getResponseBody = options.unauthorizedResponse
 
     if(!getResponseBody)
-        getResponseBody = function() { return ''; };
+        getResponseBody = function() { return '' }
     else if(typeof getResponseBody != 'function')
-        getResponseBody = function() { return options.unauthorizedResponse };
+        getResponseBody = function() { return options.unauthorizedResponse }
 
-    assert(typeof getResponseBody == 'function', 'Expected a string or function for the unauthorizedResponse option');
-    assert(typeof users == 'object', 'Expected an object for the basic auth users, found ' + typeof users + ' instead');
-    assert(typeof authorizer == 'function', 'Expected a function for the basic auth authorizer, found ' + typeof authorizer + ' instead');
+    assert(typeof getResponseBody == 'function', 'Expected a string or function for the unauthorizedResponse option')
+    assert(typeof users == 'object', 'Expected an object for the basic auth users, found ' + typeof users + ' instead')
+    assert(typeof authorizer == 'function', 'Expected a function for the basic auth authorizer, found ' + typeof authorizer + ' instead')
 
     function staticUsersAuthorizer(username, password) {
         for(var i in users)
             if(username == i && password == users[i])
-                return true;
+                return true
 
-        return false;
+        return false
     }
 
     return function authMiddleware(req, res, next) {
-        var authentication = auth(req);
+        var authentication = auth(req)
 
         if(!authentication)
-            return unauthorized();
+            return unauthorized()
 
         req.auth = {
             user: authentication.name,
             password: authentication.pass
-        };
+        }
 
         if(isAsync)
-            return authorizer(authentication.name, authentication.pass, authorizerCallback);
+            return authorizer(authentication.name, authentication.pass, authorizerCallback)
         else if(!authorizer(authentication.name, authentication.pass))
-            return unauthorized();
+            return unauthorized()
 
-        return next();
+        return next()
 
         function unauthorized() {
             //TODO: Allow to set realm for the challenge
             if(challenge)
-                res.set('WWW-Authenticate', 'Basic');
+                res.set('WWW-Authenticate', 'Basic')
 
             //TODO: Allow response body to be JSON (maybe autodetect?)
-            const response = getResponseBody(req);
+            const response = getResponseBody(req)
 
             if(typeof response == 'string')
-                return res.status(401).send(response);
+                return res.status(401).send(response)
 
-            return res.status(401).json(response);
+            return res.status(401).json(response)
         }
 
         function authorizerCallback(err, approved) {
-            assert.ifError(err);
+            assert.ifError(err)
 
             if(approved)
-                return next();
+                return next()
 
-            return unauthorized();
+            return unauthorized()
         }
-    };
+    }
 }
 
-module.exports = buildMiddleware;
+module.exports = buildMiddleware