@scemoon/cdh 1.0.9 → 1.0.10-beta.1

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

@@ -1,12 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,31 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-(* 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

@@ -1,14 +0,0 @@
-# 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

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

package/cdh/generators/perl/MANIFEST.toml

@@ -1,14 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-[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

@@ -1,31 +0,0 @@
-<?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

@@ -1,14 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-[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

@@ -1,13 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-[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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-# 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

@@ -1,29 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,15 +0,0 @@
-#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

@@ -1,211 +0,0 @@
-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

@@ -1,17 +0,0 @@
-[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

@@ -1,27 +0,0 @@
-# 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}}