Implement String.regex "invalidate" configuration

API.md

@@ -1542,14 +1542,26 @@ const schema = Joi.object({
 });
 ```
 
-#### `string.regex(pattern, [name])`
+#### `string.regex(pattern, [name | config])`
 
 Defines a regular expression rule where:
 - `pattern` - a regular expression object the string value must match against.
 - `name` - optional name for patterns (useful with multiple patterns). Defaults to 'required'.
+- `config` - an optional configuration object with the following supported properties:
+  - `name` - optional pattern name. Defaults to `required`.
+  - `invalidate` - optional boolean flag. Defaults to `false` behavior. If specified as `true`, the provided pattern will be disallowed instead of required.
 
 ```js
 const schema = Joi.string().regex(/^[abc]+$/);
+
+const namedSchema = Joi.string().regex(/[0-9]/, { name: 'numbers'});
+namedSchema.validate('alpha'); // ValidationError: "value" with value "alpha" fails to match the numbers pattern
+
+const invalidatedSchema = Joi.string().regex(/[a-z]/, { invalidate: true });
+invalidatedSchema.validate('lowercase'); // ValidationError: "value" with value "lowercase" matches the invalidated pattern: [a-z]
+
+const invalidatedNamedSchema = Joi.string().regex(/[a-z]/, { name: 'alpha', invalidate: true });
+invalidatedNamedSchema.validate('lowercase'); // ValidationError: "value" with value "lowercase" matches the invalidated alpha pattern
 ```
 
 #### `string.replace(pattern, replacement)`

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,30 @@ 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) {
+        const patternIsInvalidated = (typeof config === 'object' && Hoek.reach(config, 'invalidate'));
+        const testName = patternIsInvalidated ? 'invalidatedRegex' : 'regex';
 
-            if (pattern.test(value)) {
+        return this._test(testName, pattern, function (value, state, options) {
+
+            const patternMatch = pattern.test(value);
+
+            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()', () => {
@@ -3628,5 +3659,24 @@ describe('string', () => {
             });
             done();
         });
+
+        it('describes invalidate regex pattern', (done) => {
+
+            const schema = Joi.string().regex(/[a-z]/, {
+                invalidate: true
+            });
+            const description = schema.describe();
+            expect(description).to.equal({
+                type: 'string',
+                invalids: [''],
+                rules: [
+                    {
+                        name: 'invalidatedRegex',
+                        arg: /[a-z]/
+                    }
+                ]
+            });
+            done();
+        });
     });
 });