@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/cdh/generators/rust/MANIFEST.toml

@@ -1,18 +0,0 @@
-[plugin]
-name = "rust"
-display_name = "Rust"
-file_extension = ".rs"
-mime_type = "text/x-rust"
-default_outdir = "rust"
-output_filename_template = "{name}.rs"
-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/rust/template.rs.tmpl

@@ -1,16 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-use serde::{Deserialize, Serialize};
-use serde_json;
-{{if .HasDateTime}}use chrono::{DateTime, Utc};
-{{end}}{{if .HasUUID}}use uuid::Uuid;
-{{end}}
-{{range .Types}}#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct {{.Name}} {
-{{range .Properties}}    pub {{.Name}}: {{.OptionalType}},
-{{end}}}
-
-impl {{.Name}} {
-    pub fn schema_name() -> &'static str { "{{.Name}}" }
-}
-
-{{end}}

package/cdh/generators/scala/MANIFEST.toml

@@ -1,20 +0,0 @@
-[plugin]
-name = "scala"
-display_name = "Scala"
-file_extension = ".scala"
-mime_type = "text/x-scala"
-default_outdir = "scala"
-output_filename_template = "{name}.scala"
-package_name_default = "types"
-
-[features]
-enums = true
-allOf = true
-oneOf = true
-anyOf = true
-nullable = true
-format_hints = ["date-time", "uuid"]
-
-[imports]
-date-time = "import java.time.Instant"
-uuid = "import java.util.UUID"

package/cdh/generators/scala/template.scala.tmpl

@@ -1,13 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-package {{.PackageName}}
-
-import java.time.Instant
-import java.util.UUID
-import io.circe.{Codec, Decoder, Encoder}
-import io.circe.generic.semiauto._
-
-{{range .Types}}
-case class {{.Name}}(
-{{range .Properties}}  {{.Name}}: {{if .IsNullable}}Option[String]{{else}}String{{end}},
-{{end}})
-{{end}}

package/cdh/generators/scheme/MANIFEST.toml

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

package/cdh/generators/scheme/template.scm.tmpl

