graphify-php 0.0.5__py3-none-any.whl

graphify_php/config/document.py

@@ -0,0 +1,29 @@
+"""The node standing for a configuration file, and the key every reader addresses it by.
+
+The file node belongs to no single reader: routing edges and environment edges both start at it,
+and whichever reader emitted it would silently own a node the other depends on. It is emitted by
+the pass instead, and only for a document that produced at least one fact — a Symfony `config/`
+holds dozens of files about caching, routing and security that this package indexes nothing
+from, and a node per file would bury the two facts it does index.
+
+The key is the path relative to the repository root. Build paths are absolute while a build runs
+and relativized only at publish time, so keying on the absolute path would make the same file
+produce a different node on another machine.
+"""
+
+from __future__ import annotations
+
+from .facts import ConfigNode
+
+
+def file_key(path: str) -> str:
+    return f"cfg::file::{path}"
+
+
+class DocumentNodeFactory:
+    """Builds the node for one configuration file."""
+
+    def node(self, path: str) -> ConfigNode:
+        return ConfigNode(
+            key=file_key(path), label=path.rsplit("/", 1)[-1], kind="config_file", source_file=path
+        )

graphify_php/config/emit.py

@@ -0,0 +1,117 @@
+"""Turning facts into graphify nodes and edges, the only module that knows graphify's schema.
+
+Two jobs, both of which every reader would otherwise have to repeat: give a `NodeRef` an id, and
+keep the graph free of duplicates. Readers emit the same transport node once per routing entry
+on purpose — it is simpler to state the fact than to remember whether it was already stated —
+and deduplication here is what makes that safe.
+
+The schema written against, read from a real build: a node carries `id`, `label`, `file_type`,
+`source_file`, `source_location` and `_origin`; an edge carries `source`, `target`, `relation`,
+`confidence`, `weight` and `_origin`.
+
+`_origin` is not the place for authorship. graphify overwrites it with `"ast"` on every edge
+after the resolvers run (extract.py:8285-8289); it means the eviction tier, not the author. The
+marker lives in a key of this package's own, which survives.
+"""
+
+from __future__ import annotations
+
+from .class_lookup import GraphClassIndex
+from .facts import REF_CONFIG, REF_PHP_CLASS, ConfigEdge, ConfigNode, FactSet, NodeRef
+
+EDGE_MARKER = "_resolver"
+EDGE_ORIGIN = "graphify-php"
+
+REASON_CLASS_NOT_IN_GRAPH = "message_class_not_in_graph"
+
+# A configuration node describes the running application, not prose about it, so it takes the
+# same `file_type` as the code nodes it sits beside. A consumer filtering the graph down to the
+# code view would otherwise drop exactly the facts this package exists to add.
+FILE_TYPE = "code"
+
+# Configuration facts are read straight out of a declaration, not derived from one. That is
+# graphify's definition of EXTRACTED, and using its vocabulary keeps these edges rankable
+# alongside its own.
+CONFIDENCE = "EXTRACTED"
+
+
+class GraphWriter:
+    """Appends configuration nodes and edges to graphify's lists, once each."""
+
+    def __init__(
+        self, all_nodes: list[dict], all_edges: list[dict], classes: GraphClassIndex | None = None
+    ) -> None:
+        self._nodes = all_nodes
+        self._edges = all_edges
+        self._classes = classes if classes is not None else GraphClassIndex(all_nodes, all_edges)
+        self._node_ids = {n.get("id") for n in all_nodes}
+        self._pairs = {(e.get("source"), e.get("target"), e.get("relation")) for e in all_edges}
+        self.nodes_added = 0
+        self.edges_added = 0
+        self.unresolved: dict[str, int] = {}
+
+    def write(self, facts: FactSet) -> None:
+        for node in facts.nodes:
+            self._add_node(node)
+        for edge in facts.edges:
+            self._add_edge(edge)
+
+    def _add_node(self, node: ConfigNode) -> None:
+        if node.key in self._node_ids:
+            return
+        self._node_ids.add(node.key)
+        self._nodes.append(
+            {
+                "id": node.key,
+                "label": node.label,
+                "file_type": FILE_TYPE,
+                "source_file": node.source_file,
+                "source_location": node.source_location or "L1",
+                "_origin": "ast",
+                EDGE_MARKER: EDGE_ORIGIN,
+                "_config_kind": node.kind,
+            }
+        )
+        self.nodes_added += 1
+
+    def _add_edge(self, edge: ConfigEdge) -> None:
+        source = self._resolve(edge.source)
+        target = self._resolve(edge.target)
+        if source is None or target is None or source == target:
+            return
+        key = (source, target, edge.relation)
+        if key in self._pairs:
+            return
+        self._pairs.add(key)
+        self._edges.append(
+            {
+                "source": source,
+                "target": target,
+                "relation": edge.relation,
+                "confidence": CONFIDENCE,
+                "source_file": edge.source_file,
+                "source_location": edge.source_location or "L1",
+                "weight": 1.0,
+                EDGE_MARKER: EDGE_ORIGIN,
+            }
+        )
+        self.edges_added += 1
+
+    def _resolve(self, ref: NodeRef) -> str | None:
+        if ref.kind == REF_CONFIG:
+            # A config endpoint is only usable once its node exists. Facts list their nodes
+            # before their edges, so an unknown key here means a reader referenced a node it
+            # never emitted, which is a bug in that reader rather than a missing class.
+            return ref.value if ref.value in self._node_ids else None
+        if ref.kind == REF_PHP_CLASS:
+            found = self._classes.node_id(ref.value)
+            if found is None:
+                # The transport node is already written by the time this runs, so the
+                # application's transport list stays complete. What is lost is the one edge,
+                # and the count is what says how much of the routing table points outside the
+                # indexed tree.
+                self.unresolved[REASON_CLASS_NOT_IN_GRAPH] = (
+                    self.unresolved.get(REASON_CLASS_NOT_IN_GRAPH, 0) + 1
+                )
+            return found
+        return None

