camusjs

A extensible random objects generator

What is this?

You can translate templates into objects with full random objects.

This:

{
	"name": {
		"*": "name"
	},
	"age": {
		"*": "integer",
		"args": [
			{
				"min": 12,
				"max": 40
			}
		]
	}
}

Will generate some like this:

{
    "name": "Jordan Barnes",
    "age": 18
}

If you want some more complex:

{
    "name": {
        "*": "name"
    },
    "pets": {
        "*": "array",
        "minLength": 1,
        "maxLength": 3,
        "types": [
            {
				"chanceToAppear": 80,
				"definition": {
					"*": "object",
					"definition": {
						"name": {
							"*": "first"
						},
						"type": "Dog"
					}
				}
			},
			{
				"chanceToAppear": 20,
				"definition": {
					"*": "object",
					"definition": {
						"name": {
							"*": "first"
						},
						"type": "Cat"
					}
				}
			}
        ]
    }
}

It will generate a person, with a name and 1 to 3 pets. Each pet has a name and type. Dogs has 80% of chance to appear. Cats, 20%.

The result is some like this:

{
    "name": "Alvin Ramsey",
    "pets": [
        {
            "name": "Jane",
            "type": "Dog"
        },
        {
            "name": "Harry",
            "type": "Dog"
        },
        {
            "name": "Ina",
            "type": "Cat"
        }
    ]
}

It can handle only certain path if you want:

{
	store: {
		country: "Brazil",
		employees: [
			{
				"*": "name"
			}
		]
	}
}

Is translated to some like:

{
    "store": {
        "country": "Brazil",
        "employees": [
            "Maud Moran"
        ]
    }
}

How can i use this?

First, install it: npm install camusjs

var camusjs = require('camusjs')

var myTemplate = {
  "myProperty": {
    "*": "type of the generator"
  }
}

var generated = camusjs.parse(myTemplate)

// done

ChanceJS

You can use any CHANCE JS(VIEW HERE) method to generate values.

Let me show you a sample: The method guid:

chance.guid();
// 'f0d8368d-85e2-54fb-73c4-2d60374295e3'

You can add to your templates using:

{
  "id": {
    "*": "guid"
  }
}

And that's it!

If the function you want to call has arguments:

chance.integer({min: 1, max: 10});
// -7

{
  "myRandomInt": {
    "*": "integer",
    "args": [
      { "min": 1, "max": 10 }
    ]
  }
}

Nested Objects

If you want to generate nested objects, use the object template:

{
    "name": {
        "*": "name"
    },
    "job": {
        "*": "object",
        "definition": {
            "title": {
                "*": "pickone",
                "args": [
                    ["developer", "qa", "manager"]
                ]
            }
        }
    }
}

It will generate some like this:

{
	"name": "Andre Ortega",
	"job": {
		"title": "developer"
	}
}

Array

If you want a collection of objects, use the array template:

{
	"myArray": {
		"*": "array",
		"minLength": 2, // the minimum size of the array
		"maxLength": 6, // the maximum size of the array
		"types": [ // the types of content of the array
			{
				// if you have multimple types of templates in the array,
				// set the percentage of the template appear.
				"chanceToAppear": 90,
				"definition": { // you can use template here.
					"*": "object",
					"definition": {
						"myPropName": {
							"*": "name"
						}
					}
				}
			},
			{
				"chanceToAppear": 10,
				"definition": {
					"*": "integer"
				}
			}
		]
	}
}

In this sample, we generate an array with misc objects and numbers. The result must be some like this:

{
	"myArray": [
		{
			"myPropName": "Georgie Patterson"
		},
		6303461331173376,
		{
			"myPropName": "Anne Jefferson"
		},
		{
			"myPropName": "Lucinda Jordan"
		}
	]
}

Allowing NULLS

If you want to some template returns null in some case, use the chanceToBeNull modifier:

{
	"id": {
		"*": "guid",
		"chanceToBeNull": 15 // in this case, 15% of the times, the id will returns null.
	}
}

All templates accept this modifier =).

Using static values

You can use fixed informed values using the option_value and options:

var template = {
	id: {
		"*": "option_value",
		property: 'myId'
	}
}

var generated = camusjs.parse(template, {
	myId: 'abc123'
})

String Replacing

If your property has a string value and you want to replace some of this string with a random or option value, use the string_replace template:

var template = {
	url: {
		"*": "string_replace",
		value: 'http://api/authentication/%CPF%(/.*)?', // the raw string
		searchFor: '%CPF%', // what will be replaced
		replaceWith: { // the value that be replacer, you can use templates here =).
			"*": "option_value",
			property: "cpf"
		}
	}
}

var generated = camusjs.parse(template, {
	cpf: '00011122244'
})

// 'http://api/authentication/00011122244(/.*)?'

Advanced

Adding new Parsers

You can create parsers and append them to the core. For this, create the following:

var camusjs = require('camusjs')

var newParser = {
	"*": "my_name_of_generator",
	converter: function(template, options) {
		// return your value...
		return null
	}
}

camusjs.registerParser(newParser)

Now you can use:

{
	"myProperty": {
		"*": "my_name_of_generator"
	}
}

Sample of parser that generate a sword:

/*
	want to use:
	{
		"*": "sword"
	}

	and get
	{
		"name": "any name of sword",
		"damage": 12,
		"price": 300.51
	}
*/

var camusjs = require('camusjs')

var swordParser = {
	"*": "sword",
	converter: function(template, options) {
		return camusjs.parse({
			name: {
				"*": "name",
			},
			damage: {
				"*": "integer",
				args: [
					{ min: 5, max: 20 }
				]
			},
			price: {
				"*": "floating",
				args: [
					{min: 150, max: 550, fixed: 2}
				]
			}
		}, options)
	}
}

camusjs.registerParser(swordParser)

var template = {
	"item": {
		"*": "sword"
	}
}

var generated = camusjs.parse(template)

/*
	{
		"item": {
			"name": "Mitchell Mason",
			"damage": 9,
			"price": 257.21
		}
	}
*/

Adding new middlewares

Middlewares are parsers that runs BEFORE the registered parsers (chanceToBeNull is a middleware).

You can register new middlewares:

var camusjs = require('camusjs')

var myMiddleware = {
	'#': 'name_of_my_middleware',
	isGlobal: true, // if must run before ALL transformers
	converter: function(template, options, result) {
		// do what you want here
		var newValue = {} // my new value
		var mustContinue = true //must execute the next middleware or stops here and return value

		result(newValue, mustContinue)
	}
}

camusjs.registerMiddleware(myMiddleware)

For localized middlewares, you can set isGlobal to false and add it manually to your parsers:

var camusjs = require('camusjs')

var myMiddleware = {
	'#': 'name_of_my_middleware',
	isGlobal: false, // if must run before ALL transformers
	converter: function(template, options, result) {
		// do what you want here
		var newValue = {} // my new value
		var mustContinue = true //must execute the next middleware or stops here and return value

		result(newValue, mustContinue)
	}
}

camusjs.registerMiddleware(myMiddleware)

var newParser = {
	"*": "my_name_of_generator",
	middlewares: ['name_of_my_middleware'],
	converter: function(template, options) {
		// return your value...
		return null
	}
}

camusjs.registerParser(newParser)

Changelog

2.0.1

• Fix: fixing wrong template manipulation in loop generation.

2.0.0

• Breaking Change: Removing parseValue method. Use parse only for all.

1.3.1

• Fixing null exception on parse object

1.3.0

• Improve object parsing

1.2.0

• Feat: adding string_replace

1.1.0: First Release