react-native-windows 0.84.0-preview.9 → 0.84.1

package/external/folly/folly/json/JSONSchema.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/ExceptionWrapper.h>
+#include <folly/Range.h>
+#include <folly/json/dynamic.h>
+
+/**
+ * Validation according to the draft v4 standard: http://json-schema.org/
+ *
+ * If your schema is invalid, then it won't validate anything. For example, if
+ * you set "type": "invalid_type" in your schema, then it won't check for any
+ * type, as if you had left that property out. If you want to make sure your
+ * schema is valid, you can optionally validate it first according to the
+ * metaschema.
+ *
+ * Limitations:
+ * - We don't support fetching schemas via HTTP.
+ * - We don't support remote $refs.
+ * - We don't support $ref via id (only by path).
+ * - We don't support UTF-8 for string lengths, i.e. we will count bytes for
+ *   schemas that use minLength/maxLength.
+ */
+
+namespace folly {
+namespace jsonschema {
+
+/**
+ * Interface for a schema validator.
+ */
+struct Validator {
+  virtual ~Validator() = 0;
+
+  /**
+   * Check whether the given value passes the schema. Throws if it fails.
+   */
+  virtual void validate(const dynamic& value) const = 0;
+
+  /**
+   * Check whether the given value passes the schema. Returns an
+   * exception_wrapper indicating success or what the failure was.
+   */
+  virtual exception_wrapper try_validate(
+      const dynamic& value) const noexcept = 0;
+};
+
+/**
+ * Make a validator that can be used to check various json. Thread-safe.
+ */
+std::unique_ptr<Validator> makeValidator(const dynamic& schema);
+
+/**
+ * Makes a validator for schemas. You should probably check your schema with
+ * this before you use makeValidator().
+ */
+std::shared_ptr<Validator> makeSchemaValidator();
+} // namespace jsonschema
+} // namespace folly