graphify_php/config/environment.py

@@ -0,0 +1,108 @@
+"""Environment references: which variable NAME a configuration file reads.
+
+`client_secret: '%env(MICROSOFT_CLIENT_SECRET)%'` is the only place that binds the variable to
+the service that consumes it. No PHP names it — the container resolves the placeholder before
+any code runs — so "what breaks if this variable is unset" has no answer in a graph built from
+PHP alone.
+
+The name is indexed. The value is never touched, in any form: not the default inside
+`%env(default:app.fallback:NAME)%`, not the DSN the placeholder is embedded in, not the result
+of resolving it. A configuration file is where credentials live, and a graph is published,
+diffed and served to other tools. `eval/canaries.py` plants fake secrets in fixtures and asserts
+they reach no artifact; this reader is the one that would break that if it kept a value.
+
+Processor forms are Symfony's: `%env(bool:DEBUG)%`, `%env(default:fallback_param:DSN)%`,
+`%env(key:secret:JSON_FILE)%`. Every one of them puts the variable name last, so the innermost
+name is the final colon-separated segment.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+
+from .document import file_key
+from .facts import ConfigDocument, ConfigEdge, ConfigNode, FactSet, NodeRef
+
+RELATION_READS_ENV = "reads_env"
+
+REASON_UNRECOGNISED_NAME = "env_name_not_an_identifier"
+REASON_DEPTH_LIMIT = "env_depth_limit"
+
+# `[^()%]*` on purpose: a placeholder cannot contain a nested `%env(` and stopping at the first
+# `%` keeps a run-on string like `'%env(A)%:%env(B)%'` as two matches instead of one wrong one.
+_PLACEHOLDER = re.compile(r"%env\(([^()%]*)\)%")
+
+# The name as an environment variable can actually be spelled. A segment that fails this is a
+# processor argument this reader does not model, and emitting it would put a made-up variable
+# in the graph.
+_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+# Configuration nests a few levels. The bound stops a generated or vendored dump from turning
+# one file into an unbounded walk.
+_MAX_DEPTH = 12
+
+
+class EnvReferenceReader:
+    """Reads `%env(...)%` placeholders out of one document, names only."""
+
+    name = "env_references"
+
+    def read(self, document: ConfigDocument) -> FactSet:
+        facts = FactSet()
+        file_ref = NodeRef.config(file_key(document.path))
+        seen: set[str] = set()
+        for placeholder in self._placeholders(document.data, _MAX_DEPTH, facts):
+            name = placeholder.rsplit(":", 1)[-1].strip()
+            if not _NAME.match(name):
+                facts.unresolvable(REASON_UNRECOGNISED_NAME)
+                continue
+            if name in seen:
+                continue
+            seen.add(name)
+            node_key = env_key(name)
+            facts.nodes.append(
+                ConfigNode(key=node_key, label=name, kind="env_var", source_file=document.path)
+            )
+            facts.edges.append(
+                ConfigEdge(
+                    source=file_ref,
+                    target=NodeRef.config(node_key),
+                    relation=RELATION_READS_ENV,
+                    source_file=document.path,
+                )
+            )
+        return facts
+
+    def _placeholders(self, node, depth: int, facts: FactSet) -> Iterator[str]:
+        """Every placeholder body in the document, keys included.
+
+        Only the text inside `env(...)` ever leaves this method. The scalar that carried it —
+        which may be a DSN with an inline password — is not yielded, not stored and not logged.
+        """
+        if depth < 0:
+            # Past the bound the subtree is not walked, so a placeholder in it would vanish
+            # without trace. One count per cut-off subtree says that something was left out;
+            # the subtree is not read, so the count is not a number of placeholders.
+            facts.unresolvable(REASON_DEPTH_LIMIT)
+            return
+        if isinstance(node, str):
+            yield from _PLACEHOLDER.findall(node)
+        elif isinstance(node, dict):
+            for key, value in node.items():
+                if isinstance(key, str):
+                    yield from _PLACEHOLDER.findall(key)
+                yield from self._placeholders(value, depth - 1, facts)
+        elif isinstance(node, (list, tuple)):
+            for item in node:
+                yield from self._placeholders(item, depth - 1, facts)
+
+
+def env_key(name: str) -> str:
+    """Node key for a variable, shared across every file that reads it.
+
+    One variable is one node however many files reference it: the question this answers is
+    "everything that breaks when `MICROSOFT_CLIENT_SECRET` is unset", which a per-file node
+    would split into as many answers as there are files.
+    """
+    return f"cfg::env::{name}"

graphify_php/config/facts.py

@@ -0,0 +1,97 @@
+"""What a reader returns, and what the writer turns into graph nodes and edges.
+
+The whole package is shaped around this one dataclass set so that a third configuration fact
+— a scheduler definition, a workflow transition — is a new reader class and nothing else. A
+reader never touches graphify's node schema and the writer never learns what a transport is,
+so neither of them grows a branch per fact kind.
+
+An endpoint is a `NodeRef` rather than a node id because a fact knows what it means, not what
+the graph calls it. `config` means "a node this package emits, keyed by `value`"; `php_class`
+means "the class graphify already indexed under this FQN, if it did". Resolution is the
+writer's job.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# A node this package emits, addressed by the key the reader chose.
+REF_CONFIG = "config"
+# A class node graphify already made. May not exist: a message class outside the indexed tree
+# is the normal case, not an error.
+REF_PHP_CLASS = "php_class"
+
+
+@dataclass(frozen=True)
+class NodeRef:
+    kind: str
+    value: str
+
+    @staticmethod
+    def config(key: str) -> NodeRef:
+        return NodeRef(REF_CONFIG, key)
+
+    @staticmethod
+    def php_class(fqn: str) -> NodeRef:
+        return NodeRef(REF_PHP_CLASS, fqn)
+
+
+@dataclass(frozen=True)
+class ConfigNode:
+    """A node to add to the graph if it is not already there.
+
+    `key` is stable across builds and across files: two `messenger.yaml` files routing to
+    `cron` describe one transport, and emitting it twice would split a consumer's view of who
+    sends to it.
+    """
+
+    key: str
+    label: str
+    kind: str  # config_file | transport | env_var
+    source_file: str = ""
+    source_location: str = ""
+
+
+@dataclass(frozen=True)
+class ConfigEdge:
+    source: NodeRef
+    target: NodeRef
+    relation: str
+    source_file: str = ""
+    source_location: str = ""
+
+
+@dataclass
+class FactSet:
+    """One reader's answer for one document.
+
+    `unresolved` carries the reader's own reason vocabulary. The resolver prefixes it with the
+    reader name, so two readers may use the same word without merging into one meaningless
+    count.
+    """
+
+    nodes: list[ConfigNode] = field(default_factory=list)
+    edges: list[ConfigEdge] = field(default_factory=list)
+    unresolved: dict[str, int] = field(default_factory=dict)
+
+    def unresolvable(self, reason: str, count: int = 1) -> None:
+        self.unresolved[reason] = self.unresolved.get(reason, 0) + count
+
+    def extend(self, other: FactSet) -> None:
+        self.nodes.extend(other.nodes)
+        self.edges.extend(other.edges)
+        for reason, count in other.unresolved.items():
+            self.unresolvable(reason, count)
+
+
+@dataclass(frozen=True)
+class ConfigDocument:
+    """One parsed YAML document, with the path it came from.
+
+    `path` is relative to the repository root, because it becomes a node label and an absolute
+    build path would make the same file produce a different node on another machine — the
+    graph is published and compared across machines.
+    """
+
+    path: str
+    data: dict

