@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/cdh/generators/nim/template.nim.tmpl

@@ -0,0 +1,12 @@
+# Auto-generated from {{.SourceFile}}
+import std/[json, options, strutils]
+
+{{range .Types}}type
+  {{.Name}}* = object
+{{range .Properties}}    {{.Name}}*: {{if .IsNullable}}Option[string]{{else}}string{{end}}
+{{end}}
+
+proc `$`*(x: {{.Name}}): string = "TODO"
+proc toJson*(x: {{.Name}}): JsonNode = newJObject()
+proc fromJson*(x: var {{.Name}}, json: JsonNode) = discard
+{{end}}

package/cdh/generators/nix/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for nix
+[plugin]
+name = "nix"
+display_name = "Nix"
+file_extension = ".nix"
+mime_type = "text/x-nix"
+default_outdir = "nix"
+output_filename_template = "{name}}.nix"
+package_name_default = "types"
+
+[features]
+enums = false
+nullable = true
+format_hints = ["date-time", "uuid"]

package/cdh/generators/nix/template.nix.tmpl

@@ -0,0 +1,8 @@
+# Auto-generated from {{.SourceFile}}
+{ lib }:
+
+{
+{{range .Types}}  {{.Name}} = {
+{{range .Properties}}    {{.Name}} = {{if .IsNullable}}"''${toString null}''"{{else}}""{{end}};
+{{end}}  };
+{{end}}}

package/cdh/generators/objective-c/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for objective-c
+[plugin]
+name = "objective-c"
+display_name = "Objective-C"
+file_extension = ".m"
+mime_type = "text/x-objective-c"
+default_outdir = "objc"
+output_filename_template = "{name}}.h"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/objective-c/template.m.tmpl

@@ -0,0 +1,31 @@
+// Auto-generated from {{.SourceFile}}
+#import <Foundation/Foundation.h>
+
+{{range .Types}}
+@interface {{.Name}} : NSObject
+
+{{range .Properties}}
+@property (nonatomic, {{if .IsNullable}}nullable{{end}}) NSString *{{.Name}};
+{{end}}
+
++ (instancetype)fromJson:(NSDictionary *)json;
+- (NSDictionary *)toJson;
+
+@end
+
+@implementation {{.Name}}
+
++ (instancetype)fromJson:(NSDictionary *)json {
+    {{.Name}} *instance = [[{{.Name}} alloc] init];
+{{range .Properties}}    instance.{{.Name}} = json[@"{{.JsonName}}"];
+{{end}}    return instance;
+}
+
+- (NSDictionary *)toJson {
+    return @{
+{{range .Properties}}        @"{{.JsonName}}": self.{{.Name}} ?: [NSNull null],
+{{end}}    };
+}
+
+@end
+{{end}}

package/cdh/generators/ocaml/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for ocaml
+[plugin]
+name = "ocaml"
+display_name = "OCaml"
+file_extension = ".ml"
+mime_type = "text/x-ocaml"
+default_outdir = "ocaml"
+output_filename_template = "{name}}.ml"
+package_name_default = "types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/ocaml/template.ml.tmpl

@@ -0,0 +1,13 @@
+(* Auto-generated from {{.SourceFile}} *)
+open Yojson
+
+module Types = struct
+{{range .Types}}
+  type {{.Name | lower}} = {
+{{range .Properties}}    {{.Name | lower}} : {{if .IsNullable}}string option{{else}}string{{end}}{{end}}
+  }
+
+  let {{.Name | lower}}_of_json (json : Yojson.Safe.t) =
+{{range .Properties}}    {{.Name | lower}} : (json |> Yojson.Safe.Util.member "{{.JsonName}}" |> Yojson.Safe.Util.to_string_option){{end}}
+{{end}}
+end

package/cdh/generators/pascal/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for pascal
+[plugin]
+name = "pascal"
+display_name = "Pascal"
+file_extension = ".pas"
+mime_type = "text/x-pascal"
+default_outdir = "pascal"
+output_filename_template = "{name}}.pas"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = false
+format_hints = ["date-time", "uuid"]

package/cdh/generators/pascal/template.pas.tmpl

@@ -0,0 +1,5 @@
+{{range .Types}}type
+  {{.Name}} = class
+{{range .Properties}}    F{{.Name}}: string;
+{{end}}  end;
+{{end}}

