Format template expressions and prepare for LSP (#5)

* Add formatting for expressions within template and prepare for being used LSP
* Rename tests files for clarity and split formatter into template
* Update `__init__` calls in Components to new `init` hook
* Fix encoding

Author: berendkleinhaneveld

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ruff-cgx"
-version = "0.1.2"
+version = "0.1.3"
 description = "Ruff linter and formatter for collagraph single-file components"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -39,6 +39,7 @@ select = [
     "T10", # flake8-debugger
     "T20", # flake8-print
     "RUF", # ruff
+    "ARG", # flake8-unused-arguments
 ]
 unfixable = [
     "F401",  # Unused import

ruff_cgx/__init__.py

@@ -1,7 +1,15 @@
-from .formatter import format_file
-from .linter import lint_file
-
-__all__ = (
+from .formatter import (
+    format_cgx_content,
     format_file,
+)
+from .linter import (
+    lint_cgx_content,
     lint_file,
 )
+
+__all__ = (
+    "format_cgx_content",
+    "format_file",
+    "lint_cgx_content",
+    "lint_file",
+)

ruff_cgx/formatter.py

@@ -1,84 +1,55 @@
 import logging
-import os
-import subprocess
-import tempfile
 from pathlib import Path
 
-from collagraph.sfc.parser import CGXParser
-
 from .template_formatter import format_template
+from .utils import get_script_range, parse_cgx_file, run_ruff_format
 
 logger = logging.getLogger(__name__)
 
 
-def format_script(path, script_node, source_lines, check):
-    """
-    Returns formatted source and the original location of the node
+def format_script(script_node, source_lines):
     """
-    start, end = script_node.location[0], script_node.end[0] - 1
+    Format script section (CLI version with printing).
 
+    Returns formatted source and the original location of the node.
+    """
+    start, end = get_script_range(script_node)
     source = "".join(source_lines[start:end])
 
-    ruff_command = ["ruff", "format"]
-    if check:
-        ruff_command.append("--check")
-
-    # Write source to a temp file
-    with tempfile.TemporaryDirectory() as directory:
-        target_file = Path(directory) / "source.py"
-        target_file.write_text(source)
-        ruff_command.append(str(target_file))
-
-        # Enable color output for ruff
-        # TODO: check whether we want to force color or not?
-        env = os.environ.copy()
-        env["CLICOLOR_FORCE"] = "1"
-        # Then run ruff to format the temp file
-        output = subprocess.run(ruff_command, capture_output=True, text=True, env=env)
-        with target_file.open(mode="r", encoding="utf-8") as fh:
-            formatted_source = fh.readlines()
-
-        stdout = output.stdout.replace(str(target_file), str(path))
-
-    print(stdout, end="")  # noqa: T201
-    if check:
-        if output.returncode:
-            exit(output.returncode)
+    # Format using ruff
+    formatted_source = run_ruff_format(source, check=False)
 
-    # Then return the contents
-    return formatted_source, (start, end)
+    # Convert back to lines for consistency
+    formatted_lines = formatted_source.splitlines(keepends=True)
+
+    return formatted_lines, (start, end)
 
 
 def format_file(path, check=False, write=True):
     """
     Format CGX files (the contents of the script tag) with ruff.
 
-    Returns 0 if everything succeeded, or nothing changed.
-    Returns 1 when running check and something would change.
-    Returns list of lines when write is set to False instead
-    of an error code (used for the test-suite).
+    Args:
+        content: The CGX file content as a string
+        uri: Optional URI for logging purposes
+
+    Returns:
+        0 if everything succeeded, or nothing changed.
+        1 when running check and something would change.
+        list of lines when write is set to False instead
+        of an error code (used for the test-suite).
     """
     path = Path(path)
     if path.suffix != ".cgx":
         return
 
-    parser = CGXParser()
-    parser.feed(path.read_text())
-
-    with path.open(mode="r") as fh:
-        lines = fh.readlines()
+    content = path.read_text(encoding="utf-8")
+    parsed = parse_cgx_file(content)
 
-    script_node = parser.root.child_with_tag("script")
-    template_nodes = [
-        node
-        for node in parser.root.children
-        if not hasattr(node, "tag") or node.tag != "script"
-    ]
+    lines = content.splitlines(keepends=True)
 
-    script_content, script_location = format_script(path, script_node, lines, check)
-    formatted_template_nodes = [
-        format_template(node, lines, parser=parser) for node in template_nodes
-    ]
+    script_content, script_location = format_script(parsed.script_node, lines)
+    formatted_template_nodes = [format_template(node) for node in parsed.template_nodes]
 
     changed_script = lines[script_location[0] : script_location[1]] != script_content
     changed_template = any(
@@ -91,8 +62,9 @@ def format_file(path, check=False, write=True):
     changed = changed_script or changed_template or needs_newline_at_end_of_file
     if check:
         if changed:
-            logger.warning(f"Would change: {path}")
+            print(f"Would reformat: {path}")  # noqa: T201
             return 1
+        print("1 file already formatted")  # noqa: T201
         return 0
 
     formatted_parts = reversed(
@@ -111,10 +83,109 @@ def format_file(path, check=False, write=True):
     if needs_newline_at_end_of_file:
         lines.append("\n")
 
+    # Print status message based on changes
+    if changed:
+        print("1 file reformatted")  # noqa: T201
+    else:
+        print("1 file left unchanged")  # noqa: T201
+
     if not write:
+        # For testing, return the lines instead of writing
         return lines
 
     if changed:
-        with path.open(mode="w") as fh:
+        with path.open(mode="w", encoding="utf-8") as fh:
             fh.writelines(lines)
+
     return 0
+
+
+def format_cgx_content(content: str, uri: str = "") -> str:
+    """
+    Format CGX file content (for LSP use).
+
+    Args:
+        content: The CGX file content as a string
+        uri: Optional URI for logging purposes
+
+    Returns:
+        Formatted content as a string
+    """
+    try:
+        # Parse the CGX file
+        parsed = parse_cgx_file(content)
+
+        # Split content into lines
+        lines = content.splitlines(keepends=True)
+
+        # Check for script node
+        if not parsed.script_node:
+            logger.warning(f"Missing script node in {uri}")
+            return content
+
+        # Format script section (using updated signature for LSP)
+        script_content, script_location = format_script_content(
+            parsed.script_node, lines
+        )
+
+        # Format all template nodes
+        formatted_template_nodes = [
+            format_template(node) for node in parsed.template_nodes
+        ]
+
+        # Check if newline is needed at end of file
+        needs_newline_at_end_of_file = lines and not lines[-1].endswith("\n")
+
+        # Sort all formatted parts by their starting location
+        # (in reverse order for replacement)
+        formatted_parts = reversed(
+            sorted(
+                [
+                    (script_content, script_location),
+                    *formatted_template_nodes,
+                ],
+                key=lambda x: x[1][0],
+            )
+        )
+
+        # Replace content in reverse order to maintain correct line indices
+        for formatted_content, (start, end) in formatted_parts:
+            lines[start:end] = formatted_content
+
+        # Add newline at end if needed
+        if needs_newline_at_end_of_file:
+            lines.append("\n")
+
+        return "".join(lines)
+
+    except Exception as e:
+        logger.error(f"Error formatting {uri}: {e}", exc_info=True)
+        # Return original content on error
+        return content
+
+
+def format_script_content(script_node, source_lines):
+    """
+    Format the script section of a CGX file using ruff (for LSP use).
+
+    Args:
+        script_node: script node from collagraph's parser
+        source_lines: contents of source file as list of lines
+
+    Returns:
+        Formatted source and the original location of the node.
+    """
+    if script_node.end is None:
+        raise RuntimeError("Invalid script node: no end")
+
+    start, end = get_script_range(script_node)
+    source = "".join(source_lines[start:end])
+
+    # Format using ruff
+    formatted_source = run_ruff_format(source)
+
+    # Convert to lines for consistency
+    formatted_lines = formatted_source.splitlines(keepends=True)
+
+    # Return the formatted content and its location
+    return formatted_lines, (start, end)