graphify_php/config/messaging.py

@@ -0,0 +1,142 @@
+"""Message routing: which transport carries which message class.
+
+Nothing in PHP states this. The sender calls `$bus->dispatch($message)` and the handler declares
+`__invoke(TimezoneInitializedMessage $m)`; the transport between them exists only as a key in
+`messenger.yaml`. A graph built from PHP alone has the sender and the handler as unconnected
+islands, and `rg 'TimezoneInitializedMessage'` returns all three files without saying which is
+which.
+
+The reader emits the transport as a node in its own right and the message class as the edge
+source, so "what does `cron` carry" and "where does this message go" are the same lookup from
+two ends.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+
+from .document import file_key
+from .facts import ConfigDocument, ConfigEdge, ConfigNode, FactSet, NodeRef
+
+RELATION_ROUTED_TO = "routed_to"
+RELATION_DECLARES = "declares_transport"
+
+REASON_NOT_A_CLASS = "routing_key_is_not_a_class"
+REASON_NO_TRANSPORT = "routing_entry_names_no_transport"
+
+# Symfony accepts `'App\Foo': async`, `'App\Foo': [async, audit]` and
+# `'App\Foo': {senders: [async]}`. The third form is the documented long form of the first two.
+_SENDERS_KEY = "senders"
+
+# A routing key is a class or interface FQN. Anything else in that position — a `*` wildcard
+# included — is a Symfony feature this reader does not model, and guessing would put a
+# fabricated class on the edge.
+_CLASS_KEY = re.compile(
+    r"^\\?[A-Za-z_\x80-\xff][\w\x80-\xff]*(\\[A-Za-z_\x80-\xff][\w\x80-\xff]*)*$"
+)
+
+# How deep to look for a `messenger` block. Symfony nests it at `framework.messenger` and under
+# an environment guard at `when@test.framework.messenger`; three is one more than the deepest
+# real form, and the bound is what keeps a large document from being walked in full.
+_MAX_DEPTH = 3
+
+
+class MessageRoutingReader:
+    """Reads `messenger` routing tables out of one document."""
+
+    name = "message_routing"
+
+    def read(self, document: ConfigDocument) -> FactSet:
+        facts = FactSet()
+        tables = list(self._routing_tables(document.data))
+        if not tables:
+            return facts
+
+        file_ref = NodeRef.config(file_key(document.path))
+        for table in tables:
+            for key, value in table.items():
+                transports = list(self._transports(value))
+                if not transports:
+                    facts.unresolvable(REASON_NO_TRANSPORT)
+                    continue
+                for transport in transports:
+                    node_key = transport_key(transport)
+                    facts.nodes.append(
+                        ConfigNode(
+                            key=node_key,
+                            label=transport,
+                            kind="transport",
+                            source_file=document.path,
+                        )
+                    )
+                    # The file-to-transport edge is written whether or not the message class is
+                    # in the graph. A transport whose message lives in a package this build did
+                    # not index is still a transport this application declares, and dropping the
+                    # node would report the application as having fewer than it has.
+                    facts.edges.append(
+                        ConfigEdge(
+                            source=file_ref,
+                            target=NodeRef.config(node_key),
+                            relation=RELATION_DECLARES,
+                            source_file=document.path,
+                        )
+                    )
+                    class_fqn = str(key).lstrip("\\")
+                    if not _CLASS_KEY.match(class_fqn):
+                        facts.unresolvable(REASON_NOT_A_CLASS)
+                        continue
+                    facts.edges.append(
+                        ConfigEdge(
+                            source=NodeRef.php_class(class_fqn),
+                            target=NodeRef.config(node_key),
+                            relation=RELATION_ROUTED_TO,
+                            source_file=document.path,
+                        )
+                    )
+        return facts
+
+    def _routing_tables(self, data: dict) -> Iterator[dict]:
+        """Every `routing` mapping this document declares.
+
+        Both shapes are accepted because both occur: the full `framework.messenger.routing`
+        path an application file uses, and a bare top-level `routing` in a file that is already
+        scoped to messenger by an import.
+        """
+        top = data.get("routing")
+        if isinstance(top, dict):
+            yield top
+        for block in self._messenger_blocks(data, _MAX_DEPTH):
+            table = block.get("routing")
+            if isinstance(table, dict):
+                yield table
+
+    def _messenger_blocks(self, node, depth: int) -> Iterator[dict]:
+        if depth < 0 or not isinstance(node, dict):
+            return
+        for key, value in node.items():
+            if not isinstance(value, dict):
+                continue
+            if key == "messenger":
+                yield value
+            else:
+                yield from self._messenger_blocks(value, depth - 1)
+
+    def _transports(self, value) -> Iterator[str]:
+        if isinstance(value, str):
+            yield value
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, str):
+                    yield item
+        elif isinstance(value, dict):
+            yield from self._transports(value.get(_SENDERS_KEY))
+
+
+def transport_key(name: str) -> str:
+    """Node key for a transport, shared by every file that names it.
+
+    Two files routing to `cron` describe one transport. Keying by name is what keeps them one
+    node, so "everything on cron" is a single neighbourhood rather than one per file.
+    """
+    return f"cfg::transport::{name}"

graphify_php/config/ports.py

@@ -0,0 +1,23 @@
+"""The one interface a configuration fact has to implement.
+
+A reader is handed a parsed document and returns facts. It does not know where the file came
+from, how it was parsed, what a graph node is, or which other readers exist. That is what makes
+a third fact — scheduler definitions, workflow transitions — a new class in this package rather
+than a branch in an existing one.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from .facts import ConfigDocument, FactSet
+
+
+@runtime_checkable
+class ConfigFactReader(Protocol):
+    name: str
+
+    def read(self, document: ConfigDocument) -> FactSet:
+        """Facts this reader finds in one document. A document with none of its fact yields an
+        empty `FactSet`, never an exception: most configuration files hold neither routing nor
+        an environment reference, and that is not a condition worth reporting."""

