Implement regex "invalidate" configuration

Author: WesTyler

lib/language.js

@@ -122,7 +122,9 @@ exports.errors = {
         token: 'must only contain alpha-numeric and underscore characters',
         regex: {
             base: 'with value "{{!value}}" fails to match the required pattern: {{pattern}}',
-            name: 'with value "{{!value}}" fails to match the {{name}} pattern'
+            invalidated: 'with value "{{!value}}" matches the invalidated pattern: {{pattern}}',
+            name: 'with value "{{!value}}" fails to match the {{name}} pattern',
+            invalidatedName: 'with value "{{!value}}" matches the invalidated {{name}} pattern'
         },
         email: 'must be a valid email',
         uri: 'must be a valid uri',

lib/string.js

@@ -91,19 +91,28 @@ internals.String = class extends Any {
         });
     }
 
-    regex(pattern, name) {
+    regex(pattern, config) {
 
         Hoek.assert(pattern instanceof RegExp, 'pattern must be a RegExp');
 
         pattern = new RegExp(pattern.source, pattern.ignoreCase ? 'i' : undefined);         // Future version should break this and forbid unsupported regex flags
 
         return this._test('regex', pattern, function (value, state, options) {
 
-            if (pattern.test(value)) {
+            const patternMatch = pattern.test(value);
+            const patternIsInvalidated = (typeof config === 'object' && Hoek.reach(config, 'invalidate'));
+
+            if ((patternMatch && !patternIsInvalidated) || (!patternMatch && patternIsInvalidated)) {
                 return value;
             }
 
-            return this.createError((name ? 'string.regex.name' : 'string.regex.base'), { name, pattern, value }, state, options);
+            const name = typeof config === 'string' ?
+                config :
+                Hoek.reach(config, 'name');
+            const baseRegex = patternIsInvalidated ? 'string.regex.invalidated' : 'string.regex.base';
+            const nameRegex = patternIsInvalidated ? 'string.regex.invalidatedName' : 'string.regex.name';
+
+            return this.createError((name ? nameRegex : baseRegex), { name, pattern, value }, state, options);
         });
     }
 

test/string.js

@@ -875,6 +875,37 @@ describe('string', () => {
                 done();
             });
         });
+
+        it('should include a pattern name in options object', (done) => {
+
+            const schema = Joi.string().regex(/[a-z]+/, { name: 'letters' }).regex(/[0-9]+/, { name: 'numbers' });
+            schema.validate('abcd', (err, value) => {
+
+                expect(err.message).to.contain('numbers pattern');
+                done();
+            });
+        });
+
+        it('should "invalidate" regex pattern if specified in options object', (done) => {
+
+            const schema = Joi.string().regex(/[a-z]/, { invalidate: true });
+            Helper.validate(schema, [
+                ['0123456789', true],
+                ['abcdefg', false, null, '"value" with value "abcdefg" matches the invalidated pattern: /[a-z]/']
+            ], done);
+        });
+
+        it('should include invalidated pattern name if specified', (done) => {
+
+            const schema = Joi.string().regex(/[a-z]/, {
+                name      : 'lowercase',
+                invalidate: true
+            });
+            Helper.validate(schema, [
+                ['0123456789', true],
+                ['abcdefg', false, null, '"value" with value "abcdefg" matches the invalidated lowercase pattern']
+            ], done);
+        });
     });
 
     describe('ip()', () => {