utils.js

/**
 * Module dependencies.
 */

var debug = require('debug')('reactive:utils');
//var props = require('props');

/**
 * Function cache.
 */

var cache = {};

/**
 * Return possible properties of a string
 * @param {String} str
 * @return {Array} of properties found in the string
 * @api private
 */
var props = function(str) {
  return str
    .replace(/\w+ *\(|"[^"]*"|'[^']*'|\/([^/]+)\//g, '')
    .match(/[a-zA-Z_]\w*([.][a-zA-Z_]\w*)*/g)
    || [];
};
/**
 * Return interpolation property names in `str`,
 * for example "{foo} and {bar}" would return
 * ['foo', 'bar'].
 *
 * @param {String} str
 * @return {Array}
 * @api private
 */

exports.interpolationProps = function(str) {
  var m;
  var arr = [];
  var re = /\{([^}]+)\}/g;

  while (m = re.exec(str)) {
    var expr = m[1];
    arr = arr.concat(props(expr));
  }

  return unique(arr);
};

/**
 * Interpolate `str` with the given `fn`.
 *
 * @param {String} str
 * @param {Function} fn
 * @return {String}
 * @api private
 */

exports.interpolate = function(str, fn){
  return str.replace(/\{([^}]+)\}/g, function(_, expr){
    var cb = cache[expr];
    if (cb == null) cb = cache[expr] = compile(expr);
    var val = fn(expr.trim(), cb);
    return val == null ? '' : val;
  });
};

/**
 * Check if `str` has interpolation.
 *
 * @param {String} str
 * @return {Boolean}
 * @api private
 */

exports.hasInterpolation = function(str) {
  return ~str.indexOf('{');
};

/**
 * Compile `expr` to a `Function`.
 *
 * @param {String} expr
 * @return {Function}
 * @api private
 */

function compile(expr) {
  var re = /\.\w+|\w+ *\(|"[^"]*"|'[^']*'|\/([^/]+)\/|[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*/g;
  var p = props(expr);

  // replace function calls with [ ] syntax to avoid capture as property
  var funCallRe = /.\w+ *\(/g;
  var body = expr.replace(funCallRe, function(_) {
    return '[\'' + _.slice(1, -1) + '\'](';
  });

  body = body.replace(re, function(_) {
    if (p.indexOf(_) >= 0) {
      return access(_);
    };

    return _;
  });

  debug('compile `%s`', body);
  return new Function('reactive', 'return ' + body);
}

/**
 * Access a method `prop` with dot notation.
 *
 * @param {String} prop
 * @return {String}
 * @api private
 */

function access(prop) {
  return 'reactive.get(\'' + prop + '\')';
}

/**
 * Return unique array.
 *
 * @param {Array} arr
 * @return {Array}
 * @api private
 */

function unique(arr) {
  var ret = [];

  for (var i = 0; i < arr.length; i++) {
    if (~ret.indexOf(arr[i])) continue;
    ret.push(arr[i]);
  }

  return ret;
}