pythonnative 0.41.0__tar.gz → 0.42.0__tar.gz

{pythonnative-0.41.0/src/pythonnative.egg-info → pythonnative-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.41.0
+Version: 0.42.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.41.0 → pythonnative-0.42.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.41.0"
+version = "0.42.0"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }

{pythonnative-0.41.0 → pythonnative-0.42.0}/src/pythonnative/__init__.py

@@ -64,7 +64,7 @@ Example:
     ```
 """
 
-__version__ = "0.41.0"
+__version__ = "0.42.0"
 
 from . import appearance, diagnostics, gestures, runtime, sdk
 from .alerts import Alert

{pythonnative-0.41.0 → pythonnative-0.42.0}/src/pythonnative/cli/pn.py

@@ -25,7 +25,7 @@ The console script `pn` (declared in `pyproject.toml`) dispatches to:
 - `pn build android|ios`: produce standalone artifacts (signed APK/AAB,
   or an iOS archive/IPA, optionally uploaded to App Store Connect).
 - `pn app-id android|ios`: print the resolved application/bundle id
-  (handy for scripts and CI).
+  (handy for scripts and CI), as plain text or as JSON with `--json`.
 - `pn clean`: remove the local `build/` directory.
 
 The heavy lifting lives in the ``pythonnative.project`` and
@@ -147,6 +147,37 @@ def _sanitize_name(name: str) -> str:
 
 
 def _app_id_from_name(name: str) -> str:
+    """Derive the default reverse-DNS app id from a project name.
+
+    The result is an identifier rather than a name, and it fills
+    ``app.id``, the default for both the Android application id and the
+    iOS bundle id. It therefore has to satisfy the stricter of the two
+    grammars, ``config._APP_ID_SEGMENT``, which admits no hyphen. An
+    explicit ``[ios].bundle_id`` may contain one, because
+    ``config._validate_app_id`` is called with ``allow_hyphen=True`` for
+    that field alone.
+
+    Deleting hyphens is lossy, so the derivation is not injective:
+    ``my-app`` and ``myapp`` both give ``com.example.myapp``. Mapping
+    ``-`` to ``_`` instead would not fix that, only move it, since
+    ``_NAME_RE`` permits both characters and ``my-app`` would then
+    collide with ``my_app``. Injectivity would need an escaping scheme;
+    deletion is the deliberate choice here.
+
+    The ``app`` prefix covers the name taken from the current directory
+    when ``pn init`` is given none. A typed name cannot reach it, because
+    ``_NAME_RE`` already guarantees a leading letter.
+
+    The result always satisfies ``_APP_ID_SEGMENT`` but is not guaranteed
+    to pass ``config._validate_app_id``, which also rejects reserved
+    words: ``class`` is a legal project name and passes through here.
+
+    Args:
+        name: A project name, either typed or taken from the directory.
+
+    Returns:
+        A reverse-DNS id under ``com.example``.
+    """
     slug = re.sub(r"[^a-z0-9_]", "", name.lower())
     if not slug or not slug[0].isalpha():
         slug = "app" + slug
@@ -312,11 +343,27 @@ def doctor_command(args: argparse.Namespace) -> None:
 def app_id_command(args: argparse.Namespace) -> None:
     """Print the resolved application id (Android) or bundle id (iOS).
 
+    With ``--json``, stdout carries one object,
+    ``{"platform": "...", "app_id": "..."}``, and nothing else; the config
+    error goes to stderr instead so stdout stays parseable. Keys may be
+    added to that object later, but none will be removed or renamed, so
+    a caller reading ``app_id`` keeps working.
+
+    A missing or invalid config still exits 1, with or without the flag.
+    That differs from ``pn devices --json``, which exits 0 on an empty
+    result, because "no devices" is a valid answer to a query whereas
+    an unreadable config means there is no id to report at all.
+
     Args:
-        args: Parsed namespace with ``platform``.
+        args: Parsed namespace with ``platform`` and optional ``json``.
     """
-    config = _load_config_or_exit()
-    print(config.application_id if args.platform == "android" else config.bundle_id)
+    as_json: bool = getattr(args, "json", False)
+    config = _load_config_or_exit(stream=sys.stderr if as_json else None)
+    app_id = config.application_id if args.platform == "android" else config.bundle_id
+    if as_json:
+        print(json.dumps({"platform": args.platform, "app_id": app_id}, indent=2))
+        return
+    print(app_id)
 
 
 # ======================================================================
@@ -950,11 +997,22 @@ def clean_project(args: argparse.Namespace) -> None:
 # ======================================================================
 
 
-def _load_config_or_exit(project_dir: Optional[Path] = None) -> AppConfig:
+def _load_config_or_exit(project_dir: Optional[Path] = None, *, stream: Optional[TextIO] = None) -> AppConfig:
+    """Load the project config or exit 1, reporting the error on ``stream``.
+
+    Args:
+        project_dir: Project root; defaults to the current directory.
+        stream: Where to report a failure. Defaults to stdout, which is
+            what every caller wants except a machine-readable mode, where
+            an error on stdout would corrupt the document.
+
+    Returns:
+        The loaded config.
+    """
     try:
         return AppConfig.load(project_dir or Path.cwd())
     except ConfigError as exc:
-        print(f"Error: {exc}")
+        print(f"Error: {exc}", file=stream or sys.stdout)
         sys.exit(1)
 
 
@@ -1169,7 +1227,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_devices.set_defaults(func=devices_command)
 
     parser_run = subparsers.add_parser("run", help="Build, install, and launch on a device/simulator")
-    parser_run.add_argument("platform", choices=["android", "ios"])
+    parser_run.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_run.add_argument(
         "--device",
         "-d",
@@ -1196,7 +1254,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_run.set_defaults(func=run_project)
 
     parser_logs = subparsers.add_parser("logs", help="Stream logs from the running app")
-    parser_logs.add_argument("platform", choices=["android", "ios"])
+    parser_logs.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_logs.add_argument(
         "--device",
         "-d",
@@ -1206,7 +1264,7 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_logs.set_defaults(func=logs_command)
 
     parser_build = subparsers.add_parser("build", help="Build distributable artifacts")
-    parser_build.add_argument("platform", choices=["android", "ios"])
+    parser_build.add_argument("platform", choices=["android", "ios"], help="Target platform")
     parser_build.add_argument("--debug", action="store_true", help="Build the debug variant instead of release")
     parser_build.add_argument(
         "--upload",
@@ -1216,7 +1274,10 @@ def _build_parser() -> argparse.ArgumentParser:
     parser_build.set_defaults(func=build_project)
 
     parser_app_id = subparsers.add_parser("app-id", help="Print the resolved application/bundle id")
-    parser_app_id.add_argument("platform", choices=["android", "ios"])
+    parser_app_id.add_argument("platform", choices=["android", "ios"], help="Target platform")
+    parser_app_id.add_argument(
+        "--json", action="store_true", help="Print a JSON object to stdout for scripting (errors go to stderr)"
+    )
     parser_app_id.set_defaults(func=app_id_command)
 
     parser_clean = subparsers.add_parser("clean", help="Remove the local build/ directory")

{pythonnative-0.41.0 → pythonnative-0.42.0/src/pythonnative.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.41.0
+Version: 0.42.0
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.41.0 → pythonnative-0.42.0}/tests/test_cli.py

@@ -1,6 +1,7 @@
 import argparse
 import json
 import os
+import re
 import shutil
 import subprocess
 import sys
@@ -309,16 +310,103 @@ def test_cli_init_suggestion_is_stable_for_legal_names() -> None:
         assert pn_cli._sanitize_name(name) == name
 
 
-def test_cli_init_without_name_accepts_a_cwd_that_fails_the_pattern(tmp_path: Path) -> None:
-    # Validation covers the typed name only. A directory named MyProject is
-    # extremely ordinary, and `pn init` there must keep working.
-    project_dir = tmp_path / "MyProject"
+# _app_id_from_name maps a project name onto a reverse-DNS segment, whose
+# grammar (config._APP_ID_SEGMENT) differs from _NAME_RE's. These two groups
+# split by which entry path can actually produce the input.
+
+# Reachable from a typed `pn init <name>`: _NAME_RE admits only [a-z][a-z0-9_-]*,
+# so the sole character the substitution can remove is the hyphen.
+_APP_ID_TYPED_CASES = [
+    pytest.param("my_app", "com.example.my_app", id="underscore"),
+    pytest.param("myapp", "com.example.myapp", id="plain"),
+    pytest.param("my-app", "com.example.myapp", id="hyphen"),
+    pytest.param("my--app", "com.example.myapp", id="doubled-hyphen"),
+    pytest.param("my-app-", "com.example.myapp", id="trailing-hyphen"),
+    pytest.param("e2e-suite", "com.example.e2esuite", id="digits-and-hyphen"),
+]
+
+# Reachable only from the derived path, `pn init` with no name taking cwd.name,
+# which is never validated. A typed name cannot produce any of these: _NAME_RE
+# rejects uppercase, a leading digit, a leading underscore, the empty string,
+# and non-ASCII.
+_APP_ID_DERIVED_ONLY_CASES = [
+    pytest.param("MyApp", "com.example.myapp", id="uppercase"),
+    pytest.param("MyProject", "com.example.myproject", id="mixed-case"),
+    pytest.param("3d_viewer", "com.example.app3d_viewer", id="digit-leading"),
+    pytest.param("2048", "com.example.app2048", id="all-digits"),
+    pytest.param("_leading", "com.example.app_leading", id="underscore-leading"),
+    pytest.param("", "com.example.app", id="empty"),
+    pytest.param("\u5de5\u7a0b", "com.example.app", id="all-non-ascii"),
+    pytest.param("caf\u00e9", "com.example.caf", id="partly-stripped-non-ascii"),
+    pytest.param("app.v2", "com.example.appv2", id="dotted"),
+]
+
+_APP_ID_ALL_CASES = _APP_ID_TYPED_CASES + _APP_ID_DERIVED_ONLY_CASES
+
+# The pattern the issue suggests asserting. It cannot fail against the current
+# implementation for any input, because the substitution leaves only [a-z0-9_]
+# and the "app" prefix supplies a leading letter otherwise. It still earns its
+# place: it catches a change that admits a character outside the segment
+# grammar, such as keeping hyphens. It does not catch a changed prefix, which
+# is what the exact-value cases above are for.
+_REVERSE_DNS_RE = re.compile(r"^com\.example\.[a-z][a-z0-9_]*$")
+
+
+@pytest.mark.parametrize(("name", "expected"), _APP_ID_TYPED_CASES)
+def test_cli_app_id_from_name_typed_names(name: str, expected: str) -> None:
+    assert pn_cli._NAME_RE.fullmatch(name), f"{name!r} should be typeable"
+    assert pn_cli._app_id_from_name(name) == expected
+
+
+@pytest.mark.parametrize(("name", "expected"), _APP_ID_DERIVED_ONLY_CASES)
+def test_cli_app_id_from_name_derived_only_names(name: str, expected: str) -> None:
+    assert not pn_cli._NAME_RE.fullmatch(name), f"{name!r} should not be typeable"
+    assert pn_cli._app_id_from_name(name) == expected
+
+
+@pytest.mark.parametrize(("name", "expected"), _APP_ID_ALL_CASES)
+def test_cli_app_id_from_name_is_reverse_dns(name: str, expected: str) -> None:
+    assert _REVERSE_DNS_RE.fullmatch(pn_cli._app_id_from_name(name))
+
+
+def test_cli_app_id_from_name_collides_on_hyphens() -> None:
+    # Deleting hyphens is lossy, so distinct names share an id. Recorded so
+    # the collision is known rather than discovered when two projects install
+    # over each other.
+    assert pn_cli._app_id_from_name("my-app") == pn_cli._app_id_from_name("myapp")
+    assert pn_cli._app_id_from_name("a-b-c") == pn_cli._app_id_from_name("abc")
+    # Mapping "-" to "_" would not fix this, only move it: _NAME_RE permits
+    # both characters, so this pair, distinct today, would merge under that
+    # scheme. Across every typed-legal name up to length 4 the two schemes
+    # lose the same number of names to collision.
+    assert pn_cli._app_id_from_name("my-app") != pn_cli._app_id_from_name("my_app")
+
+
+def _init_in_directory_named(tmp_path: Path, dirname: str) -> str:
+    """`pn init` with no name inside a directory called ``dirname``."""
+    project_dir = tmp_path / dirname
     project_dir.mkdir()
 
     result = run_pn(["init"], str(project_dir))
 
     assert result.returncode == 0, result.stdout
-    toml_text = (project_dir / "pythonnative.toml").read_text(encoding="utf-8")
+    return (project_dir / "pythonnative.toml").read_text(encoding="utf-8")
+
+
+def test_cli_init_without_name_reaches_the_app_prefix(tmp_path: Path) -> None:
+    # The prefix branch is unreachable from a typed name, so this is the only
+    # end-to-end path to it: a directory whose name starts with a digit.
+    toml_text = _init_in_directory_named(tmp_path, "3d_viewer")
+
+    assert 'id = "com.example.app3d_viewer"' in toml_text
+    assert 'name = "3d_viewer"' in toml_text
+
+
+def test_cli_init_without_name_accepts_a_cwd_that_fails_the_pattern(tmp_path: Path) -> None:
+    # Validation covers the typed name only. A directory named MyProject is
+    # extremely ordinary, and `pn init` there must keep working.
+    toml_text = _init_in_directory_named(tmp_path, "MyProject")
+
     assert 'name = "MyProject"' in toml_text
     assert 'id = "com.example.myproject"' in toml_text
 
@@ -331,6 +419,7 @@ def test_cli_run_help_lists_flags() -> None:
         assert "--no-logs" in result.stdout
         assert "--dev-server" in result.stdout
         assert "--prepare-only" in result.stdout
+        assert "Target platform" in result.stdout
     finally:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
@@ -341,6 +430,7 @@ def test_cli_build_help_lists_debug() -> None:
         result = run_pn(["build", "--help"], tmpdir)
         assert result.returncode == 0, result.stderr
         assert "--debug" in result.stdout
+        assert "Target platform" in result.stdout
     finally:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
@@ -364,13 +454,111 @@ def test_cli_run_without_config_errors() -> None:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
 
-def test_cli_app_id_resolves(tmp_path: Path) -> None:
-    assert run_pn(["init", "my_app"], str(tmp_path)).returncode == 0
-    project_dir = str(tmp_path / "my_app")
-    result = run_pn(["app-id", "android"], project_dir)
+# A default `pn init` scaffold sets only `app.id`, so both platforms resolve to
+# the same string and a test built on it passes with the platform branch
+# inverted. These per-platform overrides make the two diverge.
+_APP_ID_TOML = """\
+[app]
+id = "com.example.base"
+name = "over"
+
+[ios]
+bundle_id = "com.example.ios_override"
+
+[android]
+application_id = "com.example.android_override"
+"""
+
+_EXPECTED_APP_IDS = {
+    "android": "com.example.android_override",
+    "ios": "com.example.ios_override",
+}
+
+
+def _app_id_project(tmp_path: Path) -> str:
+    project_dir = tmp_path / "proj"
+    project_dir.mkdir()
+    (project_dir / "pythonnative.toml").write_text(_APP_ID_TOML, encoding="utf-8")
+    return str(project_dir)
+
+
+@pytest.mark.parametrize("platform", ["android", "ios"])
+def test_cli_app_id_resolves(tmp_path: Path, platform: str) -> None:
+    project_dir = _app_id_project(tmp_path)
+
+    result = run_pn(["app-id", platform], project_dir)
+
     assert result.returncode == 0, result.stderr
-    assert result.stdout.strip() == "com.example.my_app"
-    assert run_pn(["app-id", "ios"], project_dir).stdout.strip() == "com.example.my_app"
+    # Unstripped, because scripts/run-e2e.sh captures this into a shell
+    # variable: any extra line would corrupt APP_ID and only surface later
+    # as a Maestro failure against a bundle id that doesn't exist.
+    assert result.stdout == f"{_EXPECTED_APP_IDS[platform]}\n"
+    assert result.stderr == ""
+
+
+@pytest.mark.parametrize("platform", ["android", "ios"])
+def test_cli_app_id_json(tmp_path: Path, platform: str) -> None:
+    project_dir = _app_id_project(tmp_path)
+
+    result = run_pn(["app-id", platform, "--json"], project_dir)
+
+    assert result.returncode == 0, result.stderr
+    payload = json.loads(result.stdout)
+    assert payload == {"platform": platform, "app_id": _EXPECTED_APP_IDS[platform]}
+    assert result.stderr == ""
+
+
+def test_cli_app_id_json_is_indented(tmp_path: Path) -> None:
+    # json.loads is blind to formatting, so nothing else here would notice
+    # indent=2 being dropped. Scripts consume the bytes, and the docstring
+    # promises an additive-only contract, so pin the exact shape once.
+    project_dir = _app_id_project(tmp_path)
+
+    result = run_pn(["app-id", "android", "--json"], project_dir)
+
+    assert result.stdout == ("{\n" '  "platform": "android",\n' '  "app_id": "com.example.android_override"\n' "}\n")
+
+
+def test_cli_app_id_json_differs_per_platform(tmp_path: Path) -> None:
+    # The pair, so a branch that ignored `platform` would fail even if each
+    # single-platform assertion above were somehow satisfied.
+    project_dir = _app_id_project(tmp_path)
+
+    android = json.loads(run_pn(["app-id", "android", "--json"], project_dir).stdout)
+    ios = json.loads(run_pn(["app-id", "ios", "--json"], project_dir).stdout)
+
+    assert android["app_id"] != ios["app_id"]
+
+
+def test_cli_app_id_json_keeps_errors_off_stdout(tmp_path: Path) -> None:
+    # Without --json this same error goes to stdout, which is why the stream
+    # is scoped rather than global.
+    result = run_pn(["app-id", "android", "--json"], str(tmp_path))
+
+    assert result.returncode == 1
+    assert result.stdout == ""
+    # Match the noun, not the sentence. A malformed config also exits 1 with
+    # an error on stderr, so without this phrase the test passes for either.
+    assert "No pythonnative.toml" in result.stderr
+
+
+def test_cli_app_id_plain_error_stays_on_stdout(tmp_path: Path) -> None:
+    # Pins the scoping: the default path is untouched by the stream change.
+    result = run_pn(["app-id", "android"], str(tmp_path))
+
+    assert result.returncode == 1
+    assert "No pythonnative.toml" in result.stdout
+    assert result.stderr == ""
+
+
+def test_cli_app_id_json_flag_is_wired_through_argparse(tmp_path: Path) -> None:
+    # Everything here goes through run_pn, so argparse is always exercised.
+    # Confirmed rather than assumed: #22 shipped six in-process tests that
+    # all passed with the add_argument deleted.
+    result = run_pn(["app-id", "android", "--json"], str(tmp_path))
+
+    assert result.returncode == 1, "expected the config error, not argparse exit 2"
+    assert "unrecognized arguments" not in result.stderr
 
 
 def test_cli_doctor_runs(tmp_path: Path) -> None: