Fix linting and formatting inconsistencies (#12)

* Fix linting and formatting inconsistencies due to differences in whether the line break after the script is taken into account
* Refactor to cleanup duplicated code and simplify
* Remove unnecessary method
* Use PEP 604 syntax instead of using Optional
* Make tests more specific and add some edge cases

Author: berendkleinhaneveld

ruff_cgx/formatter.py

@@ -2,27 +2,59 @@
 from pathlib import Path
 
 from .template_formatter import format_template
-from .utils import get_script_range, parse_cgx_file, run_ruff_format
+from .utils import (
+    extract_script_content,
+    parse_cgx_file,
+    run_ruff_format,
+)
 
 logger = logging.getLogger(__name__)
 
 
-def format_script(script_node, source_lines):
+def format_script(script_node, source_lines, check=False):
     """
-    Format script section (CLI version with printing).
+    Format script section using ruff.
 
-    Returns formatted source and the original location of the node.
+    Args:
+        script_node: script node from collagraph's parser
+        source_lines: contents of source file as list of lines
+        check: If True, only check without modifying (for ruff format --check)
+
+    Returns:
+        Tuple of (formatted_lines, (start_line, end_line))
     """
-    start, end = get_script_range(script_node)
-    source = "".join(source_lines[start:end])
+    if script_node.end is None:
+        raise RuntimeError("Invalid script node: no end")
+
+    # Extract pure Python content
+    script_content = extract_script_content(script_node)
+    if not script_content:
+        # No content to format - return original lines unchanged
+        start = script_node.location[0] - 1  # Convert to 0-indexed
+        end = script_node.end[0] - 1  # End tag line
+        return source_lines[start:end], (start, end)
 
     # Format using ruff
-    formatted_source = run_ruff_format(source, check=False)
+    formatted_source = run_ruff_format(script_content.python_code, check=check)
 
-    # Convert back to lines for consistency
+    # Convert to lines
     formatted_lines = formatted_source.splitlines(keepends=True)
 
-    return formatted_lines, (start, end)
+    # If Python was on same line as tag, prepend the tag on its own line
+    if not script_content.starts_on_new_line:
+        formatted_lines = ["<script>\n", *formatted_lines]
+
+    # If closing tag was inline with Python code, we need to:
+    # 1. Append closing tag to formatted output
+    # 2. Extend replacement range to include that line
+    if script_content.closing_tag_inline:
+        formatted_lines.append("</script>\n")
+        replacement_end = script_content.end_line + 1
+    else:
+        replacement_end = script_content.end_line
+
+    # Return formatted content with range that will be replaced
+    return formatted_lines, (script_content.start_line, replacement_end)
 
 
 def format_file(path, check=False, write=True):
@@ -123,10 +155,8 @@ def format_cgx_content(content: str, uri: str = "") -> str:
             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 script section
+        script_content, script_location = format_script(parsed.script_node, lines)
 
         # Format all template nodes
         formatted_template_nodes = [
@@ -162,30 +192,3 @@ def format_cgx_content(content: str, uri: str = "") -> str:
         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)

ruff_cgx/linter.py

@@ -5,12 +5,49 @@
 
 from .utils import (
     create_virtual_render_content,
-    get_script_range,
+    extract_script_content,
     parse_cgx_file,
     run_ruff_check,
 )
 
 
+def _prepare_content_for_linting(content: str) -> str | None:
+    """
+    Prepare CGX content for linting by extracting Python and creating virtual content.
+
+    Args:
+        content: The CGX file content as a string
+
+    Returns:
+        The prepared Python code ready for ruff, or None if no script section
+    """
+    # Parse the CGX file
+    parsed = parse_cgx_file(content)
+    if not parsed.script_node:
+        return None
+
+    # Extract pure Python content
+    script_content = extract_script_content(parsed.script_node)
+    if not script_content:
+        return None
+
+    # Prepend with comment lines to preserve line numbers for diagnostics
+    prefix_lines = ["#\n"] * script_content.start_line
+    python_lines = script_content.python_code.splitlines(keepends=True)
+    modified_lines = prefix_lines + python_lines
+
+    # Add newline to lines that don't have it
+    modified_lines = [
+        line if line.endswith("\n") else f"{line}\n" for line in modified_lines
+    ]
+
+    # Create virtual content with render method
+    # This allows ruff to see template variable usage
+    virtual_content = create_virtual_render_content(content, modified_lines)
+
+    return virtual_content
+
+
 def lint_file(path, **_):
     """
     Lint a CGX file using ruff (CLI version).
@@ -26,26 +63,11 @@ def lint_file(path, **_):
     path = Path(path)
     content = path.read_text(encoding="utf-8")
 
-    # Parse CGX file
-    parsed = parse_cgx_file(content)
-    if not parsed.script_node:
+    # Prepare content for linting
+    virtual_content = _prepare_content_for_linting(content)
+    if virtual_content is None:
         return 1
 
-    # Get script range
-    start, end = get_script_range(parsed.script_node)
-    script_range = range(start, end)
-
-    # Read source lines
-    lines = content.splitlines(keepends=True)
-
-    # Comment out all non-script lines
-    template_commented = [
-        line if idx in script_range else "#\n" for idx, line in enumerate(lines)
-    ]
-
-    # Create virtual content with render method
-    virtual_content = create_virtual_render_content(content, template_commented)
-
     # Run ruff check with full output (for CLI)
     result, temp_path = run_ruff_check(virtual_content, output_format="full")
 
@@ -80,36 +102,11 @@ def lint_cgx_content(content: str) -> List[Diagnostic]:
     Returns:
         List of diagnostics
     """
-    # Parse the CGX file using Collagraph's parser
-    parsed = parse_cgx_file(content)
-
-    # Check if there's a script section
-    if not parsed.script_node:
-        # No script section, nothing to lint
+    # Prepare content for linting
+    virtual_content = _prepare_content_for_linting(content)
+    if virtual_content is None:
         return []
 
-    # Get the line range of the script section
-    start_line, end_line = get_script_range(parsed.script_node)
-
-    # Create a modified version where non-script lines are commented out
-    source_lines = content.splitlines(keepends=True)
-
-    # Add newline to lines that don't have it (to make sure last line has it?)
-    source_lines = [
-        line if line.endswith("\n") else f"{line}\n" for line in source_lines
-    ]
-
-    script_range = range(start_line, end_line)
-
-    # Comment out all non-script lines to preserve line numbers
-    modified_lines = [
-        line if idx in script_range else "#\n" for idx, line in enumerate(source_lines)
-    ]
-
-    # Try to construct AST and append virtual render method
-    # This allows ruff to see template variable usage
-    virtual_content = create_virtual_render_content(content, modified_lines)
-
     # Run ruff on the virtual file
     diagnostics = _run_ruff(virtual_content)
 

ruff_cgx/utils.py

@@ -8,13 +8,13 @@
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
 from collagraph.sfc.compiler import construct_ast
 from collagraph.sfc.parser import CGXParser, Element
 
 # Module-level configuration for ruff command
-_ruff_command: Optional[str] = None
+_ruff_command: str | None = None
 
 
 def set_ruff_command(command: str) -> None:
@@ -68,10 +68,21 @@ class ParsedCGX:
     """Result of parsing a CGX file."""
 
     parser: CGXParser
-    script_node: Optional[Element]
+    script_node: Element | None
     template_nodes: List[Element]
 
 
+@dataclass
+class ScriptContent:
+    """Result of extracting Python content from a script node."""
+
+    python_code: str  # Pure Python content (without leading newline)
+    start_line: int  # 0-indexed line where Python actually starts
+    end_line: int  # 0-indexed line where </script> tag is
+    starts_on_new_line: bool  # Whether Python was on a new line after <script>
+    closing_tag_inline: bool  # Whether </script> is on same line as last Python code
+
+
 def parse_cgx_file(content: str) -> ParsedCGX:
     """
     Parse a CGX file and extract script and template nodes.
@@ -99,19 +110,59 @@ def parse_cgx_file(content: str) -> ParsedCGX:
     )
 
 
-def get_script_range(script_node: Element) -> tuple[int, int]:
+def extract_script_content(script_node: Element) -> ScriptContent | None:
     """
-    Get the line range of a script node.
+    Extract pure Python content from a script node.
+
+    This handles cases where Python code is on the same line as the <script> tag
+    by extracting the content from the TextElement child and determining the actual
+    line boundaries.
 
     Args:
         script_node: The script node from CGXParser
 
     Returns:
-        Tuple of (start_line, end_line) where end_line is exclusive
+        ScriptContent with pure Python code and location info, or None if no content
     """
-    start = script_node.location[0]
-    end = script_node.end[0] - 1  # -1 because end points to closing tag
-    return start, end
+    if not script_node.children:
+        return None
+
+    script_child = script_node.children[0]
+    python_content = script_child.content
+
+    # Get the line where the <script> tag starts and where it ends
+    script_tag_line = script_node.location[0] - 1  # Convert to 0-indexed
+    end_line = script_node.end[0] - 1  # End tag line (0-indexed)
+
+    # Determine if Python starts on a new line after <script>
+    starts_on_new_line = python_content.startswith("\n")
+
+    # Determine if closing tag is on the same line as Python code
+    # If column > 0, there's content before the closing tag
+    closing_tag_inline = script_node.end[1] > 0
+
+    # Strip leading newline if present
+    if starts_on_new_line:
+        python_content = python_content[1:]
+        start_line = script_tag_line + 1
+    else:
+        start_line = script_tag_line
+
+    # Strip leading/trailing whitespace from the Python content
+    # (parser may include spaces when tags are inline)
+    python_content = python_content.strip()
+
+    # Ensure content ends with a newline for proper formatting
+    if python_content and not python_content.endswith("\n"):
+        python_content += "\n"
+
+    return ScriptContent(
+        python_code=python_content,
+        start_line=start_line,
+        end_line=end_line,
+        starts_on_new_line=starts_on_new_line,
+        closing_tag_inline=closing_tag_inline,
+    )
 
 
 def create_virtual_render_content(