diff --git a/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.c b/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.c new file mode 100644 index 0000000..5284248 --- /dev/null +++ b/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.c @@ -0,0 +1,393 @@ +/** + * TopLevel.c + * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT + */ + +#include "TopLevel.h" + +enum Status cJSON_GetStatusValue(const cJSON * j) { + enum Status x = 0; + if (NULL != j) { + if (!strcmp(cJSON_GetStringValue(j), "ready")) x = STATUS_READY; + else if (!strcmp(cJSON_GetStringValue(j), "done")) x = STATUS_DONE; + } + return x; +} + +cJSON * cJSON_CreateStatus(const enum Status x) { + cJSON * j = NULL; + switch (x) { + case STATUS_READY: j = cJSON_CreateString("ready"); break; + case STATUS_DONE: j = cJSON_CreateString("done"); break; + } + return j; +} + +struct DateTime * cJSON_ParseDateTime(const char * s) { + struct DateTime * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetDateTimeValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct DateTime * cJSON_GetDateTimeValue(const cJSON * j) { + struct DateTime * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct DateTime)))) { + memset(x, 0, sizeof(struct DateTime)); + if (!cJSON_HasObjectItem(j, "value")) { cJSON_DeleteDateTime(x); return NULL; } + if (cJSON_HasObjectItem(j, "value")) { + if (!quicktype_cJSON_IsInteger(cJSON_GetObjectItemCaseSensitive(j, "value"))) { cJSON_DeleteDateTime(x); return NULL; } + x->value = cJSON_GetNumberValue(cJSON_GetObjectItemCaseSensitive(j, "value")); + } + } + } + return x; +} + +cJSON * cJSON_CreateDateTime(const struct DateTime * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + cJSON_AddNumberToObject(j, "value", x->value); + } + } + return j; +} + +char * cJSON_PrintDateTime(const struct DateTime * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateDateTime(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteDateTime(struct DateTime * x) { + if (NULL != x) { + cJSON_free(x); + } +} + +struct EnumValues * cJSON_ParseEnumValues(const char * s) { + struct EnumValues * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetEnumValuesValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct EnumValues * cJSON_GetEnumValuesValue(const cJSON * j) { + struct EnumValues * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct EnumValues)))) { + memset(x, 0, sizeof(struct EnumValues)); + if (!cJSON_HasObjectItem(j, "label")) { cJSON_DeleteEnumValues(x); return NULL; } + if (cJSON_HasObjectItem(j, "label")) { + if (!cJSON_IsString(cJSON_GetObjectItemCaseSensitive(j, "label"))) { cJSON_DeleteEnumValues(x); return NULL; } + x->label = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "label"))); + } + else { + if (NULL != (x->label = cJSON_malloc(sizeof(char)))) { + x->label[0] = '\0'; + } + } + } + } + return x; +} + +cJSON * cJSON_CreateEnumValues(const struct EnumValues * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + if (NULL != x->label) { + cJSON_AddStringToObject(j, "label", x->label); + } + else { + cJSON_AddStringToObject(j, "label", ""); + } + } + } + return j; +} + +char * cJSON_PrintEnumValues(const struct EnumValues * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateEnumValues(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteEnumValues(struct EnumValues * x) { + if (NULL != x) { + if (NULL != x->label) { + cJSON_free(x->label); + } + cJSON_free(x); + } +} + +struct FormatException * cJSON_ParseFormatException(const char * s) { + struct FormatException * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetFormatExceptionValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct FormatException * cJSON_GetFormatExceptionValue(const cJSON * j) { + struct FormatException * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct FormatException)))) { + memset(x, 0, sizeof(struct FormatException)); + if (!cJSON_HasObjectItem(j, "count")) { cJSON_DeleteFormatException(x); return NULL; } + if (cJSON_HasObjectItem(j, "count")) { + if (!quicktype_cJSON_IsInteger(cJSON_GetObjectItemCaseSensitive(j, "count"))) { cJSON_DeleteFormatException(x); return NULL; } + x->count = cJSON_GetNumberValue(cJSON_GetObjectItemCaseSensitive(j, "count")); + } + } + } + return x; +} + +cJSON * cJSON_CreateFormatException(const struct FormatException * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + cJSON_AddNumberToObject(j, "count", x->count); + } + } + return j; +} + +char * cJSON_PrintFormatException(const struct FormatException * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateFormatException(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteFormatException(struct FormatException * x) { + if (NULL != x) { + cJSON_free(x); + } +} + +struct RegExp * cJSON_ParseRegExp(const char * s) { + struct RegExp * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetRegExpValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct RegExp * cJSON_GetRegExpValue(const cJSON * j) { + struct RegExp * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct RegExp)))) { + memset(x, 0, sizeof(struct RegExp)); + if (!cJSON_HasObjectItem(j, "active")) { cJSON_DeleteRegExp(x); return NULL; } + if (cJSON_HasObjectItem(j, "active")) { + if (!cJSON_IsBool(cJSON_GetObjectItemCaseSensitive(j, "active"))) { cJSON_DeleteRegExp(x); return NULL; } + x->active = cJSON_IsTrue(cJSON_GetObjectItemCaseSensitive(j, "active")); + } + } + } + return x; +} + +cJSON * cJSON_CreateRegExp(const struct RegExp * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + cJSON_AddBoolToObject(j, "active", x->active); + } + } + return j; +} + +char * cJSON_PrintRegExp(const struct RegExp * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateRegExp(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteRegExp(struct RegExp * x) { + if (NULL != x) { + cJSON_free(x); + } +} + +struct TopLevel * cJSON_ParseTopLevel(const char * s) { + struct TopLevel * x = NULL; + if (NULL != s) { + cJSON * j = cJSON_Parse(s); + if (NULL != j) { + x = cJSON_GetTopLevelValue(j); + cJSON_Delete(j); + } + } + return x; +} + +struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j) { + struct TopLevel * x = NULL; + if (NULL != j) { + if (NULL != (x = cJSON_malloc(sizeof(struct TopLevel)))) { + memset(x, 0, sizeof(struct TopLevel)); + if (!cJSON_HasObjectItem(j, "code")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "code")) { + if (!cJSON_IsString(cJSON_GetObjectItemCaseSensitive(j, "code"))) { cJSON_DeleteTopLevel(x); return NULL; } + regex_t regex; regcomp(®ex, "^[a-z]+$", REG_EXTENDED); if (regexec(®ex, cJSON_GetObjectItemCaseSensitive(j, "code")->valuestring, 0, NULL, 0)) { regfree(®ex); cJSON_DeleteTopLevel(x); return NULL; } regfree(®ex); + if (strlen(cJSON_GetObjectItemCaseSensitive(j, "code")->valuestring) < 1) { cJSON_DeleteTopLevel(x); return NULL; } + x->code = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "code"))); + } + else { + if (NULL != (x->code = cJSON_malloc(sizeof(char)))) { + x->code[0] = '\0'; + } + } + if (!cJSON_HasObjectItem(j, "dateTime")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "dateTime")) { + if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "dateTime"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->date_time = cJSON_GetDateTimeValue(cJSON_GetObjectItemCaseSensitive(j, "dateTime")); + if (NULL == x->date_time) { cJSON_DeleteTopLevel(x); return NULL; } + } + if (!cJSON_HasObjectItem(j, "enumValues")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "enumValues")) { + if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "enumValues"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->enum_values = cJSON_GetEnumValuesValue(cJSON_GetObjectItemCaseSensitive(j, "enumValues")); + if (NULL == x->enum_values) { cJSON_DeleteTopLevel(x); return NULL; } + } + if (!cJSON_HasObjectItem(j, "formatException")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "formatException")) { + if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "formatException"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->format_exception = cJSON_GetFormatExceptionValue(cJSON_GetObjectItemCaseSensitive(j, "formatException")); + if (NULL == x->format_exception) { cJSON_DeleteTopLevel(x); return NULL; } + } + if (!cJSON_HasObjectItem(j, "regExp")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "regExp")) { + if (!cJSON_IsObject(cJSON_GetObjectItemCaseSensitive(j, "regExp"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->reg_exp = cJSON_GetRegExpValue(cJSON_GetObjectItemCaseSensitive(j, "regExp")); + if (NULL == x->reg_exp) { cJSON_DeleteTopLevel(x); return NULL; } + } + if (!cJSON_HasObjectItem(j, "status")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "status")) { + if (!cJSON_IsString(cJSON_GetObjectItemCaseSensitive(j, "status"))) { cJSON_DeleteTopLevel(x); return NULL; } + if (!cJSON_IsString(cJSON_GetObjectItemCaseSensitive(j, "status")) || 0 == cJSON_GetStatusValue(cJSON_GetObjectItemCaseSensitive(j, "status"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->status = cJSON_GetStatusValue(cJSON_GetObjectItemCaseSensitive(j, "status")); + } + if (!cJSON_HasObjectItem(j, "timestamp")) { cJSON_DeleteTopLevel(x); return NULL; } + if (cJSON_HasObjectItem(j, "timestamp")) { + if (!cJSON_IsString(cJSON_GetObjectItemCaseSensitive(j, "timestamp"))) { cJSON_DeleteTopLevel(x); return NULL; } + x->timestamp = strdup(cJSON_GetStringValue(cJSON_GetObjectItemCaseSensitive(j, "timestamp"))); + } + else { + if (NULL != (x->timestamp = cJSON_malloc(sizeof(char)))) { + x->timestamp[0] = '\0'; + } + } + } + } + return x; +} + +cJSON * cJSON_CreateTopLevel(const struct TopLevel * x) { + cJSON * j = NULL; + if (NULL != x) { + if (NULL != (j = cJSON_CreateObject())) { + if (NULL != x->code) { + cJSON_AddStringToObject(j, "code", x->code); + } + else { + cJSON_AddStringToObject(j, "code", ""); + } + cJSON_AddItemToObject(j, "dateTime", cJSON_CreateDateTime(x->date_time)); + cJSON_AddItemToObject(j, "enumValues", cJSON_CreateEnumValues(x->enum_values)); + cJSON_AddItemToObject(j, "formatException", cJSON_CreateFormatException(x->format_exception)); + cJSON_AddItemToObject(j, "regExp", cJSON_CreateRegExp(x->reg_exp)); + cJSON_AddItemToObject(j, "status", cJSON_CreateStatus(x->status)); + if (NULL != x->timestamp) { + cJSON_AddStringToObject(j, "timestamp", x->timestamp); + } + else { + cJSON_AddStringToObject(j, "timestamp", ""); + } + } + } + return j; +} + +char * cJSON_PrintTopLevel(const struct TopLevel * x) { + char * s = NULL; + if (NULL != x) { + cJSON * j = cJSON_CreateTopLevel(x); + if (NULL != j) { + s = cJSON_Print(j); + cJSON_Delete(j); + } + } + return s; +} + +void cJSON_DeleteTopLevel(struct TopLevel * x) { + if (NULL != x) { + if (NULL != x->code) { + cJSON_free(x->code); + } + if (NULL != x->date_time) { + cJSON_DeleteDateTime(x->date_time); + } + if (NULL != x->enum_values) { + cJSON_DeleteEnumValues(x->enum_values); + } + if (NULL != x->format_exception) { + cJSON_DeleteFormatException(x->format_exception); + } + if (NULL != x->reg_exp) { + cJSON_DeleteRegExp(x->reg_exp); + } + if (NULL != x->timestamp) { + cJSON_free(x->timestamp); + } + cJSON_free(x); + } +} diff --git a/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.h b/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.h new file mode 100644 index 0000000..bca175d --- /dev/null +++ b/head/schema-cjson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.h @@ -0,0 +1,109 @@ +/** + * TopLevel.h + * This file has been autogenerated using quicktype https://github.com/quicktype/quicktype - DO NOT EDIT + * This file depends of https://github.com/DaveGamble/cJSON, https://github.com/joelguittet/c-list and https://github.com/joelguittet/c-hashtable + * To parse json data from json string use the following: struct * data = cJSON_Parse(); + * To get json data from cJSON object use the following: struct * data = cJSON_GetValue(); + * To get cJSON object from json data use the following: cJSON * cjson = cJSON_Create(); + * To print json string from json data use the following: char * string = cJSON_Print(); + * To delete json data use the following: cJSON_Delete(); + */ + +#ifndef __TOPLEVEL_H__ +#define __TOPLEVEL_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#define quicktype_cJSON_Duplicate(j) cJSON_Duplicate(j, true) +#define cJSON_Integer (1 << 18) +#define quicktype_cJSON_IsInteger(j) (cJSON_IsNumber(j) && (j)->valuedouble == (int64_t)(j)->valuedouble) +#ifndef cJSON_Bool +#define cJSON_Bool (cJSON_True | cJSON_False) +#endif +#ifndef cJSON_Map +#define cJSON_Map (1 << 16) +#endif +#ifndef cJSON_Enum +#define cJSON_Enum (1 << 17) +#endif + +struct DateTime { + int64_t value; +}; + +struct EnumValues { + char * label; +}; + +struct FormatException { + int64_t count; +}; + +struct RegExp { + bool active; +}; + +enum Status { + STATUS_READY = 1, + STATUS_DONE, +}; + +struct TopLevel { + char * code; + struct DateTime * date_time; + struct EnumValues * enum_values; + struct FormatException * format_exception; + struct RegExp * reg_exp; + enum Status status; + char * timestamp; +}; + +enum Status cJSON_GetStatusValue(const cJSON * j); +cJSON * cJSON_CreateStatus(const enum Status x); + +struct DateTime * cJSON_ParseDateTime(const char * s); +struct DateTime * cJSON_GetDateTimeValue(const cJSON * j); +cJSON * cJSON_CreateDateTime(const struct DateTime * x); +char * cJSON_PrintDateTime(const struct DateTime * x); +void cJSON_DeleteDateTime(struct DateTime * x); + +struct EnumValues * cJSON_ParseEnumValues(const char * s); +struct EnumValues * cJSON_GetEnumValuesValue(const cJSON * j); +cJSON * cJSON_CreateEnumValues(const struct EnumValues * x); +char * cJSON_PrintEnumValues(const struct EnumValues * x); +void cJSON_DeleteEnumValues(struct EnumValues * x); + +struct FormatException * cJSON_ParseFormatException(const char * s); +struct FormatException * cJSON_GetFormatExceptionValue(const cJSON * j); +cJSON * cJSON_CreateFormatException(const struct FormatException * x); +char * cJSON_PrintFormatException(const struct FormatException * x); +void cJSON_DeleteFormatException(struct FormatException * x); + +struct RegExp * cJSON_ParseRegExp(const char * s); +struct RegExp * cJSON_GetRegExpValue(const cJSON * j); +cJSON * cJSON_CreateRegExp(const struct RegExp * x); +char * cJSON_PrintRegExp(const struct RegExp * x); +void cJSON_DeleteRegExp(struct RegExp * x); + +struct TopLevel * cJSON_ParseTopLevel(const char * s); +struct TopLevel * cJSON_GetTopLevelValue(const cJSON * j); +cJSON * cJSON_CreateTopLevel(const struct TopLevel * x); +char * cJSON_PrintTopLevel(const struct TopLevel * x); +void cJSON_DeleteTopLevel(struct TopLevel * x); + +#ifdef __cplusplus +} +#endif + +#endif /* __TOPLEVEL_H__ */ diff --git a/head/schema-cplusplus/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.hpp b/head/schema-cplusplus/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.hpp new file mode 100644 index 0000000..97bf1aa --- /dev/null +++ b/head/schema-cplusplus/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.hpp @@ -0,0 +1,368 @@ +// To parse this JSON data, first install +// +// json.hpp https://github.com/nlohmann/json +// +// Then include this file, and then do +// +// TopLevel data = nlohmann::json::parse(jsonString); + +#pragma once + +#include "json.hpp" + +#include +#include +#include + +namespace quicktype { + using nlohmann::json; + + class ClassMemberConstraints { + private: + std::optional min_int_value; + std::optional max_int_value; + std::optional min_double_value; + std::optional max_double_value; + std::optional min_length; + std::optional max_length; + std::optional pattern; + + public: + ClassMemberConstraints( + std::optional min_int_value, + std::optional max_int_value, + std::optional min_double_value, + std::optional max_double_value, + std::optional min_length, + std::optional max_length, + std::optional pattern + ) : min_int_value(min_int_value), max_int_value(max_int_value), min_double_value(min_double_value), max_double_value(max_double_value), min_length(min_length), max_length(max_length), pattern(pattern) {} + ClassMemberConstraints() = default; + virtual ~ClassMemberConstraints() = default; + + void set_min_int_value(int64_t min_int_value) { this->min_int_value = min_int_value; } + auto get_min_int_value() const { return min_int_value; } + + void set_max_int_value(int64_t max_int_value) { this->max_int_value = max_int_value; } + auto get_max_int_value() const { return max_int_value; } + + void set_min_double_value(double min_double_value) { this->min_double_value = min_double_value; } + auto get_min_double_value() const { return min_double_value; } + + void set_max_double_value(double max_double_value) { this->max_double_value = max_double_value; } + auto get_max_double_value() const { return max_double_value; } + + void set_min_length(size_t min_length) { this->min_length = min_length; } + auto get_min_length() const { return min_length; } + + void set_max_length(size_t max_length) { this->max_length = max_length; } + auto get_max_length() const { return max_length; } + + void set_pattern(const std::string & pattern) { this->pattern = pattern; } + auto get_pattern() const { return pattern; } + }; + + class ClassMemberConstraintException : public std::runtime_error { + public: + ClassMemberConstraintException(const std::string & msg) : std::runtime_error(msg) {} + }; + + class ValueTooLowException : public ClassMemberConstraintException { + public: + ValueTooLowException(const std::string & msg) : ClassMemberConstraintException(msg) {} + }; + + class ValueTooHighException : public ClassMemberConstraintException { + public: + ValueTooHighException(const std::string & msg) : ClassMemberConstraintException(msg) {} + }; + + class ValueTooShortException : public ClassMemberConstraintException { + public: + ValueTooShortException(const std::string & msg) : ClassMemberConstraintException(msg) {} + }; + + class ValueTooLongException : public ClassMemberConstraintException { + public: + ValueTooLongException(const std::string & msg) : ClassMemberConstraintException(msg) {} + }; + + class InvalidPatternException : public ClassMemberConstraintException { + public: + InvalidPatternException(const std::string & msg) : ClassMemberConstraintException(msg) {} + }; + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, int64_t value) { + if (c.get_min_int_value() != std::nullopt && value < *c.get_min_int_value()) { + throw ValueTooLowException ("Value too low for " + name + " (" + std::to_string(value) + "<" + std::to_string(*c.get_min_int_value()) + ")"); + } + + if (c.get_max_int_value() != std::nullopt && value > *c.get_max_int_value()) { + throw ValueTooHighException ("Value too high for " + name + " (" + std::to_string(value) + ">" + std::to_string(*c.get_max_int_value()) + ")"); + } + } + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, const std::optional & value) { + if (value) { + CheckConstraint(name, c, *value); + } + } + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, double value) { + if (c.get_min_double_value() != std::nullopt && value < *c.get_min_double_value()) { + throw ValueTooLowException ("Value too low for " + name + " (" + std::to_string(value) + "<" + std::to_string(*c.get_min_double_value()) + ")"); + } + + if (c.get_max_double_value() != std::nullopt && value > *c.get_max_double_value()) { + throw ValueTooHighException ("Value too high for " + name + " (" + std::to_string(value) + ">" + std::to_string(*c.get_max_double_value()) + ")"); + } + } + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, const std::optional & value) { + if (value) { + CheckConstraint(name, c, *value); + } + } + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, const std::string & value) { + if (c.get_min_length() != std::nullopt && value.length() < *c.get_min_length()) { + throw ValueTooShortException ("Value too short for " + name + " (" + std::to_string(value.length()) + "<" + std::to_string(*c.get_min_length()) + ")"); + } + + if (c.get_max_length() != std::nullopt && value.length() > *c.get_max_length()) { + throw ValueTooLongException ("Value too long for " + name + " (" + std::to_string(value.length()) + ">" + std::to_string(*c.get_max_length()) + ")"); + } + + if (c.get_pattern() != std::nullopt) { + std::smatch result; + std::regex_search(value, result, std::regex( *c.get_pattern() )); + if (result.empty()) { + throw InvalidPatternException ("Value doesn't match pattern for " + name + " (" + value +" != " + *c.get_pattern() + ")"); + } + } + } + + inline void CheckConstraint(const std::string & name, const ClassMemberConstraints & c, const std::optional & value) { + if (value) { + CheckConstraint(name, c, *value); + } + } + + #ifndef NLOHMANN_UNTYPED_quicktype_HELPER + #define NLOHMANN_UNTYPED_quicktype_HELPER + inline json get_untyped(const json & j, const char * property) { + if (j.find(property) != j.end()) { + return j.at(property).get(); + } + return json(); + } + + inline json get_untyped(const json & j, std::string property) { + return get_untyped(j, property.data()); + } + #endif + + class DateTime { + public: + DateTime() = default; + virtual ~DateTime() = default; + + private: + int64_t value; + + public: + const int64_t & get_value() const { return value; } + int64_t & get_mutable_value() { return value; } + void set_value(const int64_t & value) { this->value = value; } + }; + + class EnumValues { + public: + EnumValues() = default; + virtual ~EnumValues() = default; + + private: + std::string label; + + public: + const std::string & get_label() const { return label; } + std::string & get_mutable_label() { return label; } + void set_label(const std::string & value) { this->label = value; } + }; + + class FormatException { + public: + FormatException() = default; + virtual ~FormatException() = default; + + private: + int64_t count; + + public: + const int64_t & get_count() const { return count; } + int64_t & get_mutable_count() { return count; } + void set_count(const int64_t & value) { this->count = value; } + }; + + class RegExp { + public: + RegExp() = default; + virtual ~RegExp() = default; + + private: + bool active; + + public: + const bool & get_active() const { return active; } + bool & get_mutable_active() { return active; } + void set_active(const bool & value) { this->active = value; } + }; + + enum class Status : int { READY, DONE }; + + class TopLevel { + public: + TopLevel() : + code_constraint(std::nullopt, std::nullopt, std::nullopt, std::nullopt, 1, std::nullopt, std::string("^[a-z]+$")) + {} + virtual ~TopLevel() = default; + + private: + std::string code; + ClassMemberConstraints code_constraint; + DateTime date_time; + EnumValues enum_values; + FormatException format_exception; + RegExp reg_exp; + Status status; + std::string timestamp; + + public: + const std::string & get_code() const { return code; } + std::string & get_mutable_code() { return code; } + void set_code(const std::string & value) { CheckConstraint("code", code_constraint, value); this->code = value; } + + const DateTime & get_date_time() const { return date_time; } + DateTime & get_mutable_date_time() { return date_time; } + void set_date_time(const DateTime & value) { this->date_time = value; } + + const EnumValues & get_enum_values() const { return enum_values; } + EnumValues & get_mutable_enum_values() { return enum_values; } + void set_enum_values(const EnumValues & value) { this->enum_values = value; } + + const FormatException & get_format_exception() const { return format_exception; } + FormatException & get_mutable_format_exception() { return format_exception; } + void set_format_exception(const FormatException & value) { this->format_exception = value; } + + const RegExp & get_reg_exp() const { return reg_exp; } + RegExp & get_mutable_reg_exp() { return reg_exp; } + void set_reg_exp(const RegExp & value) { this->reg_exp = value; } + + const Status & get_status() const { return status; } + Status & get_mutable_status() { return status; } + void set_status(const Status & value) { this->status = value; } + + const std::string & get_timestamp() const { return timestamp; } + std::string & get_mutable_timestamp() { return timestamp; } + void set_timestamp(const std::string & value) { this->timestamp = value; } + }; +} + +namespace quicktype { + void from_json(const json & j, DateTime & x); + void to_json(json & j, const DateTime & x); + + void from_json(const json & j, EnumValues & x); + void to_json(json & j, const EnumValues & x); + + void from_json(const json & j, FormatException & x); + void to_json(json & j, const FormatException & x); + + void from_json(const json & j, RegExp & x); + void to_json(json & j, const RegExp & x); + + void from_json(const json & j, TopLevel & x); + void to_json(json & j, const TopLevel & x); + + void from_json(const json & j, Status & x); + void to_json(json & j, const Status & x); + + inline void from_json(const json & j, DateTime& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + if (j.find("value") != j.end() && !j.at("value").is_number_integer()) throw std::runtime_error("Expected integer"); + x.set_value(j.at("value").get()); + } + + inline void to_json(json & j, const DateTime & x) { + j = json::object(); + j["value"] = x.get_value(); + } + + inline void from_json(const json & j, EnumValues& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + x.set_label(j.at("label").get()); + } + + inline void to_json(json & j, const EnumValues & x) { + j = json::object(); + j["label"] = x.get_label(); + } + + inline void from_json(const json & j, FormatException& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + if (j.find("count") != j.end() && !j.at("count").is_number_integer()) throw std::runtime_error("Expected integer"); + x.set_count(j.at("count").get()); + } + + inline void to_json(json & j, const FormatException & x) { + j = json::object(); + j["count"] = x.get_count(); + } + + inline void from_json(const json & j, RegExp& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + x.set_active(j.at("active").get()); + } + + inline void to_json(json & j, const RegExp & x) { + j = json::object(); + j["active"] = x.get_active(); + } + + inline void from_json(const json & j, TopLevel& x) { + if (!j.is_object()) throw std::runtime_error("Expected object"); + x.set_code(j.at("code").get()); + x.set_date_time(j.at("dateTime").get()); + x.set_enum_values(j.at("enumValues").get()); + x.set_format_exception(j.at("formatException").get()); + x.set_reg_exp(j.at("regExp").get()); + x.set_status(j.at("status").get()); + if (j.find("timestamp") != j.end() && !std::regex_match(j.at("timestamp").get(), std::regex("^[0-9]{4}-[0-9]{2}-[0-9]{2}T.*$"))) throw std::runtime_error("Expected date-time"); + x.set_timestamp(j.at("timestamp").get()); + } + + inline void to_json(json & j, const TopLevel & x) { + j = json::object(); + j["code"] = x.get_code(); + j["dateTime"] = x.get_date_time(); + j["enumValues"] = x.get_enum_values(); + j["formatException"] = x.get_format_exception(); + j["regExp"] = x.get_reg_exp(); + j["status"] = x.get_status(); + j["timestamp"] = x.get_timestamp(); + } + + inline void from_json(const json & j, Status & x) { + if (j == "ready") x = Status::READY; + else if (j == "done") x = Status::DONE; + else { throw std::runtime_error("Cannot deserialize to enumeration \"Status\""); } + } + + inline void to_json(json & j, const Status & x) { + switch (x) { + case Status::READY: j = "ready"; break; + case Status::DONE: j = "done"; break; + default: throw std::runtime_error("Unexpected value in enumeration \"Status\": " + std::to_string(static_cast(x))); + } + } +} diff --git a/head/schema-crystal/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.cr b/head/schema-crystal/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.cr new file mode 100644 index 0000000..4836f1b --- /dev/null +++ b/head/schema-crystal/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.cr @@ -0,0 +1,47 @@ +require "json" + +class TopLevel + include JSON::Serializable + + property code : String + + @[JSON::Field(key: "dateTime")] + property date_time : DateTime + + @[JSON::Field(key: "enumValues")] + property enum_values : EnumValues + + @[JSON::Field(key: "formatException")] + property format_exception : FormatException + + @[JSON::Field(key: "regExp")] + property reg_exp : RegExp + + property status : String + + property timestamp : String +end + +class DateTime + include JSON::Serializable + + property value : Int64 +end + +class EnumValues + include JSON::Serializable + + property label : String +end + +class FormatException + include JSON::Serializable + + property count : Int64 +end + +class RegExp + include JSON::Serializable + + property active : Bool +end diff --git a/head/schema-csharp/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs b/head/schema-csharp/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs new file mode 100644 index 0000000..32f5373 --- /dev/null +++ b/head/schema-csharp/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs @@ -0,0 +1,176 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial class TopLevel + { + [JsonProperty("code", Required = Required.Always)] + [JsonConverter(typeof(MinMaxLengthCheckConverter))] + public string Code { get; set; } + + [JsonProperty("dateTime", Required = Required.Always)] + public DateTime DateTime { get; set; } + + [JsonProperty("enumValues", Required = Required.Always)] + public EnumValues EnumValues { get; set; } + + [JsonProperty("formatException", Required = Required.Always)] + public FormatException FormatException { get; set; } + + [JsonProperty("regExp", Required = Required.Always)] + public RegExp RegExp { get; set; } + + [JsonProperty("status", Required = Required.Always)] + public Status Status { get; set; } + + [JsonProperty("timestamp", Required = Required.Always)] + public DateTimeOffset Timestamp { get; set; } + } + + public partial class DateTime + { + [JsonProperty("value", Required = Required.Always)] + public long Value { get; set; } + } + + public partial class EnumValues + { + [JsonProperty("label", Required = Required.Always)] + public string Label { get; set; } + } + + public partial class FormatException + { + [JsonProperty("count", Required = Required.Always)] + public long Count { get; set; } + } + + public partial class RegExp + { + [JsonProperty("active", Required = Required.Always)] + public bool Active { get; set; } + } + + public enum Status { Ready, Done }; + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + StatusConverter.Singleton, + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } + + internal class MinMaxLengthCheckConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(string); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + var value = serializer.Deserialize(reader); + if (value.Length >= 1) + { + return value; + } + throw new Exception("Cannot unmarshal type string"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + var value = (string)untypedValue; + if (value.Length >= 1) + { + serializer.Serialize(writer, value); + return; + } + throw new Exception("Cannot marshal type string"); + } + + public static readonly MinMaxLengthCheckConverter Singleton = new MinMaxLengthCheckConverter(); + } + + internal class StatusConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(Status) || t == typeof(Status?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + if (reader.TokenType == JsonToken.Null) return null; + var value = serializer.Deserialize(reader); + switch (value) + { + case "ready": + return Status.Ready; + case "done": + return Status.Done; + } + throw new Exception("Cannot unmarshal type Status"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + if (untypedValue == null) + { + serializer.Serialize(writer, null); + return; + } + var value = (Status)untypedValue; + switch (value) + { + case Status.Ready: + serializer.Serialize(writer, "ready"); + return; + case Status.Done: + serializer.Serialize(writer, "done"); + return; + } + throw new Exception("Cannot marshal type Status"); + } + + public static readonly StatusConverter Singleton = new StatusConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-csharp-SystemTextJson/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs b/head/schema-csharp-SystemTextJson/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs new file mode 100644 index 0000000..3d17650 --- /dev/null +++ b/head/schema-csharp-SystemTextJson/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs @@ -0,0 +1,283 @@ +// +// +// To parse this JSON data, add NuGet 'System.Text.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Text.Json; + using System.Text.Json.Serialization; + using System.Globalization; + + public partial class TopLevel + { + [JsonRequired] + [JsonPropertyName("code")] + [JsonConverter(typeof(MinMaxLengthCheckConverter))] + public string Code { get; set; } + + [JsonRequired] + [JsonPropertyName("dateTime")] + public DateTime DateTime { get; set; } + + [JsonRequired] + [JsonPropertyName("enumValues")] + public EnumValues EnumValues { get; set; } + + [JsonRequired] + [JsonPropertyName("formatException")] + public FormatException FormatException { get; set; } + + [JsonRequired] + [JsonPropertyName("regExp")] + public RegExp RegExp { get; set; } + + [JsonRequired] + [JsonPropertyName("status")] + public Status Status { get; set; } + + [JsonRequired] + [JsonPropertyName("timestamp")] + public DateTimeOffset Timestamp { get; set; } + } + + public partial class DateTime + { + [JsonRequired] + [JsonPropertyName("value")] + public long Value { get; set; } + } + + public partial class EnumValues + { + [JsonRequired] + [JsonPropertyName("label")] + public string Label { get; set; } + } + + public partial class FormatException + { + [JsonRequired] + [JsonPropertyName("count")] + public long Count { get; set; } + } + + public partial class RegExp + { + [JsonRequired] + [JsonPropertyName("active")] + public bool Active { get; set; } + } + + public enum Status { Ready, Done }; + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => global::System.Text.Json.JsonSerializer.Deserialize(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonSerializer.Serialize(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General) + { + Converters = + { + StatusConverter.Singleton, + new DateOnlyConverter(), + new TimeOnlyConverter(), + IsoDateTimeOffsetConverter.Singleton + }, + }; + } + + internal class MinMaxLengthCheckConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(string); + + public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + if (value.Length >= 1) + { + return value; + } + throw new JsonException("Cannot unmarshal type string"); + } + + public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) + { + if (value.Length >= 1) + { + JsonSerializer.Serialize(writer, value, options); + return; + } + throw new NotSupportedException("Cannot marshal type string"); + } + + public static readonly MinMaxLengthCheckConverter Singleton = new MinMaxLengthCheckConverter(); + } + + internal class StatusConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(Status); + + public override Status Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + switch (value) + { + case "ready": + return Status.Ready; + case "done": + return Status.Done; + } + throw new JsonException("Cannot unmarshal type Status"); + } + + public override void Write(Utf8JsonWriter writer, Status value, JsonSerializerOptions options) + { + switch (value) + { + case Status.Ready: + JsonSerializer.Serialize(writer, "ready", options); + return; + case Status.Done: + JsonSerializer.Serialize(writer, "done", options); + return; + } + throw new NotSupportedException("Cannot marshal type Status"); + } + + public static readonly StatusConverter Singleton = new StatusConverter(); + } + + public class DateOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + public DateOnlyConverter() : this(null) { } + + public DateOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "yyyy-MM-dd"; + } + + public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return DateOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + public class TimeOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + + public TimeOnlyConverter() : this(null) { } + + public TimeOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff"; + } + + public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return TimeOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + internal class IsoDateTimeOffsetConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(DateTimeOffset); + + private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; + + private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind; + private string? _dateTimeFormat; + private CultureInfo? _culture; + + public DateTimeStyles DateTimeStyles + { + get => _dateTimeStyles; + set => _dateTimeStyles = value; + } + + public string? DateTimeFormat + { + get => _dateTimeFormat ?? string.Empty; + set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value; + } + + public CultureInfo Culture + { + get => _culture ?? CultureInfo.CurrentCulture; + set => _culture = value; + } + + public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options) + { + string text; + + + if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal + || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) + { + value = value.ToUniversalTime(); + } + + text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); + + writer.WriteStringValue(text); + } + + public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + string? dateText = reader.GetString(); + + if (string.IsNullOrEmpty(dateText) == false) + { + if (!string.IsNullOrEmpty(_dateTimeFormat)) + { + return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles); + } + else + { + return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles); + } + } + else + { + return default(DateTimeOffset); + } + } + + + public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 diff --git a/head/schema-csharp-records/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs b/head/schema-csharp-records/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs new file mode 100644 index 0000000..c282d2e --- /dev/null +++ b/head/schema-csharp-records/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.cs @@ -0,0 +1,176 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial record TopLevel + { + [JsonProperty("code", Required = Required.Always)] + [JsonConverter(typeof(MinMaxLengthCheckConverter))] + public string Code { get; set; } + + [JsonProperty("dateTime", Required = Required.Always)] + public DateTime DateTime { get; set; } + + [JsonProperty("enumValues", Required = Required.Always)] + public EnumValues EnumValues { get; set; } + + [JsonProperty("formatException", Required = Required.Always)] + public FormatException FormatException { get; set; } + + [JsonProperty("regExp", Required = Required.Always)] + public RegExp RegExp { get; set; } + + [JsonProperty("status", Required = Required.Always)] + public Status Status { get; set; } + + [JsonProperty("timestamp", Required = Required.Always)] + public DateTimeOffset Timestamp { get; set; } + } + + public partial record DateTime + { + [JsonProperty("value", Required = Required.Always)] + public long Value { get; set; } + } + + public partial record EnumValues + { + [JsonProperty("label", Required = Required.Always)] + public string Label { get; set; } + } + + public partial record FormatException + { + [JsonProperty("count", Required = Required.Always)] + public long Count { get; set; } + } + + public partial record RegExp + { + [JsonProperty("active", Required = Required.Always)] + public bool Active { get; set; } + } + + public enum Status { Ready, Done }; + + public partial record TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + StatusConverter.Singleton, + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } + + internal class MinMaxLengthCheckConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(string); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + var value = serializer.Deserialize(reader); + if (value.Length >= 1) + { + return value; + } + throw new Exception("Cannot unmarshal type string"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + var value = (string)untypedValue; + if (value.Length >= 1) + { + serializer.Serialize(writer, value); + return; + } + throw new Exception("Cannot marshal type string"); + } + + public static readonly MinMaxLengthCheckConverter Singleton = new MinMaxLengthCheckConverter(); + } + + internal class StatusConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(Status) || t == typeof(Status?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + if (reader.TokenType == JsonToken.Null) return null; + var value = serializer.Deserialize(reader); + switch (value) + { + case "ready": + return Status.Ready; + case "done": + return Status.Done; + } + throw new Exception("Cannot unmarshal type Status"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + if (untypedValue == null) + { + serializer.Serialize(writer, null); + return; + } + var value = (Status)untypedValue; + switch (value) + { + case Status.Ready: + serializer.Serialize(writer, "ready"); + return; + case Status.Done: + serializer.Serialize(writer, "done"); + return; + } + throw new Exception("Cannot marshal type Status"); + } + + public static readonly StatusConverter Singleton = new StatusConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/schema-dart/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.dart new file mode 100644 index 0000000..14fdbde --- /dev/null +++ b/head/schema-dart/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.dart @@ -0,0 +1,135 @@ +// To parse this JSON data, do +// +// final topLevel = topLevelFromJson(jsonString); + +import 'dart:convert'; + +TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str)); + +String topLevelToJson(TopLevel data) => json.encode(data.toJson()); + +class TopLevel { + final String code; + final DateTimeClass dateTime; + final EnumValuesClass enumValues; + final FormatExceptionClass formatException; + final RegExpClass regExp; + final Status status; + final DateTime timestamp; + + TopLevel({ + required this.code, + required this.dateTime, + required this.enumValues, + required this.formatException, + required this.regExp, + required this.status, + required this.timestamp, + }); + + factory TopLevel.fromJson(Map json) => TopLevel( + code: ((x) => RegExp("^[a-z]+\u0024").hasMatch(x) ? x : throw FormatException("Expected matching string"))(((x) => x.length >= 1 && true ? x : throw FormatException("Expected bounded string"))(json["code"])), + dateTime: DateTimeClass.fromJson(json["dateTime"]), + enumValues: EnumValuesClass.fromJson(json["enumValues"]), + formatException: FormatExceptionClass.fromJson(json["formatException"]), + regExp: RegExpClass.fromJson(json["regExp"]), + status: statusValues.map[json["status"]]!, + timestamp: DateTime.parse(json["timestamp"]), + ); + + Map toJson() => { + "code": code, + "dateTime": dateTime.toJson(), + "enumValues": enumValues.toJson(), + "formatException": formatException.toJson(), + "regExp": regExp.toJson(), + "status": statusValues.reverse[status], + "timestamp": timestamp.toIso8601String(), + }; +} + +class DateTimeClass { + final int value; + + DateTimeClass({ + required this.value, + }); + + factory DateTimeClass.fromJson(Map json) => DateTimeClass( + value: json["value"], + ); + + Map toJson() => { + "value": value, + }; +} + +class EnumValuesClass { + final String label; + + EnumValuesClass({ + required this.label, + }); + + factory EnumValuesClass.fromJson(Map json) => EnumValuesClass( + label: json["label"], + ); + + Map toJson() => { + "label": label, + }; +} + +class FormatExceptionClass { + final int count; + + FormatExceptionClass({ + required this.count, + }); + + factory FormatExceptionClass.fromJson(Map json) => FormatExceptionClass( + count: json["count"], + ); + + Map toJson() => { + "count": count, + }; +} + +class RegExpClass { + final bool active; + + RegExpClass({ + required this.active, + }); + + factory RegExpClass.fromJson(Map json) => RegExpClass( + active: json["active"], + ); + + Map toJson() => { + "active": active, + }; +} + +enum Status { + READY, + DONE +} + +final statusValues = EnumValues({ + "ready": Status.READY, + "done": Status.DONE +}); + +class EnumValues { + Map map; + late Map reverseMap; + + EnumValues(this.map); + + Map get reverse { + reverseMap = map.map((k, v) => MapEntry(v, k)); + return reverseMap; + } +} diff --git a/base/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart index 16b29ad..ab4f2be 100644 --- a/base/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart +++ b/head/schema-dart/test/inputs/schema/vega-lite.schema/default/TopLevel.dart @@ -4840,7 +4840,7 @@ class Predicate { ///If both month and quarter are provided, month has higher precedence. ///`day` cannot be combined with other date. ///We accept string for month and day names. -class DateTime { +class DateTimeClass { ///Integer value representing the date from 1-31. final double? date; @@ -4879,7 +4879,7 @@ class DateTime { ///Integer value representing the year. final double? year; - DateTime({ + DateTimeClass({ this.date, this.day, this.hours, @@ -4892,7 +4892,7 @@ class DateTime { this.year, }); - factory DateTime.fromJson(Map json) => DateTime( + factory DateTimeClass.fromJson(Map json) => DateTimeClass( date: json["date"]?.toDouble() == null ? null : ((x) => x >= 1 && x <= 31 ? x : throw FormatException("Expected bounded number"))(json["date"]?.toDouble()), day: json["day"], hours: json["hours"]?.toDouble() == null ? null : ((x) => x >= 0 && x <= 23 ? x : throw FormatException("Expected bounded number"))(json["hours"]?.toDouble()), diff --git a/head/schema-elixir/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.ex new file mode 100644 index 0000000..dc349c2 --- /dev/null +++ b/head/schema-elixir/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.ex @@ -0,0 +1,273 @@ +# This file was autogenerated using quicktype https://github.com/quicktype/quicktype +# +# Add Jason to your mix.exs +# +# Decode a JSON string: TopLevel.from_json(data) +# Encode into a JSON string: TopLevel.to_json(struct) + +defmodule DateTimeClass do + @enforce_keys [:value] + defstruct [:value] + + @type t :: %__MODULE__{ + value: integer() + } + + def decode_value(value) when is_integer(value), do: value + def decode_value(_), do: {:error, "Unexpected type when decoding DateTimeClass.value"} + + def encode_value(value) when is_integer(value), do: value + def encode_value(_), do: {:error, "Unexpected type when encoding DateTimeClass.value"} + + def from_map(m) do + %DateTimeClass{ + value: decode_value(m["value"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "value" => struct.value, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + +defmodule EnumValues do + @enforce_keys [:label] + defstruct [:label] + + @type t :: %__MODULE__{ + label: String.t() + } + + def decode_label(value) when is_binary(value), do: value + def decode_label(_), do: {:error, "Unexpected type when decoding EnumValues.label"} + + def encode_label(value) when is_binary(value), do: value + def encode_label(_), do: {:error, "Unexpected type when encoding EnumValues.label"} + + def from_map(m) do + %EnumValues{ + label: decode_label(m["label"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "label" => struct.label, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + +defmodule FormatException do + @enforce_keys [:count] + defstruct [:count] + + @type t :: %__MODULE__{ + count: integer() + } + + def decode_count(value) when is_integer(value), do: value + def decode_count(_), do: {:error, "Unexpected type when decoding FormatException.count"} + + def encode_count(value) when is_integer(value), do: value + def encode_count(_), do: {:error, "Unexpected type when encoding FormatException.count"} + + def from_map(m) do + %FormatException{ + count: decode_count(m["count"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "count" => struct.count, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + +defmodule RegExp do + @enforce_keys [:active] + defstruct [:active] + + @type t :: %__MODULE__{ + active: boolean() + } + + def decode_active(value) when is_boolean(value), do: value + def decode_active(_), do: {:error, "Unexpected type when decoding RegExp.active"} + + def encode_active(value) when is_boolean(value), do: value + def encode_active(_), do: {:error, "Unexpected type when encoding RegExp.active"} + + def from_map(m) do + %RegExp{ + active: decode_active(m["active"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "active" => struct.active, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end + +defmodule Status do + @valid_enum_members [ + :ready, + :done, + ] + + def valid_atom?(value), do: value in @valid_enum_members + + def valid_atom_string?(value) do + try do + atom = String.to_existing_atom(value) + atom in @valid_enum_members + rescue + ArgumentError -> false + end + end + + def encode(value) do + if valid_atom?(value) do + Atom.to_string(value) + else + {:error, "Unexpected value when encoding atom: #{inspect(value)}"} + end + end + + def decode(value) do + if valid_atom_string?(value) do + String.to_existing_atom(value) + else + {:error, "Unexpected value when decoding atom: #{inspect(value)}"} + end + end + + def from_json(json) do + json + |> Jason.decode!() + |> decode() + end + + def to_json(data) do + data + |> encode() + |> Jason.encode!() + end +end + +defmodule TopLevel do + @enforce_keys [:code, :date_time, :enum_values, :format_exception, :reg_exp, :status, :timestamp] + defstruct [:code, :date_time, :enum_values, :format_exception, :reg_exp, :status, :timestamp] + + @type t :: %__MODULE__{ + code: String.t(), + date_time: DateTimeClass.t(), + enum_values: EnumValues.t(), + format_exception: FormatException.t(), + reg_exp: RegExp.t(), + status: Status.t(), + timestamp: String.t() + } + + def decode_code(value) when is_binary(value) do + if String.length(value) >= 1 and Regex.match?(Regex.compile!("^[a-z]+$"), value), do: value, else: raise(ArgumentError) + end + def decode_code(_), do: {:error, "Unexpected type when decoding TopLevel.code"} + + def encode_code(value) when is_binary(value), do: value + def encode_code(_), do: {:error, "Unexpected type when encoding TopLevel.code"} + + def decode_timestamp(value) when is_binary(value), do: value + def decode_timestamp(_), do: {:error, "Unexpected type when decoding TopLevel.timestamp"} + + def encode_timestamp(value) when is_binary(value), do: value + def encode_timestamp(_), do: {:error, "Unexpected type when encoding TopLevel.timestamp"} + + def from_map(m) do + %TopLevel{ + code: decode_code(m["code"]), + date_time: DateTimeClass.from_map(m["dateTime"]), + enum_values: EnumValues.from_map(m["enumValues"]), + format_exception: FormatException.from_map(m["formatException"]), + reg_exp: RegExp.from_map(m["regExp"]), + status: Status.decode(m["status"]), + timestamp: decode_timestamp(m["timestamp"]), + } + end + + def from_json(json) do + json + |> Jason.decode!() + |> from_map() + end + + def to_map(struct) do + %{ + "code" => struct.code, + "dateTime" => DateTimeClass.to_map(struct.date_time), + "enumValues" => EnumValues.to_map(struct.enum_values), + "formatException" => FormatException.to_map(struct.format_exception), + "regExp" => RegExp.to_map(struct.reg_exp), + "status" => Status.encode(struct.status), + "timestamp" => struct.timestamp, + } + end + + def to_json(struct) do + struct + |> to_map() + |> Jason.encode!() + end +end diff --git a/head/schema-elm/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.elm b/head/schema-elm/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.elm new file mode 100644 index 0000000..c7d531f --- /dev/null +++ b/head/schema-elm/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.elm @@ -0,0 +1,159 @@ +-- To decode the JSON data, add this file to your project, run +-- +-- elm install NoRedInk/elm-json-decode-pipeline +-- +-- add these imports +-- +-- import Json.Decode exposing (decodeString) +-- import QuickType exposing (quickType) +-- +-- and you're off to the races with +-- +-- decodeString quickType myJsonString + +module QuickType exposing + ( QuickType + , quickTypeToString + , quickType + , DateTime + , EnumValues + , FormatException + , RegExp + , Status(..) + ) + +import Json.Decode as Jdec +import Json.Decode.Pipeline as Jpipe +import Json.Encode as Jenc +import Dict exposing (Dict) + +type alias QuickType = + { code : String + , dateTime : DateTime + , enumValues : EnumValues + , formatException : FormatException + , regExp : RegExp + , status : Status + , timestamp : String + } + +type alias DateTime = + { value : Int + } + +type alias EnumValues = + { label : String + } + +type alias FormatException = + { count : Int + } + +type alias RegExp = + { active : Bool + } + +type Status + = Ready + | Done + +-- decoders and encoders +optionalField key decoder fallback = + Jdec.dict Jdec.value + |> Jdec.andThen (\m -> + case Dict.get key m of + Nothing -> Jdec.succeed fallback + Just x -> Jdec.decodeValue decoder x |> Result.map Jdec.succeed |> Result.withDefault (Jdec.fail ("Invalid " ++ key))) + +quickTypeToString : QuickType -> String +quickTypeToString r = Jenc.encode 0 (encodeQuickType r) + +quickType : Jdec.Decoder QuickType +quickType = + Jdec.succeed QuickType + |> Jpipe.required "code" (Jdec.andThen (\x -> if String.length x >= 1 && True then Jdec.succeed x else Jdec.fail "String length out of range") Jdec.string) + |> Jpipe.required "dateTime" dateTime + |> Jpipe.required "enumValues" enumValues + |> Jpipe.required "formatException" formatException + |> Jpipe.required "regExp" regExp + |> Jpipe.required "status" status + |> Jpipe.required "timestamp" Jdec.string + +encodeQuickType : QuickType -> Jenc.Value +encodeQuickType x = + Jenc.object + [ ("code", Jenc.string x.code) + , ("dateTime", encodeDateTime x.dateTime) + , ("enumValues", encodeEnumValues x.enumValues) + , ("formatException", encodeFormatException x.formatException) + , ("regExp", encodeRegExp x.regExp) + , ("status", encodeStatus x.status) + , ("timestamp", Jenc.string x.timestamp) + ] + +dateTime : Jdec.Decoder DateTime +dateTime = + Jdec.succeed DateTime + |> Jpipe.required "value" Jdec.int + +encodeDateTime : DateTime -> Jenc.Value +encodeDateTime x = + Jenc.object + [ ("value", Jenc.int x.value) + ] + +enumValues : Jdec.Decoder EnumValues +enumValues = + Jdec.succeed EnumValues + |> Jpipe.required "label" Jdec.string + +encodeEnumValues : EnumValues -> Jenc.Value +encodeEnumValues x = + Jenc.object + [ ("label", Jenc.string x.label) + ] + +formatException : Jdec.Decoder FormatException +formatException = + Jdec.succeed FormatException + |> Jpipe.required "count" Jdec.int + +encodeFormatException : FormatException -> Jenc.Value +encodeFormatException x = + Jenc.object + [ ("count", Jenc.int x.count) + ] + +regExp : Jdec.Decoder RegExp +regExp = + Jdec.succeed RegExp + |> Jpipe.required "active" Jdec.bool + +encodeRegExp : RegExp -> Jenc.Value +encodeRegExp x = + Jenc.object + [ ("active", Jenc.bool x.active) + ] + +status : Jdec.Decoder Status +status = + Jdec.string + |> Jdec.andThen (\str -> + case str of + "ready" -> Jdec.succeed Ready + "done" -> Jdec.succeed Done + somethingElse -> Jdec.fail <| "Invalid Status: " ++ somethingElse + ) + +encodeStatus : Status -> Jenc.Value +encodeStatus x = case x of + Ready -> Jenc.string "ready" + Done -> Jenc.string "done" + +--- encoder helpers + +makeNullableEncoder : (a -> Jenc.Value) -> Maybe a -> Jenc.Value +makeNullableEncoder f m = + case m of + Just x -> f x + Nothing -> Jenc.null diff --git a/head/schema-flow/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js b/head/schema-flow/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js new file mode 100644 index 0000000..635caac --- /dev/null +++ b/head/schema-flow/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js @@ -0,0 +1,261 @@ +// @flow + +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export type TopLevel = { + code: string; + dateTime: DateTime; + enumValues: EnumValues; + formatException: FormatException; + regExp: RegExp; + status: Status; + timestamp: Date; +}; + +export type DateTime = { + value: number; + [property: string]: mixed | number; +}; + +export type EnumValues = { + label: string; + [property: string]: mixed | string; +}; + +export type FormatException = { + count: number; + [property: string]: mixed | number; +}; + +export type RegExp = { + active: boolean; + [property: string]: mixed | boolean; +}; + +export type Status = + "ready" + | "done"; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ: any, val: any, key: any, parent: any = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "code", js: "code", typ: s(p("^[a-z]+$"), 1, undefined) }, + { json: "dateTime", js: "dateTime", typ: r("DateTime") }, + { json: "enumValues", js: "enumValues", typ: r("EnumValues") }, + { json: "formatException", js: "formatException", typ: r("FormatException") }, + { json: "regExp", js: "regExp", typ: r("RegExp") }, + { json: "status", js: "status", typ: r("Status") }, + { json: "timestamp", js: "timestamp", typ: Date }, + ], false), + "DateTime": o([ + { json: "value", js: "value", typ: i(0) }, + ], "any"), + "EnumValues": o([ + { json: "label", js: "label", typ: "" }, + ], "any"), + "FormatException": o([ + { json: "count", js: "count", typ: i(0) }, + ], "any"), + "RegExp": o([ + { json: "active", js: "active", typ: true }, + ], "any"), + "Status": [ + "ready", + "done", + ], +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-golang/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.go b/head/schema-golang/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.go new file mode 100644 index 0000000..4442a82 --- /dev/null +++ b/head/schema-golang/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.go @@ -0,0 +1,66 @@ +// Code generated from JSON Schema using quicktype. DO NOT EDIT. +// To parse and unparse this JSON data, add this code to your project and do: +// +// topLevel, err := UnmarshalTopLevel(bytes) +// bytes, err = topLevel.Marshal() + +package main + +import "time" + +import "encoding/json" + +func UnmarshalTopLevel(data []byte) (TopLevel, error) { + var r TopLevel + err := json.Unmarshal(data, &r) + return r, err +} + +func (r *TopLevel) Marshal() ([]byte, error) { + return json.Marshal(r) +} + +type TopLevel struct { + Code string `json:"code"` + DateTime DateTime `json:"dateTime"` + EnumValues EnumValues `json:"enumValues"` + FormatException FormatException `json:"formatException"` + RegExp RegExp `json:"regExp"` + Status Status `json:"status"` + Timestamp time.Time `json:"timestamp"` +} + +type DateTime struct { + Value int64 `json:"value"` +} + +type EnumValues struct { + Label string `json:"label"` +} + +type FormatException struct { + Count int64 `json:"count"` +} + +type RegExp struct { + Active bool `json:"active"` +} + +type Status string + +const ( + Ready Status = "ready" + Done Status = "done" +) + +type invalidStatus string +func (x invalidStatus) Error() string { return "invalid Status: " + string(x) } + +func (x *Status) UnmarshalJSON(data []byte) error { + var value string + if err := json.Unmarshal(data, &value); err != nil { return err } + switch Status(value) { + case Ready, Done: *x = Status(value); return nil + } + return invalidStatus(value) +} diff --git a/head/schema-haskell/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.hs b/head/schema-haskell/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.hs new file mode 100644 index 0000000..5d02612 --- /dev/null +++ b/head/schema-haskell/test/inputs/schema/dart-runtime-type-names.schema/default/QuickType.hs @@ -0,0 +1,124 @@ +{-# LANGUAGE StrictData #-} +{-# LANGUAGE OverloadedStrings #-} + +module QuickType + ( QuickType (..) + , DateTime (..) + , EnumValues (..) + , FormatException (..) + , RegExp (..) + , Status (..) + , decodeTopLevel + ) where + +import Data.Aeson +import Data.Aeson.Types (emptyObject) +import Data.ByteString.Lazy (ByteString) +import Data.HashMap.Strict (HashMap) +import Data.Text (Text) + +data QuickType = QuickType + { codeQuickType :: Text + , dateTimeQuickType :: DateTime + , enumValuesQuickType :: EnumValues + , formatExceptionQuickType :: FormatException + , regExpQuickType :: RegExp + , statusQuickType :: Status + , timestampQuickType :: Text + } deriving (Show) + +data DateTime = DateTime + { valueDateTime :: Int + } deriving (Show) + +data EnumValues = EnumValues + { labelEnumValues :: Text + } deriving (Show) + +data FormatException = FormatException + { countFormatException :: Int + } deriving (Show) + +data RegExp = RegExp + { activeRegExp :: Bool + } deriving (Show) + +data Status + = ReadyStatus + | DoneStatus + deriving (Show) + +decodeTopLevel :: ByteString -> Maybe QuickType +decodeTopLevel = decode + +instance ToJSON QuickType where + toJSON (QuickType codeQuickType dateTimeQuickType enumValuesQuickType formatExceptionQuickType regExpQuickType statusQuickType timestampQuickType) = + object + [ "code" .= codeQuickType + , "dateTime" .= dateTimeQuickType + , "enumValues" .= enumValuesQuickType + , "formatException" .= formatExceptionQuickType + , "regExp" .= regExpQuickType + , "status" .= statusQuickType + , "timestamp" .= timestampQuickType + ] + +instance FromJSON QuickType where + parseJSON (Object v) = QuickType + <$> v .: "code" + <*> v .: "dateTime" + <*> v .: "enumValues" + <*> v .: "formatException" + <*> v .: "regExp" + <*> v .: "status" + <*> v .: "timestamp" + +instance ToJSON DateTime where + toJSON (DateTime valueDateTime) = + object + [ "value" .= valueDateTime + ] + +instance FromJSON DateTime where + parseJSON (Object v) = DateTime + <$> v .: "value" + +instance ToJSON EnumValues where + toJSON (EnumValues labelEnumValues) = + object + [ "label" .= labelEnumValues + ] + +instance FromJSON EnumValues where + parseJSON (Object v) = EnumValues + <$> v .: "label" + +instance ToJSON FormatException where + toJSON (FormatException countFormatException) = + object + [ "count" .= countFormatException + ] + +instance FromJSON FormatException where + parseJSON (Object v) = FormatException + <$> v .: "count" + +instance ToJSON RegExp where + toJSON (RegExp activeRegExp) = + object + [ "active" .= activeRegExp + ] + +instance FromJSON RegExp where + parseJSON (Object v) = RegExp + <$> v .: "active" + +instance ToJSON Status where + toJSON ReadyStatus = "ready" + toJSON DoneStatus = "done" + +instance FromJSON Status where + parseJSON = withText "Status" parseText + where + parseText "ready" = return ReadyStatus + parseText "done" = return DoneStatus diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..d243dc1 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,103 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(DeserializationFeature.ACCEPT_FLOAT_AS_INT, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java new file mode 100644 index 0000000..9d358b7 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class DateTime { + private long value; + + @JsonProperty("value") + public long getValue() { return value; } + @JsonProperty("value") + public void setValue(long value) { this.value = value; } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java new file mode 100644 index 0000000..393b64d --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class EnumValues { + private String label; + + @JsonProperty("label") + public String getLabel() { return label; } + @JsonProperty("label") + public void setLabel(String value) { this.label = value; } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java new file mode 100644 index 0000000..35cb026 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class FormatException { + private long count; + + @JsonProperty("count") + public long getCount() { return count; } + @JsonProperty("count") + public void setCount(long value) { this.count = value; } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java new file mode 100644 index 0000000..254c5e1 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class RegExp { + private boolean active; + + @JsonProperty("active") + public boolean getActive() { return active; } + @JsonProperty("active") + public void setActive(boolean value) { this.active = value; } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java new file mode 100644 index 0000000..5932577 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java @@ -0,0 +1,24 @@ +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.annotation.*; + +public enum Status { + READY, DONE; + + @JsonValue + public String toValue() { + switch (this) { + case READY: return "ready"; + case DONE: return "done"; + } + return null; + } + + @JsonCreator + public static Status forValue(String value) throws IOException { + if (value.equals("ready")) return READY; + if (value.equals("done")) return DONE; + throw new IOException("Cannot deserialize Status"); + } +} diff --git a/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..6bd5ef6 --- /dev/null +++ b/head/schema-java/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,49 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.time.OffsetDateTime; + +public class TopLevel { + private String code; + private DateTime dateTime; + private EnumValues enumValues; + private FormatException formatException; + private RegExp regExp; + private Status status; + private OffsetDateTime timestamp; + + @JsonProperty("code") + public String getCode() { return code; } + @JsonProperty("code") + public void setCode(String value) { this.code = value; } + + @JsonProperty("dateTime") + public DateTime getDateTime() { return dateTime; } + @JsonProperty("dateTime") + public void setDateTime(DateTime value) { this.dateTime = value; } + + @JsonProperty("enumValues") + public EnumValues getEnumValues() { return enumValues; } + @JsonProperty("enumValues") + public void setEnumValues(EnumValues value) { this.enumValues = value; } + + @JsonProperty("formatException") + public FormatException getFormatException() { return formatException; } + @JsonProperty("formatException") + public void setFormatException(FormatException value) { this.formatException = value; } + + @JsonProperty("regExp") + public RegExp getRegExp() { return regExp; } + @JsonProperty("regExp") + public void setRegExp(RegExp value) { this.regExp = value; } + + @JsonProperty("status") + public Status getStatus() { return status; } + @JsonProperty("status") + public void setStatus(Status value) { this.status = value; } + + @JsonProperty("timestamp") + public OffsetDateTime getTimestamp() { return timestamp; } + @JsonProperty("timestamp") + public void setTimestamp(OffsetDateTime value) { this.timestamp = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..aeaa704 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,124 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import java.util.*; +import java.util.Date; +import java.text.SimpleDateFormat; + +public class Converter { + // Date-time helpers + + private static final String[] DATE_TIME_FORMATS = { + "yyyy-MM-dd'T'HH:mm:ss.SX", + "yyyy-MM-dd'T'HH:mm:ss.S", + "yyyy-MM-dd'T'HH:mm:ssX", + "yyyy-MM-dd'T'HH:mm:ss", + "yyyy-MM-dd HH:mm:ss.SX", + "yyyy-MM-dd HH:mm:ss.S", + "yyyy-MM-dd HH:mm:ssX", + "yyyy-MM-dd HH:mm:ss", + "HH:mm:ss.SZ", + "HH:mm:ss.S", + "HH:mm:ssZ", + "HH:mm:ss", + "yyyy-MM-dd", + }; + + public static Date parseAllDateTimeString(String str) { + str = str.replaceFirst("(\\.\\d{3})\\d+", "$1"); + for (String format : DATE_TIME_FORMATS) { + try { + return new SimpleDateFormat(format).parse(str); + } catch (Exception ex) { + // Ignored + } + } + return null; + } + + public static String serializeDateTime(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ").format(datetime); + } + + public static String serializeDate(Date datetime) { + return new SimpleDateFormat("yyyy-MM-dd").format(datetime); + } + + public static String serializeTime(Date datetime) { + return new SimpleDateFormat("hh:mm:ssZ").format(datetime); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(DeserializationFeature.ACCEPT_FLOAT_AS_INT, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + module.addDeserializer(Date.class, new JsonDeserializer() { + @Override + public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseAllDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java new file mode 100644 index 0000000..9d358b7 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class DateTime { + private long value; + + @JsonProperty("value") + public long getValue() { return value; } + @JsonProperty("value") + public void setValue(long value) { this.value = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java new file mode 100644 index 0000000..393b64d --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class EnumValues { + private String label; + + @JsonProperty("label") + public String getLabel() { return label; } + @JsonProperty("label") + public void setLabel(String value) { this.label = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java new file mode 100644 index 0000000..35cb026 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class FormatException { + private long count; + + @JsonProperty("count") + public long getCount() { return count; } + @JsonProperty("count") + public void setCount(long value) { this.count = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java new file mode 100644 index 0000000..254c5e1 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class RegExp { + private boolean active; + + @JsonProperty("active") + public boolean getActive() { return active; } + @JsonProperty("active") + public void setActive(boolean value) { this.active = value; } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java new file mode 100644 index 0000000..5932577 --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java @@ -0,0 +1,24 @@ +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.annotation.*; + +public enum Status { + READY, DONE; + + @JsonValue + public String toValue() { + switch (this) { + case READY: return "ready"; + case DONE: return "done"; + } + return null; + } + + @JsonCreator + public static Status forValue(String value) throws IOException { + if (value.equals("ready")) return READY; + if (value.equals("done")) return DONE; + throw new IOException("Cannot deserialize Status"); + } +} diff --git a/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..f6ddead --- /dev/null +++ b/head/schema-java-datetime-legacy/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,51 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.util.Date; + +public class TopLevel { + private String code; + private DateTime dateTime; + private EnumValues enumValues; + private FormatException formatException; + private RegExp regExp; + private Status status; + private Date timestamp; + + @JsonProperty("code") + public String getCode() { return code; } + @JsonProperty("code") + public void setCode(String value) { this.code = value; } + + @JsonProperty("dateTime") + public DateTime getDateTime() { return dateTime; } + @JsonProperty("dateTime") + public void setDateTime(DateTime value) { this.dateTime = value; } + + @JsonProperty("enumValues") + public EnumValues getEnumValues() { return enumValues; } + @JsonProperty("enumValues") + public void setEnumValues(EnumValues value) { this.enumValues = value; } + + @JsonProperty("formatException") + public FormatException getFormatException() { return formatException; } + @JsonProperty("formatException") + public void setFormatException(FormatException value) { this.formatException = value; } + + @JsonProperty("regExp") + public RegExp getRegExp() { return regExp; } + @JsonProperty("regExp") + public void setRegExp(RegExp value) { this.regExp = value; } + + @JsonProperty("status") + public Status getStatus() { return status; } + @JsonProperty("status") + public void setStatus(Status value) { this.status = value; } + + @JsonProperty("timestamp") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSX", timezone = "UTC") + public Date getTimestamp() { return timestamp; } + @JsonProperty("timestamp") + @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSX", timezone = "UTC") + public void setTimestamp(Date value) { this.timestamp = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java new file mode 100644 index 0000000..d243dc1 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Converter.java @@ -0,0 +1,103 @@ +// To use this code, add the following Maven dependency to your project: +// +// +// com.fasterxml.jackson.core : jackson-databind : 2.9.0 +// com.fasterxml.jackson.datatype : jackson-datatype-jsr310 : 2.9.0 +// +// Import this package: +// +// import io.quicktype.Converter; +// +// Then you can deserialize a JSON string with +// +// TopLevel data = Converter.fromJsonString(jsonString); + +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.module.SimpleModule; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import java.util.*; +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; + +public class Converter { + // Date-time helpers + + private static final DateTimeFormatter DATE_TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_DATE_TIME) + .appendOptional(DateTimeFormatter.ISO_INSTANT) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssX")) + .appendOptional(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetDateTime parseDateTimeString(String str) { + return ZonedDateTime.from(Converter.DATE_TIME_FORMATTER.parse(str)).toOffsetDateTime(); + } + + private static final DateTimeFormatter TIME_FORMATTER = new DateTimeFormatterBuilder() + .appendOptional(DateTimeFormatter.ISO_TIME) + .appendOptional(DateTimeFormatter.ISO_OFFSET_TIME) + .parseDefaulting(ChronoField.YEAR, 2020) + .parseDefaulting(ChronoField.MONTH_OF_YEAR, 1) + .parseDefaulting(ChronoField.DAY_OF_MONTH, 1) + .toFormatter() + .withZone(ZoneOffset.UTC); + + public static OffsetTime parseTimeString(String str) { + return ZonedDateTime.from(Converter.TIME_FORMATTER.parse(str)).toOffsetDateTime().toOffsetTime(); + } + // Serialize/deserialize helpers + + public static TopLevel fromJsonString(String json) throws IOException { + return getObjectReader().readValue(json); + } + + public static String toJsonString(TopLevel obj) throws JsonProcessingException { + return getObjectWriter().writeValueAsString(obj); + } + + private static ObjectReader reader; + private static ObjectWriter writer; + + private static void instantiateMapper() { + ObjectMapper mapper = new ObjectMapper(); + mapper.findAndRegisterModules(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + mapper.configure(DeserializationFeature.ACCEPT_FLOAT_AS_INT, false); + mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); + SimpleModule module = new SimpleModule(); + module.addDeserializer(OffsetDateTime.class, new JsonDeserializer() { + @Override + public OffsetDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + String value = jsonParser.getText(); + return Converter.parseDateTimeString(value); + } + }); + mapper.registerModule(module); + reader = mapper.readerFor(TopLevel.class); + writer = mapper.writerFor(TopLevel.class); + } + + private static ObjectReader getObjectReader() { + if (reader == null) instantiateMapper(); + return reader; + } + + private static ObjectWriter getObjectWriter() { + if (writer == null) instantiateMapper(); + return writer; + } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java new file mode 100644 index 0000000..9d358b7 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/DateTime.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class DateTime { + private long value; + + @JsonProperty("value") + public long getValue() { return value; } + @JsonProperty("value") + public void setValue(long value) { this.value = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java new file mode 100644 index 0000000..393b64d --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/EnumValues.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class EnumValues { + private String label; + + @JsonProperty("label") + public String getLabel() { return label; } + @JsonProperty("label") + public void setLabel(String value) { this.label = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java new file mode 100644 index 0000000..35cb026 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/FormatException.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class FormatException { + private long count; + + @JsonProperty("count") + public long getCount() { return count; } + @JsonProperty("count") + public void setCount(long value) { this.count = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java new file mode 100644 index 0000000..254c5e1 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/RegExp.java @@ -0,0 +1,12 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; + +public class RegExp { + private boolean active; + + @JsonProperty("active") + public boolean getActive() { return active; } + @JsonProperty("active") + public void setActive(boolean value) { this.active = value; } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java new file mode 100644 index 0000000..5932577 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/Status.java @@ -0,0 +1,24 @@ +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.annotation.*; + +public enum Status { + READY, DONE; + + @JsonValue + public String toValue() { + switch (this) { + case READY: return "ready"; + case DONE: return "done"; + } + return null; + } + + @JsonCreator + public static Status forValue(String value) throws IOException { + if (value.equals("ready")) return READY; + if (value.equals("done")) return DONE; + throw new IOException("Cannot deserialize Status"); + } +} diff --git a/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java new file mode 100644 index 0000000..6bd5ef6 --- /dev/null +++ b/head/schema-java-lombok/test/inputs/schema/dart-runtime-type-names.schema/default/src/main/java/io/quicktype/TopLevel.java @@ -0,0 +1,49 @@ +package io.quicktype; + +import com.fasterxml.jackson.annotation.*; +import java.time.OffsetDateTime; + +public class TopLevel { + private String code; + private DateTime dateTime; + private EnumValues enumValues; + private FormatException formatException; + private RegExp regExp; + private Status status; + private OffsetDateTime timestamp; + + @JsonProperty("code") + public String getCode() { return code; } + @JsonProperty("code") + public void setCode(String value) { this.code = value; } + + @JsonProperty("dateTime") + public DateTime getDateTime() { return dateTime; } + @JsonProperty("dateTime") + public void setDateTime(DateTime value) { this.dateTime = value; } + + @JsonProperty("enumValues") + public EnumValues getEnumValues() { return enumValues; } + @JsonProperty("enumValues") + public void setEnumValues(EnumValues value) { this.enumValues = value; } + + @JsonProperty("formatException") + public FormatException getFormatException() { return formatException; } + @JsonProperty("formatException") + public void setFormatException(FormatException value) { this.formatException = value; } + + @JsonProperty("regExp") + public RegExp getRegExp() { return regExp; } + @JsonProperty("regExp") + public void setRegExp(RegExp value) { this.regExp = value; } + + @JsonProperty("status") + public Status getStatus() { return status; } + @JsonProperty("status") + public void setStatus(Status value) { this.status = value; } + + @JsonProperty("timestamp") + public OffsetDateTime getTimestamp() { return timestamp; } + @JsonProperty("timestamp") + public void setTimestamp(OffsetDateTime value) { this.timestamp = value; } +} diff --git a/head/schema-javascript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js b/head/schema-javascript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js new file mode 100644 index 0000000..c7bcd27 --- /dev/null +++ b/head/schema-javascript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.js @@ -0,0 +1,225 @@ +// To parse this data: +// +// const Convert = require("./TopLevel"); +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +function toTopLevel(json) { + return cast(JSON.parse(json), r("TopLevel")); +} + +function topLevelToJson(value) { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); +} + +function invalidValue(typ, val, key, parent = '') { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ) { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ) { + if (typ.jsonToJS === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ) { + if (typ.jsToJSON === undefined) { + const map = {}; + typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val, typ, getProps, key = '', parent = '') { + function transformPrimitive(typ, val) { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs, val) { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases, val) { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ, val) { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val) { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props, additional, val) { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val, typ) { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val, typ) { + return transform(val, typ, jsToJSONProps); +} + +function l(typ) { + return { literal: typ }; +} + +function a(typ) { + return { arrayItems: typ }; +} + +function i(typ) { + return { integer: typ }; +} + +function p(pattern) { + return { pattern }; +} + +function s(typ, min, max) { + return { string: typ, min, max }; +} + +function n(typ, min, max) { + return { number: typ, min, max }; +} + +function u(...typs) { + return { unionMembers: typs }; +} + +function o(props, additional) { + return { props, additional }; +} + +function m(additional) { + const props = []; + return { props, additional }; +} + +function r(name) { + return { ref: name }; +} + +const typeMap = { + "TopLevel": o([ + { json: "code", js: "code", typ: s(p("^[a-z]+$"), 1, undefined) }, + { json: "dateTime", js: "dateTime", typ: r("DateTime") }, + { json: "enumValues", js: "enumValues", typ: r("EnumValues") }, + { json: "formatException", js: "formatException", typ: r("FormatException") }, + { json: "regExp", js: "regExp", typ: r("RegExp") }, + { json: "status", js: "status", typ: r("Status") }, + { json: "timestamp", js: "timestamp", typ: Date }, + ], false), + "DateTime": o([ + { json: "value", js: "value", typ: i(0) }, + ], "any"), + "EnumValues": o([ + { json: "label", js: "label", typ: "" }, + ], "any"), + "FormatException": o([ + { json: "count", js: "count", typ: i(0) }, + ], "any"), + "RegExp": o([ + { json: "active", js: "active", typ: true }, + ], "any"), + "Status": [ + "ready", + "done", + ], +}; + +module.exports = { + "topLevelToJson": topLevelToJson, + "toTopLevel": toTopLevel, +}; diff --git a/head/schema-javascript-prop-types/test/inputs/schema/dart-runtime-type-names.schema/default/toplevel.js b/head/schema-javascript-prop-types/test/inputs/schema/dart-runtime-type-names.schema/default/toplevel.js new file mode 100644 index 0000000..23751d4 --- /dev/null +++ b/head/schema-javascript-prop-types/test/inputs/schema/dart-runtime-type-names.schema/default/toplevel.js @@ -0,0 +1,44 @@ +// Example usage: +// +// import { MyShape } from ./myShape.js; +// +// class MyComponent extends React.Component { +// // +// } +// +// MyComponent.propTypes = { +// input: MyShape +// }; + +import PropTypes from "prop-types"; +const Integer = (props, name) => props[name] == null || Number.isInteger(props[name]) ? null : new Error("Expected integer"); + +let _TopLevel; +let _DateTime; +let _EnumValues; +let _FormatException; +let _RegExp; +const _Status = PropTypes.oneOf(['ready', 'done']); +_DateTime = PropTypes.shape({ + "value": PropTypes.oneOfType([Integer]).isRequired, +}); +_EnumValues = PropTypes.shape({ + "label": PropTypes.oneOfType([PropTypes.string]).isRequired, +}); +_FormatException = PropTypes.shape({ + "count": PropTypes.oneOfType([Integer]).isRequired, +}); +_RegExp = PropTypes.shape({ + "active": PropTypes.oneOfType([PropTypes.bool]).isRequired, +}); +_TopLevel = PropTypes.shape({ + "code": PropTypes.oneOfType([(props, name) => { const value = props[name]; return value == null || (typeof value === 'string' && value.length >= 1 && new RegExp("^[a-z]+$").test(value)) ? null : new Error("Expected bounded string"); }]).isRequired, + "dateTime": _DateTime, + "enumValues": _EnumValues, + "formatException": _FormatException, + "regExp": _RegExp, + "status": _Status, + "timestamp": PropTypes.oneOfType([(props, name) => props[name] == null || !Number.isNaN(Date.parse(props[name])) ? null : new Error("Expected date-time")]).isRequired, +}); + +export const TopLevel = _TopLevel; diff --git a/head/schema-kotlin/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt b/head/schema-kotlin/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt new file mode 100644 index 0000000..658cc3d --- /dev/null +++ b/head/schema-kotlin/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt @@ -0,0 +1,72 @@ +// To parse the JSON, install Klaxon and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import java.time.OffsetDateTime + +import com.beust.klaxon.* + +private fun Klaxon.convert(k: kotlin.reflect.KClass<*>, fromJson: (JsonValue) -> T, toJson: (T) -> String, isUnion: Boolean = false) = + this.converter(object: Converter { + @Suppress("UNCHECKED_CAST") + override fun toJson(value: Any) = toJson(value as T) + override fun fromJson(jv: JsonValue) = fromJson(jv) as Any + override fun canConvert(cls: Class<*>) = cls == k.java || (isUnion && cls.superclass == k.java) + }) + +private val klaxon = Klaxon() + .convert(OffsetDateTime::class, { OffsetDateTime.parse(it.string!!) }, { "\"${java.time.format.DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it)}\"" }) + .convert(Status::class, { Status.fromValue(it.string!!) }, { "\"${it.value}\"" }) + +data class TopLevel ( + val code: String, + val dateTime: DateTime, + val enumValues: EnumValues, + val formatException: FormatException, + val regExp: RegExp, + val status: Status, + val timestamp: OffsetDateTime +) { + init { + require(code.length >= 1) + } + init { + require(Regex("^[a-z]+\$").containsMatchIn(code)) + } + public fun toJson() = klaxon.toJsonString(this) + + companion object { + public fun fromJson(json: String) = klaxon.parse(json) + } +} + +data class DateTime ( + val value: Long +) + +data class EnumValues ( + val label: String +) + +data class FormatException ( + val count: Long +) + +data class RegExp ( + val active: Boolean +) + +enum class Status(val value: String) { + Ready("ready"), + Done("done"); + + companion object { + public fun fromValue(value: String): Status = when (value) { + "ready" -> Ready + "done" -> Done + else -> throw IllegalArgumentException() + } + } +} diff --git a/head/schema-kotlin-jackson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt b/head/schema-kotlin-jackson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt new file mode 100644 index 0000000..6c9cb40 --- /dev/null +++ b/head/schema-kotlin-jackson/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt @@ -0,0 +1,101 @@ +// To parse the JSON, install jackson-module-kotlin and do: +// +// val topLevel = TopLevel.fromJson(jsonString) + +package quicktype + +import java.time.OffsetDateTime + +import com.fasterxml.jackson.annotation.* +import com.fasterxml.jackson.core.* +import com.fasterxml.jackson.databind.* +import com.fasterxml.jackson.databind.deser.std.StdDeserializer +import com.fasterxml.jackson.databind.module.SimpleModule +import com.fasterxml.jackson.databind.node.* +import com.fasterxml.jackson.databind.ser.std.StdSerializer +import com.fasterxml.jackson.module.kotlin.* + + +@Suppress("UNCHECKED_CAST") +private fun ObjectMapper.convert(k: kotlin.reflect.KClass<*>, fromJson: (JsonNode) -> T, toJson: (T) -> String, isUnion: Boolean = false) = registerModule(SimpleModule().apply { + addSerializer(k.java as Class, object : StdSerializer(k.java as Class) { + override fun serialize(value: T, gen: JsonGenerator, provider: SerializerProvider) = gen.writeRawValue(toJson(value)) + }) + addDeserializer(k.java as Class, object : StdDeserializer(k.java as Class) { + override fun deserialize(p: JsonParser, ctxt: DeserializationContext) = fromJson(p.readValueAsTree()) + }) +}) + +val mapper = jacksonObjectMapper().apply { + propertyNamingStrategy = object : PropertyNamingStrategy.PropertyNamingStrategyBase() { override fun translate(name: String) = if (name == "empty") "" else name } + setSerializationInclusion(JsonInclude.Include.NON_NULL) + disable(DeserializationFeature.ACCEPT_FLOAT_AS_INT) + convert(OffsetDateTime::class, { OffsetDateTime.parse(it.asText()) }, { "\"${java.time.format.DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(it)}\"" }) + convert(Status::class, { Status.fromValue(it.asText()) }, { "\"${it.value}\"" }) +} + +data class TopLevel ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val code: String, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val dateTime: DateTime, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val enumValues: EnumValues, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val formatException: FormatException, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val regExp: RegExp, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val status: Status, + + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val timestamp: OffsetDateTime +) { + init { + require(code.length >= 1) + require(Regex("^[a-z]+\$").containsMatchIn(code)) + } + fun toJson() = mapper.writeValueAsString(this) + + companion object { + fun fromJson(json: String) = mapper.readValue(json) + } +} + +data class DateTime ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val value: Long +) + +data class EnumValues ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val label: String +) + +data class FormatException ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val count: Long +) + +data class RegExp ( + @get:JsonProperty(required=true)@field:JsonProperty(required=true) + val active: Boolean +) + +enum class Status(val value: String) { + Ready("ready"), + Done("done"); + + companion object { + fun fromValue(value: String): Status = when (value) { + "ready" -> Ready + "done" -> Done + else -> throw IllegalArgumentException() + } + } +} diff --git a/head/schema-kotlinx/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt b/head/schema-kotlinx/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt new file mode 100644 index 0000000..35517d1 --- /dev/null +++ b/head/schema-kotlinx/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.kt @@ -0,0 +1,60 @@ +// To parse the JSON, install kotlin's serialization plugin and do: +// +// val json = Json { allowStructuredMapKeys = true } +// val topLevel = json.parse(TopLevel.serializer(), jsonString) + +@file:UseSerializers(OffsetDateTimeSerializer::class) + +package quicktype + +import java.time.OffsetDateTime + +import kotlinx.serialization.* +import kotlinx.serialization.json.* +import kotlinx.serialization.descriptors.* +import kotlinx.serialization.encoding.* + +@Serializable +data class TopLevel ( + val code: String, + val dateTime: DateTime, + val enumValues: EnumValues, + val formatException: FormatException, + val regExp: RegExp, + val status: Status, + val timestamp: OffsetDateTime +) + +@Serializable +data class DateTime ( + val value: Long +) + +@Serializable +data class EnumValues ( + val label: String +) + +@Serializable +data class FormatException ( + val count: Long +) + +@Serializable +data class RegExp ( + val active: Boolean +) + +@Serializable +enum class Status(val value: String) { + @SerialName("ready") Ready("ready"), + @SerialName("done") Done("done"); +} + +object OffsetDateTimeSerializer : KSerializer { + override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("OffsetDateTime", PrimitiveKind.STRING) + override fun deserialize(decoder: Decoder): OffsetDateTime = OffsetDateTime.parse(decoder.decodeString()) + override fun serialize(encoder: Encoder, value: OffsetDateTime) { + encoder.encodeString(java.time.format.DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(value)) + } +} diff --git a/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.h b/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.h new file mode 100644 index 0000000..33fa558 --- /dev/null +++ b/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.h @@ -0,0 +1,66 @@ +// To parse this JSON: +// +// NSError *error; +// QTTopLevel *topLevel = [QTTopLevel fromJSON:json encoding:NSUTF8Encoding error:&error]; + +#import + +@class QTTopLevel; +@class QTDateTime; +@class QTEnumValues; +@class QTFormatException; +@class QTRegExp; +@class QTStatus; + +NS_ASSUME_NONNULL_BEGIN + +#pragma mark - Boxed enums + +@interface QTStatus : NSObject +@property (nonatomic, readonly, copy) NSString *value; ++ (instancetype _Nullable)withValue:(NSString *)value; ++ (QTStatus *)ready; ++ (QTStatus *)done; +@end + +#pragma mark - Top-level marshaling functions + +QTTopLevel *_Nullable QTTopLevelFromData(NSData *data, NSError **error); +QTTopLevel *_Nullable QTTopLevelFromJSON(NSString *json, NSStringEncoding encoding, NSError **error); +NSData *_Nullable QTTopLevelToData(QTTopLevel *topLevel, NSError **error); +NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding encoding, NSError **error); + +#pragma mark - Object interfaces + +@interface QTTopLevel : NSObject +@property (nonatomic, copy) NSString *code; +@property (nonatomic, strong) QTDateTime *dateTime; +@property (nonatomic, strong) QTEnumValues *enumValues; +@property (nonatomic, strong) QTFormatException *formatException; +@property (nonatomic, strong) QTRegExp *regExp; +@property (nonatomic, assign) QTStatus *status; +@property (nonatomic, copy) NSString *timestamp; + ++ (_Nullable instancetype)fromJSON:(NSString *)json encoding:(NSStringEncoding)encoding error:(NSError *_Nullable *)error; ++ (_Nullable instancetype)fromData:(NSData *)data error:(NSError *_Nullable *)error; +- (NSString *_Nullable)toJSON:(NSStringEncoding)encoding error:(NSError *_Nullable *)error; +- (NSData *_Nullable)toData:(NSError *_Nullable *)error; +@end + +@interface QTDateTime : NSObject +@property (nonatomic, assign) NSInteger value; +@end + +@interface QTEnumValues : NSObject +@property (nonatomic, copy) NSString *label; +@end + +@interface QTFormatException : NSObject +@property (nonatomic, assign) NSInteger count; +@end + +@interface QTRegExp : NSObject +@property (nonatomic, assign) BOOL isActive; +@end + +NS_ASSUME_NONNULL_END diff --git a/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.m b/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.m new file mode 100644 index 0000000..5c76b76 --- /dev/null +++ b/head/schema-objective-c/test/inputs/schema/dart-runtime-type-names.schema/default/QTTopLevel.m @@ -0,0 +1,374 @@ +#import "QTTopLevel.h" + +#define λ(decl, expr) (^(decl) { return (expr); }) + +static id NSNullify(id _Nullable x) { + return (x == nil || x == NSNull.null) ? NSNull.null : x; +} + +NS_ASSUME_NONNULL_BEGIN + +@interface QTTopLevel (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + +@interface QTDateTime (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + +@interface QTEnumValues (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + +@interface QTFormatException (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + +@interface QTRegExp (JSONConversion) ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict; +- (NSDictionary *)JSONDictionary; +@end + +@implementation QTStatus ++ (NSDictionary *)values +{ + static NSDictionary *values; + return values = values ? values : @{ + @"ready": [[QTStatus alloc] initWithValue:@"ready"], + @"done": [[QTStatus alloc] initWithValue:@"done"], + }; +} + ++ (QTStatus *)ready { return QTStatus.values[@"ready"]; } ++ (QTStatus *)done { return QTStatus.values[@"done"]; } + ++ (instancetype _Nullable)withValue:(NSString *)value +{ + return QTStatus.values[value]; +} + +- (instancetype)initWithValue:(NSString *)value +{ + if (self = [super init]) _value = value; + return self; +} + +- (NSUInteger)hash { return _value.hash; } +@end + +#pragma mark - JSON serialization + +QTTopLevel *_Nullable QTTopLevelFromData(NSData *data, NSError **error) +{ + @try { + id json = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingAllowFragments error:error]; + return *error ? nil : [QTTopLevel fromJSONDictionary:json]; + } @catch (NSException *exception) { + *error = [NSError errorWithDomain:@"JSONSerialization" code:-1 userInfo:@{ @"exception": exception }]; + return nil; + } +} + +QTTopLevel *_Nullable QTTopLevelFromJSON(NSString *json, NSStringEncoding encoding, NSError **error) +{ + return QTTopLevelFromData([json dataUsingEncoding:encoding], error); +} + +NSData *_Nullable QTTopLevelToData(QTTopLevel *topLevel, NSError **error) +{ + @try { + id json = [topLevel JSONDictionary]; + NSData *data = [NSJSONSerialization dataWithJSONObject:json options:NSJSONWritingFragmentsAllowed error:error]; + return *error ? nil : data; + } @catch (NSException *exception) { + *error = [NSError errorWithDomain:@"JSONSerialization" code:-1 userInfo:@{ @"exception": exception }]; + return nil; + } +} + +NSString *_Nullable QTTopLevelToJSON(QTTopLevel *topLevel, NSStringEncoding encoding, NSError **error) +{ + NSData *data = QTTopLevelToData(topLevel, error); + return data ? [[NSString alloc] initWithData:data encoding:encoding] : nil; +} + +@implementation QTTopLevel ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"code": @"code", + @"dateTime": @"dateTime", + @"enumValues": @"enumValues", + @"formatException": @"formatException", + @"regExp": @"regExp", + @"status": @"status", + @"timestamp": @"timestamp", + }; +} + ++ (_Nullable instancetype)fromData:(NSData *)data error:(NSError *_Nullable *)error +{ + return QTTopLevelFromData(data, error); +} + ++ (_Nullable instancetype)fromJSON:(NSString *)json encoding:(NSStringEncoding)encoding error:(NSError *_Nullable *)error +{ + return QTTopLevelFromJSON(json, encoding, error); +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTTopLevel alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (dict[@"code"] && [dict[@"code"] rangeOfString:@"^[a-z]+$" options:NSRegularExpressionSearch].location == NSNotFound) return nil; + if (dict[@"code"] && [dict[@"code"] length] < 1) return nil; + if (![dict[@"code"] isKindOfClass:NSString.class]) return nil; + if (![dict[@"dateTime"] isKindOfClass:NSDictionary.class]) return nil; + if (![dict[@"enumValues"] isKindOfClass:NSDictionary.class]) return nil; + if (![dict[@"formatException"] isKindOfClass:NSDictionary.class]) return nil; + if (![dict[@"regExp"] isKindOfClass:NSDictionary.class]) return nil; + if (![dict[@"status"] isKindOfClass:NSString.class]) return nil; + if (dict[@"timestamp"] && [dict[@"timestamp"] rangeOfString:@"^[0-9]{4}-[0-9]{2}-[0-9]{2}T" options:NSRegularExpressionSearch].location == NSNotFound) return nil; + if (![dict[@"timestamp"] isKindOfClass:NSString.class]) return nil; + [self setValuesForKeysWithDictionary:dict]; + _dateTime = [QTDateTime fromJSONDictionary:(id)_dateTime]; + if (!_dateTime && dict[@"dateTime"] && ![dict[@"dateTime"] isKindOfClass:NSNull.class]) return nil; + _enumValues = [QTEnumValues fromJSONDictionary:(id)_enumValues]; + if (!_enumValues && dict[@"enumValues"] && ![dict[@"enumValues"] isKindOfClass:NSNull.class]) return nil; + _formatException = [QTFormatException fromJSONDictionary:(id)_formatException]; + if (!_formatException && dict[@"formatException"] && ![dict[@"formatException"] isKindOfClass:NSNull.class]) return nil; + _regExp = [QTRegExp fromJSONDictionary:(id)_regExp]; + if (!_regExp && dict[@"regExp"] && ![dict[@"regExp"] isKindOfClass:NSNull.class]) return nil; + _status = [QTStatus withValue:(id)_status]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTTopLevel.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTTopLevel.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + id dict = [[self dictionaryWithValuesForKeys:QTTopLevel.properties.allValues] mutableCopy]; + + [dict addEntriesFromDictionary:@{ + @"dateTime": [_dateTime JSONDictionary], + @"enumValues": [_enumValues JSONDictionary], + @"formatException": [_formatException JSONDictionary], + @"regExp": [_regExp JSONDictionary], + @"status": [_status value], + }]; + + return dict; +} + +- (NSData *_Nullable)toData:(NSError *_Nullable *)error +{ + return QTTopLevelToData(self, error); +} + +- (NSString *_Nullable)toJSON:(NSStringEncoding)encoding error:(NSError *_Nullable *)error +{ + return QTTopLevelToJSON(self, encoding, error); +} +@end + +@implementation QTDateTime ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"value": @"value", + }; +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTDateTime alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (![dict[@"value"] isKindOfClass:NSNumber.class]) return nil; + if ([dict[@"value"] doubleValue] != [dict[@"value"] longLongValue]) return nil; + [self setValuesForKeysWithDictionary:dict]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTDateTime.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTDateTime.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + return [self dictionaryWithValuesForKeys:QTDateTime.properties.allValues]; +} +@end + +@implementation QTEnumValues ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"label": @"label", + }; +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTEnumValues alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (![dict[@"label"] isKindOfClass:NSString.class]) return nil; + [self setValuesForKeysWithDictionary:dict]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTEnumValues.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTEnumValues.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + return [self dictionaryWithValuesForKeys:QTEnumValues.properties.allValues]; +} +@end + +@implementation QTFormatException ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"count": @"count", + }; +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTFormatException alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (![dict[@"count"] isKindOfClass:NSNumber.class]) return nil; + if ([dict[@"count"] doubleValue] != [dict[@"count"] longLongValue]) return nil; + [self setValuesForKeysWithDictionary:dict]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTFormatException.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTFormatException.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + return [self dictionaryWithValuesForKeys:QTFormatException.properties.allValues]; +} +@end + +@implementation QTRegExp ++ (NSDictionary *)properties +{ + static NSDictionary *properties; + return properties = properties ? properties : @{ + @"active": @"isActive", + }; +} + ++ (instancetype)fromJSONDictionary:(NSDictionary *)dict +{ + return [dict isKindOfClass:NSDictionary.class] ? [[QTRegExp alloc] initWithJSONDictionary:dict] : nil; +} + +- (instancetype)initWithJSONDictionary:(NSDictionary *)dict +{ + if (self = [super init]) { + if (![dict[@"active"] isKindOfClass:NSNumber.class]) return nil; + [self setValuesForKeysWithDictionary:dict]; + } + return self; +} + +- (void)setValue:(nullable id)value forKey:(NSString *)key +{ + id resolved = QTRegExp.properties[key]; + if (resolved) [super setValue:value forKey:resolved]; +} + +- (void)setNilValueForKey:(NSString *)key +{ + id resolved = QTRegExp.properties[key]; + if (resolved) [super setValue:@(0) forKey:resolved]; +} + +- (NSDictionary *)JSONDictionary +{ + id dict = [[self dictionaryWithValuesForKeys:QTRegExp.properties.allValues] mutableCopy]; + + for (id jsonName in QTRegExp.properties) { + id propertyName = QTRegExp.properties[jsonName]; + if (![jsonName isEqualToString:propertyName]) { + dict[jsonName] = dict[propertyName]; + [dict removeObjectForKey:propertyName]; + } + } + + [dict addEntriesFromDictionary:@{ + @"active": _isActive ? @YES : @NO, + }]; + + return dict; +} +@end + +NS_ASSUME_NONNULL_END diff --git a/head/schema-php/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.php b/head/schema-php/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.php new file mode 100644 index 0000000..09e5971 --- /dev/null +++ b/head/schema-php/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.php @@ -0,0 +1,916 @@ +code = $code; + $this->dateTime = $dateTime; + $this->enumValues = $enumValues; + $this->formatException = $formatException; + $this->regExp = $regExp; + $this->status = $status; + $this->timestamp = $timestamp; + } + + /** + * @param string $value + * @throws Exception + * @return string + */ + public static function fromCode(string $value): string { + return $value; /*string*/ + } + + /** + * @throws Exception + * @return string + */ + public function toCode(): string { + if (TopLevel::validateCode($this->code)) { + return $this->code; /*string*/ + } + throw new Exception('never get to this TopLevel::code'); + } + + /** + * @param string + * @return bool + * @throws Exception + */ + public static function validateCode(string $value): bool { + if (preg_match_all('/./us', $value) < 1) { + throw new Exception("Attribute Error"); + } + if (preg_match('~^[a-z]+$~u', $value) !== 1) { + throw new Exception("Attribute Error"); + } + return true; + } + + /** + * @throws Exception + * @return string + */ + public function getCode(): string { + if (TopLevel::validateCode($this->code)) { + return $this->code; + } + throw new Exception('never get to getCode TopLevel::code'); + } + + /** + * @return string + */ + public static function sampleCode(): string { + return 'TopLevel::code::31'; /*31:code*/ + } + + /** + * @param stdClass $value + * @throws Exception + * @return DateTimeClass + */ + public static function fromDateTime(stdClass $value): DateTimeClass { + return DateTimeClass::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toDateTime(): stdClass { + if (TopLevel::validateDateTime($this->dateTime)) { + return $this->dateTime->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::dateTime'); + } + + /** + * @param DateTimeClass + * @return bool + * @throws Exception + */ + public static function validateDateTime(DateTimeClass $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return DateTimeClass + */ + public function getDateTime(): DateTimeClass { + if (TopLevel::validateDateTime($this->dateTime)) { + return $this->dateTime; + } + throw new Exception('never get to getDateTime TopLevel::dateTime'); + } + + /** + * @return DateTimeClass + */ + public static function sampleDateTime(): DateTimeClass { + return DateTimeClass::sample(); /*32:dateTime*/ + } + + /** + * @param stdClass $value + * @throws Exception + * @return EnumValues + */ + public static function fromEnumValues(stdClass $value): EnumValues { + return EnumValues::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toEnumValues(): stdClass { + if (TopLevel::validateEnumValues($this->enumValues)) { + return $this->enumValues->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::enumValues'); + } + + /** + * @param EnumValues + * @return bool + * @throws Exception + */ + public static function validateEnumValues(EnumValues $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return EnumValues + */ + public function getEnumValues(): EnumValues { + if (TopLevel::validateEnumValues($this->enumValues)) { + return $this->enumValues; + } + throw new Exception('never get to getEnumValues TopLevel::enumValues'); + } + + /** + * @return EnumValues + */ + public static function sampleEnumValues(): EnumValues { + return EnumValues::sample(); /*33:enumValues*/ + } + + /** + * @param stdClass $value + * @throws Exception + * @return FormatException + */ + public static function fromFormatException(stdClass $value): FormatException { + return FormatException::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toFormatException(): stdClass { + if (TopLevel::validateFormatException($this->formatException)) { + return $this->formatException->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::formatException'); + } + + /** + * @param FormatException + * @return bool + * @throws Exception + */ + public static function validateFormatException(FormatException $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return FormatException + */ + public function getFormatException(): FormatException { + if (TopLevel::validateFormatException($this->formatException)) { + return $this->formatException; + } + throw new Exception('never get to getFormatException TopLevel::formatException'); + } + + /** + * @return FormatException + */ + public static function sampleFormatException(): FormatException { + return FormatException::sample(); /*34:formatException*/ + } + + /** + * @param stdClass $value + * @throws Exception + * @return RegExp + */ + public static function fromRegExp(stdClass $value): RegExp { + return RegExp::from($value); /*class*/ + } + + /** + * @throws Exception + * @return stdClass + */ + public function toRegExp(): stdClass { + if (TopLevel::validateRegExp($this->regExp)) { + return $this->regExp->to(); /*class*/ + } + throw new Exception('never get to this TopLevel::regExp'); + } + + /** + * @param RegExp + * @return bool + * @throws Exception + */ + public static function validateRegExp(RegExp $value): bool { + $value->validate(); + return true; + } + + /** + * @throws Exception + * @return RegExp + */ + public function getRegExp(): RegExp { + if (TopLevel::validateRegExp($this->regExp)) { + return $this->regExp; + } + throw new Exception('never get to getRegExp TopLevel::regExp'); + } + + /** + * @return RegExp + */ + public static function sampleRegExp(): RegExp { + return RegExp::sample(); /*35:regExp*/ + } + + /** + * @param string $value + * @throws Exception + * @return Status + */ + public static function fromStatus(string $value): Status { + return Status::from($value); /*enum*/ + } + + /** + * @throws Exception + * @return string + */ + public function toStatus(): string { + if (TopLevel::validateStatus($this->status)) { + return Status::to($this->status); /*enum*/ + } + throw new Exception('never get to this TopLevel::status'); + } + + /** + * @param Status + * @return bool + * @throws Exception + */ + public static function validateStatus(Status $value): bool { + Status::to($value); + return true; + } + + /** + * @throws Exception + * @return Status + */ + public function getStatus(): Status { + if (TopLevel::validateStatus($this->status)) { + return $this->status; + } + throw new Exception('never get to getStatus TopLevel::status'); + } + + /** + * @return Status + */ + public static function sampleStatus(): Status { + return Status::sample(); /*enum*/ + } + + /** + * @param string $value + * @throws Exception + * @return DateTime + */ + public static function fromTimestamp(string $value): DateTime { + $tmp = new DateTime($value); + if (!is_a($tmp, 'DateTime')) { + throw new Exception('Attribute Error:TopLevel::'); + } + return $tmp; + } + + /** + * @throws Exception + * @return string + */ + public function toTimestamp(): string { + if (TopLevel::validateTimestamp($this->timestamp)) { + return $this->timestamp->format("Y-m-d\\TH:i:s.uP"); + } + throw new Exception('never get to this TopLevel::timestamp'); + } + + /** + * @param DateTime + * @return bool + * @throws Exception + */ + public static function validateTimestamp(DateTime $value): bool { + if (!is_a($value, 'DateTime')) { + throw new Exception('Attribute Error:TopLevel::timestamp'); + } + return true; + } + + /** + * @throws Exception + * @return DateTime + */ + public function getTimestamp(): DateTime { + if (TopLevel::validateTimestamp($this->timestamp)) { + return $this->timestamp; + } + throw new Exception('never get to getTimestamp TopLevel::timestamp'); + } + + /** + * @return DateTime + */ + public static function sampleTimestamp(): DateTime { + return DateTime::createFromFormat(DateTimeInterface::ISO8601, '2020-12-70T12:70:70+00:00'); + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return TopLevel::validateCode($this->code) + || TopLevel::validateDateTime($this->dateTime) + || TopLevel::validateEnumValues($this->enumValues) + || TopLevel::validateFormatException($this->formatException) + || TopLevel::validateRegExp($this->regExp) + || TopLevel::validateStatus($this->status) + || TopLevel::validateTimestamp($this->timestamp); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'code'} = $this->toCode(); + $out->{'dateTime'} = $this->toDateTime(); + $out->{'enumValues'} = $this->toEnumValues(); + $out->{'formatException'} = $this->toFormatException(); + $out->{'regExp'} = $this->toRegExp(); + $out->{'status'} = $this->toStatus(); + $out->{'timestamp'} = $this->toTimestamp(); + return $out; + } + + /** + * @param stdClass $obj + * @return TopLevel + * @throws Exception + */ + public static function from(stdClass $obj): TopLevel { + if (!property_exists($obj, 'code')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'dateTime')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'enumValues')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'formatException')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'regExp')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'status')) { + throw new Exception("Missing required property"); + } + if (!property_exists($obj, 'timestamp')) { + throw new Exception("Missing required property"); + } + return new TopLevel( + TopLevel::fromCode($obj->{'code'}) + ,TopLevel::fromDateTime($obj->{'dateTime'}) + ,TopLevel::fromEnumValues($obj->{'enumValues'}) + ,TopLevel::fromFormatException($obj->{'formatException'}) + ,TopLevel::fromRegExp($obj->{'regExp'}) + ,TopLevel::fromStatus($obj->{'status'}) + ,TopLevel::fromTimestamp($obj->{'timestamp'}) + ); + } + + /** + * @return TopLevel + */ + public static function sample(): TopLevel { + return new TopLevel( + TopLevel::sampleCode() + ,TopLevel::sampleDateTime() + ,TopLevel::sampleEnumValues() + ,TopLevel::sampleFormatException() + ,TopLevel::sampleRegExp() + ,TopLevel::sampleStatus() + ,TopLevel::sampleTimestamp() + ); + } +} + +// This is an autogenerated file:DateTimeClass + +class DateTimeClass { + private int $value; // json:value Required + + /** + * @param int $value + */ + public function __construct(int $value) { + $this->value = $value; + } + + /** + * @param int $value + * @throws Exception + * @return int + */ + public static function fromValue(int $value): int { + return $value; /*int*/ + } + + /** + * @throws Exception + * @return int + */ + public function toValue(): int { + if (DateTimeClass::validateValue($this->value)) { + return $this->value; /*int*/ + } + throw new Exception('never get to this DateTimeClass::value'); + } + + /** + * @param int + * @return bool + * @throws Exception + */ + public static function validateValue(int $value): bool { + return true; + } + + /** + * @throws Exception + * @return int + */ + public function getValue(): int { + if (DateTimeClass::validateValue($this->value)) { + return $this->value; + } + throw new Exception('never get to getValue DateTimeClass::value'); + } + + /** + * @return int + */ + public static function sampleValue(): int { + return 31; /*31:value*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return DateTimeClass::validateValue($this->value); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'value'} = $this->toValue(); + return $out; + } + + /** + * @param stdClass $obj + * @return DateTimeClass + * @throws Exception + */ + public static function from(stdClass $obj): DateTimeClass { + if (!property_exists($obj, 'value')) { + throw new Exception("Missing required property"); + } + return new DateTimeClass( + DateTimeClass::fromValue($obj->{'value'}) + ); + } + + /** + * @return DateTimeClass + */ + public static function sample(): DateTimeClass { + return new DateTimeClass( + DateTimeClass::sampleValue() + ); + } +} + +// This is an autogenerated file:EnumValues + +class EnumValues { + private string $label; // json:label Required + + /** + * @param string $label + */ + public function __construct(string $label) { + $this->label = $label; + } + + /** + * @param string $value + * @throws Exception + * @return string + */ + public static function fromLabel(string $value): string { + return $value; /*string*/ + } + + /** + * @throws Exception + * @return string + */ + public function toLabel(): string { + if (EnumValues::validateLabel($this->label)) { + return $this->label; /*string*/ + } + throw new Exception('never get to this EnumValues::label'); + } + + /** + * @param string + * @return bool + * @throws Exception + */ + public static function validateLabel(string $value): bool { + return true; + } + + /** + * @throws Exception + * @return string + */ + public function getLabel(): string { + if (EnumValues::validateLabel($this->label)) { + return $this->label; + } + throw new Exception('never get to getLabel EnumValues::label'); + } + + /** + * @return string + */ + public static function sampleLabel(): string { + return 'EnumValues::label::31'; /*31:label*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return EnumValues::validateLabel($this->label); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'label'} = $this->toLabel(); + return $out; + } + + /** + * @param stdClass $obj + * @return EnumValues + * @throws Exception + */ + public static function from(stdClass $obj): EnumValues { + if (!property_exists($obj, 'label')) { + throw new Exception("Missing required property"); + } + return new EnumValues( + EnumValues::fromLabel($obj->{'label'}) + ); + } + + /** + * @return EnumValues + */ + public static function sample(): EnumValues { + return new EnumValues( + EnumValues::sampleLabel() + ); + } +} + +// This is an autogenerated file:FormatException + +class FormatException { + private int $count; // json:count Required + + /** + * @param int $count + */ + public function __construct(int $count) { + $this->count = $count; + } + + /** + * @param int $value + * @throws Exception + * @return int + */ + public static function fromCount(int $value): int { + return $value; /*int*/ + } + + /** + * @throws Exception + * @return int + */ + public function toCount(): int { + if (FormatException::validateCount($this->count)) { + return $this->count; /*int*/ + } + throw new Exception('never get to this FormatException::count'); + } + + /** + * @param int + * @return bool + * @throws Exception + */ + public static function validateCount(int $value): bool { + return true; + } + + /** + * @throws Exception + * @return int + */ + public function getCount(): int { + if (FormatException::validateCount($this->count)) { + return $this->count; + } + throw new Exception('never get to getCount FormatException::count'); + } + + /** + * @return int + */ + public static function sampleCount(): int { + return 31; /*31:count*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return FormatException::validateCount($this->count); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'count'} = $this->toCount(); + return $out; + } + + /** + * @param stdClass $obj + * @return FormatException + * @throws Exception + */ + public static function from(stdClass $obj): FormatException { + if (!property_exists($obj, 'count')) { + throw new Exception("Missing required property"); + } + return new FormatException( + FormatException::fromCount($obj->{'count'}) + ); + } + + /** + * @return FormatException + */ + public static function sample(): FormatException { + return new FormatException( + FormatException::sampleCount() + ); + } +} + +// This is an autogenerated file:RegExp + +class RegExp { + private bool $active; // json:active Required + + /** + * @param bool $active + */ + public function __construct(bool $active) { + $this->active = $active; + } + + /** + * @param bool $value + * @throws Exception + * @return bool + */ + public static function fromActive(bool $value): bool { + return $value; /*bool*/ + } + + /** + * @throws Exception + * @return bool + */ + public function toActive(): bool { + if (RegExp::validateActive($this->active)) { + return $this->active; /*bool*/ + } + throw new Exception('never get to this RegExp::active'); + } + + /** + * @param bool + * @return bool + * @throws Exception + */ + public static function validateActive(bool $value): bool { + return true; + } + + /** + * @throws Exception + * @return bool + */ + public function getActive(): bool { + if (RegExp::validateActive($this->active)) { + return $this->active; + } + throw new Exception('never get to getActive RegExp::active'); + } + + /** + * @return bool + */ + public static function sampleActive(): bool { + return true; /*31:active*/ + } + + /** + * @throws Exception + * @return bool + */ + public function validate(): bool { + return RegExp::validateActive($this->active); + } + + /** + * @return stdClass + * @throws Exception + */ + public function to(): stdClass { + $out = new stdClass(); + $out->{'active'} = $this->toActive(); + return $out; + } + + /** + * @param stdClass $obj + * @return RegExp + * @throws Exception + */ + public static function from(stdClass $obj): RegExp { + if (!property_exists($obj, 'active')) { + throw new Exception("Missing required property"); + } + return new RegExp( + RegExp::fromActive($obj->{'active'}) + ); + } + + /** + * @return RegExp + */ + public static function sample(): RegExp { + return new RegExp( + RegExp::sampleActive() + ); + } +} + +// This is an autogenerated file:Status + +class Status { + public static Status $READY; + public static Status $DONE; + public static function init() { + Status::$READY = new Status('ready'); + Status::$DONE = new Status('done'); + } + private string $enum; + public function __construct(string $enum) { + $this->enum = $enum; + } + + /** + * @param Status + * @return string + * @throws Exception + */ + public static function to(Status $obj): string { + switch ($obj->enum) { + case Status::$READY->enum: return 'ready'; + case Status::$DONE->enum: return 'done'; + } + throw new Exception('the give value is not an enum-value.'); + } + + /** + * @param mixed + * @return Status + * @throws Exception + */ + public static function from($obj): Status { + switch ($obj) { + case 'ready': return Status::$READY; + case 'done': return Status::$DONE; + } + throw new Exception("Cannot deserialize Status"); + } + + /** + * @return Status + */ + public static function sample(): Status { + return Status::$READY; + } +} +Status::init(); diff --git a/head/schema-pike/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.pmod b/head/schema-pike/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.pmod new file mode 100644 index 0000000..7c05955 --- /dev/null +++ b/head/schema-pike/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.pmod @@ -0,0 +1,145 @@ +// This source has been automatically generated by quicktype. +// ( https://github.com/quicktype/quicktype ) +// +// To use this code, simply import it into your project as a Pike module. +// To JSON-encode your object, you can pass it to `Standards.JSON.encode` +// or call `encode_json` on it. +// +// To decode a JSON string, first pass it to `Standards.JSON.decode`, +// and then pass the result to `_from_JSON`. +// It will return an instance of . +// Bear in mind that these functions have unexpected behavior, +// and will likely throw an error, if the JSON string does not +// match the expected interface, even if the JSON itself is valid. + +class TopLevel { + string code; // json: "code" + DateTime date_time; // json: "dateTime" + EnumValues enum_values; // json: "enumValues" + FormatException format_exception; // json: "formatException" + RegExp reg_exp; // json: "regExp" + Status status; // json: "status" + string timestamp; // json: "timestamp" + + string encode_json() { + mapping(string:mixed) json = ([ + "code" : code, + "dateTime" : date_time, + "enumValues" : enum_values, + "formatException" : format_exception, + "regExp" : reg_exp, + "status" : status, + "timestamp" : timestamp, + ]); + + return Standards.JSON.encode(json); + } +} + +TopLevel TopLevel_from_JSON(mixed json) { + TopLevel retval = TopLevel(); + + if (sizeof(json["code"]) < 1) error("String too short"); + if (!Regexp("^[a-z]+$")->match(json["code"])) error("String does not match pattern"); + retval.code = json["code"]; + retval.date_time = json["dateTime"]; + retval.enum_values = json["enumValues"]; + retval.format_exception = json["formatException"]; + retval.reg_exp = json["regExp"]; + retval.status = Status_from_JSON(json["status"]); + retval.timestamp = json["timestamp"]; + + return retval; +} + +class DateTime { + int value; // json: "value" + + string encode_json() { + mapping(string:mixed) json = ([ + "value" : value, + ]); + + return Standards.JSON.encode(json); + } +} + +DateTime DateTime_from_JSON(mixed json) { + DateTime retval = DateTime(); + + if (!intp(json["value"])) error("Expected integer"); + retval.value = json["value"]; + + return retval; +} + +class EnumValues { + string label; // json: "label" + + string encode_json() { + mapping(string:mixed) json = ([ + "label" : label, + ]); + + return Standards.JSON.encode(json); + } +} + +EnumValues EnumValues_from_JSON(mixed json) { + EnumValues retval = EnumValues(); + + retval.label = json["label"]; + + return retval; +} + +class FormatException { + int count; // json: "count" + + string encode_json() { + mapping(string:mixed) json = ([ + "count" : count, + ]); + + return Standards.JSON.encode(json); + } +} + +FormatException FormatException_from_JSON(mixed json) { + FormatException retval = FormatException(); + + if (!intp(json["count"])) error("Expected integer"); + retval.count = json["count"]; + + return retval; +} + +class RegExp { + bool active; // json: "active" + + string encode_json() { + mapping(string:mixed) json = ([ + "active" : active, + ]); + + return Standards.JSON.encode(json); + } +} + +RegExp RegExp_from_JSON(mixed json) { + RegExp retval = RegExp(); + + if (json["active"] != Standards.JSON.true && json["active"] != Standards.JSON.false) error("Expected bool"); + retval.active = json["active"]; + + return retval; +} + +enum Status { + READY = "ready", // json: "ready" + DONE = "done", // json: "done" +} + +Status Status_from_JSON(mixed json) { + if(json&&json != "ready"&&json != "done")error("enum");return json; +} diff --git a/head/schema-python/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.py b/head/schema-python/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.py new file mode 100644 index 0000000..ed8330c --- /dev/null +++ b/head/schema-python/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.py @@ -0,0 +1,149 @@ +import datetime +from dataclasses import dataclass +from typing import Any, TypeVar, Type, cast +from enum import Enum +import dateutil.parser + + +T = TypeVar("T") +EnumT = TypeVar("EnumT", bound=Enum) + + +def from_int(x: Any) -> int: + assert isinstance(x, int) and not isinstance(x, bool) + return x + + +def from_str(x: Any) -> str: + assert isinstance(x, str) + return x + + +def from_bool(x: Any) -> bool: + assert isinstance(x, bool) + return x + + +def from_datetime(x: Any) -> datetime.datetime: + return dateutil.parser.parse(x) + + +def to_class(c: Type[T], x: Any) -> dict: + assert isinstance(x, c) + return cast(Any, x).to_dict() + + +def to_enum(c: Type[EnumT], x: Any) -> EnumT: + assert isinstance(x, c) + return x.value + + +@dataclass +class DateTime: + value: int + + @staticmethod + def from_dict(obj: Any) -> 'DateTime': + assert isinstance(obj, dict) + value = from_int(obj.get("value")) + return DateTime(value) + + def to_dict(self) -> dict: + result: dict = {} + result["value"] = from_int(self.value) + return result + + +@dataclass +class EnumValues: + label: str + + @staticmethod + def from_dict(obj: Any) -> 'EnumValues': + assert isinstance(obj, dict) + label = from_str(obj.get("label")) + return EnumValues(label) + + def to_dict(self) -> dict: + result: dict = {} + result["label"] = from_str(self.label) + return result + + +@dataclass +class FormatException: + count: int + + @staticmethod + def from_dict(obj: Any) -> 'FormatException': + assert isinstance(obj, dict) + count = from_int(obj.get("count")) + return FormatException(count) + + def to_dict(self) -> dict: + result: dict = {} + result["count"] = from_int(self.count) + return result + + +@dataclass +class RegExp: + active: bool + + @staticmethod + def from_dict(obj: Any) -> 'RegExp': + assert isinstance(obj, dict) + active = from_bool(obj.get("active")) + return RegExp(active) + + def to_dict(self) -> dict: + result: dict = {} + result["active"] = from_bool(self.active) + return result + + +class Status(Enum): + READY = "ready" + DONE = "done" + + +@dataclass +class TopLevel: + code: str + date_time: DateTime + enum_values: EnumValues + format_exception: FormatException + reg_exp: RegExp + status: Status + timestamp: datetime.datetime + + @staticmethod + def from_dict(obj: Any) -> 'TopLevel': + assert isinstance(obj, dict) + code = from_str(obj.get("code")) + date_time = DateTime.from_dict(obj.get("dateTime")) + enum_values = EnumValues.from_dict(obj.get("enumValues")) + format_exception = FormatException.from_dict(obj.get("formatException")) + reg_exp = RegExp.from_dict(obj.get("regExp")) + status = Status(obj.get("status")) + timestamp = from_datetime(obj.get("timestamp")) + return TopLevel(code, date_time, enum_values, format_exception, reg_exp, status, timestamp) + + def to_dict(self) -> dict: + result: dict = {} + result["code"] = from_str(self.code) + result["dateTime"] = to_class(DateTime, self.date_time) + result["enumValues"] = to_class(EnumValues, self.enum_values) + result["formatException"] = to_class(FormatException, self.format_exception) + result["regExp"] = to_class(RegExp, self.reg_exp) + result["status"] = to_enum(Status, self.status) + result["timestamp"] = self.timestamp.isoformat() + return result + + +def top_level_from_dict(s: Any) -> TopLevel: + return TopLevel.from_dict(s) + + +def top_level_to_dict(x: TopLevel) -> Any: + return to_class(TopLevel, x) diff --git a/head/schema-ruby/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.rb b/head/schema-ruby/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.rb new file mode 100644 index 0000000..e53771e --- /dev/null +++ b/head/schema-ruby/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.rb @@ -0,0 +1,171 @@ +# This code may look unusually verbose for Ruby (and it is), but +# it performs some subtle and complex validation of JSON data. +# +# To parse this JSON, add 'dry-struct' and 'dry-types' gems, then do: +# +# top_level = TopLevel.from_json! "{…}" +# puts top_level.reg_exp.active +# +# If from_json! succeeds, the value returned matches the schema. + +require 'json' +require 'dry-types' +require 'dry-struct' + +module Types + include Dry.Types(default: :nominal) + + Integer = Strict::Integer + Bool = Strict::Bool + Hash = Strict::Hash + String = Strict::String + Status = Strict::String.enum("ready", "done") +end + +class DateTime < Dry::Struct + attribute :value, Types::Integer + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + value: d.fetch("value"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "value" => value, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class EnumValues < Dry::Struct + attribute :label, Types::String + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + label: d.fetch("label"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "label" => label, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class FormatException < Dry::Struct + attribute :count, Types::Integer + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + count: d.fetch("count"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "count" => count, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +class RegExp < Dry::Struct + attribute :active, Types::Bool + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + active: d.fetch("active"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "active" => active, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end + +module Status + Ready = "ready" + Done = "done" +end + +class TopLevel < Dry::Struct + attribute :code, Types::String.constrained(min_size: 1).constrained(format: Regexp.new("^[a-z]+$")) + attribute :date_time, DateTime + attribute :enum_values, EnumValues + attribute :format_exception, FormatException + attribute :reg_exp, RegExp + attribute :status, Types::Status + attribute :timestamp, Types::String.constrained(format: /\A\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)\z/i) + + def self.from_dynamic!(d) + d = Types::Hash[d] + new( + code: d.fetch("code"), + date_time: DateTime.from_dynamic!(d.fetch("dateTime")), + enum_values: EnumValues.from_dynamic!(d.fetch("enumValues")), + format_exception: FormatException.from_dynamic!(d.fetch("formatException")), + reg_exp: RegExp.from_dynamic!(d.fetch("regExp")), + status: d.fetch("status"), + timestamp: d.fetch("timestamp"), + ) + end + + def self.from_json!(json) + from_dynamic!(JSON.parse(json)) + end + + def to_dynamic + { + "code" => code, + "dateTime" => date_time.to_dynamic, + "enumValues" => enum_values.to_dynamic, + "formatException" => format_exception.to_dynamic, + "regExp" => reg_exp.to_dynamic, + "status" => status, + "timestamp" => timestamp, + } + end + + def to_json(options = nil) + JSON.generate(to_dynamic, options) + end +end diff --git a/head/schema-rust/test/inputs/schema/dart-runtime-type-names.schema/default/module_under_test.rs b/head/schema-rust/test/inputs/schema/dart-runtime-type-names.schema/default/module_under_test.rs new file mode 100644 index 0000000..a6f1d16 --- /dev/null +++ b/head/schema-rust/test/inputs/schema/dart-runtime-type-names.schema/default/module_under_test.rs @@ -0,0 +1,60 @@ +// Example code that deserializes and serializes the model. +// extern crate serde; +// #[macro_use] +// extern crate serde_derive; +// extern crate serde_json; +// +// use generated_module::TopLevel; +// +// fn main() { +// let json = r#"{"answer": 42}"#; +// let model: TopLevel = serde_json::from_str(&json).unwrap(); +// } + +use serde::{Serialize, Deserialize}; + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct TopLevel { + pub code: String, + + pub date_time: DateTime, + + pub enum_values: EnumValues, + + pub format_exception: FormatException, + + pub reg_exp: RegExp, + + pub status: Status, + + pub timestamp: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DateTime { + pub value: i64, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct EnumValues { + pub label: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct FormatException { + pub count: i64, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RegExp { + pub active: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum Status { + Ready, + + Done, +} diff --git a/head/schema-scala3/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala b/head/schema-scala3/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala new file mode 100644 index 0000000..4f97ab6 --- /dev/null +++ b/head/schema-scala3/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala @@ -0,0 +1,48 @@ +package quicktype + +import io.circe.syntax._ +import io.circe._ +import cats.syntax.functor._ + +// If a union has a null in, then we'll need this too... +type NullValue = None.type + +case class TopLevel ( + val code : String, + val dateTime : DateTime, + val enumValues : EnumValues, + val formatException : FormatException, + val regExp : RegExp, + val status : Status, + val timestamp : java.time.Instant +) derives Encoder.AsObject, Decoder + +case class DateTime ( + val value : Long +) derives Encoder.AsObject, Decoder + +case class EnumValues ( + val label : String +) derives Encoder.AsObject, Decoder + +case class FormatException ( + val count : Long +) derives Encoder.AsObject, Decoder + +case class RegExp ( + val active : Boolean +) derives Encoder.AsObject, Decoder + +enum Status : + case Ready + case Done + +given Decoder[Status] = Decoder.decodeString.emap { + case "ready" => scala.Right(Status.Ready) + case "done" => scala.Right(Status.Done) + case other => scala.Left("invalid Status: " + other) +} +given Encoder[Status] = Encoder.encodeString.contramap { + case Status.Ready => "ready" + case Status.Done => "done" +} diff --git a/head/schema-scala3-upickle/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala b/head/schema-scala3-upickle/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala new file mode 100644 index 0000000..1db190e --- /dev/null +++ b/head/schema-scala3-upickle/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.scala @@ -0,0 +1,110 @@ +package quicktype + +// Custom pickler so that missing keys and JSON nulls both read as None, +// and None is left out when writing (upickle's default for Option is a +// JSON array). +object OptionPickler extends upickle.AttributeTagged: + import upickle.default.Writer + import upickle.default.Reader + override implicit def OptionWriter[T: Writer]: Writer[Option[T]] = + implicitly[Writer[T]].comap[Option[T]] { + case None => null.asInstanceOf[T] + case Some(x) => x + } + + override implicit def OptionReader[T: Reader]: Reader[Option[T]] = { + new Reader.Delegate[Any, Option[T]](implicitly[Reader[T]].map(Some(_))){ + override def visitNull(index: Int) = None + } + } +end OptionPickler + +// If a union has a null in, then we'll need this too... +type NullValue = None.type +given OptionPickler.ReadWriter[NullValue] = OptionPickler.readwriter[ujson.Value].bimap[NullValue]( + _ => ujson.Null, + json => if json.isNull then None else throw new upickle.core.Abort("not null") +) +given OptionPickler.ReadWriter[java.time.Instant] = OptionPickler.readwriter[String].bimap(_.toString, java.time.Instant.parse) + +object JsonExt: + val valueReader = OptionPickler.readwriter[ujson.Value] + + // upickle's built-in primitive readers are lenient -- the numeric and + // boolean readers accept strings, and the string reader accepts + // numbers and booleans -- so untagged unions need strict readers to + // pick the right member. + val strictString: OptionPickler.Reader[String] = valueReader.map { + case ujson.Str(s) => s + case json => throw new upickle.core.Abort("expected string, got " + json) + } + val strictLong: OptionPickler.Reader[Long] = valueReader.map { + case ujson.Num(n) if n.isWhole => n.toLong + case json => throw new upickle.core.Abort("expected integer, got " + json) + } + val strictDouble: OptionPickler.Reader[Double] = valueReader.map { + case ujson.Num(n) => n + case json => throw new upickle.core.Abort("expected number, got " + json) + } + val strictBoolean: OptionPickler.Reader[Boolean] = valueReader.map { + case ujson.Bool(b) => b + case json => throw new upickle.core.Abort("expected boolean, got " + json) + } + + def badMerge[T](r1: => OptionPickler.Reader[?], rest: OptionPickler.Reader[?]*): OptionPickler.Reader[T] = valueReader.map { json => + var t: T | Null = null + val stack = Vector.newBuilder[Throwable] + (r1 +: rest).foreach { reader => + if t == null then + try + t = OptionPickler.read[T](json, trace = true)(using reader.asInstanceOf[OptionPickler.Reader[T]]) + catch + case exc => stack += exc + } + if t != null then t.nn else throw new Exception(json.toString(), stack.result().headOption.getOrElse(null)) + } +end JsonExt +given OptionPickler.Reader[Long] = JsonExt.strictLong + + +case class TopLevel ( + val code : String, + val dateTime : DateTime, + val enumValues : EnumValues, + val formatException : FormatException, + val regExp : RegExp, + val status : Status, + val timestamp : java.time.Instant +) derives OptionPickler.ReadWriter + +case class DateTime ( + val value : Long +) derives OptionPickler.ReadWriter + +case class EnumValues ( + val label : String +) derives OptionPickler.ReadWriter + +case class FormatException ( + val count : Long +) derives OptionPickler.ReadWriter + +case class RegExp ( + val active : Boolean +) derives OptionPickler.ReadWriter + +enum Status : + case Ready + case Done + +given OptionPickler.ReadWriter[Status] = OptionPickler.readwriter[String].bimap[Status]( + { + case Status.Ready => "ready" + case Status.Done => "done" + }, + { + case "ready" => Status.Ready + case "done" => Status.Done + case other => throw new upickle.core.Abort("invalid Status: " + other) + } +) diff --git a/head/schema-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.schema b/head/schema-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.schema new file mode 100644 index 0000000..8a44a89 --- /dev/null +++ b/head/schema-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.schema @@ -0,0 +1,106 @@ +{ + "$schema": "http://json-schema.org/draft-06/schema#", + "$ref": "#/definitions/TopLevel", + "definitions": { + "TopLevel": { + "type": "object", + "additionalProperties": false, + "properties": { + "code": { + "type": "string", + "minLength": 1, + "pattern": "^[a-z]+$" + }, + "dateTime": { + "$ref": "#/definitions/DateTime" + }, + "enumValues": { + "$ref": "#/definitions/EnumValues" + }, + "formatException": { + "$ref": "#/definitions/FormatException" + }, + "regExp": { + "$ref": "#/definitions/RegExp" + }, + "status": { + "$ref": "#/definitions/Status" + }, + "timestamp": { + "type": "string", + "format": "date-time" + } + }, + "required": [ + "code", + "dateTime", + "enumValues", + "formatException", + "regExp", + "status", + "timestamp" + ], + "title": "TopLevel" + }, + "DateTime": { + "type": "object", + "additionalProperties": {}, + "properties": { + "value": { + "type": "integer" + } + }, + "required": [ + "value" + ], + "title": "DateTime" + }, + "EnumValues": { + "type": "object", + "additionalProperties": {}, + "properties": { + "label": { + "type": "string" + } + }, + "required": [ + "label" + ], + "title": "EnumValues" + }, + "FormatException": { + "type": "object", + "additionalProperties": {}, + "properties": { + "count": { + "type": "integer" + } + }, + "required": [ + "count" + ], + "title": "FormatException" + }, + "RegExp": { + "type": "object", + "additionalProperties": {}, + "properties": { + "active": { + "type": "boolean" + } + }, + "required": [ + "active" + ], + "title": "RegExp" + }, + "Status": { + "type": "string", + "enum": [ + "ready", + "done" + ], + "title": "Status" + } + } +} diff --git a/head/schema-swift/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.swift b/head/schema-swift/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.swift new file mode 100644 index 0000000..ed5871a --- /dev/null +++ b/head/schema-swift/test/inputs/schema/dart-runtime-type-names.schema/default/quicktype.swift @@ -0,0 +1,291 @@ +// This file was generated from JSON Schema using quicktype, do not modify it directly. +// To parse the JSON, add this file to your project and do: +// +// let topLevel = try TopLevel(json) + +import Foundation + +// MARK: - TopLevel +struct TopLevel: Codable { + let code: String + let dateTime: DateTime + let enumValues: EnumValues + let formatException: FormatException + let regExp: RegExp + let status: Status + let timestamp: Date + + enum CodingKeys: String, CodingKey { + case code = "code" + case dateTime = "dateTime" + case enumValues = "enumValues" + case formatException = "formatException" + case regExp = "regExp" + case status = "status" + case timestamp = "timestamp" + } +} + +// MARK: TopLevel convenience initializers and mutators + +extension TopLevel { + init(data: Data) throws { + self = try newJSONDecoder().decode(TopLevel.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + code: String? = nil, + dateTime: DateTime? = nil, + enumValues: EnumValues? = nil, + formatException: FormatException? = nil, + regExp: RegExp? = nil, + status: Status? = nil, + timestamp: Date? = nil + ) -> TopLevel { + return TopLevel( + code: code ?? self.code, + dateTime: dateTime ?? self.dateTime, + enumValues: enumValues ?? self.enumValues, + formatException: formatException ?? self.formatException, + regExp: regExp ?? self.regExp, + status: status ?? self.status, + timestamp: timestamp ?? self.timestamp + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - DateTime +struct DateTime: Codable { + let value: Int + + enum CodingKeys: String, CodingKey { + case value = "value" + } +} + +// MARK: DateTime convenience initializers and mutators + +extension DateTime { + init(data: Data) throws { + self = try newJSONDecoder().decode(DateTime.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + value: Int? = nil + ) -> DateTime { + return DateTime( + value: value ?? self.value + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - EnumValues +struct EnumValues: Codable { + let label: String + + enum CodingKeys: String, CodingKey { + case label = "label" + } +} + +// MARK: EnumValues convenience initializers and mutators + +extension EnumValues { + init(data: Data) throws { + self = try newJSONDecoder().decode(EnumValues.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + label: String? = nil + ) -> EnumValues { + return EnumValues( + label: label ?? self.label + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - FormatException +struct FormatException: Codable { + let count: Int + + enum CodingKeys: String, CodingKey { + case count = "count" + } +} + +// MARK: FormatException convenience initializers and mutators + +extension FormatException { + init(data: Data) throws { + self = try newJSONDecoder().decode(FormatException.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + count: Int? = nil + ) -> FormatException { + return FormatException( + count: count ?? self.count + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +// MARK: - RegExp +struct RegExp: Codable { + let active: Bool + + enum CodingKeys: String, CodingKey { + case active = "active" + } +} + +// MARK: RegExp convenience initializers and mutators + +extension RegExp { + init(data: Data) throws { + self = try newJSONDecoder().decode(RegExp.self, from: data) + } + + init(_ json: String, using encoding: String.Encoding = .utf8) throws { + guard let data = json.data(using: encoding) else { + throw NSError(domain: "JSONDecoding", code: 0, userInfo: nil) + } + try self.init(data: data) + } + + init(fromURL url: URL) throws { + try self.init(data: try Data(contentsOf: url)) + } + + func with( + active: Bool? = nil + ) -> RegExp { + return RegExp( + active: active ?? self.active + ) + } + + func jsonData() throws -> Data { + return try newJSONEncoder().encode(self) + } + + func jsonString(encoding: String.Encoding = .utf8) throws -> String? { + return String(data: try self.jsonData(), encoding: encoding) + } +} + +enum Status: String, Codable { + case ready = "ready" + case done = "done" +} + +// MARK: - Helper functions for creating encoders and decoders + +func newJSONDecoder() -> JSONDecoder { + let decoder = JSONDecoder() + decoder.dateDecodingStrategy = .custom({ (decoder) -> Date in + let container = try decoder.singleValueContainer() + let dateStr = try container.decode(String.self) + + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ssXXXXX" + if let date = formatter.date(from: dateStr) { + return date + } + throw DecodingError.typeMismatch(Date.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Could not decode date")) + }) + return decoder +} + +func newJSONEncoder() -> JSONEncoder { + let encoder = JSONEncoder() + let formatter = DateFormatter() + formatter.calendar = Calendar(identifier: .iso8601) + formatter.locale = Locale(identifier: "en_US_POSIX") + formatter.timeZone = TimeZone(secondsFromGMT: 0) + formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX" + encoder.dateEncodingStrategy = .formatted(formatter) + return encoder +} diff --git a/head/schema-typescript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts b/head/schema-typescript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts new file mode 100644 index 0000000..eb0a9b6 --- /dev/null +++ b/head/schema-typescript/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts @@ -0,0 +1,254 @@ +// To parse this data: +// +// import { Convert, TopLevel } from "./TopLevel"; +// +// const topLevel = Convert.toTopLevel(json); +// +// These functions will throw an error if the JSON doesn't +// match the expected interface, even if the JSON is valid. + +export interface TopLevel { + code: string; + dateTime: DateTime; + enumValues: EnumValues; + formatException: FormatException; + regExp: RegExp; + status: Status; + timestamp: Date; +} + +export interface DateTime { + value: number; + [property: string]: unknown | number; +} + +export interface EnumValues { + label: string; + [property: string]: unknown | string; +} + +export interface FormatException { + count: number; + [property: string]: unknown | number; +} + +export interface RegExp { + active: boolean; + [property: string]: unknown | boolean; +} + +export type Status = "ready" | "done"; + +// Converts JSON strings to/from your types +// and asserts the results of JSON.parse at runtime +export class Convert { + public static toTopLevel(json: string): TopLevel { + return cast(JSON.parse(json), r("TopLevel")); + } + + public static topLevelToJson(value: TopLevel): string { + return JSON.stringify(uncast(value, r("TopLevel")), null, 2); + } +} + +function invalidValue(typ: any, val: any, key: any, parent: any = ''): never { + const prettyTyp = prettyTypeName(typ); + const parentText = parent ? ` on ${parent}` : ''; + const keyText = key ? ` for key "${key}"` : ''; + throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`); +} + +function prettyTypeName(typ: any): string { + if (Array.isArray(typ)) { + if (typ.length === 2 && typ[0] === undefined) { + return `an optional ${prettyTypeName(typ[1])}`; + } else { + return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`; + } + } else if (typeof typ === "object" && typ.literal !== undefined) { + return typ.literal; + } else { + return typeof typ; + } +} + +function jsonToJSProps(typ: any): any { + if (typ.jsonToJS === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ }); + typ.jsonToJS = map; + } + return typ.jsonToJS; +} + +function jsToJSONProps(typ: any): any { + if (typ.jsToJSON === undefined) { + const map: any = {}; + typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ }); + typ.jsToJSON = map; + } + return typ.jsToJSON; +} + +function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any { + function transformPrimitive(typ: string, val: any): any { + if (typeof typ === typeof val) return val; + return invalidValue(typ, val, key, parent); + } + + function transformUnion(typs: any[], val: any): any { + // val must validate against one typ in typs + const l = typs.length; + for (let i = 0; i < l; i++) { + const typ = typs[i]; + try { + return transform(val, typ, getProps); + } catch (_) {} + } + return invalidValue(typs, val, key, parent); + } + + function transformEnum(cases: string[], val: any): any { + if (cases.indexOf(val) !== -1) return val; + return invalidValue(cases.map(a => { return l(a); }), val, key, parent); + } + + function transformArray(typ: any, val: any): any { + // val must be an array with no invalid elements + if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent); + + return val.map(el => transform(el, typ, getProps)); + } + + function transformDate(val: any): any { + if (val === null) { + return null; + } + const d = new Date(val); + if (isNaN(d.valueOf())) { + return invalidValue(l("Date"), val, key, parent); + } + return d; + } + + function transformObject(props: { [k: string]: any }, additional: any, val: any): any { + if (val === null || typeof val !== "object" || Array.isArray(val)) { + return invalidValue(l(ref || "object"), val, key, parent); + } + const result: any = {}; + Object.getOwnPropertyNames(props).forEach(key => { + const prop = props[key]; + const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined; + result[prop.key] = transform(v, prop.typ, getProps, key, ref); + }); + Object.getOwnPropertyNames(val).forEach(key => { + if (!Object.prototype.hasOwnProperty.call(props, key)) { + result[key] = transform(val[key], additional, getProps, key, ref); + } + }); + return result; + } + + if (typ === "any") return val; + if (typ === null) { + if (val === null) return val; + return invalidValue(typ, val, key, parent); + } + if (typ === false) return invalidValue(typ, val, key, parent); + let ref: any = undefined; + while (typeof typ === "object" && typ.ref !== undefined) { + ref = typ.ref; + typ = typeMap[typ.ref]; + } + if (Array.isArray(typ)) return transformEnum(typ, val); + if (typeof typ === "object") { + return typ.hasOwnProperty("pattern") ? typeof val === "string" && new RegExp(typ.pattern).test(val) ? val : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("string") ? typeof val === "string" && (typ.min === undefined || val.length >= typ.min) && (typ.max === undefined || val.length <= typ.max) ? transform(val, typ.string, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("number") ? typeof val === "number" && (typ.min === undefined || val >= typ.min) && (typ.max === undefined || val <= typ.max) ? transform(val, typ.number, getProps, key, parent) : invalidValue(typ, val, key, parent) + : typ.hasOwnProperty("integer") ? typeof val === "number" && val % 1 === 0 ? val : invalidValue(l("integer"), val, key, parent) + : typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val) + : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val) + : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val) + : invalidValue(typ, val, key, parent); + } + // Numbers can be parsed by Date but shouldn't be. + if (typ === Date && typeof val !== "number") return transformDate(val); + return transformPrimitive(typ, val); +} + +function cast(val: any, typ: any): T { + return transform(val, typ, jsonToJSProps); +} + +function uncast(val: T, typ: any): any { + return transform(val, typ, jsToJSONProps); +} + +function l(typ: any) { + return { literal: typ }; +} + +function a(typ: any) { + return { arrayItems: typ }; +} + +function i(typ: any) { + return { integer: typ }; +} + +function p(pattern: any) { + return { pattern }; +} + +function s(typ: any, min: any, max: any) { + return { string: typ, min, max }; +} + +function n(typ: any, min: any, max: any) { + return { number: typ, min, max }; +} + +function u(...typs: any[]) { + return { unionMembers: typs }; +} + +function o(props: any[], additional: any) { + return { props, additional }; +} + +function m(additional: any) { + const props: any[] = []; + return { props, additional }; +} + +function r(name: string) { + return { ref: name }; +} + +const typeMap: any = { + "TopLevel": o([ + { json: "code", js: "code", typ: s(p("^[a-z]+$"), 1, undefined) }, + { json: "dateTime", js: "dateTime", typ: r("DateTime") }, + { json: "enumValues", js: "enumValues", typ: r("EnumValues") }, + { json: "formatException", js: "formatException", typ: r("FormatException") }, + { json: "regExp", js: "regExp", typ: r("RegExp") }, + { json: "status", js: "status", typ: r("Status") }, + { json: "timestamp", js: "timestamp", typ: Date }, + ], false), + "DateTime": o([ + { json: "value", js: "value", typ: i(0) }, + ], "any"), + "EnumValues": o([ + { json: "label", js: "label", typ: "" }, + ], "any"), + "FormatException": o([ + { json: "count", js: "count", typ: i(0) }, + ], "any"), + "RegExp": o([ + { json: "active", js: "active", typ: true }, + ], "any"), + "Status": [ + "ready", + "done", + ], +}; diff --git a/head/schema-typescript-effect-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts b/head/schema-typescript-effect-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts new file mode 100644 index 0000000..e3da1d2 --- /dev/null +++ b/head/schema-typescript-effect-schema/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts @@ -0,0 +1,34 @@ +import * as S from "effect/Schema"; + + +export const Status = S.Literal( + "ready", + "done", +); +export type Status = S.Schema.Type; + +export class RegExp extends S.Class("RegExp")({ + "active": S.Boolean, +}) {} + +export class FormatException extends S.Class("FormatException")({ + "count": S.Int, +}) {} + +export class EnumValues extends S.Class("EnumValues")({ + "label": S.String, +}) {} + +export class DateTime extends S.Class("DateTime")({ + "value": S.Int, +}) {} + +export class TopLevel extends S.Class("TopLevel")({ + "code": S.String.pipe(S.minLength(1)).pipe(S.pattern(new RegExp("^[a-z]+$"))), + "dateTime": DateTime, + "enumValues": EnumValues, + "formatException": FormatException, + "regExp": RegExp, + "status": Status, + "timestamp": S.String.pipe(S.pattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/)), +}) {} diff --git a/head/schema-typescript-zod/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts new file mode 100644 index 0000000..fbbf2cd --- /dev/null +++ b/head/schema-typescript-zod/test/inputs/schema/dart-runtime-type-names.schema/default/TopLevel.ts @@ -0,0 +1,39 @@ +import * as z from "zod"; + + +export const StatusSchema = z.enum([ + "ready", + "done", +]); +export type Status = z.infer; + +export const DateTimeSchema = z.object({ + "value": z.number().int(), +}); +export type DateTime = z.infer; + +export const EnumValuesSchema = z.object({ + "label": z.string(), +}); +export type EnumValues = z.infer; + +export const FormatExceptionSchema = z.object({ + "count": z.number().int(), +}); +export type FormatException = z.infer; + +export const RegExpSchema = z.object({ + "active": z.boolean(), +}); +export type RegExp = z.infer; + +export const TopLevelSchema = z.object({ + "code": z.string().min(1).regex(new RegExp("^[a-z]+$")), + "dateTime": DateTimeSchema, + "enumValues": EnumValuesSchema, + "formatException": FormatExceptionSchema, + "regExp": RegExpSchema, + "status": StatusSchema, + "timestamp": z.coerce.date(), +}); +export type TopLevel = z.infer;