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

souschef/parsers/attributes.py

@@ -4,9 +4,11 @@ import re
 from typing import Any
 
 from souschef.core.constants import (
+    ATTRIBUTE_PREFIX,
     ERROR_FILE_NOT_FOUND,
     ERROR_IS_DIRECTORY,
     ERROR_PERMISSION_DENIED,
+    VALUE_PREFIX,
 )
 from souschef.core.path_utils import _normalize_path
 from souschef.parsers.template import _strip_ruby_comments
@@ -64,7 +66,351 @@ def parse_attributes(path: str, resolve_precedence: bool = True) -> str:
         return f"An error occurred: {e}"
 
 
-def _extract_attributes(content: str) -> list[dict[str, str]]:
+def _extract_precedence_and_path(line: str) -> tuple[str, str, str] | None:
+    """Extract precedence and attribute path from a line."""
+    precedence_types = (
+        "default",
+        "force_default",
+        "normal",
+        "override",
+        "force_override",
+        "automatic",
+    )
+    if not (line.startswith(precedence_types) and "[" in line):
+        return None
+
+    # Extract precedence
+    if line.startswith("default"):
+        precedence = "default"
+        attr_part = line[7:].strip()
+    elif line.startswith("force_default"):
+        precedence = "force_default"
+        attr_part = line[13:].strip()
+    elif line.startswith("normal"):
+        precedence = "normal"
+        attr_part = line[6:].strip()
+    elif line.startswith("override"):
+        precedence = "override"
+        attr_part = line[8:].strip()
+    elif line.startswith("force_override"):
+        precedence = "force_override"
+        attr_part = line[14:].strip()
+    elif line.startswith("automatic"):
+        precedence = "automatic"
+        attr_part = line[9:].strip()
+    else:
+        return None
+
+    # Find the attribute path and value
+    equals_pos = attr_part.find("=")
+    if equals_pos == -1:
+        return None
+
+    attr_path_part = attr_part[:equals_pos].strip()
+    value_start = attr_part[equals_pos + 1 :].strip()
+
+    # Clean up the path
+    attr_path = (
+        attr_path_part.replace("']['", ".")
+        .replace('"]["', ".")
+        .replace("['", "")
+        .replace("']", "")
+        .replace('["', "")
+        .replace('"]', "")
+    )
+
+    return precedence, attr_path, value_start
+
+
+def _is_ruby_array_syntax(value: str) -> bool:
+    """Check if value uses Ruby array syntax."""
+    stripped = value.strip()
+    return stripped.startswith("%w") or (
+        stripped.startswith("[") and stripped.endswith("]")
+    )
+
+
+def _should_stop_collecting(stripped: str, precedence_types: tuple[str, ...]) -> bool:
+    """Check if we should stop collecting multiline value based on line content."""
+    # Stop if we hit another attribute declaration
+    if stripped.startswith(precedence_types) and "[" in stripped:
+        return True
+
+    # Stop if we hit Ruby control structures that indicate end of attribute
+    return stripped.startswith(
+        (
+            "case ",
+            "if ",
+            "unless ",
+            "when ",
+            "else",
+            "end",
+            "def ",
+            "class ",
+            "module ",
+        )
+    )
+
+
+def _update_string_state(
+    char: str,
+    in_string: bool,
+    string_char: str | None,
+    line: str,
+    value_lines: list[str],
+) -> tuple[bool, str | None]:
+    """Update string parsing state for a single character."""
+    if not in_string and char in ('"', "'"):
+        return True, char
+    elif (
+        in_string
+        and string_char is not None
+        and char == string_char
+        and (
+            not value_lines
+            or line[value_lines[-1].rfind(string_char) + 1 :].count("\\") % 2 == 0
+        )
+    ):
+        return False, None
+    return in_string, string_char
+
+
+def _update_bracket_depths(
+    char: str,
+    brace_depth: int,
+    bracket_depth: int,
+    paren_depth: int,
+) -> tuple[int, int, int]:
+    """Update bracket/braces/parentheses depth counters for a single character."""
+    if char == "{":
+        return brace_depth + 1, bracket_depth, paren_depth
+    elif char == "}":
+        return brace_depth - 1, bracket_depth, paren_depth
+    elif char == "[":
+        return brace_depth, bracket_depth + 1, paren_depth
+    elif char == "]":
+        return brace_depth, bracket_depth - 1, paren_depth
+    elif char == "(":
+        return brace_depth, bracket_depth, paren_depth + 1
+    elif char == ")":
+        return brace_depth, bracket_depth, paren_depth - 1
+    return brace_depth, bracket_depth, paren_depth
+
+
+def _update_parsing_state(
+    line: str,
+    in_string: bool,
+    string_char: str | None,
+    brace_depth: int,
+    bracket_depth: int,
+    paren_depth: int,
+    value_lines: list[str],
+) -> tuple[bool, str | None, int, int, int]:
+    """Update parsing state for string literals and bracket/braces depth."""
+    for char in line:
+        if in_string:
+            in_string, string_char = _update_string_state(
+                char,
+                in_string,
+                string_char,
+                line,
+                value_lines,
+            )
+        else:
+            # Check for entering string
+            if char in ('"', "'"):
+                in_string, string_char = True, char
+            else:
+                # Update bracket depths
+                brace_depth, bracket_depth, paren_depth = _update_bracket_depths(
+                    char, brace_depth, bracket_depth, paren_depth
+                )
+
+    return in_string, string_char, brace_depth, bracket_depth, paren_depth
+
+
+def _is_value_complete(
+    in_string: bool,
+    brace_depth: int,
+    bracket_depth: int,
+    paren_depth: int,
+    value_lines: list[str],
+    line: str,
+    next_line: str,
+    precedence_types: tuple[str, ...],
+) -> bool:
+    """Check if the multiline value collection is complete."""
+    # Must be outside strings and have balanced brackets/braces
+    if in_string or brace_depth > 0 or bracket_depth > 0 or paren_depth > 0:
+        return False
+
+    # For arrays like %w(...), check if we have the closing paren
+    if value_lines and value_lines[0].strip().startswith("%w"):
+        return ")" in line
+
+    # For regular arrays/hashes, break when brackets are balanced
+    return (
+        brace_depth == 0
+        and bracket_depth == 0
+        and paren_depth == 0
+        and (
+            not next_line
+            or next_line.startswith(precedence_types)
+            or next_line.startswith(("case ", "if ", "unless "))
+        )
+    )
+
+
+def _collect_multiline_value(lines: list[str], start_idx: int) -> tuple[str, int]:
+    """Collect multiline attribute value."""
+    value_lines: list[str] = []
+    i = start_idx
+    brace_depth = 0
+    bracket_depth = 0
+    paren_depth = 0
+    in_string = False
+    string_char = None
+
+    precedence_types = (
+        "default",
+        "force_default",
+        "normal",
+        "override",
+        "force_override",
+        "automatic",
+    )
+
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.strip()
+
+        # Skip empty lines at the beginning
+        if not value_lines and not stripped:
+            i += 1
+            continue
+
+        # Check if we should stop collecting
+        if _should_stop_collecting(stripped, precedence_types):
+            break
+
+        # Update parsing state for strings and brackets
+        (
+            in_string,
+            string_char,
+            brace_depth,
+            bracket_depth,
+            paren_depth,
+        ) = _update_parsing_state(
+            line,
+            in_string,
+            string_char,
+            brace_depth,
+            bracket_depth,
+            paren_depth,
+            value_lines,
+        )
+
+        value_lines.append(line)
+
+        # Check if the value is complete
+        next_line = lines[i + 1].strip() if i + 1 < len(lines) else ""
+        if _is_value_complete(
+            in_string,
+            brace_depth,
+            bracket_depth,
+            paren_depth,
+            value_lines,
+            line,
+            next_line,
+            precedence_types,
+        ):
+            break
+
+        i += 1
+
+    return "\n".join(value_lines).strip(), i
+
+
+def _convert_ruby_word_array(content: str) -> str:
+    """Convert Ruby %w(...) array syntax to YAML list."""
+    # Extract the array content
+    match = re.match(r"%w\s*\((.*?)\)", content, re.DOTALL)
+    if not match:
+        return content
+
+    array_content = match.group(1)
+    # Split on whitespace and newlines, clean up
+    items = []
+    for item in re.split(r"\s+", array_content):
+        item = item.strip()
+        if item and not item.startswith("#"):  # Skip comments
+            items.append(f"  - {item}")
+    return "\n".join(items) if items else "[]"
+
+
+def _convert_ruby_array(content: str) -> str:
+    """Convert Ruby [item1, item2] array syntax to YAML list."""
+    # Remove brackets and strip
+    array_content = content.strip()[1:-1]
+    if not array_content.strip():
+        return "[]"
+
+    items = []
+    # Split on commas, but be careful with nested structures
+    for item in array_content.split(","):
+        item = item.strip()
+        if item:
+            items.append(f"  - {item}")
+    return "\n".join(items) if items else "[]"
+
+
+def _convert_ruby_hash(content: str) -> str:
+    """Convert Ruby {key: value} hash syntax to YAML mapping."""
+    # Remove braces and strip
+    hash_content = content.strip()[1:-1]
+    if not hash_content.strip():
+        return "{}"
+
+    lines = []
+    # Split on commas
+    for pair in hash_content.split(","):
+        pair = pair.strip()
+        if ":" in pair:
+            key, val = pair.split(":", 1)
+            lines.append(f"  {key.strip()}: {val.strip()}")
+    return "\n".join(lines) if lines else "{}"
+
+
+def _convert_ruby_value_to_yaml(value: str) -> str:
+    """
+    Convert Ruby value syntax to YAML-compatible format.
+
+    Args:
+        value: Raw Ruby value string.
+
+    Returns:
+        YAML-compatible value string.
+
+    """
+    stripped = value.strip()
+
+    # Handle %w(...) array syntax
+    if stripped.startswith("%w"):
+        return _convert_ruby_word_array(stripped)
+
+    # Handle regular arrays [item1, item2]
+    if stripped.startswith("[") and stripped.endswith("]"):
+        return _convert_ruby_array(stripped)
+
+    # Handle hashes {key: value, key2: value2}
+    if stripped.startswith("{") and stripped.endswith("}"):
+        return _convert_ruby_hash(stripped)
+
+    # Return as-is for other values
+    return value
+
+
+def _extract_attributes(content: str) -> list[dict[str, str]]:  # noqa: C901
     """
     Extract Chef attributes from attributes file content.
 
@@ -79,36 +425,55 @@ def _extract_attributes(content: str) -> list[dict[str, str]]:
     # Strip comments first
     clean_content = _strip_ruby_comments(content)
 
-    # Match attribute declarations with all precedence levels
-    # Chef precedence levels (lowest to highest):
-    # default < force_default < normal < override < force_override < automatic
-    pattern = (
-        r"(default|force_default|normal|override|force_override|automatic)"
-        r"((?:\[[^\]]+\])+)\s*=\s*([^\n]+)"
-    )
+    # Split content into lines for easier processing
+    lines = clean_content.split("\n")
+    i = 0
 
-    for match in re.finditer(pattern, clean_content, re.DOTALL):
-        precedence = match.group(1)
-        # Extract the bracket part and clean it up
-        brackets = match.group(2)
-        # Clean up the path - remove quotes and brackets, convert to dot notation
-        attr_path = (
-            brackets.replace("']['", ".")
-            .replace('"]["', ".")
-            .replace("['", "")
-            .replace("']", "")
-            .replace('["', "")
-            .replace('"]', "")
-        )
-        value = match.group(3).strip()
-
-        attributes.append(
-            {
-                "precedence": precedence,
-                "path": attr_path,
-                "value": value,
-            }
-        )
+    while i < len(lines):
+        line = lines[i].strip()
+
+        # Try to extract precedence and path
+        result = _extract_precedence_and_path(line)
+        if result is not None:
+            precedence, attr_path, value_start = result
+
+            # Check if this is Ruby array syntax
+            is_ruby_array = _is_ruby_array_syntax(value_start)
+
+            # Collect the value (may span multiple lines)
+            value_lines = [value_start]
+            i += 1
+
+            # Continue collecting lines
+            full_value, i = _collect_multiline_value(lines, i)
+
+            if full_value:
+                value_lines[0] = full_value
+
+            # Join value lines and clean up
+            value = "\n".join(value_lines).strip()
+
+            # For Ruby arrays, reconstruct the full syntax for conversion
+            if (
+                is_ruby_array
+                and not value.startswith("%w")
+                and (not value.startswith("["))
+            ):
+                # This was a multiline Ruby array, reconstruct %w syntax
+                value = f"%w(\n{value}\n)"
+
+            # Convert Ruby syntax to YAML-compatible format
+            value = _convert_ruby_value_to_yaml(value)
+
+            attributes.append(
+                {
+                    "precedence": precedence,
+                    "path": attr_path,
+                    "value": value,
+                }
+            )
+        else:
+            i += 1
 
     return attributes
 
@@ -236,8 +601,8 @@ def _format_resolved_attributes(
     # Sort by attribute path for consistent output
     for path in sorted(resolved.keys()):
         info = resolved[path]
-        result.append(f"Attribute: {path}")
-        result.append(f"  Value: {info['value']}")
+        result.append(f"{ATTRIBUTE_PREFIX}{path}")
+        result.append(f"  {VALUE_PREFIX}{info['value']}")
         result.append(
             f"  Precedence: {info['precedence']} (level {info['precedence_level']})"
         )

souschef/parsers/recipe.py

@@ -38,11 +38,15 @@ def parse_recipe(path: str) -> str:
         content = file_path.read_text(encoding="utf-8")
 
         resources = _extract_resources(content)
+        include_recipes = _extract_include_recipes(content)
 
-        if not resources:
-            return f"Warning: No Chef resources found in {path}"
+        # Combine resources and include_recipes
+        all_items = resources + include_recipes
 
-        return _format_resources(resources)
+        if not all_items:
+            return f"Warning: No Chef resources or include_recipe calls found in {path}"
+
+        return _format_resources(all_items)
 
     except ValueError as e:
         return f"Error: {e}"
@@ -114,6 +118,36 @@ def _extract_resources(content: str) -> list[dict[str, str]]:
     return resources
 
 
+def _extract_include_recipes(content: str) -> list[dict[str, str]]:
+    """
+    Extract include_recipe calls from recipe content.
+
+    Args:
+        content: Raw content of recipe file.
+
+    Returns:
+        List of dictionaries containing include_recipe information.
+
+    """
+    include_recipes = []
+    # Strip comments first
+    clean_content = _strip_ruby_comments(content)
+
+    # Match include_recipe calls: include_recipe 'recipe_name'
+    pattern = r"include_recipe\s+['\"]([^'\"]+)['\"]"
+
+    for match in re.finditer(pattern, clean_content):
+        recipe_name = match.group(1)
+        include_recipes.append(
+            {
+                "type": "include_recipe",
+                "name": recipe_name,
+            }
+        )
+
+    return include_recipes
+
+
 def _extract_conditionals(content: str) -> list[dict[str, Any]]:
     """
     Extract Ruby conditionals from recipe code.
@@ -189,12 +223,16 @@ def _format_resources(resources: list[dict[str, Any]]) -> str:
     for i, resource in enumerate(resources, 1):
         if i > 1:
             result.append("")
-        result.append(f"Resource {i}:")
-        result.append(f"  Type: {resource['type']}")
-        result.append(f"  Name: {resource['name']}")
-        if "action" in resource:
-            result.append(f"  Action: {resource['action']}")
-        if "properties" in resource:
-            result.append(f"  Properties: {resource['properties']}")
+        if resource["type"] == "include_recipe":
+            result.append(f"Include Recipe {i}:")
+            result.append(f"  Recipe: {resource['name']}")
+        else:
+            result.append(f"Resource {i}:")
+            result.append(f"  Type: {resource['type']}")
+            result.append(f"  Name: {resource['name']}")
+            if "action" in resource:
+                result.append(f"  Action: {resource['action']}")
+            if "properties" in resource:
+                result.append(f"  Properties: {resource['properties']}")
 
     return "\n".join(result)