quicktype-core 23.0.32 → 23.0.33

package/dist/language/Rust.js

@@ -37,6 +37,54 @@ exports.rustOptions = {
     edition2018: new RendererOptions_1.BooleanOption("edition-2018", "Edition 2018", true),
     leadingComments: new RendererOptions_1.BooleanOption("leading-comments", "Leading Comments", true)
 };
+const namingStyles = {
+    "snake_case": {
+        regex: /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/,
+        toParts: (name) => name.split('_'),
+        fromParts: (parts) => parts.map(p => p.toLowerCase()).join('_'),
+    },
+    "SCREAMING_SNAKE_CASE": {
+        regex: /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/,
+        toParts: (name) => name.split('_'),
+        fromParts: (parts) => parts.map(p => p.toUpperCase()).join('_'),
+    },
+    "camelCase": {
+        regex: /^[a-z]+([A-Z0-9][a-z]*)*$/,
+        toParts: (name) => namingStyles.snake_case.toParts(name.replace(/(.)([A-Z])/g, "$1_$2")),
+        fromParts: (parts) => parts
+            .map((p, i) => i === 0
+            ? p.toLowerCase()
+            : p.substring(0, 1).toUpperCase() + p.substring(1).toLowerCase())
+            .join(''),
+    },
+    "PascalCase": {
+        regex: /^[A-Z][a-z]*([A-Z0-9][a-z]*)*$/,
+        toParts: (name) => namingStyles.snake_case.toParts(name.replace(/(.)([A-Z])/g, "$1_$2")),
+        fromParts: (parts) => parts
+            .map(p => p.substring(0, 1).toUpperCase() + p.substring(1).toLowerCase())
+            .join(''),
+    },
+    "kebab-case": {
+        regex: /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+        toParts: (name) => name.split('-'),
+        fromParts: (parts) => parts.map(p => p.toLowerCase()).join('-'),
+    },
+    "SCREAMING-KEBAB-CASE": {
+        regex: /^[A-Z][A-Z0-9]*(-[A-Z0-9]+)*$/,
+        toParts: (name) => name.split('-'),
+        fromParts: (parts) => parts.map(p => p.toUpperCase()).join('-'),
+    },
+    "lowercase": {
+        regex: /^[a-z][a-z0-9]*$/,
+        toParts: (name) => [name],
+        fromParts: (parts) => parts.map(p => p.toLowerCase()).join(''),
+    },
+    "UPPERCASE": {
+        regex: /^[A-Z][A-Z0-9]*$/,
+        toParts: (name) => [name],
+        fromParts: (parts) => parts.map(p => p.toUpperCase()).join(''),
+    },
+};
 class RustTargetLanguage extends TargetLanguage_1.TargetLanguage {
     makeRenderer(renderContext, untypedOptionValues) {
         return new RustRenderer(this, renderContext, (0, RendererOptions_1.getOptionValues)(exports.rustOptions, untypedOptionValues));
@@ -211,10 +259,12 @@ class RustRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         const isCycleBreaker = this.isCycleBreakerType(t);
         return isCycleBreaker ? ["Box<", rustType, ">"] : rustType;
     }
-    emitRenameAttribute(propName, jsonName) {
+    emitRenameAttribute(propName, jsonName, defaultNamingStyle, preferedNamingStyle) {
         const escapedName = rustStringEscape(jsonName);
-        const namesDiffer = this.sourcelikeToString(propName) !== escapedName;
-        if (namesDiffer || this._options.density === Density.Normal) {
+        const name = namingStyles[defaultNamingStyle].fromParts(this.sourcelikeToString(propName).split(" "));
+        const styledName = nameToNamingStyle(name, preferedNamingStyle);
+        const namesDiffer = escapedName !== styledName;
+        if (namesDiffer) {
             this.emitLine('#[serde(rename = "', escapedName, '")]');
         }
     }
@@ -230,10 +280,21 @@ class RustRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitStructDefinition(c, className) {
         this.emitDescription(this.descriptionForType(c));
         this.emitLine("#[derive(", this._options.deriveDebug ? "Debug, " : "", this._options.deriveClone ? "Clone, " : "", "Serialize, Deserialize)]");
+        // List the possible naming styles for every class property
+        const propertiesNamingStyles = {};
+        this.forEachClassProperty(c, "none", (_name, jsonName, _prop) => {
+            propertiesNamingStyles[jsonName] = listMatchingNamingStyles(jsonName);
+        });
+        // Set the default naming style on the struct
+        const defaultStyle = "snake_case";
+        const preferedNamingStyle = getPreferedNamingStyle(Object.values(propertiesNamingStyles).flat(), defaultStyle);
+        if (preferedNamingStyle !== defaultStyle) {
+            this.emitLine(`#[serde(rename_all = "${preferedNamingStyle}")]`);
+        }
         const blankLines = this._options.density === Density.Dense ? "none" : "interposing";
         const structBody = () => this.forEachClassProperty(c, blankLines, (name, jsonName, prop) => {
             this.emitDescription(this.descriptionForClassProperty(c, jsonName));
-            this.emitRenameAttribute(name, jsonName);
+            this.emitRenameAttribute(name, jsonName, defaultStyle, preferedNamingStyle);
             this.emitLine(this.visibility, name, ": ", this.breakCycle(prop.type, true), ",");
         });
         this.emitBlock(["pub struct ", className], structBody);
@@ -261,9 +322,20 @@ class RustRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
     emitEnumDefinition(e, enumName) {
         this.emitDescription(this.descriptionForType(e));
         this.emitLine("#[derive(", this._options.deriveDebug ? "Debug, " : "", this._options.deriveClone ? "Clone, " : "", "Serialize, Deserialize)]");
+        // List the possible naming styles for every enum case
+        const enumCasesNamingStyles = {};
+        this.forEachEnumCase(e, "none", (_name, jsonName) => {
+            enumCasesNamingStyles[jsonName] = listMatchingNamingStyles(jsonName);
+        });
+        // Set the default naming style on the enum
+        const defaultStyle = "PascalCase";
+        const preferedNamingStyle = getPreferedNamingStyle(Object.values(enumCasesNamingStyles).flat(), defaultStyle);
+        if (preferedNamingStyle !== defaultStyle) {
+            this.emitLine(`#[serde(rename_all = "${preferedNamingStyle}")]`);
+        }
         const blankLines = this._options.density === Density.Dense ? "none" : "interposing";
         this.emitBlock(["pub enum ", enumName], () => this.forEachEnumCase(e, blankLines, (name, jsonName) => {
-            this.emitRenameAttribute(name, jsonName);
+            this.emitRenameAttribute(name, jsonName, defaultStyle, preferedNamingStyle);
             this.emitLine([name, ","]);
         }));
     }
@@ -304,9 +376,35 @@ class RustRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitLine("use std::collections::HashMap;");
         }
         this.forEachTopLevel("leading", (t, name) => this.emitTopLevelAlias(t, name), t => this.namedTypeToNameForTopLevel(t) === undefined);
-        this.forEachObject("leading-and-interposing", (c, name) => this.emitStructDefinition(c, name));
-        this.forEachUnion("leading-and-interposing", (u, name) => this.emitUnion(u, name));
-        this.forEachEnum("leading-and-interposing", (e, name) => this.emitEnumDefinition(e, name));
+        this.forEachNamedType("leading-and-interposing", (c, name) => this.emitStructDefinition(c, name), (e, name) => this.emitEnumDefinition(e, name), (u, name) => this.emitUnion(u, name));
     }
 }
 exports.RustRenderer = RustRenderer;
+function getPreferedNamingStyle(namingStyleOccurences, defaultStyle) {
+    const occurrences = Object.fromEntries(Object.keys(namingStyles).map(key => [key, 0]));
+    namingStyleOccurences
+        .forEach(style => ++occurrences[style]);
+    const max = Math.max(...Object.values(occurrences));
+    const preferedStyles = Object.entries(occurrences)
+        .filter(([_style, num]) => num === max)
+        .map(([style, _num]) => style);
+    if (preferedStyles.includes(defaultStyle)) {
+        return defaultStyle;
+    }
+    return preferedStyles[0];
+}
+function listMatchingNamingStyles(name) {
+    return Object.entries(namingStyles)
+        .filter(([_, { regex }]) => regex.test(name))
+        .map(([namingStyle, _]) => namingStyle);
+}
+function nameToNamingStyle(name, style) {
+    if (namingStyles[style].regex.test(name)) {
+        return name;
+    }
+    const fromStyle = listMatchingNamingStyles(name)[0];
+    if (fromStyle === undefined) {
+        return name;
+    }
+    return namingStyles[style].fromParts(namingStyles[fromStyle].toParts(name));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "23.0.32",
+    "version": "23.0.33",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",