Added dependencies

Upcase incode and outcodes
Moved dependency
Full list of Ordnance Survey postcodes
Exhaustive tests

Author: cblanc

README.md

@@ -1,8 +1,11 @@
 [![Build Status](https://travis-ci.org/cblanc/postcode.js.png)](https://travis-ci.org/cblanc/postcode.js) 
+[![Dependency Status](https://gemnasium.com/cblanc/postcode.js.png)](https://gemnasium.com/cblanc/postcode.js)
 
 # Postcodes
 
-Utility methods for UK Postcodes
+Utility methods for UK Postcodes.
+
+Included is a test suite that tests against all postcodes listed in the Ordnance Survey's postcode dataset as of January 2014. 
 
 ## Getting Started
 
@@ -35,4 +38,6 @@ Postcodes cannot be validated just with a regular expression. Proper postcode va
 
 ## License
 
-MIT
+MIT
+
+Contains Ordnance Survey Data © Crown Copyright & Database Right 2014

index.js

@@ -1,14 +1,14 @@
 "use strict";
 
-var validationRegex = /^[a-z0-9]{1,4}\s?\d[a-z]{2}$/i,
+var validationRegex = /^[a-z0-9]{1,4}\s*?\d[a-z]{2}$/i,
 		outcodeRegex = /\d[a-z]{2}$/i;
 
 function isValidPostcode (postcode) {
 	return !!postcode.match(validationRegex);
 }
 
 function parseIncode (postcode) {
-	return postcode.replace(outcodeRegex, "").replace(/\s/, "");
+	return postcode.replace(outcodeRegex, "").replace(/\s+/, "");
 }
 
 function parseOutcode (postcode) {
@@ -31,21 +31,21 @@ Postcode.prototype.valid = function () {
 Postcode.prototype.incode = function () {
 	if (!this._valid) return null;
 	if (this._incode) return this._incode;
-	this._incode = parseIncode(this._raw);
+	this._incode = parseIncode(this._raw).toUpperCase();
 	return this._incode;
 }
 
 Postcode.prototype.outcode = function () {
 	if (!this._valid) return null;
 	if (this._outcode) return this._outcode;
-	this._outcode = parseOutcode(this._raw);
+	this._outcode = parseOutcode(this._raw).toUpperCase();
 	return this._outcode;
 }
 
 Postcode.prototype.normalise = function () {
 	if (!this._valid) return null;
 	if (this.postcode) return this.postcode;
-	return [this.incode().toUpperCase()," ", this.outcode().toUpperCase()].join("");
+	return [this.incode()," ", this.outcode()].join("");
 }
 
 module.exports = Postcode;

package.json

@@ -7,10 +7,11 @@
     "test": "tests"
   },
   "dependencies": {
-    "chai": "~1.8.1"
   },
   "devDependencies": {
-    "mocha": "~1.17.0"
+    "mocha": "~1.17.0",
+    "csv": "~0.3.6",
+    "chai": "~1.8.1"
   },
   "scripts": {
     "test": "mocha tests/"

tests/data/postcodes.csv.gz

@@ -0,0 +1,114 @@
+var assert = require("chai").assert,
+		fs = require("fs"),
+		csv = require("csv"),
+		path = require("path"),
+		zlib = require("zlib"),
+		dataDir = path.join(__dirname, "./data"),
+		Postcode = require(path.join(__dirname, "../index"));
+
+describe("Exhaustive postcode test", function () {
+	var gunzip, input, output, testData, testResult,
+			inputFile = path.join(dataDir, "postcodes.csv.gz"),
+			outputFile = path.join(dataDir, "postcodes.csv");
+
+	before(function (done) {
+		this.timeout(60000);
+		gunzip = zlib.createGunzip();
+		input = fs.createReadStream(inputFile);
+		output = fs.createWriteStream(outputFile);
+		input.pipe(gunzip).pipe(output);
+		input.on("end", function () {
+			console.log("Loading in complete array of postcodes (this might take a while)...");
+			csv().from.path(outputFile).to.array(function (data, count) {
+				testData = data;
+				done();
+			});
+		});
+	});
+
+	after(function (done) {
+		fs.unlink(outputFile, done);
+	});
+
+	describe("Postcode#Valid", function () {
+		it ("should all be valid", function (done) {
+			this.timeout(60000);
+			testData.forEach(function (testPostcode) {
+				var pc = testPostcode[0],
+						postcode = new Postcode(testPostcode[0]);
+				assert.isTrue(postcode.valid(), "Expected " + testPostcode[0] +" to be valid");
+			});
+			done();
+		});
+	});
+	describe("Postcode normalisation", function () {
+		it ("should not throw and provide consistant normalised postcode", function (done) {
+			this.timeout(60000);
+			testData.forEach(function (testPostcode) {
+				var pc = testPostcode[0],
+						postcode = new Postcode(pc),
+						downcasePostcode = new Postcode(pc.toLowerCase()),
+						unspacedPostcode = new Postcode(pc.replace(/\s/, ""));
+				if (pc.length === 7) {
+					// Since this isn't normalised in dataset, best we can do is see if normalised data matches
+					assert.equal(postcode.normalise(), downcasePostcode.normalise());
+					assert.equal(postcode.normalise(), unspacedPostcode.normalise());
+				} else {
+					// Any space indicates incode/outcode
+					assert.equal(postcode.normalise(), pc.replace(/\s*/, " "));
+					assert.equal(downcasePostcode.normalise(), pc.replace(/\s*/, " "));
+					assert.equal(unspacedPostcode.normalise(), pc.replace(/\s*/, " "));
+				}
+			});
+			done();
+		});
+	});
+	describe("Incode parsing", function () {
+		it("should return the correct incode", function (done) {
+			this.timeout(60000);
+			testData.forEach(function (testPostcode) {
+				var pc = testPostcode[0],
+						postcode = new Postcode(pc),
+						downcasePostcode = new Postcode(pc.toLowerCase()),
+						unspacedPostcode = new Postcode(pc.replace(/\s/, "")),
+						testIncode;
+				if (pc.length === 7) {
+					// Since this isn't normalised in dataset, best we can do is see if normalised data matches
+					assert.equal(postcode.incode(), downcasePostcode.incode());
+					assert.equal(postcode.incode(), unspacedPostcode.incode());
+				} else {
+					// Any space indicates incode/outcode
+					testIncode = pc.match(/.*\s/)[0].replace(/\s/, "");
+					assert.equal(postcode.incode(), testIncode);
+					assert.equal(downcasePostcode.incode(), testIncode);
+					assert.equal(unspacedPostcode.incode(), testIncode);
+				}
+			});
+			done();
+		});
+	});
+	describe("Outcode parsing", function () {
+		it("should return the correct outcode", function (done) {
+			this.timeout(60000);
+			testData.forEach(function (testPostcode) {
+				var pc = testPostcode[0],
+						postcode = new Postcode(pc),
+						downcasePostcode = new Postcode(pc.toLowerCase()),
+						unspacedPostcode = new Postcode(pc.replace(/\s/, "")),
+						testIncode;
+				if (pc.length === 7) {
+					// Since this isn't normalised in dataset, best we can do is see if normalised data matches
+					assert.equal(postcode.outcode(), downcasePostcode.outcode());
+					assert.equal(postcode.outcode(), unspacedPostcode.outcode());
+				} else {
+					// Any space indicates incode/outcode
+					testIncode = pc.match(/\s.*/)[0].replace(/\s/, "");
+					assert.equal(postcode.outcode(), testIncode);
+					assert.equal(downcasePostcode.outcode(), testIncode);
+					assert.equal(unspacedPostcode.outcode(), testIncode);
+				}
+			});
+			done();
+		});
+	});
+});