strictcli 0.14.0__tar.gz → 0.15.0__tar.gz

strictcli-0.15.0/.rlsbl/changes/.validated

@@ -0,0 +1 @@
+a6dff298b7a2dad7fa928b088eeb4f3f9c0b2cf5

strictcli-0.15.0/.rlsbl/changes/0.15.0.jsonl

@@ -0,0 +1,6 @@
+{"commits":["057edc5200703fe2a2d37d28f488833b35254a06"],"user_facing":false}
+{"commits":["e6af4e228227d55585c09ec9012cca846eff2651"],"user_facing":false}
+{"commits":["e5dc999d0d920ba0737d2c565be818af8465de1c"],"user_facing":true,"description":"**Breaking.** `config set` now validates keys against registered flags and rejects unknown keys.","type":"breaking"}
+{"commits":["e5dc999d0d920ba0737d2c565be818af8465de1c"],"user_facing":true,"description":"**New feature.** `config set` coerces values to the flag's declared type (int, bool, float) before writing to config.","type":"feature"}
+{"commits":["4cf2df20f76491a8d9b504307de8d78ca514e7ab"],"user_facing":false}
+{"commits":["050a53f9af245a308f6d5895307beb7f479c9c27"],"user_facing":false}

strictcli-0.15.0/.rlsbl/releases/v0.15.0.toml

@@ -0,0 +1,8 @@
+# Version bump type: patch, minor, or major
+bump = "minor"
+# Short description of this release (required)
+description = "Config set type coercion and key validation"
+# Optional context explaining why these changes were made
+context = "config set now validates keys against registered flags and coerces string values to the flag's declared type before writing. This is a breaking change: unknown keys are rejected."
+include = ["pypi", "npm"]
+exclude = []

{strictcli-0.14.0 → strictcli-0.15.0}/CHANGELOG.md

@@ -2,17 +2,27 @@
 
 # Changelog
 
-## 0.14.0
+## 0.15.0
 
-checks_embed for inline TOML data
+Config set type coercion and key validation
 
 <details>
 <summary>Context</summary>
 
-Adds checks_embed parameter as an alternative to checks_path, allowing TOML bytes to be passed directly without requiring a file on disk.
+config set now validates keys against registered flags and coerces string values to the flag's declared type before writing. This is a breaking change: unknown keys are rejected.
 
 </details>
 
+### Breaking
+
+- **Breaking.** `config set` now validates keys against registered flags and rejects unknown keys.
+
+### Features
+
+- **New feature.** `config set` coerces values to the flag's declared type (int, bool, float) before writing to config.
+
+## 0.14.0
+
 ### Features
 
 - **New feature.** `checks_embed` parameter accepts raw TOML bytes, enabling inline checks configuration without a file on disk.

{strictcli-0.14.0 → strictcli-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: strictcli
-Version: 0.14.0
+Version: 0.15.0
 Summary: A strict, zero-dependency CLI framework for Python
 Project-URL: Homepage, https://github.com/smm-h/strictcli
 Project-URL: Repository, https://github.com/smm-h/strictcli

{strictcli-0.14.0 → strictcli-0.15.0}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "strictcli",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "strictcli",
-      "version": "0.14.0",
+      "version": "0.15.0",
       "hasInstallScript": true,
       "license": "MIT"
     }

