Add regular expression support in json_schema component

components/json_schema/json_schema_validator.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/json_schema/json_schema_validator.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
+#include <vector>
 
 #include "base/json/json_reader.h"
+#include "base/logging.h"
+#include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "components/json_schema/json_schema_constants.h"
+#include "third_party/re2/re2/re2.h"
 
 namespace schema = json_schema_constants;
 
 namespace {
 
 double GetNumberValue(const base::Value* value) {
   double result = 0;
   CHECK(value->GetAsDouble(&result))
       << "Unexpected value type: " << value->GetType();
   return result;
@@ skipping 52 matching lines @@
     { schema::kDescription,             base::Value::TYPE_STRING      },
     { schema::kEnum,                    base::Value::TYPE_LIST        },
     { schema::kId,                      base::Value::TYPE_STRING      },
     { schema::kMaxItems,                base::Value::TYPE_INTEGER     },
     { schema::kMaxLength,               base::Value::TYPE_INTEGER     },
     { schema::kMaximum,                 base::Value::TYPE_DOUBLE      },
     { schema::kMinItems,                base::Value::TYPE_INTEGER     },
     { schema::kMinLength,               base::Value::TYPE_INTEGER     },
     { schema::kMinimum,                 base::Value::TYPE_DOUBLE      },
     { schema::kOptional,                base::Value::TYPE_BOOLEAN     },
+    { schema::kPattern,                 base::Value::TYPE_STRING      },
+    { schema::kPatternProperties,       base::Value::TYPE_DICTIONARY  },
     { schema::kProperties,              base::Value::TYPE_DICTIONARY  },
     { schema::kTitle,                   base::Value::TYPE_STRING      },
   };
 
   bool has_type_or_ref = false;
   const base::ListValue* list_value = NULL;
   const base::DictionaryValue* dictionary_value = NULL;
   std::string string_value;
 
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
@@ skipping 80 matching lines @@
       if (integer_value < 0) {
         *error = base::StringPrintf("Value of %s must be >= 0, got %d",
                                     it.key().c_str(), integer_value);
         return false;
       }
     }
 
     // Validate the "properties" attribute. Each entry maps a key to a schema.
     if (it.key() == schema::kProperties) {
       it.value().GetAsDictionary(&dictionary_value);
-      for (base::DictionaryValue::Iterator it(*dictionary_value);
-           !it.IsAtEnd(); it.Advance()) {
-        if (!it.value().GetAsDictionary(&dictionary_value)) {
-          *error = "Invalid value for properties attribute";
+      for (base::DictionaryValue::Iterator iter(*dictionary_value);
+           !iter.IsAtEnd(); iter.Advance()) {
+        if (!iter.value().GetAsDictionary(&dictionary_value)) {
+          *error = "properties must be a dictionary";
           return false;
         }
         if (!IsValidSchema(dictionary_value, options, error)) {
+          DCHECK(!error->empty());
+          return false;
+        }
+      }
+    }
+
+    // Validate the "patternProperties" attribute. Each entry maps a valid
+    // regular expression to a schema.
+    if (it.key() == schema::kPatternProperties) {
+      it.value().GetAsDictionary(&dictionary_value);
+      for (base::DictionaryValue::Iterator iter(*dictionary_value);
+           !iter.IsAtEnd(); iter.Advance()) {
+        if (!iter.value().GetAsDictionary(&dictionary_value)) {
+          *error = "patternProperty must be a dictionary";

[Joao da Silva, 2014/03/21 10:15:16]

patternProperties

[binjin, 2014/03/21 14:57:43]

Done.

+          return false;
+        }
+        if (!IsValidSchema(dictionary_value, options, error)) {
           DCHECK(!error->empty());
           return false;
         }
       }
     }
 
     // Validate "additionalProperties" attribute, which is a schema.
     if (it.key() == schema::kAdditionalProperties) {
       it.value().GetAsDictionary(&dictionary_value);
       if (!IsValidSchema(dictionary_value, options, error)) {
@@ skipping 86 matching lines @@
     "Array must have at least * items.";
 const char JSONSchemaValidator::kArrayMaxItems[] =
     "Array must not have more than * items.";
 const char JSONSchemaValidator::kArrayItemRequired[] =
     "Item is required.";
 const char JSONSchemaValidator::kStringMinLength[] =
     "String must be at least * characters long.";
 const char JSONSchemaValidator::kStringMaxLength[] =
     "String must not be more than * characters long.";
 const char JSONSchemaValidator::kStringPattern[] =
     "String must match the pattern: *.";

[Joao da Silva, 2014/03/21 10:15:16]

Change this to: "String doesn't match pattern /*/: *" (see below)

[binjin, 2014/03/21 14:57:43]

I don't think the change is necessary, telling the pattern looks enough to me.
More important, the tests reply strictly on error message, so it's quite
possible that changes to re2 will break the tests.

[Joao da Silva, 2014/03/21 15:06:40]

sgtm

 const char JSONSchemaValidator::kNumberMinimum[] =
     "Value must not be less than *.";
 const char JSONSchemaValidator::kNumberMaximum[] =
     "Value must not be greater than *.";
 const char JSONSchemaValidator::kInvalidType[] =
     "Expected '*' but got '*'.";
 const char JSONSchemaValidator::kInvalidTypeIntegerNumber[] =
     "Expected 'integer' but got 'number', consider using Math.round().";
+const char JSONSchemaValidator::kInvalidRegex[] =
+    "Regular expression /*/ in Schema is invalid.";

[Joao da Silva, 2014/03/21 10:15:16]

Change this to: "Regular expression /*/ is invalid: *" (see below)

[binjin, 2014/03/21 14:57:43]

Done. As a note I don't plan to add tests for this, since re2 might break the
tests in unexpected way and the invalid regular expression is actually  not
allowed in json-schema so I think validating against such schema is not defined
either.

 
 
 // static
 std::string JSONSchemaValidator::GetJSONSchemaType(const base::Value* value) {
   switch (value->GetType()) {
     case base::Value::TYPE_NULL:
       return schema::kNull;
     case base::Value::TYPE_BOOLEAN:
       return schema::kBoolean;
     case base::Value::TYPE_INTEGER:
@@ skipping 223 matching lines @@
     }
   }
 
   errors_.push_back(Error(path, kInvalidEnum));
 }
 
 void JSONSchemaValidator::ValidateObject(const base::DictionaryValue* instance,
                                          const base::DictionaryValue* schema,
                                          const std::string& path) {
   const base::DictionaryValue* properties = NULL;
-  schema->GetDictionary(schema::kProperties, &properties);
-  if (properties) {
+  if (schema->GetDictionary(schema::kProperties, &properties)) {
     for (base::DictionaryValue::Iterator it(*properties); !it.IsAtEnd();
          it.Advance()) {
       std::string prop_path = path.empty() ? it.key() : (path + "." + it.key());
       const base::DictionaryValue* prop_schema = NULL;
       CHECK(it.value().GetAsDictionary(&prop_schema));
 
       const base::Value* prop_value = NULL;
       if (instance->Get(it.key(), &prop_value)) {
         Validate(prop_value, prop_schema, prop_path);
       } else {
         // Properties are required unless there is an optional field set to
         // 'true'.
         bool is_optional = false;
         prop_schema->GetBoolean(schema::kOptional, &is_optional);
         if (!is_optional) {
           errors_.push_back(Error(prop_path, kObjectPropertyIsRequired));
         }
       }
     }
   }
 
+  // Allowing any additional items will ignore pattern properties as well.
   const base::DictionaryValue* additional_properties_schema = NULL;
-  if (SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema))
-    return;
+  bool allow_any_additional_properties =
+      SchemaAllowsAnyAdditionalItems(schema, &additional_properties_schema);
 
-  // Validate additional properties.
+  const base::DictionaryValue* pattern_properties = NULL;
+  ScopedVector<re2::RE2> pattern_properties_pattern;
+  std::vector<const base::DictionaryValue*> pattern_properties_schema;
+
+  if (schema->GetDictionary(schema::kPatternProperties, &pattern_properties)) {
+    for (base::DictionaryValue::Iterator it(*pattern_properties); !it.IsAtEnd();
+         it.Advance()) {
+      re2::RE2* prop_pattern = new re2::RE2(it.key());
+      if (!prop_pattern->ok()) {
+        LOG(WARNING) << "Regular expression /" << it.key()
+                     << "/ is invalid: " << prop_pattern->error() << ".";
+        errors_.push_back(
+            Error(path, FormatErrorMessage(kInvalidRegex, it.key())));

[Joao da Silva, 2014/03/21 10:15:16]

Include prop_pattern->error() in this Error (see kInvalidType for an example
using two arguments)

[binjin, 2014/03/21 14:57:43]

Done.

+      }
+      const base::DictionaryValue* prop_schema = NULL;
+      CHECK(it.value().GetAsDictionary(&prop_schema));
+      pattern_properties_pattern.push_back(prop_pattern);
+      pattern_properties_schema.push_back(prop_schema);
+    }
+  }
+
+  // Validate pattern properties and additional properties.
   for (base::DictionaryValue::Iterator it(*instance); !it.IsAtEnd();
        it.Advance()) {
-    if (properties && properties->HasKey(it.key()))
+    std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
+
+    bool found_matching_pattern = false;
+    for (size_t index = 0; index < pattern_properties_pattern.size(); ++index) {
+      if (pattern_properties_pattern[index]->ok() &&
+          re2::RE2::PartialMatch(it.key(),
+                                 *pattern_properties_pattern[index])) {
+        found_matching_pattern = true;
+        Validate(&it.value(), pattern_properties_schema[index], prop_path);
+        break;
+      }
+    }
+
+    if (found_matching_pattern || allow_any_additional_properties ||
+        (properties && properties->HasKey(it.key())))
       continue;
 
-    std::string prop_path = path.empty() ? it.key() : path + "." + it.key();
     if (!additional_properties_schema) {
       errors_.push_back(Error(prop_path, kUnexpectedProperty));
     } else {
       Validate(&it.value(), additional_properties_schema, prop_path);
     }
   }
 }
 
 void JSONSchemaValidator::ValidateArray(const base::ListValue* instance,
                                         const base::DictionaryValue* schema,
@@ skipping 102 matching lines @@
 
   int max_length = 0;
   if (schema->GetInteger(schema::kMaxLength, &max_length)) {
     CHECK(max_length >= 0);
     if (value.size() > static_cast<size_t>(max_length)) {
       errors_.push_back(Error(path, FormatErrorMessage(
           kStringMaxLength, base::IntToString(max_length))));
     }
   }
 
-  CHECK(!schema->HasKey(schema::kPattern)) << "Pattern is not supported.";
+  std::string pattern;
+  if (schema->GetString(schema::kPattern, &pattern)) {
+    re2::RE2 compiled_regex(pattern);
+    if (!compiled_regex.ok()) {
+      LOG(WARNING) << "Regular expression /" << pattern
+                   << "/ is invalid: " << compiled_regex.error() << ".";
+      errors_.push_back(
+          Error(path, FormatErrorMessage(kInvalidRegex, pattern)));

[Joao da Silva, 2014/03/21 10:15:16]

Include compiled_reger.error() in this Error too (same as above)

[binjin, 2014/03/21 14:57:43]

Done.

+    } else if (!re2::RE2::PartialMatch(value, compiled_regex)) {
+      errors_.push_back(
+          Error(path, FormatErrorMessage(kStringPattern, pattern)));

[Joao da Silva, 2014/03/21 10:15:16]

Include compiled_reger.error() in this Error too (same as above)

[binjin, 2014/03/21 14:57:43]

Not changed, as mentioned above.

+    }
+  }
 }
 
 void JSONSchemaValidator::ValidateNumber(const base::Value* instance,
                                          const base::DictionaryValue* schema,
                                          const std::string& path) {
   double value = GetNumberValue(instance);
 
   // TODO(aa): It would be good to test that the double is not infinity or nan,
   // but isnan and isinf aren't defined on Windows.
 
@@ skipping 40 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type(schema::kAny);
     CHECK((*additional_properties_schema)->GetString(
         schema::kType, &additional_properties_type));
     return additional_properties_type == schema::kAny;
   } else {
     return default_allow_additional_properties_;
   }
 }