@@ -1,16 +0,0 @@
-;; Auto-generated from {{.SourceFile}}
-(define-module (types)
-  #:export ({{range .Types}}make-{{.Name}} {{end}}))
-
-{{range .Types}}
-(define-record-type {{.Name}}
-  ({{.Name}} {{range .Properties}}{{.Name}} {{end}})
-  {{.Name}}?
-{{range .Properties}}  ({{.Name}}-{{.Name}} {{.Name}}) {{end}})
-
-(define ({{.Name}}->alist x)
-  (list {{range .Properties}}(cons '{{.JsonName}}' ({{.Name}}-{{.Name}} x)) {{end}}))
-
-(define (alist->{{.Name}} alst)
-  ({{.Name}} {{range .Properties}}(cond ((assoc '{{.JsonName}} alst) => cdr) (else #f)) {{end}}))
-{{end}}

package/cdh/generators/solidity/MANIFEST.toml

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

package/cdh/generators/solidity/template.sol.tmpl

@@ -1,24 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-{{range .Types}}
-struct {{.Name}} {
-{{range .Properties}}    {{.Type}} {{.Name}};
-{{end}}}
-{{end}}
-
-library Types {
-{{range .Types}}    function toStruct({{.Name}} memory self) internal pure returns ({{.Name}} memory) {
-        return self;
-    }
-
-    function toJson({{.Name}} memory self) internal pure returns (bytes memory) {
-        return abi.encode(self);
-    }
-
-    function fromJson(bytes memory data) internal pure returns ({{.Name}} memory) {
-        return abi.decode(data, ({{.Name}}));
-    }
-{{end}}
-}

package/cdh/generators/swift/MANIFEST.toml

@@ -1,18 +0,0 @@
-[plugin]
-name = "swift"
-display_name = "Swift"
-file_extension = ".swift"
-mime_type = "text/x-swift"
-default_outdir = "swift"
-output_filename_template = "{name}.swift"
-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/swift/template.swift.tmpl

@@ -1,10 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-import Foundation
-
-public protocol GeneratedType: Codable {}
-
-{{range .Types}}public struct {{.Name}}: GeneratedType {
-{{range .Properties}}    public let {{.Name}}: {{.NullableType}}
-{{end}}}
-
-{{end}}

package/cdh/generators/typescript/MANIFEST.toml

@@ -1,18 +0,0 @@
-[plugin]
-name = "typescript"
-display_name = "TypeScript"
-file_extension = ".ts"
-mime_type = "text/typescript"
-default_outdir = "."
-output_filename_template = "{name}.ts"
-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/typescript/template.ts.tmpl

@@ -1,7 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-{{range .Types}}{{if .Description}}/** {{.Description}} */
-{{end}}export interface {{.Name}} {
-{{range .Properties}}  {{.JsonName}}{{if .IsNullable}}?{{end}}: {{.Type}};
-{{end}}}
-
-{{end}}

package/cdh/generators/version.py

@@ -1,214 +0,0 @@
-"""SemVer 2.0 parsing, comparison, and dependency resolution for aidlc plugins.
-
-Usage::
-
-    from cdh.generators.version import SemVer, resolve_dependencies
-    v1 = SemVer.from_string("1.2.3")
-    v2 = SemVer.from_string("2.0.0-alpha.1")
-    print(v1 < v2)  # True
-
-    deps = [{"name": "kotlin", "version": ">=1.0.0"}, {"name": "jvm", "version": "^2.0.0"}]
-    resolved = resolve_dependencies(deps, available={"kotlin": SemVer("1.5.0"), "jvm": SemVer("2.1.0")})
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import Iterable
-
-__all__ = ["SemVer", "VersionSpec", "resolve_dependencies", "parse_version_spec"]
-
-
-@dataclass(frozen=True, order=True)
-class SemVer:
-    """Semantic version 2.0.0."""
-
-    major: int
-    minor: int
-    patch: int
-    pre: tuple[str, ...] = ()
-    build: tuple[str, ...] = ()
-
-    _RE = re.compile(
-        r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"
-        r"(?:-(?P<pre>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
-        r"(?:\+(?P<build>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?$"
-    )
-
-    @classmethod
-    def from_string(cls, s: str) -> "SemVer":
-        m = cls._RE.match(s.strip())
-        if not m:
-            raise ValueError(f"Invalid semver: {s!r}")
-        pre = tuple(m["pre"].split(".")) if m["pre"] else ()
-        build = tuple(m["build"].split(".")) if m["build"] else ()
-        return cls(
-            major=int(m["major"]),
-            minor=int(m["minor"]),
-            patch=int(m["patch"]),
-            pre=pre,
-            build=build,
-        )
-
-    def __str__(self) -> str:
-        base = f"{self.major}.{self.minor}.{self.patch}"
-        if self.pre:
-            base += "-" + ".".join(self.pre)
-        if self.build:
-            base += "+" + ".".join(self.build)
-        return base
-
-    def satisfies(self, spec: "VersionSpec") -> bool:
-        return spec.matches(self)
-
-
-@dataclass(frozen=True)
-class VersionSpec:
-    """A version constraint like ^1.0.0, >=2.0.0, <3.0.0."""
-
-    op: str
-    version: SemVer
-
-    _OPS = {"==", "!=", ">=", "<=", ">", "<", "~>", "^", "="}
-
-    @classmethod
-    def parse(cls, s: str) -> "VersionSpec":
-        s = s.strip()
-        if s.startswith((">=", "<=", "==", "!=", ">", "<", "~>", "^")):
-            op = s[:2] if s.startswith((">=", "<=", "==", "!=", "~>", "^")) else s[:1]
-            ver_str = s[len(op):]
-        elif s.startswith("="):
-            op, ver_str = "==", s[1:]
-        else:
-            raise ValueError(f"Cannot parse version spec: {s!r}")
-        return cls(op=op, version=SemVer.from_string(ver_str.strip()))
-
-    def matches(self, v: SemVer) -> bool:
-        base = self.version
-        if self.op == "==":
-            return v == base
-        if self.op == "!=":
-            return v != base
-        if self.op == ">":
-            return v > base
-        if self.op == ">=":
-            return v >= base
-        if self.op == "<":
-            return v < base
-        if self.op == "<=":
-            return v <= base
-        if self.op == "^":
-            return v.major == base.major and (v.minor > base.minor or (v.minor == base.minor and v.patch >= base.patch))
-        if self.op == "~>":
-            return v.major == base.major and v.minor == base.minor and v.patch >= base.patch
-        if self.op == "=":
-            return v == base
-        raise ValueError(f"Unknown op: {self.op!r}")
-
-
-def parse_version_spec(constraint: str) -> VersionSpec:
-    """Parse a single version constraint string."""
-    return VersionSpec.parse(constraint)
-
-
-def resolve_dependencies(
-    deps: Iterable[dict[str, str]],
-    available: dict[str, SemVer],
-) -> dict[str, SemVer]:
-    """Resolve plugin dependencies.
-
-    Args:
-        deps: Iterable of {"name": str, "version": str} constraints
-        available: Map of plugin name -> installed SemVer
-
-    Returns:
-        Dict of plugin name -> resolved SemVer that satisfies constraints
-
-    Raises:
-        ValueError: If a dependency cannot be satisfied
-    """
-    resolved: dict[str, SemVer] = {}
-    for dep in deps:
-        name = dep.get("name") or dep.get("plugin")
-        constraint_str = dep.get("version") or dep.get("spec") or ">=0.0.0"
-        if not name:
-            continue
-
-        if name in resolved:
-            continue
-
-        if name not in available:
-            raise ValueError(f"Dependency {name} {constraint_str} not available")
-
-        spec = parse_version_spec(constraint_str)
-        candidate = available[name]
-
-        if not spec.matches(candidate):
-            raise ValueError(
-                f"Plugin {name}@{candidate} does not satisfy {spec.op}{spec.version} "
-                f"(available: {name}@{candidate})"
-            )
-
-        resolved[name] = candidate
-
-    return resolved
-
-
-class PluginRegistry:
-    """Plugin registry with version tracking and dependency resolution."""
-
-    def __init__(self):
-        self._plugins: dict[str, dict[str, SemVer | list[dict[str, str]]]] = {}
-
-    def add_plugin(
-        self,
-        name: str,
-        version: SemVer,
-        dependencies: list[dict[str, str]] | None = None,
-    ) -> None:
-        self._plugins[name] = {
-            "version": version,
-            "dependencies": dependencies or [],
-        }
-
-    def get_version(self, name: str) -> SemVer | None:
-        entry = self._plugins.get(name)
-        return entry["version"] if entry else None
-
-    def get_dependencies(self, name: str) -> list[dict[str, str]]:
-        entry = self._plugins.get(name)
-        return entry["dependencies"] if entry else []
-
-    def resolve_all(self) -> dict[str, SemVer]:
-        """Resolve all plugins and their transitive dependencies."""
-        resolved: dict[str, SemVer] = {}
-        to_resolve: list[tuple[str, list[dict[str, str]]]] = [
-            (name, deps) for name, info in self._plugins.items()
-            for deps in [info["dependencies"]]
-        ]
-
-        while to_resolve:
-            name, deps = to_resolve.pop(0)
-            if name in resolved:
-                continue
-            version = self.get_version(name)
-            if version is None:
-                raise ValueError(f"Plugin {name} not found in registry")
-            resolved[name] = version
-            for dep in deps:
-                dep_name = dep.get("name") or dep.get("plugin")
-                if dep_name:
-                    dep_deps = self.get_dependencies(dep_name)
-                    to_resolve.append((dep_name, dep_deps))
-
-        return resolved
-
-    def check_conflicts(self, selected: dict[str, SemVer]) -> list[str]:
-        """Check for version conflicts in selected plugins."""
-        conflicts: list[str] = []
-        for name, version in selected.items():
-            current = self.get_version(name)
-            if current and current != version:
-                conflicts.append(f"{name}: tried to set {version} but registry has {current}")
-        return conflicts

package/cdh/generators/zig/MANIFEST.toml

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

package/cdh/generators/zig/template.zig.tmpl

@@ -1,20 +0,0 @@
-// Auto-generated from {{.SourceFile}}
-const std = @import("std");
-const json = std.json;
-
-{{range .Types}}
-pub const {{.Name}} = struct {
-{{range .Properties}}    {{.Name}}: {{if .IsNullable}}?[]const u8{{else}}[]const u8{{end}},
-{{end}}};
-
-pub fn {{.Name}}_from_json(allocator: std.mem.Allocator, json_str: []const u8) !{{.Name}} {
-    const parsed = try json.parseFromSlice({{.Name}}, allocator, json_str);
-    return parsed.value;
-}
-
-pub fn {{.Name}}_to_json(allocator: std.mem.Allocator, obj: {{.Name}}) ![]u8 {
-    var buf = std.ArrayList(u8).init(allocator);
-    try json.stringify(allocator, obj, buf.writer());
-    return buf.toOwnedSlice();
-}
-{{end}}