Merge pull request #2 from CodingCarlos/develop

New models

Author: CodingCarlos

README.md

@@ -42,20 +42,22 @@ Validators are just functions. It will be executed for each property, and return
  - [Length](#length)
  - [Value](#value)
  - [Custom function](#custom-function)
+ - [Date](#date)
+ - [Model](#model)
 
- ## Type
- If the data has not the specifed type, validation will fail, and that field will not be added to final validated data.
- 
- ```javascript
- {
-     type: String	// Check if data has a JS type (uses typeof)
- }
- ```
+## Type
+If the data has not the specifed type, validation will fail, and that field will not be added to final validated data.
+
+```javascript
+{
+	type: String	// Check if data has a JS type (uses typeof)
+}
+```
 
- ## Length
- Check data length. It uses default .length param, so it's valid for so much types.
- 
- ```javascript
+## Length
+Check data length. It uses default .length param, so it's valid for so much types.
+
+```javascript
 {
 	length: {
     eq: Number,		// Exact allowed value
@@ -65,8 +67,8 @@ Validators are just functions. It will be executed for each property, and return
 }
  ```
 
- ## Value
-  Check data length. It uses default .length param, so it's valid for so much types.
+## Value
+Check data length. It uses default .length param, so it's valid for so much types.
 
  ```javascript
 {
@@ -89,7 +91,7 @@ Use a custom function to check at your own criteria. The only necessary thing is
 ```
 
 The function might look like this: 
-```
+```javascript
 function is42(value) {
   var allowed = [42, '42', 'cuarenta y dos', 'fourty two', 'the answer to the life the universe and everything'];
   if(allowedValues.indexOf(value) === -1) {
@@ -98,3 +100,58 @@ function is42(value) {
   return true;
 }
 ```
+
+## Date
+Check if data is a JavaScript Date. Just need to set a boolean `date` parameter, like: 
+
+```javascript
+{
+	data: Boolean	// Check if data is a JS Date
+}
+```
+> _Remember that JavaScript dates has type `Object`_
+
+
+## Model
+Yes, models can also validate (and modelate) other models. It's just neccessary the model to exists. To add that model validation, just set a property "model", with the string value of the model name:
+
+```javascript
+{
+	model: String	// Check if data is of a defined model
+}
+```
+An example of when and how to use it, would be a geopoint:
+```javascript
+var coords = Modelate('Coords').set({ 
+	lat: {
+		type: 'number'
+	}, 
+	lon: {
+		type: 'number'
+	}
+});
+
+var geopoint = Modelate('Geopoint').set({
+	coords: {
+		model: 'Coords'
+	},
+	name: {
+		type: 'String',
+		length: {
+			max: 140
+		}
+	}
+});
+
+// Now, you can validate Geopoint objects ^^
+var myGeopoint = {
+	name: 'Batman Symbol'
+	coords: {
+		lat: 26.357896,
+		long: 127.783809
+	}
+}
+
+var batman = geopoint.modelate(myGeopoint);
+console.log(batman);
+```

examples/chat.js

@@ -0,0 +1,86 @@
+/* Just a first basic test */
+var Modelate = require('../index');
+
+// Models
+var userModel = {
+	name: {
+		type: 'string',
+		length: {		// For now, length do nothng.
+			max: 10,
+			min: 1
+		},
+		value: {
+			eq: 'Paco'
+		}
+	},
+	surname: {
+		type: 'string',
+		length: {		// For now, length do nothng.
+			max: 3,
+			min: 1
+		},
+		value: {
+			contains: 'os'
+		}
+	},
+	age: {
+		type: 'number',
+		value: {
+			max: 95,
+			min: 18
+		}
+	},
+	dni: {
+		type: 'string',
+		value: {
+			max: 95,
+			min: 18
+		},
+		func: function startOnFive(value) {
+			if(value.charAt(0) === '5') {
+				return true;
+			}
+
+			return false;
+		}
+	}
+};
+var User = Modelate('User').set(userModel);
+
+// Modelate a user
+var myUserData = {
+	name: 'Paco',
+	surname: 'santos',
+	age: 19,
+	dni: '51402430A',
+	unexpected: 'property'
+};
+// var myUser = User.modelate(myUserData);
+// console.log(myUser);	
+
+var messageModel = {
+	user: {
+		type: 'object',
+		model: 'User'
+	},
+	date: {
+		date: true
+	},
+	message: {
+		type: 'string',
+		length: {
+			min: 1,
+			max: 255
+		}
+	}
+};
+var Message = Modelate('Message').set(messageModel);
+
+// Modelate a message
+var myMessageData = {
+	message: 'Using models inside models. Crazy.',
+	date: new Date(),
+	user: myUserData
+};
+var myMessage = Message.modelate(myMessageData);
+console.log(myMessage);	

test.js examples/user.jstest.js renamed to examples/user.js

@@ -1,5 +1,5 @@
 /* Just a first basic test */
-var Modelate = require('./index');
+var Modelate = require('../index');
 
 var model = {
 	name: {
@@ -44,13 +44,13 @@ var model = {
 		}
 	}
 };
-var user = Modelate('User').model(model);
+var user = Modelate('User').set(model);
 
 var data = {
 	name: 'Paco',
 	surname: 'santos',
 	age: 19,
-	dni: '41402430A'
+	dni: '51402430A'
 };
 var result = user.modelate(data);
 

index.js

@@ -2,27 +2,19 @@
 const model = require('./lib/model');
 const modelate = require('./lib/modelate');
 
-const models = model.models;
-
-
+/**
+ *	Modelate instance.
+ */
 function Modelate(name) {
 	const self = this;
 
 	self.modelName = name;
-	self.model = model.add;
+	self.model = model.get;
+	self.set = model.add;
 	self.modelate = modelate;
 
-	models[name] = {};
-
 	return this;
 }
 
 
 module.exports = Modelate;
-/*{
-	add: function () { },
-	remove: null,
-	list: null,
-	modelate: null
-};*/
-

lib/model.js

@@ -3,12 +3,19 @@ const models = {};
 function model(data) {
 	// ToDo: Validate model
 	// ToDo: Check if model already exists to merge instead of set
-	models[this.name] = data;
+	
+	models[this.modelName] = data;
 
 	return this;
 }
 
+function get() {
+	return models[this.modelName];
+}
+
+
 module.exports = {
 	models: models,
-	add: model
+	add: model,
+	get: get
 };

lib/modelate.js

@@ -1,20 +1,32 @@
 const util = require('./util');
 
 const models = require('./model').models;
-const validate = require('./validate');
+const validate = require('./validate').check;
 
-function modelate(data) {
-	const model = util.clone(models[this.name]);
+/**
+ *	Create a new modelate, validating all properties
+ *	Options might be:
+ *	 - model: {Object} A model to use (instead of this.modelName)
+ *	@param data {Object} The data to validate
+ *	@param opts {Object} Options for the modelate. 
+ */
+function modelate(data, opts) {
+	if (!this.modelName && opts && !opts.model) {
+		return {};
+	}
+
+	const model = opts && opts.model || models[this.modelName];
+	const result = util.clone(model);
 
-	for(let prop in model) {
-		if(validate(data[prop], model[prop])) {
-			model[prop] = data[prop];
+	for (let prop in model) {
+		if (validate(data[prop], model[prop])) {
+			result[prop] = data[prop];
 		} else {
-			delete model[prop];
+			delete result[prop];
 		}
 	}
 
-	return model;
+	return result;
 }
 
 module.exports = modelate;