package/external/folly/folly/json/JsonMockUtil.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <folly/portability/GMock.h>
+#include <folly/test/JsonTestUtil.h>
+
+namespace folly {
+
+namespace detail {
+template <typename T>
+class JsonEqMatcher : public ::testing::MatcherInterface<T> {
+ public:
+  explicit JsonEqMatcher(std::string expected, std::string prefixBeforeJson)
+      : expected_(std::move(expected)),
+        prefixBeforeJson_(std::move(prefixBeforeJson)) {}
+
+  virtual bool MatchAndExplain(
+      T actual, ::testing::MatchResultListener* /*listener*/) const override {
+    StringPiece sp{actual};
+    if (!sp.startsWith(prefixBeforeJson_)) {
+      return false;
+    }
+    return compareJson(sp.subpiece(prefixBeforeJson_.size()), expected_);
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const override {
+    *os << "JSON is equivalent to " << expected_;
+    if (prefixBeforeJson_.size() > 0) {
+      *os << " after removing prefix '" << prefixBeforeJson_ << "'";
+    }
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "JSON is not equivalent to " << expected_;
+    if (prefixBeforeJson_.size() > 0) {
+      *os << " after removing prefix '" << prefixBeforeJson_ << "'";
+    }
+  }
+
+ private:
+  std::string expected_;
+  std::string prefixBeforeJson_;
+};
+} // namespace detail
+
+/**
+ * GMock matcher that uses compareJson, expecting exactly a type T as an
+ * argument. Popular choices for T are std::string const&, StringPiece, and
+ * std::string. prefixBeforeJson should not be present in expected.
+ */
+template <typename T>
+::testing::Matcher<T> JsonEq(
+    std::string expected, std::string prefixBeforeJson = "") {
+  return ::testing::MakeMatcher(new detail::JsonEqMatcher<T>(
+      std::move(expected), std::move(prefixBeforeJson)));
+}
+
+} // namespace folly

package/external/folly/folly/json/JsonTestUtil.cpp

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/json/JsonTestUtil.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include <folly/Conv.h>
+#include <folly/json/json.h>
+#include <folly/lang/Assume.h>
+
+namespace folly {
+
+bool compareJson(StringPiece json1, StringPiece json2) {
+  auto obj1 = parseJson(json1);
+  auto obj2 = parseJson(json2);
+  return obj1 == obj2;
+}
+
+bool compareJsonWithNestedJson(
+    StringPiece json1, StringPiece json2, unsigned strNestingDepth) {
+  auto obj1 = parseJson(json1);
+  auto obj2 = parseJson(json2);
+  return compareDynamicWithNestedJson(obj1, obj2, strNestingDepth);
+}
+
+bool compareDynamicWithNestedJson(
+    dynamic const& obj1, dynamic const& obj2, unsigned strNestingDepth) {
+  if (obj1 == obj2) {
+    return true;
+  }
+  if (strNestingDepth == 0) {
+    return false;
+  }
+  if (obj1.type() != obj2.type()) {
+    return false;
+  }
+
+  switch (obj1.type()) {
+    case dynamic::Type::ARRAY:
+      if (obj1.size() != obj2.size()) {
+        return false;
+      }
+      for (auto i1 = obj1.begin(), i2 = obj2.begin(); i1 != obj1.end();
+           ++i1, ++i2) {
+        if (!compareDynamicWithNestedJson(*i1, *i2, strNestingDepth)) {
+          return false;
+        }
+      }
+      return true;
+    case dynamic::Type::OBJECT:
+      if (obj1.size() != obj2.size()) {
+        return false;
+      }
+      return std::all_of(
+          obj1.items().begin(), obj1.items().end(), [&](const auto& item) {
+            const auto& value1 = item.second;
+            const auto value2 = obj2.get_ptr(item.first);
+            return value2 &&
+                compareDynamicWithNestedJson(value1, *value2, strNestingDepth);
+          });
+    case dynamic::Type::STRING:
+      if (obj1.getString().find('{') != std::string::npos &&
+          obj2.getString().find('{') != std::string::npos) {
+        try {
+          auto nested1 = parseJson(obj1.getString());
+          auto nested2 = parseJson(obj2.getString());
+          return compareDynamicWithNestedJson(
+              nested1, nested2, strNestingDepth - 1);
+        } catch (...) {
+          // parse error, rely on basic equality check already failed
+        }
+      }
+      return false;
+    case dynamic::Type::NULLT:
+    case dynamic::Type::BOOL:
+    case dynamic::Type::DOUBLE:
+    case dynamic::Type::INT64:
+    default:
+      return false;
+  }
+
+  FOLLY_ASSUME_UNREACHABLE();
+}
+
+namespace {
+
+bool isClose(double x, double y, double tolerance) {
+  return std::abs(x - y) <= tolerance;
+}
+
+} // namespace
+
+bool compareDynamicWithTolerance(
+    const dynamic& obj1, const dynamic& obj2, double tolerance) {
+  if (obj1.type() != obj2.type()) {
+    if (obj1.isNumber() && obj2.isNumber()) {
+      const auto& integ = obj1.isInt() ? obj1 : obj2;
+      const auto& doubl = obj1.isInt() ? obj2 : obj1;
+      // Use to<double> to fail on precision loss for very large
+      // integers (in which case the comparison does not make sense).
+      return isClose(to<double>(integ.asInt()), doubl.asDouble(), tolerance);
+    }
+    return false;
+  }
+
+  switch (obj1.type()) {
+    case dynamic::Type::NULLT:
+      return true;
+    case dynamic::Type::ARRAY:
+      if (obj1.size() != obj2.size()) {
+        return false;
+      }
+      for (auto i1 = obj1.begin(), i2 = obj2.begin(); i1 != obj1.end();
+           ++i1, ++i2) {
+        if (!compareDynamicWithTolerance(*i1, *i2, tolerance)) {
+          return false;
+        }
+      }
+      return true;
+    case dynamic::Type::BOOL:
+      return obj1.asBool() == obj2.asBool();
+    case dynamic::Type::DOUBLE:
+      return isClose(obj1.asDouble(), obj2.asDouble(), tolerance);
+    case dynamic::Type::INT64:
+      return obj1.asInt() == obj2.asInt();
+    case dynamic::Type::OBJECT:
+      if (obj1.size() != obj2.size()) {
+        return false;
+      }
+
+      return std::all_of(
+          obj1.items().begin(), obj1.items().end(), [&](const auto& item) {
+            const auto& value1 = item.second;
+            const auto value2 = obj2.get_ptr(item.first);
+            return value2 &&
+                compareDynamicWithTolerance(value1, *value2, tolerance);
+          });
+    case dynamic::Type::STRING:
+      return obj1.getString() == obj2.getString();
+  }
+
+  FOLLY_ASSUME_UNREACHABLE();
+}
+
+bool compareJsonWithTolerance(
+    StringPiece json1, StringPiece json2, double tolerance) {
+  auto obj1 = parseJson(json1);
+  auto obj2 = parseJson(json2);
+  return compareDynamicWithTolerance(obj1, obj2, tolerance);
+}
+
+} // namespace folly

package/external/folly/folly/json/JsonTestUtil.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <string>
+
+#include <folly/Range.h>
+#include <folly/json/dynamic.h>
+
+namespace folly {
+
+/**
+ * Compares two JSON strings and returns whether they represent the
+ * same document (thus ignoring things like object ordering or multiple
+ * representations of the same number).
+ *
+ * This is implemented by deserializing both strings into dynamic, so it
+ * is not efficient and it is meant to only be used in tests.
+ *
+ * It will throw an exception if any of the inputs is invalid.
+ */
+bool compareJson(StringPiece json1, StringPiece json2);
+
+/**
+ * Like compareJson, but if strNestingDepth > 0 then contained strings that
+ * are valid JSON will be compared using compareJsonWithNestedJson(str1,
+ * str2, strNestingDepth - 1).
+ */
+bool compareJsonWithNestedJson(
+    StringPiece json1, StringPiece json2, unsigned strNestingDepth);
+
+/**
+ * Like compareJson, but with dynamic instances.
+ */
+bool compareDynamicWithNestedJson(
+    dynamic const& obj1, dynamic const& obj2, unsigned strNestingDepth);
+
+/**
+ * Like compareJson, but allows for the given tolerance when comparing
+ * numbers.
+ *
+ * Note that in the dynamic flavor of JSON 64-bit integers are a
+ * supported type. If the values to be compared are both integers,
+ * tolerance is not applied (it may not be possible to represent them
+ * as double without loss of precision).
+ *
+ * When comparing objects exact key match is required, including if
+ * keys are doubles (again a dynamic extension).
+ */
+bool compareJsonWithTolerance(
+    StringPiece json1, StringPiece json2, double tolerance);
+
+/**
+ * Like compareJsonWithTolerance, but operates directly on the
+ * dynamics.
+ */
+bool compareDynamicWithTolerance(
+    const dynamic& obj1, const dynamic& obj2, double tolerance);
+
+} // namespace folly
+
+/**
+ * GTest helpers. Note that to use them you'll need to include the
+ * gtest headers yourself.
+ */
+#define FOLLY_EXPECT_JSON_EQ(json1, json2) \
+  EXPECT_PRED2(::folly::compareJson, json1, json2)
+
+#define FOLLY_EXPECT_JSON_WITH_NESTED_JSON_EQ(json1, json2) \
+  EXPECT_PRED3(::folly::compareJsonWithNestedJson, json1, json2, 1)
+
+#define FOLLY_EXPECT_JSON_NEAR(json1, json2, tolerance) \
+  EXPECT_PRED3(::folly::compareJsonWithTolerance, json1, json2, tolerance)

package/external/folly/folly/json/bser/BUCK

@@ -0,0 +1,24 @@
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_library(
+    name = "bser",
+    srcs = [
+        "Dump.cpp",
+        "Load.cpp",
+    ],
+    headers = [
+        "Bser.h",
+    ],
+    deps = [
+        "//folly:string",
+    ],
+    exported_deps = [
+        "//folly:c_portability",
+        "//folly:json",  # @manual
+        "//folly:optional",
+        "//folly/io:iobuf",
+        "//folly/json:dynamic",
+    ],
+)

package/external/folly/folly/json/bser/Bser.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <unordered_map>
+
+#include <folly/CPortability.h>
+#include <folly/Optional.h>
+#include <folly/io/IOBuf.h>
+#include <folly/io/IOBufQueue.h>
+#include <folly/json/dynamic.h>
+
+/* This is an implementation of the BSER binary serialization scheme.
+ * BSER was created as a binary, local-system-only representation of
+ * JSON values.  It is more space efficient in its output text than JSON,
+ * and cheaper to decode.
+ * It has no requirement that string values be UTF-8.
+ * BSER was created for use with Watchman.
+ * https://facebook.github.io/watchman/docs/bser.html
+ */
+
+namespace folly {
+namespace bser {
+
+class FOLLY_EXPORT BserDecodeError : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+enum class BserType : int8_t {
+  Array = 0,
+  Object,
+  String,
+  Int8,
+  Int16,
+  Int32,
+  Int64,
+  Real,
+  True,
+  False,
+  Null,
+  Template,
+  Skip,
+};
+extern const uint8_t kMagic[2];
+
+struct serialization_opts {
+  serialization_opts();
+
+  // Whether to sort keys of object values before serializing them.
+  // Note that this is potentially slow and that it does not apply
+  // to templated arrays defined via defineTemplate; its keys are always
+  // emitted in the order defined by the template.
+  bool sort_keys;
+
+  // incremental growth size for the underlying Appender when allocating
+  // storage for the encoded output
+  size_t growth_increment;
+
+  // BSER allows generating a more space efficient representation of a list of
+  // object values.  These are stored as an "object template" listing the keys
+  // of the objects ahead of the objects themselves.  The objects are then
+  // serialized without repeating the key string for each element.
+  //
+  // You may use the templates field to associate a template with an
+  // array.  You should construct this map after all mutations have been
+  // performed on the dynamic instance that you intend to serialize as bser,
+  // as it captures the address of the dynamic to match at encoding time.
+  // https://facebook.github.io/watchman/docs/bser.html#array-of-templated-objects
+  using TemplateMap = std::unordered_map<const folly::dynamic*, folly::dynamic>;
+  folly::Optional<TemplateMap> templates;
+};
+
+// parse a BSER value from a variety of sources.
+// The complete BSER data must be present to succeed.
+folly::dynamic parseBser(folly::StringPiece);
+folly::dynamic parseBser(folly::ByteRange);
+folly::dynamic parseBser(const folly::IOBuf*);
+
+// When reading incrementally, it is useful to know how much data to
+// read to fully decode a BSER pdu.
+// Throws std::out_of_range if more data needs to be read to decode
+// the header, or throws a runtime_error if the header is invalid
+size_t decodePduLength(const folly::IOBuf*);
+
+folly::fbstring toBser(folly::dynamic const&, const serialization_opts&);
+std::unique_ptr<folly::IOBuf> toBserIOBuf(
+    folly::dynamic const&, const serialization_opts&);
+} // namespace bser
+} // namespace folly
+
+/* vim:ts=2:sw=2:et:
+ */