Add HttpError constructor

README.md

@@ -66,9 +66,14 @@ function errorHandle(err, req, res, next) {
 
 ## API
 
-#### HttpError(statusCode, errorName, message)
+#### HttpError(statusCode[, message])
 
-The basic HttpError object constructor.
+The basic HttpError object constructor, and you can construct HttpError like this:
+
+```js
+new HttpError(404)
+new HttpError(404, 'This page is not found')
+```
 
 ##### HttpError.BadRequestError([message])
 

package.json

@@ -1,8 +1,8 @@
 {
   "name": "some-http-error",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A javascript error creator for some often used HTTP error",
-  "main": "index.js",
+  "main": "some-http-error.js",
   "scripts": {
     "test": "mocha test.js",
     "test:watch": "mocha --watch test.js",

some-http-error.js

@@ -1,48 +1,60 @@
 'use strict';
 
+var errors = {
+  "400": "Bad Request",
+  "401": "Unauthorized",
+  "403": "Forbidden",
+  "404": "Not Found",
+  "405": "Method Not Allowed"
+};
+
 function extend(child, parent) {
   child.prototype = Object.create(parent.prototype);
   child.prototype.constructor = child;
   return child;
 }
 
-function HttpError(statusCode, name, message) {
-  this.message = message;
-  this.name = name;
-  this.statusCode = statusCode;
+function HttpError(statusCode, message) {
+  if (!statusCode || statusCode < 400 || statusCode > 405) {
+    throw new Error(statusCode + ' is not support');
+  }
+  this.statusCode = +statusCode;
+  this.name = messageToName(errors[statusCode]);
+  this.message = message || errors[statusCode];
   this.stack = (new Error()).stack;
 }
 extend(HttpError, Error);
 
-HttpError.BadRequestError = function (message) {
-  message = message || 'Bad Request';
-  HttpError.call(this, 400, 'BadRequestError', message);
-};
-
-HttpError.UnauthorizedError = function (message) {
-  message = message || 'Unauthorized';
-  HttpError.call(this, 401, 'UnauthorizedError', message);
-};
-
-HttpError.ForbiddenError = function (message) {
-  message = message || 'Forbidden';
-  HttpError.call(this, 403, 'ForbiddenError', message);
-};
-
-HttpError.NotFoundError = function (message) {
-  message = message || 'Not Found';
-  HttpError.call(this, 404, 'NotFoundError', message);
-};
-
-HttpError.MethodNotAllowedError = function (message) {
-  message = message || 'Method Not Allowed';
-  HttpError.call(this, 405, 'MethodNotAllowedError', message);
-};
+HttpError.BadRequestError = function() {};
+HttpError.UnauthorizedError = function() {};
+HttpError.ForbiddenError = function() {};
+HttpError.NotFoundError = function() {};
+HttpError.BadRequestError = function() {};
+
+for (var errorCode in errors) {
+  if (errors.hasOwnProperty(errorCode)) {
+    var message = errors[errorCode];
+    var errorName = messageToName(message);
+    HttpError[errorName] = (function (code) {
+      return function (message) {
+        HttpError.call(this, code, message);
+      }
+    })(errorCode);
+    extend(HttpError[errorName], HttpError)
+  }
+}
 
-for (var property in HttpError) {
-  if (HttpError.hasOwnProperty(property)) {
-    extend(HttpError[property], HttpError);
+function messageToName(message) {
+  if (!message || typeof message !== 'string') {
+    return 'Error'
   }
+  return message
+    .split(/\s+/)
+    .map(function(word) {
+      return word[0].toUpperCase() + word.substr(1, word.length - 1)
+    })
+    .concat('Error')
+    .join('')
 }
 
 module.exports = HttpError;

test.js

@@ -1,12 +1,6 @@
 var HttpError = require('./');
 var expect = require('chai').expect;
 
-describe('HttpError', function () {
-  it('is child class of Error', function () {
-    expect(new HttpError).to.be.an.instanceof(Error);
-  });
-});
-
 describe('BadRequestError', function () {
   it('is an instance of Error', function () {
     expect(new HttpError.BadRequestError).to.be.an.instanceof(Error);
@@ -77,3 +71,22 @@ describe('MethodNotAllowedError', function () {
     expect(methodNotAllowedError.statusCode).to.equal(405);
   })
 });
+
+describe('Construct an http error', function () {
+  it('400 is an BadRequestError', function () {
+    var badRequestError = new HttpError(400);
+    expect(badRequestError).to.be.an.instanceof(Error);
+    expect(badRequestError).to.be.an.instanceof(HttpError);
+    expect(badRequestError.message).to.equal('Bad Request');
+    expect(badRequestError.name).to.equal('BadRequestError');
+    expect(badRequestError.statusCode).to.equal(400);
+  });
+  it('custom the error message', function () {
+    var badRequestError = new HttpError(404, 'This page is not found');
+    expect(badRequestError).to.be.an.instanceof(Error);
+    expect(badRequestError).to.be.an.instanceof(HttpError);
+    expect(badRequestError.message).to.equal('This page is not found');
+    expect(badRequestError.name).to.equal('NotFoundError');
+    expect(badRequestError.statusCode).to.equal(404);
+  })
+});