py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/config/config_loader.py

@@ -0,0 +1,163 @@
+"""Configuration loading utilities for WL Commands."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+from .defaults import WL_DIRECTORY, get_default_config, get_environment_defaults
+from .env_parser import EnvConfigParser
+
+if TYPE_CHECKING:
+    from .core import ConfigPathResolver
+
+
+class ConfigLoader:
+    """Load configuration from multiple sources with proper precedence."""
+
+    def __init__(self, config_file_path: str, path_resolver: ConfigPathResolver):
+        """Initialize ConfigLoader with specific config file path and path resolver.
+
+        Args:
+            config_file_path: Path to the main project configuration file
+            path_resolver: Instance of ConfigPathResolver for path operations
+        """
+        from .core import ConfigMerger
+
+        self.config_file_path = config_file_path
+        self.path_resolver = path_resolver
+        self.merger = ConfigMerger()
+        self.env_parser = EnvConfigParser()
+
+    def load_all(self) -> dict[str, Any]:
+        """Load configuration from all sources with proper precedence.
+
+        Loads and merges in this order:
+        1. Default configuration
+        2. User-level config (~/.wl/config.json)
+        3. Project-level config (project_root/.wl/config.json)
+        4. Environment defaults based on current environment
+        5. Environment-specific config file (config.{env}.json)
+        6. Environment variables (WL_* prefix)
+
+        Returns:
+            Fully merged configuration dictionary
+        """
+        # Load default configuration first
+        default_config = get_default_config()
+
+        # Load user-level configuration
+        user_config = self._load_user_config()
+
+        # Load project-level configuration
+        project_config = self.load_config_file(self.config_file_path)
+
+        # Determine current environment
+        if "environment" in project_config:
+            environment = project_config["environment"]
+        else:
+            environment = self.get_environment()
+
+        # Load environment-specific defaults
+        env_defaults = get_environment_defaults(environment)
+
+        # Load environment-specific configuration
+        env_specific_config = self._load_environment_config(environment)
+
+        # Load environment variables override
+        env_config = self.env_parser.load_from_env()
+
+        # Merge configurations with proper precedence
+        # Environment variables > Environment-specific file > Project > User > Environment defaults > Default
+        # Special case: environment defaults for log-related settings should override project config
+        merged_config = default_config.copy()
+        merged_config = self.merger.merge(merged_config, user_config)
+        merged_config = self.merger.merge(merged_config, project_config)
+
+        # Apply environment defaults for log-related settings
+        for key, value in env_defaults.items():
+            if key.startswith("log_"):
+                merged_config[key] = value
+
+        merged_config = self.merger.merge(merged_config, env_specific_config)
+        merged_config = self.merger.merge(merged_config, env_config)
+
+        # Set environment in config
+        merged_config["environment"] = environment
+
+        return merged_config
+
+    def get_environment(self) -> str:
+        """Get current environment (development, production, testing).
+
+        Checks in this order:
+        1. Environment variable WL_ENVIRONMENT
+        2. Detected from CI environment variables
+        3. Detected from TEST environment variable
+        4. Defaults to "development"
+
+        Returns:
+            Environment name as lowercase string
+        """
+        from .core import CI_ENV_VARS, TEST_ENV_VAR, WL_ENVIRONMENT_ENV
+
+        # First check environment variable
+        env = os.environ.get(WL_ENVIRONMENT_ENV)
+        if env:
+            return env.lower()
+
+        # Auto-detect environment
+        if any(os.environ.get(var) for var in CI_ENV_VARS):
+            return "production"
+        if os.environ.get(TEST_ENV_VAR):
+            return "testing"
+
+        # Default to development
+        return "development"
+
+    def load_config_file(self, file_path: str) -> dict[str, Any]:
+        """Load configuration from a specific JSON file.
+
+        Args:
+            file_path: Path to the JSON config file
+
+        Returns:
+            Loaded configuration dict, empty dict if file doesn't exist or error
+        """
+        if not Path(file_path).exists():
+            return {}
+
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                return cast("dict[str, Any]", json.load(f))
+        except (OSError, json.JSONDecodeError):
+            return {}
+
+    def _load_user_config(self) -> dict[str, Any]:
+        """Load user-level configuration from ``<home>/.wl/config.json``.
+
+        The ``.wl`` spelling comes from :data:`~wl_cli.utils.config.defaults.WL_DIRECTORY`,
+        the one definition shared with the deploy-root path. This is *not* a
+        :class:`~wl_cli.utils.root.Root`: the user-level directory is not a root a
+        starting point belongs to, so the home value -- including the caller-side
+        CWD fallback ADR 0006 documents on
+        ``ConfigPathResolver.get_user_home_dir`` -- is used as given.
+        """
+        user_config_path = (
+            Path(self.path_resolver.get_user_home_dir()) / WL_DIRECTORY / "config.json"
+        )
+        return self.load_config_file(str(user_config_path))
+
+    def _load_environment_config(self, environment: str) -> dict[str, Any]:
+        """Load environment-specific configuration from config.{env}.json."""
+        if not environment:
+            return {}
+
+        # Try to load environment-specific config file
+        env_config_path = self.config_file_path.replace(".json", f".{environment}.json")
+        if os.path.exists(env_config_path):
+            return self.load_config_file(env_config_path)
+
+        return {}