package/cdh/generators/perl/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for perl
+[plugin]
+name = "perl"
+display_name = "Perl"
+file_extension = ".pm"
+mime_type = "text/x-perl"
+default_outdir = "perl"
+output_filename_template = "{name}}.pm"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/perl/template.pm.tmpl

@@ -0,0 +1,27 @@
+# Auto-generated from {{.SourceFile}}
+package Types;
+use strict;
+use warnings;
+use JSON;
+{{range .Types}}
+
+package Types::{{.Name}};
+use strict;
+use warnings;
+use parent 'JSON::Class';
+
+{{range .Properties}}
+has '{{.Name}}' => (
+    is => 'rw',
+    isa => '{{if .IsNullable}}Str|Undef{{else}}Str{{end}}',
+    json_key => '{{.JsonName}}',
+);
+{{end}}
+
+__PACKAGE__->meta->setup;
+__PACKAGE__->register_class;
+
+package Types;
+{{end}}
+
+1;

package/cdh/generators/php/MANIFEST.toml

@@ -0,0 +1,17 @@
+[plugin]
+name = "php"
+display_name = "PHP"
+file_extension = ".php"
+mime_type = "text/x-php"
+default_outdir = "php"
+output_filename_template = "{name}.php"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid"]
+
+[imports]
+date-time = "use DateTimeImmutable;"
+uuid = "use Ramsey\\Uuid\\Uuid;"

package/cdh/generators/php/template.php.tmpl

@@ -0,0 +1,31 @@
+<?php
+// Auto-generated from {{.SourceFile}}
+
+{{range .Types}}
+class {{.Name}} implements \JsonSerializable
+{
+{{range .Properties}}    public ?string ${{.Name}};
+{{end}}
+
+    public function __construct(
+{{range .Properties}}        {{if .IsNullable}}?{{end}}string ${{.Name}},
+{{end}}    )
+    {
+{{range .Properties}}        $this->{{.Name}} = ${{.Name}};
+{{end}}    }
+
+    public static function fromJson(array $json): self
+    {
+        return new self(
+{{range .Properties}}            $json['{{.JsonName}}'] ?? null,
+{{end}}        );
+    }
+
+    public function jsonSerialize(): array
+    {
+        return [
+{{range .Properties}}            '{{.JsonName}}' => $this->{{.Name}},
+{{end}}        ];
+    }
+}
+{{end}}

package/cdh/generators/powershell/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for powershell
+[plugin]
+name = "powershell"
+display_name = "PowerShell"
+file_extension = ".ps1"
+mime_type = "text/x-powershell"
+default_outdir = "powershell"
+output_filename_template = "{name}}.ps1"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/powershell/template.ps1.tmpl

@@ -0,0 +1,20 @@
+# Auto-generated from {{.SourceFile}}
+using module Newtonsoft.Json
+
+{{range .Types}}
+class {{.Name}} {
+{{range .Properties}}    [{{if .IsNullable}}string{{else}}string{{end}}]${{.Name}}
+{{end}}
+
+    {{.Name}}() {}
+
+    static [{{.Name}}] FromJson([string]$json) {
+        $obj = [JsonConvert]::DeserializeObject($json, [{{.Name}}]::class)
+        return $obj
+    }
+
+    [string] ToJson() {
+        return [JsonConvert]::SerializeObject($this)
+    }
+}
+{{end}}

package/cdh/generators/protobuf/MANIFEST.toml

@@ -0,0 +1,18 @@
+[plugin]
+name = "protobuf"
+display_name = "Protocol Buffers"
+file_extension = ".proto"
+mime_type = "text/x-protobuf"
+default_outdir = "protobuf"
+output_filename_template = "{name}.proto"
+package_name_default = "types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+readOnly = true
+writeOnly = true
+format_hints = ["date-time", "uuid", "email", "uri", "double"]

package/cdh/generators/protobuf/template.proto.tmpl

@@ -0,0 +1,13 @@
+// Auto-generated from {{.SourceFile}}
+syntax = "proto3";
+
+package {{.PackageName}};
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+
+{{range .Types}}message {{.Name}} {
+{{range .Properties}}  {{.Type}} {{.Name}} = {{.Index}};
+{{end}}}
+
+{{end}}

