coregen-cli 3.1.6__py3-none-any.whl

generators/helpers/config.py

@@ -0,0 +1,255 @@
+"""Configuration management for CoreGen.
+
+Supports configuration from multiple sources with priority:
+1. CLI flags (highest priority)
+2. Project-level coregen.yaml
+3. Global ~/.coregenrc
+4. Default values (lowest priority)
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+from dataclasses import dataclass, field
+
+import yaml
+from rich.console import Console
+
+console = Console()
+
+# Default configuration values
+DEFAULTS = {
+    "feature_folder": "features",  # Default features folder
+    "domain_folder": "domain",  # Domain entities folder
+    "component_folder": "features/components",  # Default components folder
+    "auto_run_build_runner": True,
+    "primary_color": "#2196F3",
+    "secondary_color": "#FF9800",
+}
+
+# Config file names
+PROJECT_CONFIG_FILE = "coregen.yaml"
+GLOBAL_CONFIG_FILE = ".coregenrc"
+
+
+@dataclass
+class CoreGenConfig:
+    """Configuration class for CoreGen."""
+    
+    # Folder defaults
+    feature_folder: str = "features"
+    domain_folder: str = "domain"
+    component_folder: str = "features/components"
+    
+    # Automation
+    auto_run_build_runner: bool = True
+    
+    # UI/Styling
+    primary_color: str = "#2196F3"
+    secondary_color: str = "#FF9800"
+    
+    # Custom templates (optional paths)
+    custom_templates: dict = field(default_factory=dict)
+    
+    # Extra dependencies to add
+    extra_dependencies: list = field(default_factory=list)
+    
+    # Source of config (for debugging)
+    _source: str = "defaults"
+    
+    @classmethod
+    def from_dict(cls, data: dict, source: str = "unknown") -> "CoreGenConfig":
+        """Create config from dictionary."""
+        config = cls()
+        
+        # Map nested 'defaults' section
+        if "defaults" in data:
+            defaults = data["defaults"]
+            if "feature_folder" in defaults:
+                config.feature_folder = defaults["feature_folder"]
+            if "domain_folder" in defaults:
+                config.domain_folder = defaults["domain_folder"]
+            if "component_folder" in defaults:
+                config.component_folder = defaults["component_folder"]
+            if "auto_run_build_runner" in defaults:
+                config.auto_run_build_runner = defaults["auto_run_build_runner"]
+        
+        # Map 'styling' section
+        if "styling" in data:
+            styling = data["styling"]
+            if "primary_color" in styling:
+                config.primary_color = styling["primary_color"]
+            if "secondary_color" in styling:
+                config.secondary_color = styling["secondary_color"]
+        
+        # Map 'templates' section
+        if "templates" in data:
+            config.custom_templates = data["templates"]
+        
+        # Map 'dependencies' section
+        if "dependencies" in data:
+            config.extra_dependencies = data["dependencies"]
+        
+        # Also support flat structure (for simple configs)
+        for key in ["feature_folder", "domain_folder", "component_folder", 
+                    "auto_run_build_runner",
+                    "primary_color", "secondary_color"]:
+            if key in data:
+                setattr(config, key, data[key])
+        
+        config._source = source
+        return config
+    
+    def merge_with(self, other: "CoreGenConfig") -> "CoreGenConfig":
+        """Merge this config with another, other takes precedence for non-default values."""
+        result = CoreGenConfig()
+        
+        # Feature folder: use other's if set (default is "features")
+        result.feature_folder = other.feature_folder if other.feature_folder != "features" else self.feature_folder
+        
+        # Component folder: use other's if set (default is "features/components")
+        result.component_folder = other.component_folder if other.component_folder != "features/components" else self.component_folder
+        
+        # Domain folder has default "domain", so use other's if set
+        result.domain_folder = other.domain_folder if other.domain_folder != "domain" else self.domain_folder
+        
+        # Automation: use other's value (it's explicitly set)
+        result.auto_run_build_runner = other.auto_run_build_runner
+        
+        for key in ["primary_color", "secondary_color"]:
+            setattr(result, key, getattr(other, key))
+        
+        # Merge dictionaries and lists
+        result.custom_templates = {**self.custom_templates, **other.custom_templates}
+        result.extra_dependencies = self.extra_dependencies + other.extra_dependencies
+        
+        result._source = f"{self._source} + {other._source}"
+        return result
+
+
+def load_yaml_file(path: Path) -> Optional[dict]:
+    """Load a YAML file, return None if not found or invalid."""
+    if not path.exists():
+        return None
+    
+    try:
+        with open(path, 'r') as f:
+            return yaml.safe_load(f) or {}
+    except yaml.YAMLError as e:
+        console.print(f"[yellow]⚠️  Warning: Invalid YAML in {path}: {e}[/yellow]")
+        return None
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Warning: Could not read {path}: {e}[/yellow]")
+        return None
+
+
+def get_global_config_path() -> Path:
+    """Get path to global config file."""
+    return Path.home() / GLOBAL_CONFIG_FILE
+
+
+def get_project_config_path(project_dir: Path) -> Path:
+    """Get path to project config file."""
+    return project_dir / PROJECT_CONFIG_FILE
+
+
+def load_config(project_dir: Optional[Path] = None) -> CoreGenConfig:
+    """
+    Load configuration from all sources with proper priority.
+    
+    Priority (highest to lowest):
+    1. CLI flags (handled by caller)
+    2. Project-level coregen.yaml
+    3. Global ~/.coregenrc
+    4. Default values
+    """
+    # Start with defaults
+    config = CoreGenConfig(_source="defaults")
+    
+    # Load global config
+    global_path = get_global_config_path()
+    global_data = load_yaml_file(global_path)
+    if global_data:
+        global_config = CoreGenConfig.from_dict(global_data, f"~/{GLOBAL_CONFIG_FILE}")
+        config = config.merge_with(global_config)
+    
+    # Load project config (if project_dir provided)
+    if project_dir:
+        project_path = get_project_config_path(project_dir)
+        project_data = load_yaml_file(project_path)
+        if project_data:
+            project_config = CoreGenConfig.from_dict(project_data, PROJECT_CONFIG_FILE)
+            config = config.merge_with(project_config)
+    
+    return config
+
+
+def apply_cli_overrides(config: CoreGenConfig, **cli_args) -> CoreGenConfig:
+    """
+    Apply CLI argument overrides to config.
+    Only non-None CLI args override config values.
+    """
+    if cli_args.get("folder"):
+        config.feature_folder = cli_args["folder"]
+        config.component_folder = cli_args["folder"]
+    
+    if cli_args.get("no_build") is True:
+        config.auto_run_build_runner = False
+    
+    return config
+
+
+def create_default_config(project_dir: Path, project_name: str) -> Path:
+    """Create a default coregen.yaml in the project directory."""
+    config_path = project_dir / PROJECT_CONFIG_FILE
+    
+    default_config = f"""# CoreGen Configuration
+# Project: {project_name}
+# Documentation: https://github.com/lorenzo9598/coregen
+
+# Default folders for generated code
+defaults:
+  feature_folder: "features"         # Features folder
+  domain_folder: "domain"           # Domain entities folder (shared entities)
+  component_folder: "features/components"  # Components folder
+  auto_run_build_runner: true       # Run build_runner after generation
+
+# UI/Styling configuration
+styling:
+  primary_color: "#2196F3"
+  secondary_color: "#FF9800"
+
+# Custom templates (optional)
+# templates:
+#   entity: "templates/custom_entity.jinja"
+#   bloc: "templates/custom_bloc.jinja"
+
+# Additional dependencies to include (optional)
+# dependencies:
+#   - package: dartz
+#     version: ^0.10.1
+"""
+    
+    with open(config_path, 'w') as f:
+        f.write(default_config)
+    
+    return config_path
+
+
+def show_config(config: CoreGenConfig) -> None:
+    """Display current configuration using rich."""
+    from rich.table import Table
+    from rich.panel import Panel
+    
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Setting", style="dim")
+    table.add_column("Value")
+    
+    table.add_row("Feature Folder", config.feature_folder)
+    table.add_row("Domain Folder", config.domain_folder)
+    table.add_row("Component Folder", config.component_folder)
+    table.add_row("Auto Build Runner", "✅" if config.auto_run_build_runner else "❌")
+    table.add_row("Primary Color", config.primary_color)
+    table.add_row("Secondary Color", config.secondary_color)
+    
+    console.print(Panel(table, title=f"⚙️  Configuration ({config._source})", border_style="blue"))

generators/helpers/data_source.py

@@ -0,0 +1,180 @@
+"""Mock vs remote data source helpers — DataSourceConfig and mock JSON assets."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Optional
+
+from generators.templates.copier import generate_file
+
+REMOTE_PATTERN = re.compile(
+    r"['\"](?P<key>[a-z][a-z0-9_]*)['\"]\s*:\s*DataSource\.remote",
+)
+
+
+def scan_domain_entity_keys(lib_path: Path, domain_folder: str = "domain") -> list[str]:
+    """Return snake_case entity keys that have a repository interface."""
+    domain_root = lib_path / domain_folder
+    if not domain_root.is_dir():
+        return []
+    keys: list[str] = []
+    for entity_dir in sorted(domain_root.iterdir()):
+        if not entity_dir.is_dir():
+            continue
+        i_repo = entity_dir / "model" / f"i_{entity_dir.name}_repository.dart"
+        if i_repo.is_file():
+            keys.append(entity_dir.name)
+    return keys
+
+
+def read_preserved_remote_keys(config_path: Path) -> set[str]:
+    """Parse existing data_source_config.dart for entries already set to remote."""
+    if not config_path.is_file():
+        return set()
+    content = config_path.read_text(encoding="utf-8")
+    return {m.group("key") for m in REMOTE_PATTERN.finditer(content)}
+
+
+def build_entities_map(
+    entity_keys: list[str],
+    *,
+    has_login: bool,
+    preserved_remote: set[str],
+) -> dict[str, str]:
+    """Build entity key -> 'mock' | 'remote' for template rendering."""
+    entities: dict[str, str] = {}
+    if has_login:
+        entities["auth"] = "remote" if "auth" in preserved_remote else "mock"
+    for key in entity_keys:
+        if key in preserved_remote:
+            entities[key] = "remote"
+        else:
+            entities[key] = "mock"
+    return entities
+
+
+def _format_entities_entries(entities: dict[str, str]) -> str:
+    if not entities:
+        return ""
+    lines = []
+    for key, source in entities.items():
+        enum_val = "DataSource.mock" if source == "mock" else "DataSource.remote"
+        lines.append(f"    '{key}': {enum_val},")
+    return "\n".join(lines)
+
+
+def regenerate_data_source_config(
+    project_name: str,
+    lib_path: Path,
+    *,
+    domain_folder: str = "domain",
+    has_login: bool = False,
+) -> None:
+    """Regenerate lib/apis/common/data_source_config.dart from scanned entities."""
+    config_rel = "apis/common/data_source_config.dart"
+    config_path = lib_path / config_rel
+    entity_keys = scan_domain_entity_keys(lib_path, domain_folder)
+    preserved_remote = read_preserved_remote_keys(config_path)
+    entities = build_entities_map(
+        entity_keys,
+        has_login=has_login,
+        preserved_remote=preserved_remote,
+    )
+    generate_file(
+        project_name,
+        lib_path,
+        "apis/common/data_source_config_template.jinja",
+        config_rel,
+        {
+            "entities_entries": _format_entities_entries(entities),
+            "login": has_login,
+        },
+    )
+
+
+def ensure_mock_assets_dir(project_path: Path) -> Path:
+    """Ensure assets/mock/ exists in the Flutter project root."""
+    mock_dir = project_path / "assets" / "mock"
+    mock_dir.mkdir(parents=True, exist_ok=True)
+    return mock_dir
+
+
+def _sample_value_for_type(
+    field_name: str,
+    field_type: str,
+    index: int,
+    *,
+    known_enums: Optional[dict] = None,
+) -> object:
+    """Return a JSON-serializable sample value for a DTO field."""
+    known_enums = known_enums or {}
+    is_nullable = field_type.endswith("?")
+    base = field_type[:-1] if is_nullable else field_type
+
+    if field_name == "id":
+        return str(index)
+
+    base_lower = base.lower()
+    if base_lower in ("string", "str"):
+        return f"sample-{field_name}-{index}"
+    if base_lower == "bool":
+        return False
+    if base_lower == "int":
+        return index
+    if base_lower in ("double", "num", "float"):
+        return round(9.99 * index, 2)
+    if base_lower in ("datetime", "date"):
+        return "2024-01-15T10:00:00.000Z"
+
+    if base in known_enums:
+        values = known_enums[base].get("values") or []
+        if values:
+            return values[0]
+        return "pending"
+
+    if base.startswith("List<") or base.startswith("Set<"):
+        inner = base[base.index("<") + 1 : base.rindex(">")]
+        if inner in known_enums:
+            vals = known_enums[inner].get("values") or []
+            if vals:
+                return [vals[0]]
+        return []
+
+    if base.startswith("Map<"):
+        return {}
+
+    if base[0].isupper() if base else False:
+        return f"sample-{field_name}-{index}"
+
+    return f"sample-{field_name}-{index}"
+
+
+def generate_mock_json(
+    project_path: Path,
+    entity_folder_name: str,
+    field_list: list[dict],
+    *,
+    known_enums: Optional[dict] = None,
+    item_count: int = 3,
+) -> Path:
+    """Write assets/mock/<entity>.json with sample items."""
+    mock_dir = ensure_mock_assets_dir(project_path)
+    items = []
+    for i in range(1, item_count + 1):
+        item: dict[str, object] = {}
+        for field in field_list:
+            item[field["name"]] = _sample_value_for_type(
+                field["name"],
+                field["type"],
+                i,
+                known_enums=known_enums,
+            )
+        items.append(item)
+    out_path = mock_dir / f"{entity_folder_name}.json"
+    out_path.write_text(
+        json.dumps({"items": items}, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    return out_path