Lookup values from a dictionary with aliasing, mapping, and flattenining.
This is used by doubleshot to map values inside of content
.
Install the module with: npm install value-mapper
// Create a mapper
var ValueMapper = require('value-mapper'),
mapper = new ValueMapper({
'1 + 2': ['One', 'plus two'],
'One': function () {
this.sum = 1;
},
'plus two': function () {
this.sum += 2;
},
'= 3': 'equals three',
'equals three': function () {
assert.strictEqual(this.sum, 3);
}
}, {
middlewares: ['alias', 'map']
});
// Lookup the values on a per-key basis
mapper.lookup('1 + 2');
/*
[
function () {
this.sum = 1;
},
function () {
this.sum += 2;
}
]
*/
ValueMapper
is a constructor function
new ValueMapper(input);
new ValueMapper(input, options);
/**
* Constructor for mapping values
* @param {Object} input Key-value pairs to map values across
* @param {Object} [options] Flags to adjust how the mapping is performed
* @param {Function[]} [options.middlewares] Proxies to process resolved value through
* Built-in middlewares can be used via a 'string'.
* 'alias': If `value` is a string, returns `value = input[value];`
* 'map': If `value` is an array, each value will be processed via 'alias'
* 'flatten': If `value` is an array and contains arrays, flatten it
*/
To find values, use the lookup
method
mapper.lookup(key);
/**
* Resolve the value of a key
* @param {String} key Name to lookup value by
*/
If you choose to write your own middleware, the method signature will have to look like
/**
* @param {Mixed} val Value to perform operations on
* @returns {Object} retObj Container for value and meta information
* @returns {Mixed} retObj.value Manipulated value of `val`
* @returns {String[]} retObj.aliasesUsed Array of aliased keys used while looking up
* @returns {String[]} retObj.aliasesNotFound Array of aliased not found while looking up
*/
Inside of your middleware, you have the context (i.e. this
) of mapper
(allowing you to call this.lookup
) and access to the key
of the current lookup call via this.key
.
Values can be procesed through middlewares via process(val);
New middlewares can be added to an instance via addMiddleware(key);
(accepts built-in name or function)
Built-in middlewares can be added via ValueMapper.addMiddleware(name, fn);
Here is an example using map
, alias
, and flatten
.
// A complex mapping
var mapper = ValueMapper({
'A fruit': 'A banana',
'A banana': function () {
this.color = 'yellow';
this.fruit = new Banana();
},
'is yellow': ['hasColor', 'assertColor'],
'when peeled is white': ['when peeled', 'is white'],
'when peeled': function () {
this.color = 'white';
this.fruit = this.fruit.peel();
},
'is white': ['hasColor', 'assertColor'],
'hasColor': function () {
assert(this.fruit.color);
},
'assertColor': function () {
assert.strictEqual(this.fruit.color, this.color);
}
}, [
middlewares: [
'alias',
'map',
'flatten'
]
});
// when mapped looks like
mapper.lookup('A fruit');
/*
function () {
this.color = 'yellow';
this.fruit = new Banana();
}
*/
mapper.lookup('is yellow');
/*
[
function () {
assert(this.fruit.color);
},
function () {
assert.strictEqual(this.fruit.color, this.color);
}
]
*/
mapper.lookup('when peeled is white');
/*
[
function () {
this.color = 'white';
this.fruit = this.fruit.peel();
},
function () {
assert(this.fruit.color);
},
function () {
assert.strictEqual(this.fruit.color, this.color);
}
]
*/
Support this project and others by twolfson via gittip.
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint via grunt and test via npm test
.
Copyright (c) 2013 Todd Wolfson
Licensed under the MIT license.