Add support for truthy/falsy boolean values

API.md

@@ -52,6 +52,8 @@
     - [`array.length(limit)`](#arraylengthlimit)
     - [`array.unique([comparator])`](#arrayuniquecomparator)
   - [`boolean`](#boolean)
+    - [`boolean.truthy(value)`](#booleantruthyvalue)
+    - [`boolean.falsy(value)`](#booleanfalsyvalue)
   - [`binary`](#binary)
     - [`binary.encoding(encoding)`](#binaryencodingencoding)
     - [`binary.min(limit)`](#binaryminlimit)
@@ -808,6 +810,24 @@ const boolean = Joi.boolean();
 boolean.validate(true, (err, value) => { });
 ```
 
+#### `boolean.truthy(value)`
+
+Allows for additional strings to be considered valid boolean values in addition to default 'truthy' strings: ['true', 'yes', '1', 'on']. Accepts a string or an array of strings.
+
+```js
+const boolean = Joi.boolean().truthy('Y');
+boolean.validate('Y', (err, value) => { });
+```
+
+#### `boolean.falsy(value)`
+
+Allows for additional strings to be considered valid boolean values in addition to default 'falsy' strings: ['false', 'no', '0', 'off']. Accepts a string or an array of strings.
+
+```js
+const boolean = Joi.boolean().falsy('N');
+boolean.validate('N', (err, value) => { });
+```
+
 ### `binary`
 
 Generates a schema object that matches a Buffer data type (as well as the strings which will be converted to Buffers).

lib/boolean.js

@@ -3,6 +3,7 @@
 // Load modules
 
 const Any = require('./any');
+const Hoek = require('hoek');
 
 
 // Declare internals
@@ -15,6 +16,18 @@ internals.Boolean = class extends Any {
 
         super();
         this._type = 'boolean';
+        this._inner._truthySet = [
+            'true',
+            'yes',
+            'on',
+            '1'
+        ];
+        this._inner._falsySet = [
+            'false',
+            'no',
+            'off',
+            '0'
+        ];
     }
 
     _base(value, state, options) {
@@ -27,8 +40,8 @@ internals.Boolean = class extends Any {
             options.convert) {
 
             const lower = value.toLowerCase();
-            result.value = (lower === 'true' || lower === 'yes' || lower === 'on' || lower === '1' ? true
-                                                            : (lower === 'false' || lower === 'no' || lower === 'off' || lower === '0' ? false : value));
+            result.value = (this._inner._truthySet.indexOf(lower) !== -1 ? true
+                                                            : (this._inner._falsySet.indexOf(lower) !== -1 ? false : value));
         }
 
         if (typeof value === 'number' &&
@@ -41,6 +54,50 @@ internals.Boolean = class extends Any {
         result.errors = (typeof result.value === 'boolean') ? null : this.createError('boolean.base', null, state, options);
         return result;
     }
+
+    truthy(truthyValue) {
+
+        let truthySet = [];
+
+        if (Array.isArray(truthyValue)) {
+            truthySet = truthyValue.map((value) => {
+
+                Hoek.assert(typeof value === 'string', 'truthy value must be a string');
+
+                return value.toLowerCase();
+            });
+        }
+        else {
+            Hoek.assert(typeof truthyValue === 'string', 'truthy value must be a string');
+            truthySet.push(truthyValue.toLowerCase());
+        }
+
+        const obj = this.clone();
+        obj._inner._truthySet = truthySet.concat(obj._truthySet);
+        return obj;
+    }
+
+    falsy(falsyValue) {
+
+        let falsySet = [];
+
+        if (Array.isArray(falsyValue)) {
+            falsySet = falsyValue.map((value) => {
+
+                Hoek.assert(typeof value === 'string', 'falsy value must be a string');
+
+                return value.toLowerCase();
+            });
+        }
+        else {
+            Hoek.assert(typeof falsyValue === 'string', 'falsy value must be a string');
+            falsySet.push(falsyValue.toLowerCase());
+        }
+
+        const obj = this.clone();
+        obj._inner._falsySet = falsySet.concat(obj._falsySet);
+        return obj;
+    }
 };
 
 

test/boolean.js

@@ -159,5 +159,106 @@ describe('boolean', () => {
                 [null, true]
             ], done);
         });
+
+        it('should handle work with additional truthy value', (done) => {
+
+            const rule = Joi.boolean().truthy('Y');
+            Helper.validate(rule, [
+                ['Y', true],
+                ['y', true],
+                [true, true],
+                [false, true],
+                ['N', false, null, '"value" must be a boolean']
+            ], done);
+        });
+
+        it('should handle work with additional truthy array', (done) => {
+
+            const rule = Joi.boolean().truthy(['Y', 'Si']);
+            Helper.validate(rule, [
+                ['Si', true],
+                ['si', true],
+                ['Y', true],
+                ['y', true],
+                [true, true],
+                [false, true],
+                ['N', false, null, '"value" must be a boolean'],
+                [null, false, null, '"value" must be a boolean']
+            ], done);
+        });
+
+        it('should handle work with additional falsy value', (done) => {
+
+            const rule = Joi.boolean().falsy('N');
+            Helper.validate(rule, [
+                ['N', true],
+                ['n', true],
+                ['Y', false, null, '"value" must be a boolean'],
+                [true, true],
+                [false, true]
+            ], done);
+        });
+
+        it('should handle work with additional falsy array', (done) => {
+
+            const rule = Joi.boolean().falsy(['N', 'Never']);
+            Helper.validate(rule, [
+                ['N', true],
+                ['n', true],
+                ['Never', true],
+                ['never', true],
+                ['Y', false, null, '"value" must be a boolean'],
+                [null, false, null, '"value" must be a boolean'],
+                [true, true],
+                [false, true]
+            ], done);
+        });
+
+        it('should handle work with required, null allowed, and both additional truthy and falsy values', (done) => {
+
+            const rule = Joi.boolean().truthy(['Y', 'Si']).falsy(['N', 'Never']).allow(null).required();
+            Helper.validate(rule, [
+                ['N', true],
+                ['n', true],
+                ['Never', true],
+                ['never', true],
+                ['Y', true],
+                ['y', true],
+                ['Si', true],
+                ['si', true],
+                [true, true],
+                [false, true],
+                [null, true],
+                ['M', false, null, '"value" must be a boolean']
+            ], done);
+        });
+
+        it('errors on non-string truthy value', (done) => {
+
+            expect(() => {
+
+                Joi.boolean().truthy({});
+            }).to.throw('truthy value must be a string');
+
+            expect(() => {
+
+                Joi.boolean().truthy(['valid', {}]);
+            }).to.throw('truthy value must be a string');
+            done();
+        });
+
+        it('errors on non-string falsy value', (done) => {
+
+            expect(() => {
+
+                Joi.boolean().falsy({});
+            }).to.throw('falsy value must be a string');
+
+            expect(() => {
+
+                Joi.boolean().falsy(['valid', {}]);
+            }).to.throw('falsy value must be a string');
+            done();
+        });
     });
 });