templates refactor, pure file-based, reduce redundancy naming <-> templates

Author: MS-32154

json_explorer/codegen/core/__init__.py

@@ -14,7 +14,7 @@
 )
 from .naming import NameSanitizer, NamingCase
 from .config import GeneratorConfig, ConfigManager, ConfigError, load_config
-from .templates import TemplateEngine, TemplateError, get_default_template_engine
+from .templates import TemplateEngine, TemplateError, create_template_engine
 
 __all__ = [
     # Base generator interface
@@ -36,8 +36,8 @@
     "ConfigManager",
     "ConfigError",
     "load_config",
-    # Template system
+    # Template system - language-agnostic
     "TemplateEngine",
     "TemplateError",
-    "get_default_template_engine",
+    "create_template_engine",
 ]

json_explorer/codegen/core/generator.py

@@ -2,12 +2,13 @@
 Base generator interface for all code generation targets.
 
 Defines the contract that all language generators must implement.
-Focuses on schema-level concerns while leaving type mapping to language generators.
 """
 
 from abc import ABC, abstractmethod
 from typing import Dict, List, Any, Optional
+from pathlib import Path
 from .schema import Schema, Field, FieldType
+from .templates import TemplateEngine, create_template_engine
 
 
 class GeneratorError(Exception):
@@ -22,6 +23,17 @@ class CodeGenerator(ABC):
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """Initialize generator with optional configuration."""
         self.config = config or {}
+        self._template_engine = None
+        self._setup_templates()
+
+    def _setup_templates(self):
+        """Setup template engine for this generator."""
+        template_dir = self.get_template_directory()
+        if template_dir:
+            self._template_engine = create_template_engine(template_dir)
+        else:
+            # Fallback to in-memory templates
+            self._template_engine = create_template_engine()
 
     @property
     @abstractmethod
@@ -35,6 +47,25 @@ def file_extension(self) -> str:
         """Return the file extension for generated files (e.g., '.go', '.py')."""
         pass
 
+    def get_template_directory(self) -> Optional[Path]:
+        """
+        Return the directory containing templates for this generator.
+
+        Subclasses should override this to provide their template directory.
+        Return None to use in-memory templates only.
+
+        Returns:
+            Path to template directory or None
+        """
+        return None
+
+    @property
+    def template_engine(self) -> TemplateEngine:
+        """Get the template engine for this generator."""
+        if self._template_engine is None:
+            self._setup_templates()
+        return self._template_engine
+
     @abstractmethod
     def generate(self, schemas: Dict[str, Schema], root_schema_name: str) -> str:
         """
@@ -158,6 +189,25 @@ def format_code(self, code: str) -> str:
 
         return "\n".join(formatted_lines)
 
+    # Template helper methods
+
+    def render_template(self, template_name: str, context: Dict[str, Any]) -> str:
+        """
+        Render a template with context.
+
+        Args:
+            template_name: Template file name
+            context: Template variables
+
+        Returns:
+            Rendered content
+        """
+        return self.template_engine.render_template(template_name, context)
+
+    def template_exists(self, template_name: str) -> bool:
+        """Check if a template exists."""
+        return self.template_engine.template_exists(template_name)
+
 
 class GenerationResult:
     """Container for generation results and metadata."""
@@ -187,14 +237,6 @@ def error(cls, message: str, exception: Exception = None) -> "GenerationResult":
         result.exception = exception
         return result
 
