Add shared NDEF URI prefix table (#43)

Author: shinaji

src/schnee/adapters/ntag/profile/models.py

@@ -4,7 +4,7 @@
 
 from typing import TYPE_CHECKING, Literal, Self
 
-from pydantic import BaseModel, Field, HttpUrl, model_validator
+from pydantic import AnyUrl, BaseModel, Field, HttpUrl, model_validator
 
 if TYPE_CHECKING:
     from .planning import ChangePlan
@@ -22,7 +22,7 @@ class NdefRecord(BaseModel):
     def validate_record(self) -> Self:
         """Validate record-specific payload constraints."""
         if self.type == "url":
-            HttpUrl(self.value)
+            AnyUrl(self.value)
         return self
 
 

src/schnee/adapters/ntag/profile/ndef.py

@@ -4,6 +4,8 @@
 
 from typing import ClassVar
 
+from schnee.ndef import NdefUriPrefix
+
 from .models import NdefProfile, NdefRecord
 
 
@@ -143,18 +145,12 @@ def _parse_uri_payload(cls, payload: bytes) -> str:
             msg = "URI NDEF payload is empty"
             raise cls.NdefParseError(msg)
 
-        prefixes = {
-            0x00: "",
-            0x01: "http://www.",
-            0x02: "https://www.",
-            0x03: "http://",
-            0x04: "https://",
-        }
-        prefix = prefixes.get(payload[0])
-        if prefix is None:
-            msg = f"Unsupported URI identifier code: {payload[0]:#x}"
-            raise cls.NdefParseError(msg)
-        return f"{prefix}{payload[1:].decode()}"
+        try:
+            prefix = NdefUriPrefix.from_code(payload[0])
+        except ValueError as exc:
+            msg = str(exc)
+            raise cls.NdefParseError(msg) from exc
+        return f"{prefix.expanded_text}{payload[1:].decode()}"
 
     @classmethod
     def _parse_text_payload(cls, payload: bytes) -> str:

src/schnee/ndef.py

@@ -0,0 +1,75 @@
+"""Shared NDEF data models."""
+
+from __future__ import annotations
+
+from enum import Enum, unique
+
+
+@unique
+class NdefUriPrefix(Enum):
+    """NDEF URI Identifier Code prefix table."""
+
+    NO_PREFIX = (0x00, "")
+    HTTP_WWW = (0x01, "http://www.")
+    HTTPS_WWW = (0x02, "https://www.")
+    HTTP = (0x03, "http://")
+    HTTPS = (0x04, "https://")
+    TEL = (0x05, "tel:")
+    MAILTO = (0x06, "mailto:")
+    FTP_ANONYMOUS = (0x07, "ftp://anonymous:anonymous@")
+    FTP_FTP = (0x08, "ftp://ftp.")
+    FTPS = (0x09, "ftps://")
+    SFTP = (0x0A, "sftp://")
+    SMB = (0x0B, "smb://")
+    NFS = (0x0C, "nfs://")
+    FTP = (0x0D, "ftp://")
+    DAV = (0x0E, "dav://")
+    NEWS = (0x0F, "news:")
+    TELNET = (0x10, "telnet://")
+    IMAP = (0x11, "imap:")
+    RTSP = (0x12, "rtsp://")
+    URN = (0x13, "urn:")
+    POP = (0x14, "pop:")
+    SIP = (0x15, "sip:")
+    SIPS = (0x16, "sips:")
+    TFTP = (0x17, "tftp:")
+    BTSPP = (0x18, "btspp://")
+    BTL2CAP = (0x19, "btl2cap://")
+    BTGOEP = (0x1A, "btgoep://")
+    TCPOBEX = (0x1B, "tcpobex://")
+    IRDAOBEX = (0x1C, "irdaobex://")
+    FILE = (0x1D, "file://")
+    URN_EPC_ID = (0x1E, "urn:epc:id:")
+    URN_EPC_TAG = (0x1F, "urn:epc:tag:")
+    URN_EPC_PAT = (0x20, "urn:epc:pat:")
+    URN_EPC_RAW = (0x21, "urn:epc:raw:")
+    URN_EPC = (0x22, "urn:epc:")
+    URN_NFC = (0x23, "urn:nfc:")
+
+    def __init__(self, code: int, expanded_text: str) -> None:
+        self._code = code
+        self._expanded_text = expanded_text
+
+    @property
+    def code(self) -> int:
+        """Return the numeric URI Identifier Code."""
+        return self._code
+
+    @property
+    def expanded_text(self) -> str:
+        """Return the expanded text represented by the prefix code."""
+        return self._expanded_text
+
+    @classmethod
+    def from_code(cls, code: int) -> NdefUriPrefix:
+        """Return the URI prefix for a numeric URI Identifier Code."""
+        try:
+            return _NDEF_URI_PREFIXES_BY_CODE[code]
+        except KeyError:
+            msg = f"Unsupported URI identifier code: {code:#x}"
+            raise ValueError(msg) from None
+
+
+_NDEF_URI_PREFIXES_BY_CODE: dict[int, NdefUriPrefix] = {
+    prefix.code: prefix for prefix in NdefUriPrefix
+}

tests/schnee/adapters/ntag/profile/test_ndef.py

@@ -0,0 +1,49 @@
+"""Tests for NDEF profile parsing."""
+
+import pytest
+
+from schnee.adapters.ntag.profile.ndef import NdefProfileParser
+
+
+def _uri_record(prefix_code: int, suffix: bytes) -> list[int]:
+    payload = [prefix_code, *suffix]
+    return [
+        0xD1,
+        0x01,
+        len(payload),
+        0x55,
+        *payload,
+    ]
+
+
+@pytest.mark.parametrize(
+    ("prefix_code", "suffix", "expected"),
+    [
+        (0x04, b"example.com", "https://example.com"),
+        (0x05, b"+81312345678", "tel:+81312345678"),
+        (0x1D, b"/tmp/tag.txt", "file:///tmp/tag.txt"),
+        (0x23, b"sn:example", "urn:nfc:sn:example"),
+    ],
+)
+def test_parse_uri_record_uses_shared_prefix_table(
+    prefix_code: int,
+    suffix: bytes,
+    expected: str,
+) -> None:
+    """URI records expand NDEF URI Identifier Code prefixes."""
+    records = NdefProfileParser.parse_message(_uri_record(prefix_code, suffix))
+
+    assert len(records) == 1, "URI NDEF message should produce one profile record"
+    assert records[0].type == "url", "URI NDEF record should be represented as a URL"
+    assert records[0].value == expected, (
+        "URI NDEF record should expand the identifier code prefix"
+    )
+
+
+def test_parse_uri_record_rejects_unsupported_prefix_code() -> None:
+    """URI records reject undefined NDEF URI Identifier Code prefixes."""
+    with pytest.raises(
+        NdefProfileParser.NdefParseError,
+        match="Unsupported URI identifier code: 0x24",
+    ):
+        NdefProfileParser.parse_message(_uri_record(0x24, b"example.com"))

tests/schnee/test_ndef.py

@@ -0,0 +1,34 @@
+"""Tests for shared NDEF models."""
+
+import pytest
+
+from schnee.ndef import NdefUriPrefix
+
+URN_NFC_PREFIX_CODE = 0x23
+
+
+def test_ndef_uri_prefix_covers_complete_identifier_code_range() -> None:
+    """NDEF URI prefixes expose every defined identifier code."""
+    codes = [prefix.code for prefix in NdefUriPrefix]
+
+    assert codes == list(range(0x24)), (
+        "NDEF URI prefixes should cover every identifier code from 0x00 to 0x23"
+    )
+
+
+def test_ndef_uri_prefix_exposes_code_and_expanded_text() -> None:
+    """NDEF URI prefix members expose numeric and expanded forms."""
+    prefix = NdefUriPrefix.URN_NFC
+
+    assert prefix.code == URN_NFC_PREFIX_CODE, (
+        "URN_NFC should expose its numeric identifier code"
+    )
+    assert prefix.expanded_text == "urn:nfc:", (
+        "URN_NFC should expose its expanded URI prefix text"
+    )
+
+
+def test_ndef_uri_prefix_from_code_rejects_unsupported_code() -> None:
+    """NDEF URI prefix lookup rejects undefined identifier codes."""
+    with pytest.raises(ValueError, match="Unsupported URI identifier code: 0x24"):
+        NdefUriPrefix.from_code(0x24)