github2gerrit 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

github2gerrit/config.py

@@ -80,6 +80,8 @@ KNOWN_KEYS: set[str] = {
     "ISSUE_ID",
     "G2G_VERBOSE",
     "G2G_SKIP_GERRIT_COMMENTS",
+    "G2G_ENABLE_DERIVATION",
+    "G2G_AUTO_SAVE_CONFIG",
     "GITHUB_TOKEN",
     # Optional inputs (reusable workflow compatibility)
     "GERRIT_SERVER",
@@ -128,11 +130,7 @@ def _coerce_value(raw: str) -> str:
     # Normalize escaped newline sequences into real newlines so that values
     # like SSH keys or known_hosts entries can be specified inline using
     # '\n' or '\r\n' in configuration files.
-    normalized_newlines = (
-        unquoted.replace("\\r\\n", "\n")
-        .replace("\\n", "\n")
-        .replace("\r\n", "\n")
-    )
+    normalized_newlines = unquoted.replace("\\r\\n", "\n").replace("\\n", "\n").replace("\r\n", "\n")
     b = _normalize_bool_like(normalized_newlines)
     return b if b is not None else normalized_newlines
 
@@ -313,6 +311,210 @@ def filter_known(
     return {k: v for k, v in cfg.items() if k in KNOWN_KEYS}
 
 
+def _is_github_actions_context() -> bool:
+    """Detect if running in GitHub Actions environment."""
+    return os.getenv("GITHUB_ACTIONS") == "true" or os.getenv("GITHUB_EVENT_NAME", "").strip() != ""
+
+
+def _is_local_cli_context() -> bool:
+    """Detect if running as local CLI tool."""
+    return not _is_github_actions_context()
+
+
+def derive_gerrit_parameters(organization: str | None) -> dict[str, str]:
+    """Derive Gerrit parameters from GitHub organization name.
+
+    Args:
+        organization: GitHub organization name
+
+    Returns:
+        Dict with derived parameter values:
+        - GERRIT_SSH_USER_G2G: [org].gh2gerrit
+        - GERRIT_SSH_USER_G2G_EMAIL: releng+[org]-gh2gerrit@linuxfoundation.org
+        - GERRIT_SERVER: gerrit.[org].org
+    """
+    if not organization:
+        return {}
+
+    org = organization.strip().lower()
+    return {
+        "GERRIT_SSH_USER_G2G": f"{org}.gh2gerrit",
+        "GERRIT_SSH_USER_G2G_EMAIL": (f"releng+{org}-gh2gerrit@linuxfoundation.org"),
+        "GERRIT_SERVER": f"gerrit.{org}.org",
+    }
+
+
+def apply_parameter_derivation(
+    cfg: dict[str, str],
+    organization: str | None = None,
+    save_to_config: bool = True,
+) -> dict[str, str]:
+    """Apply dynamic parameter derivation for missing Gerrit parameters.
+
+    This function derives standard Gerrit parameters when they are not
+    explicitly configured. The derivation is based on the GitHub organization:
+
+    - gerrit_ssh_user_g2g: [org].gh2gerrit
+    - gerrit_ssh_user_g2g_email: releng+[org]-gh2gerrit@linuxfoundation.org
+    - gerrit_server: gerrit.[org].org
+
+    Derivation behavior depends on execution context:
+    - GitHub Actions: Automatic derivation when organization is available
+    - Local CLI: Requires G2G_ENABLE_DERIVATION=true for automatic
+      derivation
+
+    Args:
+        cfg: Configuration dictionary to augment
+        organization: GitHub organization name for derivation
+        save_to_config: Whether to save derived parameters to config file
+
+    Returns:
+        Configuration dictionary with derived values for missing parameters
+    """
+    if not organization:
+        return cfg
+
+    # Check execution context to determine derivation strategy
+    is_github_actions = _is_github_actions_context()
+    enable_derivation = is_github_actions or os.getenv("G2G_ENABLE_DERIVATION", "").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+    )
+
+    if not enable_derivation:
+        log.debug(
+            "Parameter derivation disabled for local CLI usage. "
+            "Set G2G_ENABLE_DERIVATION=true to enable automatic derivation."
+        )
+        return cfg
+
+    # Only derive parameters that are missing or empty
+    derived = derive_gerrit_parameters(organization)
+    result = dict(cfg)
+    newly_derived = {}
+
+    for key, value in derived.items():
+        if key not in result or not result[key].strip():
+            log.debug(
+                "Deriving %s from organization '%s': %s (context: %s)",
+                key,
+                organization,
+                value,
+                "GitHub Actions" if is_github_actions else "Local CLI",
+            )
+            result[key] = value
+            newly_derived[key] = value
+
+    if newly_derived:
+        log.info(
+            "Derived parameters applied for organization '%s' (%s): %s",
+            organization,
+            "GitHub Actions" if is_github_actions else "Local CLI",
+            ", ".join(f"{k}={v}" for k, v in newly_derived.items()),
+        )
+    # Save newly derived parameters to configuration file for future use
+    # Default to true for local CLI, false for GitHub Actions
+    default_auto_save = "false" if _is_github_actions_context() else "true"
+    auto_save_enabled = os.getenv("G2G_AUTO_SAVE_CONFIG", default_auto_save).strip().lower() in (
+        "1",
+        "true",
+        "yes",
+        "on",
+    )
+    if save_to_config and newly_derived and auto_save_enabled:
+        # Save to config in local CLI mode to create persistent configuration
+        try:
+            save_derived_parameters_to_config(organization, newly_derived)
+            log.info(
+                "Automatically saved derived parameters to configuration "
+                "file for organization '%s'. "
+                "This creates a persistent configuration that you can "
+                "customize if needed.",
+                organization,
+            )
+        except Exception as exc:
+            log.warning("Failed to save derived parameters to config: %s", exc)
+
+    return result
+
+
+def save_derived_parameters_to_config(
+    organization: str,
+    derived_params: dict[str, str],
+    config_path: str | None = None,
+) -> None:
+    """Save derived parameters to the organization's configuration file.
+
+    This function updates the configuration file to include any derived
+    parameters that are not already present in the organization section.
+    This creates a persistent configuration that users can modify if needed.
+
+    Args:
+        organization: GitHub organization name for config section
+        derived_params: Dictionary of derived parameter key-value pairs
+        config_path: Path to config file (optional, uses default if not
+                    provided)
+
+    Raises:
+        Exception: If saving fails
+    """
+    if not organization or not derived_params:
+        return
+
+    if config_path is None:
+        config_path = os.getenv("G2G_CONFIG_PATH", "").strip() or DEFAULT_CONFIG_PATH
+
+    config_file = Path(config_path).expanduser()
+
+    try:
+        # Only update when a configuration file already exists
+        if not config_file.exists():
+            log.debug(
+                "Configuration file does not exist; skipping auto-save of derived parameters: %s",
+                config_file,
+            )
+            return
+
+        # Parse existing content using configparser
+        cp = _load_ini(config_file)
+
+        # Find or create the organization section
+        org_section = _select_section(cp, organization)
+        if org_section is None:
+            # Section doesn't exist, we'll need to add it
+            cp.add_section(organization)
+            org_section = organization
+
+        # Add derived parameters that don't already exist
+        params_added = []
+        for key, value in derived_params.items():
+            if not cp.has_option(org_section, key):
+                cp.set(org_section, key, f'"{value}"')
+                params_added.append(key)
+
+        # Only write if we added parameters
+        if params_added:
+            # Write the updated configuration
+            with config_file.open("w", encoding="utf-8") as f:
+                cp.write(f)
+
+            log.debug(
+                "Saved derived parameters to configuration file %s [%s]: %s",
+                config_file,
+                organization,
+                ", ".join(params_added),
+            )
+
+    except Exception as exc:
+        log.warning(
+            "Failed to save derived parameters to configuration file %s: %s",
+            config_file,
+            exc,
+        )
+
+
 def overlay_missing(
     primary: dict[str, str],
     fallback: dict[str, str],