-    def add_warning(self, warning: str):
-        """Add a warning to the result."""
-        self.warnings.append(warning)
-
-    def add_metadata(self, key: str, value: Any):
-        """Add metadata to the result."""
-        self.metadata[key] = value
-
 
 def generate_code(
     generator: CodeGenerator, schemas: Dict[str, Schema], root_schema_name: str

json_explorer/codegen/core/templates.py

@@ -1,19 +1,18 @@
 """
 Template engine wrapper for code generation.
 
-Provides a simple interface for Jinja2 template rendering
+Provides a clean, language-agnostic interface for Jinja2 template rendering
 with common utilities for code generation.
 """
 
-import os
 from typing import Dict, Any, Optional
 from pathlib import Path
+from .naming import NameSanitizer
 
 try:
     from jinja2 import (
         Environment,
         FileSystemLoader,
-        BaseLoader,
         DictLoader,
         select_autoescape,
     )
@@ -33,7 +32,7 @@ class TemplateError(Exception):
 
 
 class TemplateEngine:
-    """Wrapper for Jinja2 template engine with code generation utilities."""
+    """Language-agnostic wrapper for Jinja2 template engine."""
 
     def __init__(self, template_dir: Optional[Path] = None):
         """
@@ -42,6 +41,8 @@ def __init__(self, template_dir: Optional[Path] = None):
         Args:
             template_dir: Directory containing template files
         """
+        self._name_sanitizer = NameSanitizer()
+
         if Environment is None:
             raise TemplateError(
                 "Jinja2 is required for template functionality. "
@@ -57,17 +58,17 @@ def _setup_environment(self):
         if self.template_dir and self.template_dir.exists():
             loader = FileSystemLoader(str(self.template_dir))
         else:
-            # Use in-memory templates
+            # Use in-memory templates as fallback
             loader = DictLoader({})
 
         self._env = Environment(
             loader=loader,
             autoescape=select_autoescape(["html", "xml"]),
-            # trim_blocks=True,
             lstrip_blocks=True,
+            # trim_blocks=True,
         )
 
-        # Add custom filters for code generation
+        # Add language-agnostic filters for code generation
         self._env.filters["snake_case"] = self._snake_case_filter
         self._env.filters["camel_case"] = self._camel_case_filter
         self._env.filters["pascal_case"] = self._pascal_case_filter
@@ -79,7 +80,7 @@ def render_template(self, template_name: str, context: Dict[str, Any]) -> str:
         Render a template with the given context.
 
         Args:
-            template_name: Name of template file
+            template_name: Name of template file (e.g., 'struct.go.j2')
             context: Variables to pass to template
 
         Returns:
@@ -122,31 +123,31 @@ def add_template(self, name: str, content: str):
 
         self._env.loader.mapping[name] = content
 
-    # Template filters for code generation
+    def template_exists(self, template_name: str) -> bool:
+        """Check if a template exists."""
+        try:
+            self._env.get_template(template_name)
+            return True
+        except:
+            return False
 
-    def _snake_case_filter(self, value: str) -> str:
-        """Convert string to snake_case."""
-        import re
+    def list_templates(self) -> list[str]:
+        """List all available templates."""
+        try:
+            return self._env.list_templates()
+        except:
+            return []
+
+    # Language-agnostic template filters
 
-        # Insert underscore before uppercase letters
-        s1 = re.sub("([a-z0-9])([A-Z])", r"\1_\2", str(value))
-        # Replace spaces and hyphens with underscores
-        s2 = re.sub(r"[-\s]+", "_", s1)
-        return s2.lower()
+    def _snake_case_filter(self, value: str) -> str:
+        return self._name_sanitizer._to_snake_case(value)
 
     def _camel_case_filter(self, value: str) -> str:
-        """Convert string to camelCase."""
-        snake = self._snake_case_filter(value)
-        parts = snake.split("_")
-        if not parts:
-            return str(value)
-        return parts[0].lower() + "".join(p.capitalize() for p in parts[1:])
+        return self._name_sanitizer._to_camel_case(value)
 
     def _pascal_case_filter(self, value: str) -> str:
-        """Convert string to PascalCase."""
-        snake = self._snake_case_filter(value)
-        parts = snake.split("_")
-        return "".join(p.capitalize() for p in parts if p)
+        return self._name_sanitizer._to_pascal_case(value)
 
     def _indent_filter(self, value: str, spaces: int = 4) -> str:
         """Indent all lines in a string."""
@@ -160,61 +161,14 @@ def _comment_filter(self, value: str, style: str = "//") -> str:
         return "\n".join(f"{style} {line}" if line.strip() else line for line in lines)
 
 
-# Built-in templates for common patterns
-GO_STRUCT_TEMPLATE = """
-{%- if description %}
-// {{ description }}
-{%- endif %}
-type {{ struct_name }} struct {
-{%- for field in fields %}
-    {%- if field.comment %}
-    // {{ field.comment }}
-    {%- endif %}
-    {{ field.name }} {{ field.type }} {% if field.json_tag %} {{ field.json_tag }} {% endif %}
-{%- endfor %}
-}
-"""
-
-PYTHON_DATACLASS_TEMPLATE = """
-@dataclass
-class {{ class_name }}:
-{%- for field in fields %}
-    {{ field.name }}: {{ field.type }}{% if field.optional %} = None{% endif %}
-{%- endfor %}
-"""
-
-# Default template engine instance
-_default_engine = None
-
-
-def get_default_template_engine() -> TemplateEngine:
-    """Get the default template engine instance."""
-    global _default_engine
-    if _default_engine is None:
-        _default_engine = TemplateEngine()
-
-        # Add built-in templates
-        _default_engine.add_template("go_struct", GO_STRUCT_TEMPLATE)
-        _default_engine.add_template("python_dataclass", PYTHON_DATACLASS_TEMPLATE)
-
-    return _default_engine
-
-
-def render_go_struct(
-    struct_name: str, fields: list, context: Dict[str, Any] = None
-) -> str:
+def create_template_engine(template_dir: Optional[Path] = None) -> TemplateEngine:
     """
-    Convenience function to render a Go struct.
+    Create a template engine instance.
 
     Args:
-        struct_name: Name of the struct
-        fields: List of field dictionaries
-        context: Additional context variables
+        template_dir: Directory containing template files
 
     Returns:
-        Rendered Go struct code
+        Configured TemplateEngine instance
     """
-    engine = get_default_template_engine()
-    template_context = {"struct_name": struct_name, "fields": fields, **(context or {})}
-
-    return engine.render_template("go_struct", template_context)
+    return TemplateEngine(template_dir)