package/cdh/generators/python/MANIFEST.toml

@@ -0,0 +1,18 @@
+[plugin]
+name = "python"
+display_name = "Python"
+file_extension = ".py"
+mime_type = "text/x-python"
+default_outdir = "."
+output_filename_template = "{name}.py"
+package_name_default = "types"
+
+[features]
+enums = true
+allOf = true
+oneOf = true
+anyOf = true
+nullable = true
+readOnly = true
+writeOnly = true
+format_hints = ["date-time", "uuid", "email", "uri", "double"]

package/cdh/generators/python/template.py.tmpl

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date, datetime, time
+from typing import Any, Literal, Optional, Union
+
+{{range .Types}}{{if .Description}}"""{{.Description}}"""
+{{end}}@dataclass
+class {{.Name}}:
+{{range .Properties}}    {{.Name}}: {{if .IsNullable}}Optional[{{.Type}}] = None{{else}}{{.Type}}{{end}}
+{{end}}
+{{end}}

package/cdh/generators/r/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for r
+[plugin]
+name = "r"
+display_name = "R"
+file_extension = ".R"
+mime_type = "text/x-r"
+default_outdir = "r"
+output_filename_template = "{name}}.R"
+package_name_default = "types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/r/template.R.tmpl

@@ -0,0 +1,29 @@
+# Auto-generated from {{.SourceFile}}
+#' @title {{.Name}} class
+#' @description Auto-generated R class for {{.SourceFile}}
+#' @slot name Character
+#' @slot properties List
+{{range .Types}}
+#' @rdname {{.Name}}
+#' @export
+{{.Name}} <- setClass(
+  "{{.Name}}",
+{{range .Properties}}  "{{.Name}}" = {{if .IsNullable}}"character"{{else}}"character"{{end}},
+{{end}}
+  prototype = prototype(
+{{range .Properties}}    {{.Name}} = NA_character_,
+{{end}}  )
+)
+
+#' @export
+from_json_{{.Name}} <- function(json_str) {
+  json <- jsonlite::fromJSON(json_str)
+{{range .Properties}}  {{.Name}} = json${{.JsonName}}{{end}}
+  new("{{.Name}}"{{range .Properties}}, {{.Name}} = {{.Name}}{{end}})
+}
+
+#' @export
+to_json_{{.Name}} <- function(obj) {
+  jsonlite::toJSON(as.list(obj), auto_unbox = TRUE)
+}
+{{end}}

package/cdh/generators/racket/MANIFEST.toml

@@ -0,0 +1,14 @@
+# Plugin manifest for racket
+[plugin]
+name = "racket"
+display_name = "Racket"
+file_extension = ".rkt"
+mime_type = "text/x-racket"
+default_outdir = "racket"
+output_filename_template = "{name}}.rkt"
+package_name_default = "types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid", "email"]

package/cdh/generators/racket/template.rkt.tmpl

