tlaplus-cli 0.3.4__tar.gz → 0.3.5__tar.gz

{tlaplus_cli-0.3.4/src/tlaplus_cli.egg-info → tlaplus_cli-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.4
+Version: 0.3.5
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -221,6 +229,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/README.md

@@ -141,6 +141,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -192,6 +200,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.3.4"
+version = "0.3.5"
 description = "TLA+ tools: download TLC, compile custom modules, run model checker"
 readme = "README.md"
 requires-python = ">=3.11"

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/build_tlc_module.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 import typer
 
-from tlaplus_cli.config import cache_dir, load_config, workspace_root
+from tlaplus_cli.config import cache_dir, load_config, save_config, workspace_root
 from tlaplus_cli.version_manager import get_pinned_version_dir
 
 
@@ -28,9 +28,8 @@ def build(
         typer.echo("Error: tla2tools.jar not found.\nRun 'tla tools install' first.", err=True)
         raise typer.Exit(1)
 
-    modules_dir = base_dir / config.workspace.modules_dir
+    modules_dir = Path(config.module_path) if config.module_path else base_dir / config.workspace.modules_dir
     classes_dir = base_dir / config.workspace.classes_dir
-
     lib_dir = base_dir / "lib"
     lib_jars = sorted(lib_dir.glob("*.jar")) if lib_dir.is_dir() else []
     classpath = os.pathsep.join([str(jar_path)] + [str(j) for j in lib_jars])
@@ -71,3 +70,17 @@ def build(
     except FileNotFoundError:
         typer.echo("Error: 'javac' not found. Ensure JDK is installed and in PATH.", err=True)
         raise typer.Exit(1) from None
+
+
+def set_modules_path(path: str = typer.Argument(..., help="Path to the custom Java modules directory.")) -> None:
+    """Configure a persistent custom Java modules path."""
+    config_obj = load_config()
+    p = Path(path).resolve()
+
+    if not p.is_dir():
+        typer.echo(f"Error: Path does not exist or is not a directory: {p}", err=True)
+        raise typer.Exit(1)
+
+    config_obj.module_path = str(p)
+    save_config(config_obj)
+    typer.echo(f"Modules path updated to: {p}")

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/cli.py

@@ -5,6 +5,7 @@ import importlib.metadata
 import typer
 
 from tlaplus_cli.build_tlc_module import build as build_tlc_cmd
+from tlaplus_cli.build_tlc_module import set_modules_path
 from tlaplus_cli.check_java import check_java_version, get_java_version
 from tlaplus_cli.config import load_config
 from tlaplus_cli.run_tlc import tlc as run_tlc_cmd
@@ -50,6 +51,7 @@ def root(
 # Attach typer subgroups
 modules_app = typer.Typer(name="modules", help="Manage TLA+ Java modules.", no_args_is_help=True)
 modules_app.command(name="build")(build_tlc_cmd)
+modules_app.command(name="path")(set_modules_path)
 
 app.add_typer(modules_app, name="modules")
 app.add_typer(tools_app, name="tools")

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/config.py

@@ -17,11 +17,31 @@ def load_config() -> Settings:
     Creates a default config on first run.
     """
     cp = _ensure_config()
-    with cp.open() as f:
+    with cp.open(encoding="utf-8") as f:
         data = yaml.safe_load(f)
         return Settings.model_validate(data)
 
 
+def save_config(settings: Settings) -> None:
+    """Save config to the user config directory.
+
+    Uses a defensive deep copy of settings.
+    """
+    cp = config_path()
+    # defensive deep copy as per plan
+    base_settings = settings.model_copy(deep=True)
+
+    # Convert to dict, excluding None values for a cleaner config if desired,
+    # but the plan doesn't specify exclusion. Pydantic's model_dump is good.
+    data = base_settings.model_dump(mode="json")
+
+    with cp.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(data, f, default_flow_style=False)
+
+    # Clear cache to ensure subsequent loads get the new data
+    load_config.cache_clear()
+
+
 def config_dir() -> Path:
     """OS-standard user config directory for this app."""
     return Path(platformdirs.user_config_dir(_APP_NAME))

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/run_tlc.py

@@ -85,6 +85,15 @@ def tlc(
 
     classpath_parts = [str(jar_path)]
     extra_jvm_opts: list[str] = []
+
+    if config.module_path:
+        custom_path = Path(config.module_path)
+        if custom_path.is_dir():
+            # Phase 4: safely append the custom directory path to the Java -cp mechanism
+            classpath_parts.append(str(custom_path))
+            # Also add to TLA-Library for convenience if TLA modules are there
+            extra_jvm_opts.append(f"-DTLA-Library={custom_path}")
+
     if project_root:
         classes_path = project_root / config.workspace.classes_dir
         if classes_path.is_dir():

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/settings.py

@@ -46,3 +46,4 @@ class Settings(BaseModel):
     workspace: WorkspaceConfig
     tlc: TlcConfig
     java: JavaConfig = Field(default_factory=JavaConfig)
+    module_path: str | None = None

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli/version_manager.py

@@ -58,10 +58,7 @@ def download_version_from_url(url: str) -> Path:
     """
     version_name = extract_version_from_url(url)
     if version_name is None:
-        msg = (
-            'could not extract a version name from the URL. '
-            'The URL must contain a version segment (e.g. "v1.8.0").'
-        )
+        msg = 'could not extract a version name from the URL. The URL must contain a version segment (e.g. "v1.8.0").'
         raise ValueError(msg)
 
     tag = _utc_now_iso()
@@ -419,7 +416,8 @@ def _fetch_from_api(
         releases_response = requests.get(releases_url, params=params, timeout=10)
         releases_response.raise_for_status()
         releases_data: list[dict[str, Any]] = releases_response.json()
-    except requests.RequestException:
+    except Exception as e:
+        typer.echo(f"⚠ Warning: Failed to fetch remote versions: {e}", err=True)
         return None
     else:
         return tags_data, releases_data

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5/src/tlaplus_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.4
+Version: 0.3.5
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -221,6 +229,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/src/tlaplus_cli.egg-info/SOURCES.txt

@@ -21,12 +21,9 @@ src/tlaplus_cli.egg-info/requires.txt
 src/tlaplus_cli.egg-info/top_level.txt
 src/tlaplus_cli/resources/__init__.py
 src/tlaplus_cli/resources/default_config.yaml
-tests/test_build_tlc_module.py
-tests/test_check_java.py
+tests/test_build_modules_path.py
 tests/test_cli.py
-tests/test_java_module_naming.py
-tests/test_project.py
-tests/test_run_tlc.py
-tests/test_spec_resolution.py
-tests/test_tools_manager.py
-tests/test_version_manager.py
+tests/test_config.py
+tests/test_modules_path.py
+tests/test_settings.py
+tests/test_tlc_modules_path.py

tlaplus_cli-0.3.5/tests/test_build_modules_path.py

@@ -0,0 +1,50 @@
+from tlaplus_cli.cli import app
+
+
+def test_build_uses_configured_module_path(mocker, tmp_path, base_settings, runner):
+    """Test that build uses module_path from config if available."""
+    # Custom module path
+    custom_modules = tmp_path / "custom_modules"
+    custom_modules.mkdir()
+    (custom_modules / "MyModule.java").write_text("class MyModule {}")
+
+    # Update settings
+    settings = base_settings.model_copy(deep=True)
+    settings.module_path = str(custom_modules)
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=settings)
+
+    # Mock subprocess.run
+    mock_run = mocker.patch("tlaplus_cli.build_tlc_module.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    # Mock jar path
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.build_tlc_module.get_pinned_version_dir", return_value=pinned_dir)
+
+    result = runner.invoke(app, ["modules", "build"])
+
+    assert result.exit_code == 0
+    args, _ = mock_run.call_args
+    cmd = args[0]
+    # Source file should be from custom_modules
+    assert str(custom_modules / "MyModule.java") in cmd
+
+
+def test_build_fails_if_module_path_missing(mocker, tmp_path, base_settings, runner):
+    """Test that build fails if the configured module_path does not exist."""
+    settings = base_settings.model_copy(deep=True)
+    settings.module_path = str(tmp_path / "non_existent")
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=settings)
+
+    # Mock jar path
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.build_tlc_module.get_pinned_version_dir", return_value=pinned_dir)
+
+    result = runner.invoke(app, ["modules", "build"])
+
+    assert result.exit_code == 1
+    assert "Error: modules directory not found" in result.output

{tlaplus_cli-0.3.4 → tlaplus_cli-0.3.5}/tests/test_cli.py

@@ -1,11 +1,8 @@
 import pytest
 import typer
-from typer.testing import CliRunner
 
 from tlaplus_cli.cli import app, version_callback
 
-runner = CliRunner()
-
 
 def test_version_callback_exits(mocker):
     """Test version callback exits after printing."""
@@ -22,7 +19,7 @@ def test_version_callback_exits(mocker):
     mock_metadata.assert_called_once_with("tlaplus-cli")
 
 
-def test_cli_version_flag(mocker):
+def test_cli_version_flag(mocker, runner):
     """Test 'tla --version' command."""
     mock_metadata = mocker.patch("importlib.metadata.metadata")
     mock_metadata.return_value = {

tlaplus_cli-0.3.5/tests/test_config.py

@@ -0,0 +1,99 @@
+from tlaplus_cli import config
+
+
+def test_config_paths(mocker, tmp_path):
+    """Test config_dir, config_path, cache_dir return correct paths."""
+    mocker.patch("platformdirs.user_config_dir", return_value=str(tmp_path / "config"))
+    mocker.patch("platformdirs.user_cache_dir", return_value=str(tmp_path / "cache"))
+
+    assert config.config_dir() == tmp_path / "config"
+    assert config.config_path() == tmp_path / "config" / "config.yaml"
+    assert config.cache_dir() == tmp_path / "cache"
+
+
+def test_ensure_config_creates_default(mocker, tmp_path):
+    """_ensure_config creates the config file if it doesn't exist."""
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+
+    assert not config_path.exists()
+    path = config._ensure_config()
+    assert path == config_path
+    assert config_path.exists()
+    assert "workspace:" in config_path.read_text()
+
+
+def test_load_config_caching(mocker, tmp_path):
+    """load_config should be cached."""
+    config.load_config.cache_clear()
+
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config._ensure_config()
+
+    # First call
+    c1 = config.load_config()
+    # Second call should return the same object from cache
+    c2 = config.load_config()
+    assert c1 is c2
+
+
+def test_workspace_root_absolute(mocker, tmp_path):
+    """workspace_root returns absolute path when config has absolute path."""
+    abs_path = (tmp_path / "my_ws").absolute()
+    mock_settings = mocker.MagicMock()
+    mock_settings.workspace.root = str(abs_path)
+    mocker.patch("tlaplus_cli.config.load_config", return_value=mock_settings)
+
+    assert config.workspace_root() == abs_path
+
+
+def test_load_module_path(mocker, tmp_path):
+    """Test that module_path can be loaded from config."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    config_content = """
+tla:
+  urls:
+    tags: https://example.com/tags
+    releases: https://example.com/releases
+    per_page: 30
+workspace:
+  root: .
+  spec_dir: spec
+  modules_dir: modules
+  classes_dir: classes
+tlc:
+  java_class: tlc2.TLC
+  overrides_class: tlc2.overrides.TLCOverrides
+module_path: /custom/path
+"""
+    config_path.write_text(config_content)
+
+    cfg = config.load_config()
+    assert cfg.module_path == "/custom/path"
+
+
+def test_save_config(mocker, tmp_path):
+    """Test saving config preserves module_path and uses deep copy."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    cfg = config.load_config()
+    cfg.module_path = "/new/path"
+
+    config.save_config(cfg)
+
+    # Reload and check
+    config.load_config.cache_clear()
+    new_cfg = config.load_config()
+    assert new_cfg.module_path == "/new/path"
+    assert "module_path: /new/path" in config_path.read_text()

tlaplus_cli-0.3.5/tests/test_modules_path.py

@@ -0,0 +1,62 @@
+from tlaplus_cli import config
+from tlaplus_cli.cli import app
+
+
+def test_modules_path_success(mocker, tmp_path, runner):
+    """Test successful setting of modules path."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    # Create a dummy module directory
+    module_dir = tmp_path / "my_modules"
+    module_dir.mkdir()
+
+    result = runner.invoke(app, ["modules", "path", str(module_dir)])
+
+    assert result.exit_code == 0
+    assert f"Modules path updated to: {module_dir}" in result.output
+
+    # Check config
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path == str(module_dir)
+
+
+def test_modules_path_invalid_dir(mocker, tmp_path, runner):
+    """Test setting modules path to non-existent directory fails."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    invalid_dir = tmp_path / "does_not_exist"
+
+    result = runner.invoke(app, ["modules", "path", str(invalid_dir)])
+
+    assert result.exit_code == 1
+    assert "Error: Path does not exist or is not a directory" in result.output
+
+    # Check config was NOT updated
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path is None
+
+
+def test_modules_path_file_instead_of_dir(mocker, tmp_path, runner):
+    """Test setting modules path to a file fails."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    some_file = tmp_path / "some_file.txt"
+    some_file.write_text("hello")
+
+    result = runner.invoke(app, ["modules", "path", str(some_file)])
+
+    assert result.exit_code == 1
+    assert "Error: Path does not exist or is not a directory" in result.output
+
+    # Check config was NOT updated
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path is None

tlaplus_cli-0.3.5/tests/test_settings.py

@@ -0,0 +1,38 @@
+import os
+
+from tlaplus_cli.settings import JavaConfig
+
+
+def test_java_config_default_opts():
+    """Default opts are set if JAVA_OPTS is not present."""
+    if "JAVA_OPTS" in os.environ:
+        del os.environ["JAVA_OPTS"]
+
+    config = JavaConfig()
+    assert "-XX:+UseParallelGC" in config.opts
+
+
+def test_java_config_env_opts_overrides(monkeypatch):
+    """JAVA_OPTS environment variable overrides the default opts."""
+    monkeypatch.setenv("JAVA_OPTS", "-Xmx4G -Xms2G")
+
+    # We must pass something to trigger the validator since it's a model_validator(mode="before")
+    # Actually, pydantic calls it even for default instantiation if not careful,
+    # but here it's called with 'data' which is the dict passed to __init__ or empty dict.
+
+    config = JavaConfig()
+    assert config.opts == ["-Xmx4G", "-Xms2G"]
+
+
+def test_java_config_env_opts_empty(monkeypatch):
+    """Empty JAVA_OPTS should be ignored (keep defaults)."""
+    monkeypatch.setenv("JAVA_OPTS", "")
+    config = JavaConfig()
+    assert "-XX:+UseParallelGC" in config.opts
+
+
+def test_java_config_explicit_opts_with_env(monkeypatch):
+    """JAVA_OPTS should override even explicitly passed opts in model_validator(mode='before')."""
+    monkeypatch.setenv("JAVA_OPTS", "-Xmx1G")
+    config = JavaConfig(opts=["-Xmx2G"])
+    assert config.opts == ["-Xmx1G"]

tlaplus_cli-0.3.5/tests/test_tlc_modules_path.py

@@ -0,0 +1,43 @@
+from tlaplus_cli.cli import app
+
+
+def test_tlc_uses_custom_module_path(mocker, tmp_path, base_settings, runner):
+    """Test that tlc uses module_path for classpath and TLA-Library."""
+    # Custom module path
+    custom_modules = tmp_path / "custom_modules"
+    custom_modules.mkdir()
+
+    # Update settings
+    settings = base_settings.model_copy(deep=True)
+    settings.module_path = str(custom_modules)
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=settings)
+
+    # Mock jar path
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.run_tlc.get_pinned_version_dir", return_value=pinned_dir)
+
+    # Create a dummy spec
+    spec_file = tmp_path / "MySpec.tla"
+    spec_file.write_text("---- MODULE MySpec ----\n====\n")
+
+    # Mock subprocess.run
+    mock_run = mocker.patch("tlaplus_cli.run_tlc.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    # Mock check_java_version to avoid potential Mock issues
+    mocker.patch("tlaplus_cli.run_tlc.check_java_version")
+
+    result = runner.invoke(app, ["tlc", str(spec_file)])
+
+    assert result.exit_code == 0
+    args, _kwargs = mock_run.call_args
+    cmd = args[0]
+    cmd_str = " ".join(cmd)
+
+    # Phase 4: append the custom directory path to the Java -cp mechanism
+    assert str(custom_modules) in cmd_str
+
+    # It should also probably be in TLA-Library
+    assert f"-DTLA-Library={custom_modules}" in cmd_str