Allow arguments and context for formatters

README.md

@@ -117,10 +117,14 @@ See hmpo-template-mixins or hmpo-components for additional field options.
 * `journeyKey` - Name of the cross-wizard field storage name
 * `default` - Default value for this field
 * `multiple` - Allow multiple incomming values for a field. The result is presented as an array
-* `formater` - Array of formatter names for this field in addition to the default formatter set
+* `formater` - Array of formatter names for this field in addition to the default formatter set, or formatter objects
+  * `type` - Formatter name
+  * `fn` - Formatter function
+  * `arguments` - Array of formatter arguments, eg. `{ type: 'truncate', arguments: [24] }`
 * `ignore-defaults` - Disabled the default set of formatters for this field
 * `validate` - An array of validator names, or validator objects
   * `type` - Validator name
+  * `fn` - Validator function
   * `arguments` - Array of validator arguments, eg. `{ type: 'minlength', arguments: [24] }`
 * `items` - Array of select box or radio button options
   * `value` - Item value

lib/controller/index.js

@@ -274,15 +274,21 @@ class BaseController {
         let values = req.form.values = req.form.values || {};
         let defaultFormatters = req.form.options.defaultFormatters;
 
+        let context = {
+            sessionModel: req.sessionModel,
+            fields,
+            values: req.body
+        };
+
         _.each(fields, (field, key) => {
             let value = req.body[key];
-            req.form.values[key] = formatting.format(fields, key, value, defaultFormatters);
+            req.form.values[key] = formatting.format(fields, key, value, defaultFormatters, context);
         });
 
         // set values to formatted '' if the field is not allowed
         _.each(fields, (field, key) => {
             if (!validation.isAllowedDependent(fields, key, values)) {
-                req.form.values[key] = formatting.format(fields, key, null, defaultFormatters);
+                req.form.values[key] = formatting.format(fields, key, null, defaultFormatters, context);
             }
         });
         this.process(req, res, next);

lib/formatting/index.js

@@ -4,23 +4,35 @@ const _ = require('underscore');
 const debug = require('debug')('hmpo:formatting');
 const formatters = require('./formatters');
 
-function applyFormatters(fieldFormatters, key, value) {
+function applyFormatters(fieldFormatters, key, value, context) {
     if (!Array.isArray(fieldFormatters)) {
         fieldFormatters = [ fieldFormatters ];
     }
     _.each(fieldFormatters, formatter => {
-        if (typeof formatter === 'string') {
-            formatter = formatters[formatter];
+        if (typeof formatter === 'string') formatter = { type: formatter };
+        if (typeof formatter === 'function') formatter = { fn: formatter };
+
+        if (typeof formatter.fn !== 'function') {
+            formatter.fn = formatters[formatter.type];
         }
-        if (typeof formatter === 'function') {
-            debug('Formatting field %s value %s with formatter %s', key, value, formatter.name);
-            value = formatter(value);
+
+        if (typeof formatter.fn === 'function') {
+            formatter.type = formatter.type || formatter.fn.name;
+
+            if (formatter.arguments === undefined) {
+                formatter.arguments = [];
+            } else if (!_.isArray(formatter.arguments)) {
+                formatter.arguments = [ formatter.arguments ];
+            }
+
+            debug('Applying %s formatter to %s with value "%s"', formatter.type, key, value, formatter.arguments);
+            value = formatter.fn.apply(context, [value].concat(formatter.arguments));
         }
     });
     return value;
 }
 
-function format(fields, key, value, defaultFormatters) {
+function format(fields, key, value, defaultFormatters, context) {
     let field = fields[key];
     if (!Array.isArray(value)) {
         value = [ value ];
@@ -34,13 +46,13 @@ function format(fields, key, value, defaultFormatters) {
     // apply default formatters first
     if (defaultFormatters && !(field && field['ignore-defaults'])) {
         debug('Formatting field %s with default formatters:', key, defaultFormatters);
-        value = value.map(item => applyFormatters(defaultFormatters, key, item));
+        value = value.map(item => applyFormatters(defaultFormatters, key, item, context));
     }
 
     // apply configured formatters
     if (field && field.formatter) {
         debug('Formatting field %s with formatters:', key, field.formatter);
-        value = value.map(item => applyFormatters(field.formatter, key, item));
+        value = value.map(item => applyFormatters(field.formatter, key, item, context));
     }
 
     if (!field.multiple) return value[0];