mcp-souschef 2.1.2__py3-none-any.whl → 2.5.3__py3-none-any.whl

souschef/converters/playbook.py

@@ -1441,8 +1441,40 @@ def _extract_chef_guards(resource: dict[str, str], raw_content: str) -> dict[str
     return guards
 
 
+def _is_opening_delimiter(char: str, in_quotes: bool) -> bool:
+    """Check if character is an opening delimiter."""
+    return char == "{" and not in_quotes
+
+
+def _is_closing_delimiter(char: str, in_quotes: bool) -> bool:
+    """Check if character is a closing delimiter."""
+    return char == "}" and not in_quotes
+
+
+def _is_quote_character(char: str) -> bool:
+    """Check if character is a quote."""
+    return char in ['"', "'"]
+
+
+def _should_split_here(char: str, in_quotes: bool, in_block: int) -> bool:
+    """Determine if we should split at this comma."""
+    return char == "," and not in_quotes and in_block == 0
+
+
 def _split_guard_array_parts(array_content: str) -> list[str]:
-    """Split array content by commas, respecting quotes and blocks."""
+    """
+    Split array content by commas, respecting quotes and blocks.
+
+    Handles Chef guard arrays like: ['test -f /file', { block }, "string"]
+    Tracks quote state and brace nesting to avoid splitting inside strings or blocks.
+
+    Args:
+        array_content: Raw array content string
+
+    Returns:
+        List of array parts split by commas
+
+    """
     parts = []
     current_part = ""
     in_quotes = False
@@ -1450,24 +1482,30 @@ def _split_guard_array_parts(array_content: str) -> list[str]:
     quote_char = None
 
     for char in array_content:
-        if char in ['"', "'"] and not in_block:
+        # Handle quote transitions
+        if _is_quote_character(char) and not in_block:
             if not in_quotes:
                 in_quotes = True
                 quote_char = char
             elif char == quote_char:
                 in_quotes = False
                 quote_char = None
-        elif char == "{" and not in_quotes:
+
+        # Handle block nesting
+        elif _is_opening_delimiter(char, in_quotes):
             in_block += 1
-        elif char == "}" and not in_quotes:
+        elif _is_closing_delimiter(char, in_quotes):
             in_block -= 1
-        elif char == "," and not in_quotes and in_block == 0:
+
+        # Handle splits at commas
+        elif _should_split_here(char, in_quotes, in_block):
             parts.append(current_part.strip())
             current_part = ""
             continue
 
         current_part += char
 
+    # Add final part if not empty
     if current_part.strip():
         parts.append(current_part.strip())
 

souschef/converters/resource.py

@@ -2,10 +2,14 @@
 
 import ast
 import json
+from collections.abc import Callable
 from typing import Any
 
 from souschef.core.constants import ACTION_TO_STATE, RESOURCE_MAPPINGS
 
+# Type alias for parameter builder functions
+ParamBuilder = Callable[[str, str, dict[str, Any]], dict[str, Any]]
+
 
 def _parse_properties(properties_str: str) -> dict[str, Any]:
     """
@@ -87,6 +91,39 @@ def _get_service_params(resource_name: str, action: str) -> dict[str, Any]:
     return params
 
 
+def _get_template_file_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for template resources."""
+    params = {
+        "src": resource_name,
+        "dest": resource_name.replace(".erb", ""),
+    }
+    if action == "create":
+        params["mode"] = "0644"
+    return params
+
+
+def _get_regular_file_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for regular file resources."""
+    params: dict[str, Any] = {"path": resource_name}
+    if action == "create":
+        params["state"] = "file"
+        params["mode"] = "0644"
+    else:
+        params["state"] = ACTION_TO_STATE.get(action, action)
+    return params
+
+
+def _get_directory_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Get parameters for directory resources."""
+    params: dict[str, Any] = {
+        "path": resource_name,
+        "state": "directory",
+    }
+    if action == "create":
+        params["mode"] = "0755"
+    return params
+
+
 def _get_file_params(
     resource_name: str, action: str, resource_type: str
 ) -> dict[str, Any]:
@@ -102,34 +139,84 @@ def _get_file_params(
         Dictionary of Ansible file parameters.
 
     """
-    params: dict[str, Any] = {}
-
     if resource_type == "template":
-        params["src"] = resource_name
-        params["dest"] = resource_name.replace(".erb", "")
-        if action == "create":
-            params["mode"] = "0644"
+        return _get_template_file_params(resource_name, action)
     elif resource_type == "file":
-        params["path"] = resource_name
-        if action == "create":
-            params["state"] = "file"
-            params["mode"] = "0644"
-        else:
-            params["state"] = ACTION_TO_STATE.get(action, action)
+        return _get_regular_file_params(resource_name, action)
     elif resource_type == "directory":
-        params["path"] = resource_name
-        params["state"] = "directory"
-        if action == "create":
-            params["mode"] = "0755"
+        return _get_directory_params(resource_name, action)
+    return {}
+
+
+def _get_package_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for package resources."""
+    return {"name": resource_name, "state": ACTION_TO_STATE.get(action, action)}
+
+
+def _get_execute_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for execute/bash resources."""
+    return {"cmd": resource_name}
+
+
+def _get_user_group_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for user/group resources."""
+    return {"name": resource_name, "state": ACTION_TO_STATE.get(action, "present")}
+
+
+def _get_remote_file_params(
+    resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """Build parameters for remote_file resources."""
+    params = {"dest": resource_name}
+    # Map Chef properties to Ansible parameters
+    prop_mappings = {
+        "source": "url",
+        "mode": "mode",
+        "owner": "owner",
+        "group": "group",
+        "checksum": "checksum",
+    }
+    for chef_prop, ansible_param in prop_mappings.items():
+        if chef_prop in props:
+            params[ansible_param] = props[chef_prop]
+    return params
 
+
+def _get_default_params(resource_name: str, action: str) -> dict[str, Any]:
+    """Build default parameters for unknown resource types."""
+    params = {"name": resource_name}
+    if action in ACTION_TO_STATE:
+        params["state"] = ACTION_TO_STATE[action]
     return params
 
 
+# Resource type to parameter builder mappings
+RESOURCE_PARAM_BUILDERS: dict[str, ParamBuilder | str] = {
+    "package": _get_package_params,
+    "service": "service",  # Uses _get_service_params
+    "systemd_unit": "service",
+    "template": "file",  # Uses _get_file_params
+    "file": "file",
+    "directory": "file",
+    "execute": _get_execute_params,
+    "bash": _get_execute_params,
+    "user": _get_user_group_params,
+    "group": _get_user_group_params,
+    "remote_file": _get_remote_file_params,
+}
+
+
 def _convert_chef_resource_to_ansible(
     resource_type: str, resource_name: str, action: str, properties: str
 ) -> dict[str, Any]:
     """
-    Convert Chef resource to Ansible task dictionary.
+    Convert Chef resource to Ansible task dictionary using data-driven approach.
 
     Args:
         resource_type: The Chef resource type.
@@ -149,46 +236,56 @@ def _convert_chef_resource_to_ansible(
         "name": f"{action.capitalize()} {resource_type} {resource_name}",
     }
 
-    # Build module parameters based on resource type
-    module_params: dict[str, Any] = {}
-
-    # Parse properties if provided
+    # Parse properties
     props = _parse_properties(properties)
 
-    if resource_type == "package":
-        module_params["name"] = resource_name
-        module_params["state"] = ACTION_TO_STATE.get(action, action)
-    elif resource_type in ["service", "systemd_unit"]:
-        module_params = _get_service_params(resource_name, action)
-    elif resource_type in ["template", "file", "directory"]:
-        module_params = _get_file_params(resource_name, action, resource_type)
-    elif resource_type in ["execute", "bash"]:
-        module_params["cmd"] = resource_name
+    # Build module parameters using appropriate builder
+    module_params = _build_module_params(resource_type, resource_name, action, props)
+
+    # Add special task-level flags for execute/bash resources
+    if resource_type in ["execute", "bash"]:
         task["changed_when"] = "false"
-    elif resource_type in ["user", "group"]:
-        module_params["name"] = resource_name
-        module_params["state"] = ACTION_TO_STATE.get(action, "present")
-    elif resource_type == "remote_file":
-        module_params["dest"] = resource_name
-        if "source" in props:
-            module_params["url"] = props["source"]
-        if "mode" in props:
-            module_params["mode"] = props["mode"]
-        if "owner" in props:
-            module_params["owner"] = props["owner"]
-        if "group" in props:
-            module_params["group"] = props["group"]
-        if "checksum" in props:
-            module_params["checksum"] = props["checksum"]
-    else:
-        module_params["name"] = resource_name
-        if action in ACTION_TO_STATE:
-            module_params["state"] = ACTION_TO_STATE[action]
 
     task[ansible_module] = module_params
     return task
 
 
+def _build_module_params(
+    resource_type: str, resource_name: str, action: str, props: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Build Ansible module parameters based on resource type.
+
+    Args:
+        resource_type: The Chef resource type.
+        resource_name: The resource name.
+        action: The Chef action.
+        props: Parsed properties dictionary.
+
+    Returns:
+        Dictionary of Ansible module parameters.
+
+    """
+    # Look up the parameter builder for this resource type
+    builder = RESOURCE_PARAM_BUILDERS.get(resource_type)
+
+    if builder is None:
+        # Unknown resource type - use default builder
+        return _get_default_params(resource_name, action)
+
+    if isinstance(builder, str):
+        # Special handler reference (service/file)
+        if builder == "service":
+            return _get_service_params(resource_name, action)
+        elif builder == "file":
+            return _get_file_params(resource_name, action, resource_type)
+        # This shouldn't happen, but handle gracefully
+        return _get_default_params(resource_name, action)
+
+    # Call the parameter builder function
+    return builder(resource_name, action, props)
+
+
 def _format_yaml_value(value: Any) -> str:
     """Format a value for YAML output."""
     if isinstance(value, str):

souschef/core/__init__.py

@@ -38,6 +38,18 @@ from souschef.core.constants import (
     REGEX_WORD_SYMBOLS,
     RESOURCE_MAPPINGS,
 )
+from souschef.core.errors import (
+    ChefFileNotFoundError,
+    ConversionError,
+    InvalidCookbookError,
+    ParseError,
+    SousChefError,
+    ValidationError,
+    format_error_with_context,
+    validate_cookbook_structure,
+    validate_directory_exists,
+    validate_file_exists,
+)
 from souschef.core.path_utils import _normalize_path, _safe_join
 from souschef.core.ruby_utils import _normalize_ruby_value
 from souschef.core.validation import (
@@ -55,4 +67,14 @@ __all__ = [
     "ValidationEngine",
     "ValidationLevel",
     "ValidationResult",
+    "SousChefError",
+    "ChefFileNotFoundError",
+    "InvalidCookbookError",
+    "ParseError",
+    "ConversionError",
+    "ValidationError",
+    "validate_file_exists",
+    "validate_directory_exists",
+    "validate_cookbook_structure",
+    "format_error_with_context",
 ]

souschef/core/errors.py

@@ -0,0 +1,275 @@
+"""Enhanced error handling with actionable messages and recovery suggestions."""
+
+from pathlib import Path
+
+
+class SousChefError(Exception):
+    """Base exception for SousChef with enhanced error messages."""
+
+    def __init__(self, message: str, suggestion: str | None = None):
+        """
+        Initialize with message and optional recovery suggestion.
+
+        Args:
+            message: The error message describing what went wrong.
+            suggestion: Optional suggestion for how to fix the error.
+
+        """
+        self.message = message
+        self.suggestion = suggestion
+        full_message = message
+        if suggestion:
+            full_message = f"{message}\n\nSuggestion: {suggestion}"
+        super().__init__(full_message)
+
+
+class ChefFileNotFoundError(SousChefError):
+    """Raised when a required file cannot be found."""
+
+    def __init__(self, path: str, file_type: str = "file"):
+        """
+        Initialize file not found error.
+
+        Args:
+            path: The path that was not found.
+            file_type: Type of file (e.g., 'cookbook', 'recipe', 'template').
+
+        """
+        message = f"Could not find {file_type}: {path}"
+        suggestion = (
+            "Check that the path exists and you have read permissions. "
+            "For cookbooks, ensure you're pointing to the cookbook root "
+            "directory containing metadata.rb."
+        )
+        super().__init__(message, suggestion)
+
+
+class InvalidCookbookError(SousChefError):
+    """Raised when a cookbook is invalid or malformed."""
+
+    def __init__(self, path: str, reason: str):
+        """
+        Initialize invalid cookbook error.
+
+        Args:
+            path: The cookbook path.
+            reason: Why the cookbook is invalid.
+
+        """
+        message = f"Invalid cookbook at {path}: {reason}"
+        suggestion = (
+            "Ensure the directory contains a valid Chef cookbook with "
+            "metadata.rb. Run 'knife cookbook test' to validate the "
+            "cookbook structure."
+        )
+        super().__init__(message, suggestion)
+
+
+class ParseError(SousChefError):
+    """Raised when parsing Chef code fails."""
+
+    def __init__(
+        self, file_path: str, line_number: int | None = None, detail: str = ""
+    ):
+        """
+        Initialize parse error.
+
+        Args:
+            file_path: The file that failed to parse.
+            line_number: Optional line number where parsing failed.
+            detail: Additional detail about the parse failure.
+
+        """
+        location = f" at line {line_number}" if line_number else ""
+        message = f"Failed to parse {file_path}{location}"
+        if detail:
+            message += f": {detail}"
+        suggestion = (
+            "Check that the file contains valid Chef Ruby DSL syntax. "
+            "Complex Ruby code may require manual review."
+        )
+        super().__init__(message, suggestion)
+
+
+class ConversionError(SousChefError):
+    """Raised when conversion from Chef to Ansible fails."""
+
+    def __init__(self, resource_type: str, reason: str):
+        """
+        Initialize conversion error.
+
+        Args:
+            resource_type: The Chef resource type that failed to convert.
+            reason: Why the conversion failed.
+
+        """
+        message = f"Cannot convert Chef resource '{resource_type}': {reason}"
+        suggestion = (
+            "This resource may require manual conversion. Check the Ansible "
+            "module documentation for equivalent modules, or consider using "
+            "the 'command' or 'shell' module as a fallback."
+        )
+        super().__init__(message, suggestion)
+
+
+class ValidationError(SousChefError):
+    """Raised when validation of converted content fails."""
+
+    def __init__(self, validation_type: str, issues: list[str]):
+        """
+        Initialize validation error.
+
+        Args:
+            validation_type: Type of validation that failed.
+            issues: List of validation issues found.
+
+        """
+        issue_list = "\n  - ".join(issues)
+        message = f"{validation_type} validation failed:\n  - {issue_list}"
+        suggestion = (
+            "Review the validation issues above and fix them in the "
+            "generated output. Run the validation again after making "
+            "corrections."
+        )
+        super().__init__(message, suggestion)
+
+
+def validate_file_exists(path: str, file_type: str = "file") -> Path:
+    """
+    Validate that a file exists and is readable.
+
+    Args:
+        path: Path to validate.
+        file_type: Type of file for error messages.
+
+    Returns:
+        Path object if validation succeeds.
+
+    Raises:
+        FileNotFoundError: If file doesn't exist or isn't readable.
+
+    """
+    file_path = Path(path)
+    if not file_path.exists():
+        raise ChefFileNotFoundError(path, file_type)
+    if not file_path.is_file():
+        raise ChefFileNotFoundError(path, file_type)
+    try:
+        # Test readability
+        with file_path.open() as f:
+            f.read(1)
+    except PermissionError as e:
+        raise SousChefError(
+            f"Permission denied reading {file_type}: {path}",
+            "Ensure you have read permissions on the file. On Unix systems, "
+            "try 'chmod +r' on the file.",
+        ) from e
+    return file_path
+
+
+def validate_directory_exists(path: str, dir_type: str = "directory") -> Path:
+    """
+    Validate that a directory exists and is readable.
+
+    Args:
+        path: Path to validate.
+        dir_type: Type of directory for error messages.
+
+    Returns:
+        Path object if validation succeeds.
+
+    Raises:
+        FileNotFoundError: If directory doesn't exist or isn't readable.
+
+    """
+    dir_path = Path(path)
+    if not dir_path.exists():
+        raise ChefFileNotFoundError(path, dir_type)
+    if not dir_path.is_dir():
+        raise SousChefError(
+            f"Path is not a {dir_type}: {path}",
+            f"Expected a directory but found a file. Check that you're "
+            f"pointing to the {dir_type} directory, not a file within it.",
+        )
+    try:
+        # Test readability
+        list(dir_path.iterdir())
+    except PermissionError as e:
+        raise SousChefError(
+            f"Permission denied reading {dir_type}: {path}",
+            "Ensure you have read and execute permissions on the directory. "
+            "On Unix systems, try 'chmod +rx' on the directory.",
+        ) from e
+    return dir_path
+
+
+def validate_cookbook_structure(path: str) -> Path:
+    """
+    Validate that a path contains a valid Chef cookbook.
+
+    Args:
+        path: Path to the cookbook root directory.
+
+    Returns:
+        Path object if validation succeeds.
+
+    Raises:
+        InvalidCookbookError: If the directory isn't a valid cookbook.
+
+    """
+    cookbook_path = validate_directory_exists(path, "cookbook")
+
+    # Check for metadata.rb or metadata.json
+    has_metadata = (cookbook_path / "metadata.rb").exists() or (
+        cookbook_path / "metadata.json"
+    ).exists()
+
+    if not has_metadata:
+        raise InvalidCookbookError(
+            path, "No metadata.rb or metadata.json found in cookbook root"
+        )
+
+    return cookbook_path
+
+
+def format_error_with_context(
+    error: Exception, operation: str, file_path: str | None = None
+) -> str:
+    """
+    Format an error message with operation context.
+
+    Args:
+        error: The exception that occurred.
+        operation: Description of the operation that failed.
+        file_path: Optional path to the file being processed.
+
+    Returns:
+        Formatted error message with context and suggestions.
+
+    """
+    if isinstance(error, SousChefError):
+        # Already has good formatting
+        return str(error)
+
+    context = f"Error during {operation}"
+    if file_path:
+        context += f" for {file_path}"
+
+    if isinstance(error, FileNotFoundError):
+        return str(ChefFileNotFoundError(file_path or "unknown", "file"))
+    elif isinstance(error, PermissionError):
+        return (
+            f"{context}: Permission denied\n\nSuggestion: Check "
+            "file/directory permissions and ensure you have read access."
+        )
+    elif isinstance(error, (ValueError, TypeError)):
+        return (
+            f"{context}: {error}\n\nSuggestion: Check that input "
+            "values are in the correct format and type."
+        )
+    else:
+        return (
+            f"{context}: {error}\n\nSuggestion: If this error persists, "
+            "please report it with the full error message at "
+            "https://github.com/kpeacocke/souschef/issues"
+        )

souschef/core/validation.py

@@ -234,10 +234,43 @@ class ValidationEngine:
         if "import pytest" in result:
             # Testinfra format
             self._validate_python_syntax(result)
-        elif "---" in result:
-            # Ansible assert format
+        elif "require 'serverspec'" in result:
+            # ServerSpec format (Ruby)
+            self._validate_ruby_syntax(result)
+        elif "---" in result or ("package:" in result and "service:" in result):
+            # Ansible assert or Goss YAML format
             self._validate_yaml_syntax(result)
 
+    def _validate_ruby_syntax(self, ruby_content: str) -> None:
+        """
+        Validate Ruby syntax.
+
+        Args:
+            ruby_content: Ruby content to validate.
+
+        """
+        # Basic Ruby syntax checks
+        if not ruby_content.strip():
+            self._add_result(
+                ValidationLevel.ERROR,
+                ValidationCategory.SYNTAX,
+                "Empty Ruby content",
+                suggestion="Ensure the conversion produced valid Ruby code",
+            )
+            return
+
+        # Check for balanced blocks (describe/do/end)
+        do_count = len(re.findall(r"\bdo\b", ruby_content))
+        end_count = len(re.findall(r"\bend\b", ruby_content))
+
+        if do_count != end_count:
+            self._add_result(
+                ValidationLevel.ERROR,
+                ValidationCategory.SYNTAX,
+                f"Unbalanced Ruby blocks: {do_count} 'do' but {end_count} 'end'",
+                suggestion="Check that all 'do' blocks have matching 'end' keywords",
+            )
+
     def _validate_yaml_syntax(self, yaml_content: str) -> None:
         """
         Validate YAML syntax.