value-mapper

Lookup values from a dictionary with aliasing, mapping, and flattenining.

npm install value-mapper
16 downloads in the last week
83 downloads in the last month

value-mapper Build status

Lookup values from a dictionary with aliasing, mapping, and flattenining.

This is used by doubleshot to map values inside of content.

Getting Started

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;
  }
]
*/

Documentation

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);

Examples

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);
  }
]
*/

Donating

Support this project and others by twolfson via gittip.

Support via Gittip

Contributing

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.

License

Copyright (c) 2013 Todd Wolfson

Licensed under the MIT license.

npm loves you