graphify_php/config/safe_yaml.py

@@ -0,0 +1,127 @@
+"""Parsing one YAML document, under the assumptions a configuration directory earns.
+
+Symfony configuration is not plain YAML. It carries tags the framework resolves at container
+build time — `!php/const App\\Kernel::VERSION`, `!php/enum App\\Status::Draft`, `!tagged_iterator`
+— and a parser that resolves tags would need PHP to mean anything by them. They are kept as
+opaque strings: the identifier inside is still text this package may index, and nothing here
+ever has to decide what it evaluates to.
+
+Three refusals, each because a configuration directory is read from a repository this package
+does not control:
+
+- the loader is `SafeLoader`, never `Loader` or `UnsafeLoader`, so no tag can construct a
+  Python object;
+- alias resolution is capped. PyYAML composes an alias to the node it already built rather
+  than to a copy, so the classic billion-laughs file does not multiply memory here — measured,
+  a four-level 9-way alias bomb parses fine. The cap bounds compose time against a file with
+  far more references than a hand-written configuration has, and it is a stated limit rather
+  than a guess about what PyYAML will keep doing;
+- a file above the size cap is refused unread rather than parsed, so one pathological file
+  cannot decide how long a build takes.
+
+A refusal is counted and named. It never raises out of this module: graphify swallows a
+resolver exception into a log line nobody reads, so a malformed file must not be able to take
+the whole pass down with it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+# A Symfony configuration file is a few kilobytes. The cap is generous enough that no real one
+# meets it and low enough that a checked-in fixture or generated dump cannot dominate a build.
+MAX_BYTES = 2 * 1024 * 1024
+
+# Aliases in real Symfony configuration number in the tens — merge keys in `services.yaml` and
+# little else. Anything past this is generated or hostile, and either way is not something this
+# package needs to finish parsing.
+MAX_ALIASES = 500
+
+REASON_TOO_LARGE = "file_too_large"
+REASON_UNREADABLE = "file_unreadable"
+REASON_MALFORMED = "yaml_malformed"
+REASON_TOO_DEEP = "yaml_nested_too_deep"
+REASON_ALIAS_BUDGET = "yaml_alias_budget_exceeded"
+REASON_NOT_A_MAPPING = "document_not_a_mapping"
+
+
+class _AliasBudgetExceeded(Exception):
+    pass
+
+
+class ConfigSafeLoader(yaml.SafeLoader):
+    """`SafeLoader` that tolerates Symfony's tags and refuses to expand aliases without bound."""
+
+    def __init__(self, stream) -> None:
+        super().__init__(stream)
+        self._aliases_seen = 0
+
+    def compose_node(self, parent, index):
+        # Every `*ref` passes through here. Counting events rather than measuring the result
+        # keeps the bound ahead of the expansion instead of behind it.
+        if self.check_event(yaml.events.AliasEvent):
+            self._aliases_seen += 1
+            if self._aliases_seen > MAX_ALIASES:
+                raise _AliasBudgetExceeded(f"more than {MAX_ALIASES} alias expansions")
+        return super().compose_node(parent, index)
+
+
+def _opaque(loader: ConfigSafeLoader, tag_suffix: str, node) -> str:
+    """Any tag the framework owns, kept as the text it was written as.
+
+    `!php/const App\\Kernel::VERSION` becomes `!php/const App\\Kernel::VERSION`. A reader that
+    wants the class name can read it; nothing here claims to know the value, which is the only
+    honest answer without running PHP.
+    """
+    if isinstance(node, yaml.ScalarNode):
+        return f"{node.tag} {loader.construct_scalar(node)}".strip()
+    # A sequence or mapping under a custom tag carries no scalar to keep. The tag alone records
+    # that something framework-specific was here without inventing a structure for it.
+    return str(node.tag)
+
+
+ConfigSafeLoader.add_multi_constructor("", _opaque)
+
+
+@dataclass(frozen=True)
+class ParseResult:
+    """Either a mapping, or the named reason there is none. Never both, never an exception."""
+
+    data: dict | None
+    reason: str = ""
+
+
+class SafeDocumentParser:
+    """Reads one file and returns its top-level mapping, or why it did not."""
+
+    def parse(self, path: Path) -> ParseResult:
+        try:
+            if path.stat().st_size > MAX_BYTES:
+                return ParseResult(None, REASON_TOO_LARGE)
+            text = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ParseResult(None, REASON_UNREADABLE)
+
+        try:
+            data = yaml.load(text, Loader=ConfigSafeLoader)  # noqa: S506 - restricted loader
+        except _AliasBudgetExceeded:
+            return ParseResult(None, REASON_ALIAS_BUDGET)
+        except yaml.YAMLError:
+            # A hand-edited configuration file with a bad indent is ordinary. It costs this one
+            # file, and the count is what makes it visible instead of silent.
+            return ParseResult(None, REASON_MALFORMED)
+        except RecursionError:
+            # PyYAML composes one stack frame per nesting level, so ten kilobytes of `[[[[` is
+            # enough to overflow it. That is not a YAMLError, and uncaught it would take the
+            # whole pass down for one file.
+            return ParseResult(None, REASON_TOO_DEEP)
+
+        if not isinstance(data, dict):
+            # An empty file parses to `None` and a list-rooted file to a list. Neither is a
+            # Symfony configuration document, and both are normal enough to count rather than
+            # complain about.
+            return ParseResult(None, REASON_NOT_A_MAPPING)
+        return ParseResult(data)