avrae-ls 0.6.1__tar.gz → 0.6.3__tar.gz

{avrae_ls-0.6.1 → avrae_ls-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.6.1
+Version: 0.6.3
 Summary: Language server for Avrae draconic aliases
 Author: 1drturtle
 License: MIT License

{avrae_ls-0.6.1 → avrae_ls-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "avrae-ls"
-version = "0.6.1"
+version = "0.6.3"
 description = "Language server for Avrae draconic aliases"
 authors = [
   { name = "1drturtle" }

{avrae_ls-0.6.1 → avrae_ls-0.6.3}/src/avrae_ls/__main__.py

@@ -2,16 +2,24 @@ from __future__ import annotations
 
 import argparse
 import asyncio
+import difflib
 import logging
 import sys
 from pathlib import Path
-from typing import Iterable
+from typing import Any, Iterable
 
 import yaml
 
 from lsprotocol import types
 
-from .alias_tests import AliasTestError, AliasTestResult, discover_test_files, parse_alias_tests, run_alias_tests
+from .alias_tests import (
+    AliasTestError,
+    AliasTestResult,
+    diff_mismatched_parts,
+    discover_test_files,
+    parse_alias_tests,
+    run_alias_tests,
+)
 from .config import CONFIG_FILENAME, load_config
 from .context import ContextBuilder
 from .diagnostics import DiagnosticProvider
@@ -81,7 +89,7 @@ def _run_analysis(path: Path) -> int:
     log = logging.getLogger(__name__)
     log.info("Analyzing %s (workspace root: %s)", path, workspace_root)
 
-    config, warnings = load_config(workspace_root)
+    config, warnings = load_config(workspace_root, default_enable_gvar_fetch=True)
     for warning in warnings:
         log.warning(warning)
 
@@ -105,7 +113,7 @@ def _run_alias_tests(target: Path) -> int:
     log = logging.getLogger(__name__)
     log.info("Running alias tests in %s (workspace root: %s)", target, workspace_root)
 
-    config, warnings = load_config(workspace_root)
+    config, warnings = load_config(workspace_root, default_enable_gvar_fetch=True)
     for warning in warnings:
         log.warning(warning)
 
@@ -152,15 +160,69 @@ def _print_test_results(results: Iterable[AliasTestResult], workspace_root: Path
             print(f"  Error: {res.error}")
         if res.details:
             print(f"  {res.details}")
-        expected = _format_value(res.case.expected)
-        actual = _format_value(res.actual)
-        print(f"  Expected: {expected}")
-        print(f"  Actual:   {actual}")
+        expected_val, actual_val = _summarize_mismatch(res.case.expected, res.actual)
+        expected = _format_value(expected_val)
+        actual = _format_value(actual_val)
+        _print_labeled_value("Expected", expected)
+        _print_labeled_value("Actual", actual)
+        diff = _render_diff(expected, actual)
+        if diff:
+            print("  Diff:")
+            for line in diff.splitlines():
+                print(f"    {line}")
         if res.stdout:
             print(f"  Stdout: {res.stdout.strip()}")
     print(f"{passed}/{total} tests passed")
 
 
+def _summarize_mismatch(expected: Any, actual: Any) -> tuple[Any, Any]:
+    diff = diff_mismatched_parts(expected, actual)
+    if diff is None:
+        return expected, actual
+    return diff
+
+
+def _render_diff(expected: str, actual: str) -> str:
+    expected_lines = expected.splitlines() or [""]
+    actual_lines = actual.splitlines() or [""]
+    if expected_lines == actual_lines:
+        return ""
+    diff_lines = list(
+        difflib.unified_diff(
+            expected_lines,
+            actual_lines,
+            fromfile="expected",
+            tofile="actual",
+            lineterm="",
+        )
+    )
+    if not diff_lines:
+        return ""
+    return "\n".join(_colorize_diff_line(line) for line in diff_lines)
+
+
+def _colorize_diff_line(line: str) -> str:
+    if not sys.stdout.isatty():
+        return line
+    if line.startswith("-"):
+        return f"\x1b[31m{line}\x1b[0m"
+    if line.startswith("+"):
+        return f"\x1b[32m{line}\x1b[0m"
+    if line.startswith("@@") or line.startswith("---") or line.startswith("+++"):
+        return f"\x1b[36m{line}\x1b[0m"
+    return line
+
+
+def _print_labeled_value(label: str, value: str) -> None:
+    lines = value.splitlines() or [""]
+    if len(lines) == 1:
+        print(f"  {label}: {lines[0]}")
+        return
+    print(f"  {label}:")
+    for line in lines:
+        print(f"    {line}")
+
+
 def _relative_to_workspace(path: Path, workspace_root: Path) -> str:
     try:
         return str(path.relative_to(workspace_root))
@@ -168,7 +230,7 @@ def _relative_to_workspace(path: Path, workspace_root: Path) -> str:
         return str(path)
 
 
-def _format_value(value) -> str:
+def _format_value(value: Any) -> str:
     if value is None:
         return "None"
     if isinstance(value, (dict, list)):

{avrae_ls-0.6.1 → avrae_ls-0.6.3}/src/avrae_ls/alias_tests.py

@@ -13,6 +13,8 @@ from .context import ContextBuilder
 from .runtime import MockExecutor
 from .config import VarSources
 
+MISSING_VALUE = "<missing>"
+
 
 class AliasTestError(Exception):
     """Raised when an alias test cannot be parsed or executed."""
@@ -224,6 +226,44 @@ def _value_matches(expected: Any, actual: Any) -> bool:
     return _scalar_matches(expected, actual)
 
 
+def diff_mismatched_parts(expected: Any, actual: Any) -> tuple[Any, Any] | None:
+    if _value_matches(expected, actual):
+        return None
+
+    if isinstance(expected, dict) and isinstance(actual, dict):
+        expected_diff: dict[str, Any] = {}
+        actual_diff: dict[str, Any] = {}
+        for key, expected_val in expected.items():
+            if key not in actual:
+                expected_diff[key] = expected_val
+                actual_diff[key] = MISSING_VALUE
+                continue
+            sub_diff = diff_mismatched_parts(expected_val, actual[key])
+            if sub_diff:
+                expected_diff[key], actual_diff[key] = sub_diff
+        if expected_diff:
+            return expected_diff, actual_diff
+        return expected, actual
+
+    if isinstance(expected, list) and isinstance(actual, list):
+        expected_diff: list[Any] = []
+        actual_diff: list[Any] = []
+        for idx, expected_val in enumerate(expected):
+            if idx >= len(actual):
+                expected_diff.append(expected_val)
+                actual_diff.append(MISSING_VALUE)
+                continue
+            sub_diff = diff_mismatched_parts(expected_val, actual[idx])
+            if sub_diff:
+                expected_diff.append(sub_diff[0])
+                actual_diff.append(sub_diff[1])
+        if expected_diff:
+            return expected_diff, actual_diff
+        return expected, actual
+
+    return expected, actual
+
+
 def _split_command(command: str, path: Path) -> list[str]:
     try:
         tokens = shlex.split(command, posix=True)

{avrae_ls-0.6.1 → avrae_ls-0.6.3}/src/avrae_ls/config.py

@@ -387,11 +387,16 @@ def _coerce_optional_str(value: Any) -> str | None:
     return value_str if value_str.strip() else None
 
 
-def load_config(workspace_root: Path) -> Tuple[AvraeLSConfig, Iterable[str]]:
+def load_config(workspace_root: Path, *, default_enable_gvar_fetch: bool = False) -> Tuple[AvraeLSConfig, Iterable[str]]:
     """Load `.avraels.json` from the workspace root, returning config and warnings."""
     path = workspace_root / CONFIG_FILENAME
     if not path.exists():
-        return AvraeLSConfig.default(workspace_root), []
+        cfg = AvraeLSConfig.default(workspace_root)
+        cfg.enable_gvar_fetch = default_enable_gvar_fetch
+        env_token = _coerce_optional_str(os.environ.get("AVRAE_TOKEN"))
+        if env_token:
+            cfg.service.token = env_token
+        return cfg, []
 
     try:
         raw = json.loads(path.read_text())
@@ -411,12 +416,13 @@ def load_config(workspace_root: Path) -> Tuple[AvraeLSConfig, Iterable[str]]:
         warnings.append(warning)
         log.warning(warning)
 
-    enable_gvar_fetch = bool(raw.get("enableGvarFetch", False))
+    enable_gvar_fetch = bool(raw.get("enableGvarFetch", default_enable_gvar_fetch))
 
     service_cfg = raw.get("avraeService") or {}
+    env_token = _coerce_optional_str(env.get("AVRAE_TOKEN"))
     service = AvraeServiceConfig(
         base_url=str(service_cfg.get("baseUrl") or AvraeServiceConfig.base_url),
-        token=_coerce_optional_str(service_cfg.get("token")),
+        token=_coerce_optional_str(service_cfg.get("token")) or env_token,
     )
 
     diag_cfg = raw.get("diagnostics") or {}