Merge branch 'develop' into modifiers

Author: CodingCarlos

README.md

@@ -56,13 +56,17 @@ Validators are just functions. It will be executed for each property, and return
  - [Custom function](#custom-function)
  - [Date](#date)
  - [Model](#model)
+ - [Email](#email)
+ - [Regex](#regex)
 
 ## Type
 If the data has not the specifed type, validation will fail, and that field will not be added to final validated data.
 
+It uses typeof, so arrays will be considered valid objects. Also, there is a type "array", wich ensures data is an array.
+
 ```javascript
 {
-	type: String	// Check if data has a JS type (uses typeof)
+	type: String	// Check if data has a JS type
 }
 ```
 
@@ -118,7 +122,7 @@ Check if data is a JavaScript Date. Just need to set a boolean `date` parameter,
 
 ```javascript
 {
-	data: Boolean	// Check if data is a JS Date
+	date: Boolean	// Check if data is a JS Date
 }
 ```
 > _Remember that JavaScript dates has type `Object`_
@@ -168,6 +172,48 @@ var batman = geopoint.modelate(myGeopoint);
 console.log(batman);
 ```
 
+## Email
+Check if data is an email. Might be just a boolean, or an object to check domains:
+
+```javascript
+{
+	email: Boolean	// Check if data is an email
+}
+```
+
+Also, to check domains:
+```javascript
+{
+	email: {
+		domain: 'gmail.com'
+	}
+}
+```
+
+Or, to enable more than one valid domains:
+```javascript
+{
+	email: {
+		domain: ['gmail.com', 'google.com']
+	}
+}
+```
+
+## Regex
+Test a regular expression over the data.
+```javascript
+{
+	regex: Regex	// Check if data is regex valid
+}
+```
+An example might be:
+```javascript
+{
+	regex: /[a]/
+}
+```
+This will validate `asd` but not `sdf`
+
 # Tests
 
 I'm currently adding tests to this code. I'm using Jasmine, and saving tests in `/spec` folder.
@@ -195,10 +241,10 @@ Master version might not have the last test updates. Check out the `develop` bra
  - [ ] Validators
 	 - [x] Type
 	 - [x] Length
-	 - [ ] Value
-	 - [ ] Custom function
-	 - [ ] Date
-	 - [ ] Model
+	 - [x] Value
+	 - [x] Custom function
+	 - [x] Date
+	 - [ ] Model (Need help with this #15)
 
 # Contribute
 You can use this code as you like. If you find a bug, or want to ask for a feature, just open an issue, and we'll do our best. If you can fix it, do a pull request to dev branch, and we promise to review it as fast as possible to merge it.

lib/validate.js

@@ -1,6 +1,6 @@
 
 // Add validator names here
-const validators = ['type', 'length', 'value', 'func', 'model', 'date', 'value'];
+const validators = ['type', 'length', 'value', 'func', 'model', 'date', 'email', 'regex'];
 
 // Turn validator names to validator instances.
 for (let i = 0; i < validators.length; i++) {

lib/validators/email.js

@@ -0,0 +1,50 @@
+/**
+ *	Email validator
+ *
+ *	{
+ *		email: {
+ *			domain: String, Array
+ *		}
+ *	}
+ */
+
+function isValid(data, model) {
+	if (!model.email) {
+		return true;
+	}
+
+	if(typeof model.email === 'object' && typeof model.email.domain !== 'undefined') {
+		if (isEmail(data)) {
+			return validateDomain(data, model.email.domain);
+		} else {
+			return false;
+		}
+	}
+	
+	return isEmail(data);
+}
+
+function isEmail(data) {
+	// regex from http://emailregex.com/
+	const emailRegex = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+	return emailRegex.test(data);
+}
+
+function validateDomain(data, domain) {
+	const dataDomain = data.split('@')[1];
+
+	if (typeof domain === 'string') {
+		return dataDomain.toUpperCase() === domain.toUpperCase();
+	} else if (Array.isArray(domain)) {
+		for (var i = domain.length - 1; i >= 0; i--) {
+			if(domain[i].toUpperCase() === dataDomain.toUpperCase()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	return false;
+}
+
+module.exports = isValid;

lib/validators/regex.js

@@ -0,0 +1,22 @@
+/**
+ *	Regex validator
+ *
+ *	{
+ *		regex: Regex
+ *	}
+ */
+
+function isValid(data, model) {
+	if (!model.regex) {
+		return true;
+	}
+
+	if(typeof model.regex === 'object' && typeof model.regex.test === 'function') {
+		return model.regex.test(data);
+	}
+	
+	return false;
+}
+
+
+module.exports = isValid;

lib/validators/type.js

@@ -11,8 +11,10 @@ function isValid(data, model) {
 		return true;
 	}
 
-	if ((typeof (data)).toUpperCase() === model.type.toUpperCase()) {
+	if ((typeof data).toUpperCase() === model.type.toUpperCase()) {
 		return true;
+	} else if (model.type.toUpperCase() === 'ARRAY') {
+		return Array.isArray(data);
 	}
 
 	return false;

lib/validators/value.js

@@ -70,7 +70,7 @@ function equals(data, expected) {
 
 	// Different types: Try to convert one to other.
 	var parsed = data;
-	var type = typeof (expected);
+	var type = typeof expected;
 	switch (type.toLowerCase()) {
 		case 'string':
 			parsed = String(data);

package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelate",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A simple data modeling tool for NodeJS",
   "main": "index.js",
   "scripts": {

spec/validators/email.spec.js

@@ -0,0 +1,113 @@
+var valid = require('../../lib/validators/email');
+
+const email = {
+	example: '[email protected]',
+	gmail: '[email protected]',
+	google: '[email protected]',
+};
+const invalidEmail = {
+	string: 'emailexamplecom',
+	notAt: 'emailexample.com',
+	notDot: 'email@example',
+	notDomain: '[email protected]',
+	notName: '@example.com'
+};
+
+const modelBool = {
+	email: true
+};
+const modelStr = {
+	email: {
+		domain: 'gmail.com'
+	}
+};
+const modelArr = {
+	email: {
+		domain: ['gmail.com', 'google.com']
+	}
+};
+
+
+describe(' - Email validator', () => {
+	it('shall be a function', () => {
+		expect(typeof valid).toEqual('function');
+	});
+
+	it('shall validate everything when empty model set', () => {
+		// Valid emails
+		for (let elem in email) {
+			expect(valid(email[elem], {})).toEqual(true);
+		}
+		// Invalid emails
+		for (let elem in invalidEmail) {
+			expect(valid(invalidEmail[elem], {})).toEqual(true);
+		}
+	});
+
+	describe('Just validate emails (boolean)', () => {
+		describe('shall validate valid emails', () => {
+			for (let elem in email) {
+				it('as is ' + email[elem], () => {
+					expect(valid(email[elem], modelBool)).toEqual(true);
+				});
+			}
+		});
+
+		describe('shall not validate invalid emails', () => {
+			for (let elem in invalidEmail) {
+				it('as is ' + invalidEmail[elem], () => {
+					expect(valid(invalidEmail[elem], modelBool)).toEqual(false);
+				});
+			}
+		});
+	});
+
+	describe('Validate email single domain (string)', () => {
+		describe('shall validate valid emails with valid domain', () => {
+			for (let elem in email) {
+				if (elem === 'gmail') {
+					it('as is ' + email[elem], () => {
+						expect(valid(email[elem], modelStr)).toEqual(true);
+					});
+				} else {
+					it('as is ' + email[elem], () => {
+						expect(valid(email[elem], modelStr)).toEqual(false);
+					});
+				}
+			}
+		});
+
+		describe('shall not validate invalid emails', () => {
+			for (let elem in invalidEmail) {
+				it('as is ' + invalidEmail[elem], () => {
+					expect(valid(invalidEmail[elem], modelStr)).toEqual(false);
+				});
+			}
+		});
+	});
+
+	describe('Validate email multiple domain (array)', () => {
+		describe('shall validate valid emails with valid domains', () => {
+			for (let elem in email) {
+				if (elem === 'gmail' || elem === 'google') {
+					it('as is ' + email[elem], () => {
+						expect(valid(email[elem], modelArr)).toEqual(true);
+					});
+				} else {
+					it('as is ' + email[elem], () => {
+						expect(valid(email[elem], modelArr)).toEqual(false);
+					});
+				}
+			}
+		});
+
+		describe('shall not validate invalid emails', () => {
+			for (let elem in invalidEmail) {
+				it('as is ' + invalidEmail[elem], () => {
+					expect(valid(invalidEmail[elem], modelArr)).toEqual(false);
+				});
+			}
+		});
+	});
+
+});

spec/validators/model.spec.js

@@ -9,16 +9,25 @@
  *	Lot of things to think about.
  */
 
-const valid = require('../../lib/validators/model');
+// const valid = require('../../lib/validators/model');
+
+const validate = {
+	valid: require('../../lib/validators/model')
+};
+const valid = validate.valid;
 
 describe(' - Model validator', () => {
 	it('shall be a function', () => {
 		expect(typeof valid).toEqual('function');
 	});
 
+	it('shall return true if no model passed', () => {
+		const resp = valid({name: ''}, {});
+		expect(resp).toEqual(true);
+	});
+
 	it('shall not validate a inexistent model', () => {
 		const resp = valid({name: ''}, {model: 'MyTestModel'});
 		expect(resp).toEqual(false);
 	});
-	
 });

spec/validators/regex.spec.js

@@ -0,0 +1,28 @@
+var valid = require('../../lib/validators/regex');
+
+const regex = /[a]/;
+const validData = 'asd';
+const invalidData = 'sdf';
+
+const model = {
+	regex: regex
+};
+
+describe(' - Regex validator', () => {
+	it('shall be a function', () => {
+		expect(typeof valid).toEqual('function');
+	});
+
+	it('shall validate everything when no model set', () => {
+		expect(valid(validData, {})).toEqual(true);
+		expect(valid(invalidData, {})).toEqual(true);
+	});
+
+	it('shall validate valid patterns when model set', () => {
+		expect(valid(validData, model)).toEqual(true);
+	});
+
+	it('shall not validate invalid patterns when model set', () => {
+		expect(valid(invalidData, model)).toEqual(false);
+	});
+});