quicktype-core 7.0.23 → 7.0.25

package/dist/language/CPlusPlus.js

@@ -1343,6 +1343,20 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitConstraintClasses();
             this.ensureBlankLine();
         }
+        this.ensureBlankLine();
+        var untypedMacroName = new String("NLOHMANN_UNTYPED_");
+        var optionalMacroName = new String("NLOHMANN_OPTIONAL_");
+        this._namespaceNames.forEach(function (value) {
+            // We can't use upper name, because namespaces are case sensitive
+            untypedMacroName += value;
+            untypedMacroName += "_";
+            optionalMacroName += value;
+            optionalMacroName += "_";
+        });
+        untypedMacroName += "HELPER";
+        untypedMacroName += "HELPER";
+        this.emitLine("#ifndef " + untypedMacroName);
+        this.emitLine("#define " + untypedMacroName);
         this.emitBlock([
             "inline json get_untyped(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"
         ], false, () => {
@@ -1357,8 +1371,12 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
         ], false, () => {
             this.emitLine("return get_untyped(j, property.data());");
         });
+        this.emitLine("#endif");
         this.ensureBlankLine();
         if (this.haveUnions || this.haveOptionalProperties) {
+            this.ensureBlankLine();
+            this.emitLine("#ifndef " + optionalMacroName);
+            this.emitLine("#define " + optionalMacroName);
             this.emitLine("template <typename T>");
             this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, ", this.withConst("char"), " * property)"], false, () => {
                 this.emitBlock(["if (j.find(property) != j.end())"], false, () => {
@@ -1371,6 +1389,7 @@ class CPlusPlusRenderer extends ConvenienceRenderer_1.ConvenienceRenderer {
             this.emitBlock(["inline ", optionalType, "<T> get_optional(", this.withConst("json"), " & j, std::string property)"], false, () => {
                 this.emitLine("return get_optional<T>(j, property.data());");
             });
+            this.emitLine("#endif");
             this.ensureBlankLine();
         }
     }

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.23",
+    "version": "7.0.25",
     "description": "The quicktype engine as a library",
     "license": "Apache-2.0",
     "main": "dist/index.js",
@@ -45,6 +45,6 @@
         "fs": false
     },
     "config": {
-        "commit": "740de7cea038033d9d2b00188c685ca3d4802773"
+        "commit": "e9e68d71ededf2006e3470a1a3816308643301fa"
     }
 }