Fix all references usages. Fixes #1030.

lib/alternatives.js

@@ -33,7 +33,7 @@ internals.Alternatives = class extends Any {
             const item = this._inner.matches[i];
             const schema = item.schema;
             if (!schema) {
-                const failed = item.is._validate(item.ref(state.parent, options), null, options, state.parent).errors;
+                const failed = item.is._validate(item.ref(state.reference || state.parent, options), null, options, state.parent).errors;
 
                 if (failed) {
                     if (item.otherwise) {

lib/date.js

@@ -163,7 +163,7 @@ internals.compare = function (type, compare) {
                 compareTo = Date.now();
             }
             else if (isRef) {
-                compareTo = internals.Date.toDate(date(state.parent, options));
+                compareTo = internals.Date.toDate(date(state.reference || state.parent, options));
 
                 if (!compareTo) {
                     return this.createError('date.ref', { ref: date.key }, state, options);

lib/number.js

@@ -62,7 +62,7 @@ internals.Number = class extends Any {
 
         return this._test('multiple', base, function (value, state, options) {
 
-            const divisor = isRef ? base(state.parent, options) : base;
+            const divisor = isRef ? base(state.reference || state.parent, options) : base;
 
             if (isRef && (typeof divisor !== 'number' || !isFinite(divisor))) {
                 return this.createError('number.ref', { ref: base.key }, state, options);
@@ -144,7 +144,7 @@ internals.compare = function (type, compare) {
 
             let compareTo;
             if (isRef) {
-                compareTo = limit(state.parent, options);
+                compareTo = limit(state.reference || state.parent, options);
 
                 if (!(typeof compareTo === 'number' && !isNaN(compareTo))) {
                     return this.createError('number.ref', { ref: limit.key }, state, options);

lib/string.js

@@ -504,7 +504,7 @@ internals.compare = function (type, compare) {
 
             let compareTo;
             if (isRef) {
-                compareTo = limit(state.parent, options);
+                compareTo = limit(state.reference || state.parent, options);
 
                 if (!Hoek.isInteger(compareTo)) {
                     return this.createError('string.ref', { ref: limit.key }, state, options);

test/alternatives.js

@@ -281,6 +281,35 @@ describe('alternatives', () => {
                 [{ b: 5 }, false, null, 'child "a" fails because ["a" is required]']
             ], done);
         });
+
+        it('validates with nested whens', (done) => {
+
+            // If ((b === 0 && a === 123) ||
+            //     (b !== 0 && a === anything))
+            // then c === 456
+            // else c === 789
+            const schema = Joi.object({
+                a: Joi.number().required(),
+                b: Joi.number().required(),
+                c: Joi.when('a', {
+                    is: Joi.when('b', {
+                        is: Joi.valid(0),
+                        then: Joi.valid(123)
+                    }),
+                    then: Joi.valid(456),
+                    otherwise: Joi.valid(789)
+                })
+            });
+
+            Helper.validate(schema, [
+                [{ a: 123, b: 0, c: 456 }, true],
+                [{ a: 0, b: 1, c: 456 }, true],
+                [{ a: 0, b: 0, c: 789 }, true],
+                [{ a: 123, b: 456, c: 456 }, true],
+                [{ a: 0, b: 0, c: 456 }, false, null, 'child "c" fails because ["c" must be one of [789]]'],
+                [{ a: 123, b: 456, c: 789 }, false, null, 'child "c" fails because ["c" must be one of [456]]']
+            ], done);
+        });
     });
 
     describe('describe()', () => {

test/date.js

@@ -135,6 +135,26 @@ describe('date', () => {
                 ], done);
             });
 
+            it('accepts references as min date within a when', (done) => {
+
+                const schema = Joi.object({
+                    a: Joi.date().required(),
+                    b: Joi.date().required(),
+                    c: Joi.number().required().when('a', {
+                        is: Joi.date().min(Joi.ref('b')), // a >= b
+                        then: Joi.number().valid(0)
+                    })
+                });
+
+                Helper.validate(schema, [
+                    [{ a: 123, b: 123, c: 0 }, true],
+                    [{ a: 123, b: 456, c: 42 }, true],
+                    [{ a: 456, b: 123, c: 0 }, true],
+                    [{ a: 123, b: 123, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]'],
+                    [{ a: 456, b: 123, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]']
+                ], done);
+            });
+
             it('accepts context references as min date', (done) => {
 
                 const schema = Joi.object({ b: Joi.date().min(Joi.ref('$a')) });

test/number.js

@@ -553,6 +553,26 @@ describe('number', () => {
             ], done);
         });
 
+        it('accepts references as min value within a when', (done) => {
+
+            const schema = Joi.object({
+                a: Joi.number().required(),
+                b: Joi.number().required(),
+                c: Joi.number().required().when('a', {
+                    is: Joi.number().min(Joi.ref('b')), // a >= b
+                    then: Joi.number().valid(0)
+                })
+            });
+
+            Helper.validate(schema, [
+                [{ a: 0, b: 1, c: 42 }, true],
+                [{ a: 1, b: 1, c: 0 }, true],
+                [{ a: 2, b: 1, c: 0 }, true],
+                [{ a: 1, b: 1, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]'],
+                [{ a: 2, b: 1, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]']
+            ], done);
+        });
+
         it('accepts context references as min value', (done) => {
 
             const schema = Joi.object({ b: Joi.number().min(Joi.ref('$a')) });
@@ -859,6 +879,25 @@ describe('number', () => {
             ], done);
         });
 
+        it('should handle references correctly within a when', (done) => {
+
+            const schema = Joi.object({
+                a: Joi.number().required(),
+                b: Joi.number().required(),
+                c: Joi.number().required().when('a', {
+                    is: Joi.number().multiple(Joi.ref('b')), // a % b === 0
+                    then: Joi.number().valid(0)
+                })
+            });
+
+            Helper.validate(schema, [
+                [{ a: 2, b: 3, c: 42 }, true],
+                [{ a: 2, b: 4, c: 42 }, true],
+                [{ a: 4, b: 2, c: 0 }, true],
+                [{ a: 4, b: 2, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]']
+            ], done);
+        });
+
         it('should handle non-number references correctly', (done) => {
 
             const schema = Joi.object({ a: Joi.string(), b: Joi.number().multiple(Joi.ref('a')) });

test/string.js

@@ -149,6 +149,24 @@ describe('string', () => {
             ], done);
         });
 
+        it('accepts references as min length within a when', (done) => {
+
+            const schema = Joi.object({
+                a: Joi.string().required(),
+                b: Joi.number().required(),
+                c: Joi.number().required().when('a', {
+                    is: Joi.string().min(Joi.ref('b')), // a.length >= b
+                    then: Joi.number().valid(0)
+                })
+            });
+
+            Helper.validate(schema, [
+                [{ a: 'abc', b: 4, c: 42 }, true],
+                [{ a: 'abc', b: 3, c: 0 }, true],
+                [{ a: 'abc', b: 3, c: 42 }, false, null, 'child "c" fails because ["c" must be one of [0]]']
+            ], done);
+        });
+
         it('accepts context references as min length', (done) => {
 
             const schema = Joi.object({ b: Joi.string().min(Joi.ref('$a'), 'utf8') });