{strictcli-0.14.0 → strictcli-0.15.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strictcli",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "A strict, zero-dependency CLI framework for Python (npm wrapper)",
   "main": "index.js",
   "scripts": {

{strictcli-0.14.0 → strictcli-0.15.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "strictcli"
-version = "0.14.0"
+version = "0.15.0"
 description = "A strict, zero-dependency CLI framework for Python"
 readme = "README.md"
 license = "MIT"

{strictcli-0.14.0 → strictcli-0.15.0}/strictcli/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.14.0"
+__version__ = "0.15.0"
 
 __all__ = [
     "App", "Flag", "Arg", "Tag", "MutexGroup", "CoRequired", "Requires",
@@ -285,6 +285,21 @@ class _ParseError(Exception):
         self.command_prefix = command_prefix
 
 
+def _strict_bool(s: str) -> bool:
+    """Parse a boolean string strictly.
+
+    Accepts: 1, true, yes (case-insensitive) -> True
+    Accepts: 0, false, no (case-insensitive) -> False
+    Everything else raises ValueError.
+    """
+    lower = s.lower()
+    if lower in ("1", "true", "yes"):
+        return True
+    if lower in ("0", "false", "no"):
+        return False
+    raise ValueError(f"expected boolean, got '{s}'")
+
+
 def _strict_int(s: str) -> int:
     """Parse an integer string strictly -- no leading/trailing whitespace allowed.
 
@@ -1014,7 +1029,7 @@ class App:
         )
 
         # config set
-        def _config_set_handler(key, value, **_kw) -> None:
+        def _config_set_handler(key, value, **_kw) -> int:
             path = _config_path(
                 app_ref.name,
                 override=app_ref.config_path,
@@ -1023,26 +1038,53 @@ class App:
             dir_path = os.path.dirname(path)
             os.makedirs(dir_path, exist_ok=True)
             # Read existing config
-            existing: dict = {}
-            if os.path.isfile(path):
-                if app_ref.config_format == "toml":
+            existing = _load_config(
+                app_ref.name,
+                config_path_override=app_ref.config_path,
+                config_format=app_ref.config_format,
+            )
+
+            # Look up the key against registered flags
+            all_flags = app_ref._collect_all_flags()
+            matched_flag = None
+            for f in all_flags:
+                if _flag_param_name(f.name) == key:
+                    matched_flag = f
+                    break
+            if matched_flag is None:
+                print(f"config set: unknown key '{key}'", file=sys.stderr)
+                return 1
+
+            # Coerce the string value to the flag's type
+            try:
+                if matched_flag.type == bool:
+                    typed_value = _strict_bool(value)
+                elif matched_flag.type == int:
                     try:
-                        with open(path, "rb") as fh:
-                            existing = tomllib.load(fh)
-                    except (tomllib.TOMLDecodeError, UnicodeDecodeError):
-                        existing = {}
-                else:
+                        typed_value = _strict_int(value)
+                    except ValueError:
+                        raise ValueError(f"expected integer, got '{value}'")
+                elif matched_flag.type == float:
                     try:
-                        with open(path) as fh:
-                            existing = json.loads(fh.read())
-                    except (json.JSONDecodeError, ValueError):
-                        existing = {}
-            existing[key] = value
+                        typed_value = _strict_float(value)
+                    except ValueError as fe:
+                        msg = str(fe)
+                        if msg in ("NaN is not allowed", "Inf is not allowed"):
+                            raise
+                        raise ValueError(f"expected float, got '{value}'") from fe
+                else:  # str
+                    typed_value = value
+            except ValueError as e:
+                print(f"config set: key '{key}': {e}", file=sys.stderr)
+                return 1
+
+            existing[key] = typed_value
             if app_ref.config_format == "toml":
                 _write_toml_flat(existing, path)
             else:
                 with open(path, "w") as fh:
                     fh.write(json.dumps(existing, indent=2) + "\n")
+            return 0
 
         config_grp.commands["set"] = Command(
             name="set",
@@ -1362,12 +1404,9 @@ class App:
                 env_val = os.environ.get(f.env)
                 if env_val is not None:
                     if f.type is bool:
-                        lower = env_val.lower()
-                        if lower in ("1", "true", "yes"):
-                            cli_set[f.name] = True
-                        elif lower in ("0", "false", "no"):
-                            cli_set[f.name] = False
-                        else:
+                        try:
+                            cli_set[f.name] = _strict_bool(env_val)
+                        except ValueError:
                             raise _ParseError(
                                 f"invalid boolean value {env_val!r} for env var "
                                 f"'{f.env}' (flag '--{f.name}')"
@@ -1760,12 +1799,9 @@ def _parse_command(
             env_val = os.environ.get(f.env)
             if env_val is not None:
                 if f.type is bool:
-                    lower = env_val.lower()
-                    if lower in ("1", "true", "yes"):
-                        cli_set[f.name] = True
-                    elif lower in ("0", "false", "no"):
-                        cli_set[f.name] = False
-                    else:
+                    try:
+                        cli_set[f.name] = _strict_bool(env_val)
+                    except ValueError:
                         raise _ParseError(
                             f"invalid boolean value {env_val!r} for env var "
                             f"'{f.env}' (flag '--{f.name}')"

strictcli-0.15.0/tests/test_config_set_bugs.py

@@ -0,0 +1,242 @@
+"""Red tests for config set bugs.
+
+These tests document bugs in the config set command and are expected to
+FAIL with the current code. They will turn green when the bugs are fixed.
+
+Bug 0.4: config set stores raw strings instead of typed values.
+Bug 0.6: config set accepts unknown keys without validation.
+"""
+
+import json
+
+import strictcli
+
+
+def test_config_set_writes_typed_values(tmp_path):
+    """config set should write typed values (int, bool, float), not strings.
+
+    Bug: _config_set_handler stores the raw string from argv without
+    coercing it to the flag's declared type. So 'config set count 42'
+    writes {"count": "42"} instead of {"count": 42}.
+    """
+    config_file = tmp_path / "config.json"
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("count", type=int, help="how many", default=0)
+    @strictcli.flag("verbose", type=bool, help="be verbose", default=False)
+    @strictcli.flag("rate", type=float, help="the rate", default=0.0)
+    def run(count, verbose, rate):
+        pass
+
+    r = app.test(["config", "set", "count", "42"])
+    assert r.exit_code == 0
+
+    r = app.test(["config", "set", "verbose", "true"])
+    assert r.exit_code == 0
+
+    r = app.test(["config", "set", "rate", "3.14"])
+    assert r.exit_code == 0
+
+    data = json.loads(config_file.read_text())
+    assert isinstance(data["count"], int), f"expected int, got {type(data['count']).__name__}: {data['count']!r}"
+    assert data["count"] == 42
+    assert isinstance(data["verbose"], bool), f"expected bool, got {type(data['verbose']).__name__}: {data['verbose']!r}"
+    assert data["verbose"] is True
+    assert isinstance(data["rate"], float), f"expected float, got {type(data['rate']).__name__}: {data['rate']!r}"
+    assert data["rate"] == 3.14
+
+
+def test_config_set_rejects_unknown_key(tmp_path):
+    """config set should reject keys that don't correspond to any registered flag.
+
+    Bug: _config_set_handler accepts any key without checking if it
+    matches a registered flag. 'config set nonexistent value' silently
+    writes {"nonexistent": "value"} to the config file.
+    """
+    config_file = tmp_path / "config.json"
+
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("name", type=str, help="the name", default="")
+    def run(name):
+        pass
+
+    r = app.test(["config", "set", "nonexistent", "value"])
+    assert r.exit_code != 0, f"expected nonzero exit code, got {r.exit_code}"
+    assert "nonexistent" in r.stderr, f"expected error about unknown key in stderr, got: {r.stderr!r}"
+
+
+def _make_app(tmp_path, **extra_flags):
+    """Helper: create an app with common typed flags for config set tests."""
+    config_file = tmp_path / "config.json"
+    app = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    @app.command("run", help="run something")
+    @strictcli.flag("debug", type=bool, help="debug mode", default=False)
+    @strictcli.flag("count", type=int, help="how many", default=0)
+    @strictcli.flag("rate", type=float, help="the rate", default=0.0)
+    @strictcli.flag("name", type=str, help="the name", default="")
+    def run(debug, count, rate, name):
+        pass
+
+    return app, config_file
+
+
+def test_config_set_typed_bool(tmp_path):
+    """config set coerces boolean values and stores them as JSON booleans."""
+    app, config_file = _make_app(tmp_path)
+
+    for true_val in ("true", "yes", "1", "True", "YES"):
+        r = app.test(["config", "set", "debug", true_val])
+        assert r.exit_code == 0, f"exit_code={r.exit_code} for '{true_val}': {r.stderr}"
+        data = json.loads(config_file.read_text())
+        assert data["debug"] is True, f"expected True for '{true_val}', got {data['debug']!r}"
+
+    for false_val in ("false", "no", "0", "False", "NO"):
+        r = app.test(["config", "set", "debug", false_val])
+        assert r.exit_code == 0, f"exit_code={r.exit_code} for '{false_val}': {r.stderr}"
+        data = json.loads(config_file.read_text())
+        assert data["debug"] is False, f"expected False for '{false_val}', got {data['debug']!r}"
+
+
+def test_config_set_typed_int(tmp_path):
+    """config set coerces integer values and stores them as JSON integers."""
+    app, config_file = _make_app(tmp_path)
+
+    r = app.test(["config", "set", "count", "42"])
+    assert r.exit_code == 0
+    data = json.loads(config_file.read_text())
+    assert isinstance(data["count"], int)
+    assert data["count"] == 42
+
+    r = app.test(["config", "set", "count", "0"])
+    assert r.exit_code == 0
+    data = json.loads(config_file.read_text())
+    assert isinstance(data["count"], int)
+    assert data["count"] == 0
+
+
+def test_config_set_typed_float(tmp_path):
+    """config set coerces float values and stores them as JSON floats."""
+    app, config_file = _make_app(tmp_path)
+
+    r = app.test(["config", "set", "rate", "3.14"])
+    assert r.exit_code == 0
+    data = json.loads(config_file.read_text())
+    assert isinstance(data["rate"], float)
+    assert data["rate"] == 3.14
+
+    # Integer-like value stored as float when flag type is float
+    r = app.test(["config", "set", "rate", "3"])
+    assert r.exit_code == 0
+    data = json.loads(config_file.read_text())
+    assert isinstance(data["rate"], float)
+    assert data["rate"] == 3.0
+
+
+def test_config_set_bad_value(tmp_path):
+    """config set rejects values that don't parse as the flag's type."""
+    app, _ = _make_app(tmp_path)
+
+    # Bad int
+    r = app.test(["config", "set", "count", "abc"])
+    assert r.exit_code != 0
+    assert "expected integer, got 'abc'" in r.stderr
+
+    # Bad bool
+    r = app.test(["config", "set", "debug", "maybe"])
+    assert r.exit_code != 0
+    assert "expected boolean, got 'maybe'" in r.stderr
+
+    # Bad float
+    r = app.test(["config", "set", "rate", "xyz"])
+    assert r.exit_code != 0
+    assert "expected float, got 'xyz'" in r.stderr
+
+    # NaN rejected for float
+    r = app.test(["config", "set", "rate", "nan"])
+    assert r.exit_code != 0
+    assert "NaN is not allowed" in r.stderr
+
+    # Inf rejected for float
+    r = app.test(["config", "set", "rate", "inf"])
+    assert r.exit_code != 0
+    assert "Inf is not allowed" in r.stderr
+
+
+def test_config_set_unknown_key_error(tmp_path):
+    """config set error format for unknown keys matches Go exactly."""
+    app, _ = _make_app(tmp_path)
+
+    r = app.test(["config", "set", "xyz", "value"])
+    assert r.exit_code == 1
+    assert r.stderr.strip() == "config set: unknown key 'xyz'"
+
+    r = app.test(["config", "set", "nonexistent_flag", "42"])
+    assert r.exit_code == 1
+    assert r.stderr.strip() == "config set: unknown key 'nonexistent_flag'"
+
+
+def test_config_set_round_trip_typed(tmp_path):
+    """Values set via config set are read back with correct types by a new app."""
+    app, config_file = _make_app(tmp_path)
+
+    app.test(["config", "set", "debug", "true"])
+    app.test(["config", "set", "count", "42"])
+    app.test(["config", "set", "rate", "3.14"])
+    app.test(["config", "set", "name", "hello"])
+
+    # Create a fresh app pointing at the same config file
+    app2 = strictcli.App(
+        name="testapp",
+        version="1.0.0",
+        help="test app",
+        config=True,
+        config_path=str(config_file),
+    )
+
+    received = {}
+
+    @app2.command("run", help="run something")
+    @strictcli.flag("debug", type=bool, help="debug mode", default=False)
+    @strictcli.flag("count", type=int, help="how many", default=0)
+    @strictcli.flag("rate", type=float, help="the rate", default=0.0)
+    @strictcli.flag("name", type=str, help="the name", default="")
+    def run(debug, count, rate, name):
+        received["debug"] = debug
+        received["count"] = count
+        received["rate"] = rate
+        received["name"] = name
+
+    r = app2.test(["run"])
+    assert r.exit_code == 0
+
+    assert received["debug"] is True
+    assert isinstance(received["debug"], bool)
+    assert received["count"] == 42
+    assert isinstance(received["count"], int)
+    assert received["rate"] == 3.14
+    assert isinstance(received["rate"], float)
+    assert received["name"] == "hello"
+    assert isinstance(received["name"], str)

{strictcli-0.14.0 → strictcli-0.15.0}/uv.lock

@@ -232,7 +232,7 @@ wheels = [
 
 [[package]]
 name = "strictcli"
-version = "0.14.0"
+version = "0.15.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

strictcli-0.14.0/.rlsbl/changes/.validated

@@ -1 +0,0 @@
-caba81b23948f3b79c908ccd06ed76596881c075