@@ -0,0 +1,15 @@
+#lang racket
+;; Auto-generated from {{.SourceFile}}
+
+(module+ types
+  (provide {{range .Types}}{{.Name}} {{end}})
+
+{{range .Types}}
+  (struct {{.Name}} ({{range .Properties}}{{.Name}} {{end}}) #:prefab)
+
+  (define (json->{{.Name}} j)
+    ({{.Name}} {{range .Properties}}(hash-ref j '{{.JsonName}}) {{end}}))
+
+  (define ({{.Name}}->json x)
+    (hasheq {{range .Properties}}'{{.JsonName}}' ({{.Name}}-{{.Name}} x) {{end}}))
+{{end}}

package/cdh/generators/registry.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+
+DEFAULT_GENERATORS_DIR = Path(__file__).parent
+
+
+class TemplateError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class PluginManifest:
+    name: str
+    display_name: str
+    file_extension: str
+    mime_type: str
+    default_outdir: str
+    output_filename_template: str
+    package_name_default: str
+    supports: tuple[str, ...]
+    format_hints: tuple[str, ...]
+    imports: Mapping[str, str]
+    directory: Path
+    template_path: Path
+    imports_template_path: Path | None = None
+
+    @property
+    def template_file(self) -> Path:
+        return self.template_path
+
+
+def _load_manifest(directory: Path) -> PluginManifest:
+    manifest_path = directory / "MANIFEST.toml"
+    try:
+        document = tomllib.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as exc:
+        raise ValueError(f"Invalid plugin manifest {manifest_path}: {exc}") from exc
+    plugin = document.get("plugin", {})
+    features = document.get("features", {})
+    required = ("name", "display_name", "file_extension")
+    missing = [key for key in required if not plugin.get(key)]
+    if missing:
+        raise ValueError(f"Plugin manifest {manifest_path} is missing: {', '.join(missing)}")
+    templates = sorted(directory.glob("template.*.tmpl"))
+    if len(templates) != 1:
+        raise ValueError(f"Plugin {plugin['name']} must contain exactly one template.*.tmpl")
+    extension = str(plugin["file_extension"])
+    if not extension.startswith("."):
+        extension = f".{extension}"
+    supported = tuple(
+        key for key in ("enums", "allOf", "oneOf", "anyOf", "nullable", "readOnly", "writeOnly")
+        if bool(features.get(key, False))
+    )
+    imports_template = directory / "imports.go.tmpl"
+    return PluginManifest(
+        name=str(plugin["name"]),
+        display_name=str(plugin["display_name"]),
+        file_extension=extension,
+        mime_type=str(plugin.get("mime_type", "text/plain")),
+        default_outdir=str(plugin.get("default_outdir", plugin["name"])),
+        output_filename_template=str(plugin.get("output_filename_template", "{name}" + extension)),
+        package_name_default=str(plugin.get("package_name_default", "types")),
+        supports=supported,
+        format_hints=tuple(str(value) for value in features.get("format_hints", [])),
+        imports={str(key): str(value) for key, value in document.get("imports", {}).items()},
+        directory=directory,
+        template_path=templates[0],
+        imports_template_path=imports_template if imports_template.is_file() else None,
+    )
+
+
+def discover_plugins(generators_dir: Path = DEFAULT_GENERATORS_DIR) -> dict[str, PluginManifest]:
+    directory = Path(generators_dir).expanduser().resolve()
+    if not directory.is_dir():
+        raise ValueError(f"Generators directory does not exist: {directory}")
+    plugins: dict[str, PluginManifest] = {}
+    for child in sorted(directory.iterdir()):
+        if not child.is_dir() or not (child / "MANIFEST.toml").is_file():
+            continue
+        manifest = _load_manifest(child)
+        if manifest.name in plugins:
+            raise ValueError(f"Duplicate plugin name: {manifest.name}")
+        plugins[manifest.name] = manifest
+    return plugins
+
+
+LANGUAGE_RENDERERS: dict[str, PluginManifest] = discover_plugins()
+_ACTIVE_RENDERERS = dict(LANGUAGE_RENDERERS)
+
+
+_TOKEN_RE = re.compile(r"\{\{(?P<trim_l>-)?\s*(?P<body>.+?)\s*(?P<trim_r>-)?\}\}", re.DOTALL)
+
+
+def _lookup(context: Any, path: str) -> Any:
+    if path == ".":
+        return context
+    current = context
+    for part in path.lstrip(".").split("."):
+        if not part:
+            continue
+        if isinstance(current, Mapping):
+            current = current.get(part)
+        else:
+            current = getattr(current, part, None)
+    return current
+
+
+def _truthy(value: Any) -> bool:
+    return bool(value)
+
+
+def _matching_end(tokens: list[tuple[int, str]], start: int) -> tuple[int, int | None]:
+    """Find matching {{end}} for a block starting at token index start."""
+    depth = 0
+    else_idx: int | None = None
+    for i in range(start + 1, len(tokens)):
+        _, body = tokens[i]
+        stripped = body.strip()
+        if stripped.startswith("if ") or stripped.startswith("range "):
+            depth += 1
+        elif stripped == "end":
+            if depth == 0:
+                return i, else_idx
+            depth -= 1
+        elif stripped == "else" and depth == 0:
+            else_idx = i
+    raise TemplateError(f"Unclosed block: {tokens[start]!r}")
+
+
+def _render_tokens(tokens: list[tuple[int, str]], context: Any, root: Mapping[str, Any]) -> str:
+    output: list[str] = []
+    i = 0
+    while i < len(tokens):
+        kind, body = tokens[i]
+        stripped = body.strip()
+        if kind == 0:  # text
+            output.append(body)
+        elif stripped.startswith("range "):
+            end, else_idx = _matching_end(tokens, i)
+            values = _lookup(context, stripped[6:].strip()) or []
+            inner_tokens = tokens[i + 1:end]
+            if values:
+                for item in values:
+                    output.append(_render_tokens(inner_tokens, item, root))
+            elif else_idx is not None:
+                output.append(_render_tokens(tokens[else_idx + 1:end], context, root))
+            i = end + 1
+        elif stripped.startswith("if "):
+            end, else_idx = _matching_end(tokens, i)
+            value = _lookup(context, stripped[3:].strip())
+            if _truthy(value):
+                branch = tokens[i + 1:else_idx] if else_idx is not None else tokens[i + 1:end]
+                output.append(_render_tokens(branch, context, root))
+            elif else_idx is not None:
+                output.append(_render_tokens(tokens[else_idx + 1:end], context, root))
+            i = end
+        elif stripped in ("else", "end"):
+            pass
+        else:
+            value = _lookup(context, body)
+            if value is None and context is not root:
+                value = _lookup(root, body)
+            output.append("" if value is None else str(value))
+        i += 1
+    return "".join(output)
+
+
+def _tokenize(template: str) -> list[tuple[int, str]]:
+    """Tokenize: 0=text, 1=action. Tracks {{ }} bodies."""
+    tokens: list[tuple[int, str]] = []
+    last_end = 0
+    for m in _TOKEN_RE.finditer(template):
+        text = template[last_end:m.start()]
+        if text:
+            tokens.append((0, text))
+        tokens.append((1, m.group("body").strip()))
+        last_end = m.end()
+    remainder = template[last_end:]
+    if remainder:
+        tokens.append((0, remainder))
+    return tokens
+
+
+def _render_template(template: str, context: Mapping[str, Any]) -> str:
+    return _render_tokens(_tokenize(template), context, context)
+
+
+def set_plugins(plugins: dict[str, PluginManifest]) -> None:
+    _ACTIVE_RENDERERS.clear()
+    _ACTIVE_RENDERERS.update(plugins)
+
+
+def render(plugin_name: str, context: dict[str, Any]) -> str:
+    try:
+        plugin = _ACTIVE_RENDERERS[plugin_name]
+    except KeyError as exc:
+        raise ValueError(f"Unknown generator plugin: {plugin_name}") from exc
+    values = dict(context)
+    values.setdefault("PackageName", plugin.package_name_default)
+    imports_str = ""
+    if plugin.imports_template_path:
+        imports_str = _render_template(plugin.imports_template_path.read_text(encoding="utf-8"), values)
+    values["Imports"] = imports_str.rstrip()
+    result = _render_template(plugin.template_path.read_text(encoding="utf-8"), values)
+    return result.rstrip() + "\n"

package/cdh/generators/ruby/MANIFEST.toml

@@ -0,0 +1,17 @@
+[plugin]
+name = "ruby"
+display_name = "Ruby"
+file_extension = ".rb"
+mime_type = "text/x-ruby"
+default_outdir = "ruby"
+output_filename_template = "{name}.rb"
+package_name_default = "Types"
+
+[features]
+enums = true
+nullable = true
+format_hints = ["date-time", "uuid"]
+
+[imports]
+date-time = "require 'time'"
+uuid = "require 'uuid'"

package/cdh/generators/ruby/template.rb.tmpl

@@ -0,0 +1,27 @@
+# Auto-generated from {{.SourceFile}}
+require 'json'
+require 'time'
+require 'uuid'
+
+{{range .Types}}
+class {{.Name}}
+{{range .Properties}}  attr_accessor :{{.Name}}
+{{end}}
+
+  def initialize({{range .Properties}}{{.Name}}: nil,
+{{end}}  )
+{{range .Properties}}    @{{.Name}} = {{.Name}}
+{{end}}  end
+
+  def self.from_json(json)
+    new({{range .Properties}}{{.Name}}: json['{{.JsonName}}'],
+{{end}}  )
+  end
+
+  def to_json(*_args)
+    JSON.generate({
+{{range .Properties}}      '{{.JsonName}}' => @{{.Name}},
+{{end}}    })
+  end
+end
+{{end}}