quicktype-core 7.0.22 → 7.0.24

package/dist/language/Golang.js

@@ -49,11 +49,6 @@ function isValueType(t) {
     const kind = t.kind;
     return primitiveValueTypeKinds.indexOf(kind) >= 0 || kind === "class" || kind === "enum";
 }
-function singleDescriptionComment(description) {
-    if (description === undefined)
-        return "";
-    return "// " + description.join("; ");
-}
 function canOmitEmpty(cp) {
     if (!cp.isOptional)
         return false;
@@ -189,10 +184,12 @@ class GoRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitPackageDefinitons(false);
         let columns = [];
         this.forEachClassProperty(c, "none", (name, jsonName, p) => {
+            const description = this.descriptionForClassProperty(c, jsonName);
+            const docStrings = description !== undefined && description.length > 0 ? description.map(d => "// " + d) : [];
             const goType = this.propertyGoType(p);
-            const comment = singleDescriptionComment(this.descriptionForClassProperty(c, jsonName));
             const omitEmpty = canOmitEmpty(p) ? ",omitempty" : [];
-            columns.push([[name, " "], [goType, " "], ['`json:"', Strings_1.stringEscape(jsonName), omitEmpty, '"`'], comment]);
+            docStrings.forEach(doc => columns.push([doc]));
+            columns.push([[name, " "], [goType, " "], ['`json:"', Strings_1.stringEscape(jsonName), omitEmpty, '"`']]);
         });
         this.emitDescription(this.descriptionForType(c));
         this.emitStruct(className, columns);

package/dist/language/ruby/index.d.ts

@@ -1,7 +1,7 @@
 import { Namer, Name } from "../../Naming";
 import { ConvenienceRenderer, ForbiddenWordsInfo } from "../../ConvenienceRenderer";
 import { TargetLanguage } from "../../TargetLanguage";
-import { Option, BooleanOption, EnumOption, OptionValues } from "../../RendererOptions";
+import { Option, BooleanOption, EnumOption, OptionValues, StringOption } from "../../RendererOptions";
 import { Type, ClassType } from "../../Type";
 import { RenderContext } from "../../Renderer";
 export declare enum Strictness {
@@ -12,6 +12,7 @@ export declare enum Strictness {
 export declare const rubyOptions: {
     justTypes: BooleanOption;
     strictness: EnumOption<Strictness>;
+    namespace: StringOption;
 };
 export declare class RubyTargetLanguage extends TargetLanguage {
     constructor();
@@ -42,6 +43,7 @@ export declare class RubyRenderer extends ConvenienceRenderer {
     private marshalsImplicitlyToDynamic;
     private propertyTypeMarshalsImplicitlyFromDynamic;
     private emitBlock;
+    private emitModule;
     private emitClass;
     private emitEnum;
     private emitUnion;

package/dist/language/ruby/index.js

@@ -27,14 +27,15 @@ exports.rubyOptions = {
         ["strict", Strictness.Strict],
         ["coercible", Strictness.Coercible],
         ["none", Strictness.None]
-    ])
+    ]),
+    namespace: new RendererOptions_1.StringOption("namespace", "Specify a wrapping Namespace", "NAME", "", "secondary")
 };
 class RubyTargetLanguage extends TargetLanguage_1.TargetLanguage {
     constructor() {
         super("Ruby", ["ruby"], "rb");
     }
     getOptions() {
-        return [exports.rubyOptions.justTypes, exports.rubyOptions.strictness];
+        return [exports.rubyOptions.justTypes, exports.rubyOptions.strictness, exports.rubyOptions.namespace];
     }
     get supportsOptionalClassProperties() {
         return true;
@@ -235,6 +236,25 @@ class RubyRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.indent(emit);
         this.emitLine("end");
     }
+    emitModule(emit) {
+        const emitModuleInner = (moduleName) => {
+            const [firstModule, ...subModules] = moduleName.split("::");
+            if (subModules.length > 0) {
+                this.emitBlock(["module ", firstModule], () => {
+                    emitModuleInner(subModules.join("::"));
+                });
+            }
+            else {
+                this.emitBlock(["module ", moduleName], emit);
+            }
+        };
+        if (this._options.namespace !== undefined && this._options.namespace !== "") {
+            emitModuleInner(this._options.namespace);
+        }
+        else {
+            emit();
+        }
+    }
     emitClass(c, className) {
         this.emitDescription(this.descriptionForType(c));
         this.emitBlock(["class ", className, " < Dry::Struct"], () => {
@@ -468,36 +488,45 @@ class RubyRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         this.emitLine("require 'dry-types'");
         this.emitLine("require 'dry-struct'");
         this.ensureBlankLine();
-        this.emitTypesModule();
-        this.forEachDeclaration("leading-and-interposing", decl => {
-            if (decl.kind === "forward") {
-                this.emitCommentLines(["(forward declaration)"]);
-                this.emitLine("class ", this.nameForNamedType(decl.type), " < Dry::Struct; end");
-            }
-        });
-        this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClass(c, n), (e, n) => this.emitEnum(e, n), (u, n) => this.emitUnion(u, n));
-        if (!this._options.justTypes) {
-            this.forEachTopLevel("leading-and-interposing", (topLevel, name) => {
-                const self = Source_1.modifySource(Strings_1.snakeCase, name);
-                // The json gem defines to_json on maps and primitives, so we only need to supply
-                // it for arrays.
-                const needsToJsonDefined = "array" === topLevel.kind;
-                this.emitBlock(["class ", name], () => {
-                    this.emitBlock(["def self.from_json!(json)"], () => {
-                        if (needsToJsonDefined) {
-                            this.emitLine(self, " = ", this.fromDynamic(topLevel, "JSON.parse(json, quirks_mode: true)"));
-                            this.emitBlock([self, ".define_singleton_method(:to_json) do"], () => {
-                                this.emitLine("JSON.generate(", this.toDynamic(topLevel, "self"), ")");
+        this.emitModule(() => {
+            this.emitTypesModule();
+            this.forEachDeclaration("leading-and-interposing", decl => {
+                if (decl.kind === "forward") {
+                    this.emitCommentLines(["(forward declaration)"]);
+                    this.emitModule(() => {
+                        this.emitLine("class ", this.nameForNamedType(decl.type), " < Dry::Struct; end");
+                    });
+                }
+            });
+            this.forEachNamedType("leading-and-interposing", (c, n) => this.emitClass(c, n), (e, n) => this.emitEnum(e, n), (u, n) => this.emitUnion(u, n));
+            if (!this._options.justTypes) {
+                this.forEachTopLevel("leading-and-interposing", (topLevel, name) => {
+                    const self = Source_1.modifySource(Strings_1.snakeCase, name);
+                    // The json gem defines to_json on maps and primitives, so we only need to supply
+                    // it for arrays.
+                    const needsToJsonDefined = "array" === topLevel.kind;
+                    const classDeclaration = () => {
+                        this.emitBlock(["class ", name], () => {
+                            this.emitBlock(["def self.from_json!(json)"], () => {
+                                if (needsToJsonDefined) {
+                                    this.emitLine(self, " = ", this.fromDynamic(topLevel, "JSON.parse(json, quirks_mode: true)"));
+                                    this.emitBlock([self, ".define_singleton_method(:to_json) do"], () => {
+                                        this.emitLine("JSON.generate(", this.toDynamic(topLevel, "self"), ")");
+                                    });
+                                    this.emitLine(self);
+                                }
+                                else {
+                                    this.emitLine(this.fromDynamic(topLevel, "JSON.parse(json, quirks_mode: true)"));
+                                }
                             });
-                            this.emitLine(self);
-                        }
-                        else {
-                            this.emitLine(this.fromDynamic(topLevel, "JSON.parse(json, quirks_mode: true)"));
-                        }
+                        });
+                    };
+                    this.emitModule(() => {
+                        classDeclaration();
                     });
-                });
-            }, t => this.namedTypeToNameForTopLevel(t) === undefined);
-        }
+                }, t => this.namedTypeToNameForTopLevel(t) === undefined);
+            }
+        });
     }
 }
 exports.RubyRenderer = RubyRenderer;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "quicktype-core",
-    "version": "7.0.22",
+    "version": "7.0.24",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -45,6 +45,6 @@
         "fs": false
     },
     "config": {
-        "commit": "e6d9552bcb36d29258d8750515d2a0af310aefcd"
+        "commit": "2dc22cb8dee03e613da69ca99ab2b4057f5bf68a"
     }
 }