graphify-php 0.0.5__py3-none-any.whl

graphify_php/syntax/routes.py

@@ -0,0 +1,288 @@
+"""Route declarations read from PHP attributes.
+
+Why this is here at all. The call graph answers questions whose subject is a symbol. It cannot
+answer one whose subject is a literal: "which repository owns `/api/v1/storage/upload/small`"
+has no symbol in it, no node label contains a route path, and the ranked search therefore
+returns a frontend caller and an unrelated class above the controller that actually serves it.
+A route declaration puts the literal into the graph, attached to the method that serves it.
+
+What a route declaration proves, and what it does not. It proves that this codebase declares
+that path and names this controller method to serve it. It does NOT prove that a deployed
+ingress, load balancer or reverse proxy routes that path here, nor that any environment loads
+the route at all — Symfony filters by `env`, a firewall may block it, and another service may
+answer the same path first. A reader will assume the stronger claim, so it is worth saying
+plainly: this is a declaration in source, not an observation of production traffic.
+
+The composition rules are read from Symfony's own loader rather than guessed, in the copy at
+`vendor/symfony/routing/Loader/AttributeClassLoader.php`:
+
+- path — `$paths[] = $prefix.$path`, plain string concatenation of the class-level path onto
+  the method-level one.
+- name — `$name = $globals['name'].$name`, the class-level name used as a prefix.
+- methods — `array_unique(array_merge($globals['methods'], $attr->methods))`, a UNION. A
+  method-level `methods:` does not replace the class-level one, which is the rule most likely
+  to be guessed wrong.
+- an abstract class is skipped entirely (`load()` throws on it).
+- a class with `__invoke` and no method-level route takes its route from the class attribute,
+  and `resetGlobals()` means no prefix is applied in that case — the class attribute IS the
+  route rather than a prefix for one.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import nodes
+
+# Matched on the short name, because that is what the attribute is written as. A `use` that
+# renames it is not followed: an alias for `Route` is vanishingly rare next to the cost of
+# resolving every attribute name in the file, and a miss here loses a node rather than
+# inventing one.
+ROUTE_ATTRIBUTE = "Route"
+
+STRING_KINDS = ("string", "encapsed_string")
+
+# Why an effective route could not be composed. Fixed strings, same discipline as the call
+# refusals: these are a work list, not a histogram of prose.
+PATH_NOT_LITERAL = "path-not-literal"
+PREFIX_NOT_LITERAL = "prefix-not-literal"
+LOCALIZED_PATH = "localized-path"
+NO_PATH = "no-path"
+
+
+@dataclass(frozen=True)
+class RouteDeclaration:
+    """One `#[Route]` as declared, with the controller method it sits on.
+
+    `path` is the template verbatim — `/api/v1/storage/upload/small/{id}` — because the
+    placeholder is what makes it searchable and matchable. It is None when composition needed
+    something this package cannot evaluate; `class_path` and `method_path` still carry
+    whichever halves were literal, so the declaration is a usable partial rather than a hole.
+    """
+
+    controller_class: str
+    controller_method: str
+    source_file: str
+    line: int
+    path: str | None = None
+    name: str | None = None
+    methods: tuple[str, ...] = ()
+    class_path: str | None = None
+    method_path: str | None = None
+    reason: str = ""
+
+    @property
+    def resolved(self) -> bool:
+        return self.path is not None
+
+    @property
+    def node_key(self) -> str:
+        """Identity of this declaration, not of the path.
+
+        The declaring method is in the key on purpose. Two repositories that both declare
+        `/health` declare two different things — each is served by its own controller — and
+        collapsing them onto one node would claim a relationship between two codebases that
+        share nothing but a string.
+        """
+        return (
+            f"{self.controller_class}::{self.controller_method}#"
+            f"{self.path or self.method_path or ''}"
+        )
+
+
+def collect_routes(root, names, source_file: str) -> list[RouteDeclaration]:
+    """Every route declared in one file.
+
+    A separate pass over the tree rather than a hook in the walker: routes are not type facts,
+    and the walker's one reason to change is scope.
+    """
+    found: list[RouteDeclaration] = []
+    _walk(root, names, source_file, found)
+    return found
+
+
+def _walk(node, names, source_file: str, found: list) -> None:
+    if node.type in nodes.CLASS_KINDS:
+        _read_class(node, names, source_file, found)
+        return
+    for child in node.children:
+        _walk(child, names, source_file, found)
+
+
+def _read_class(node, names, source_file: str, found: list) -> None:
+    if nodes.child(node, "abstract_modifier") is not None:
+        # Symfony's loader throws rather than reading attributes from an abstract class, so a
+        # route on one is a prefix for subclasses, never a route in its own right.
+        return
+    class_fqn = names.qualify_declaration(nodes.name_of(node))
+    class_attr = _route_attribute(node)
+    prefix = _Prefix.read(class_attr)
+
+    body = nodes.child(node, "declaration_list", "enum_declaration_list")
+    methods = nodes.children(body, "method_declaration") if body is not None else []
+
+    before = len(found)
+    for method in methods:
+        attribute = _route_attribute(method)
+        if attribute is None:
+            continue
+        found.append(_compose(attribute, prefix, class_fqn, nodes.name_of(method), source_file))
+
+    if len(found) == before and class_attr is not None:
+        invoke = next((m for m in methods if nodes.name_of(m) == "__invoke"), None)
+        if invoke is not None:
+            # `resetGlobals()` in the loader: the class attribute is the route itself here, so
+            # it composes with nothing.
+            found.append(_compose(class_attr, _Prefix(), class_fqn, "__invoke", source_file))
+
+
+@dataclass
+class _Prefix:
+    """The class-level attribute, as the three things it contributes."""
+
+    path: str | None = None
+    name: str = ""
+    methods: tuple[str, ...] = ()
+    path_literal: bool = True
+
+    @classmethod
+    def read(cls, attribute) -> _Prefix:
+        if attribute is None:
+            return cls()
+        positional, named = _arguments(attribute)
+        path_node = named.get("path") or (positional[0] if positional else None)
+        path, literal = _path_of(path_node)
+        return cls(
+            path=path,
+            name=_string_value(named.get("name")) or "",
+            methods=_string_list(named.get("methods")),
+            path_literal=literal,
+        )
+
+
+def _compose(
+    attribute, prefix: _Prefix, class_fqn: str, method_name: str, source_file: str
+) -> RouteDeclaration:
+    positional, named = _arguments(attribute)
+    path_node = named.get("path") or (positional[0] if positional else None)
+    method_path, literal = _path_of(path_node)
+
+    name = _string_value(named.get("name"))
+    # `array_unique(array_merge(...))`: a union, with the class-level entries first.
+    methods = tuple(dict.fromkeys(prefix.methods + _string_list(named.get("methods"))))
+
+    effective: str | None = None
+    reason = ""
+    if path_node is None:
+        reason = NO_PATH
+    elif not literal:
+        reason = (
+            LOCALIZED_PATH if method_path is None and _is_array(path_node) else PATH_NOT_LITERAL
+        )
+    elif not prefix.path_literal:
+        reason = PREFIX_NOT_LITERAL
+    else:
+        effective = (prefix.path or "") + method_path
+
+    return RouteDeclaration(
+        controller_class=class_fqn,
+        controller_method=method_name,
+        source_file=source_file,
+        line=nodes.line_span(attribute)[0],
+        path=effective,
+        name=(prefix.name + name) if name is not None else (prefix.name or None),
+        methods=methods,
+        class_path=prefix.path,
+        method_path=method_path,
+        reason=reason,
+    )
+
+
+def _route_attribute(declaration):
+    """The `#[Route(...)]` on a class or method declaration, or None.
+
+    Only attribute groups directly on this declaration are read, so an attribute on a nested
+    declaration cannot be mistaken for one on its parent.
+    """
+    attributes = nodes.child(declaration, "attribute_list")
+    if attributes is None:
+        return None
+    for group in nodes.children(attributes, "attribute_group"):
+        for attribute in nodes.children(group, "attribute"):
+            written = nodes.node_text(nodes.child(attribute, "name", "qualified_name"))
+            if written.rsplit("\\", 1)[-1] == ROUTE_ATTRIBUTE:
+                return attribute
+    return None
+
+
+def _arguments(attribute) -> tuple[list, dict]:
+    positional: list = []
+    named: dict = {}
+    argument_list = nodes.child(attribute, "arguments")
+    for argument in nodes.children(argument_list, "argument"):
+        label = nodes.child(argument, "name")
+        # Named nodes only: `name: "x"` puts a bare `:` token between the label and the value,
+        # and taking the first non-label child would take the colon.
+        value = next((c for c in argument.children if c.is_named and c is not label), None)
+        if value is None:
+            continue
+        if label is not None:
+            named[nodes.node_text(label)] = value
+        else:
+            positional.append(value)
+    return positional, named
+
+
+def _path_of(node) -> tuple[str | None, bool]:
+    """(path, was-a-literal). A non-literal keeps `None` rather than a guessed value."""
+    if node is None:
+        return None, True
+    value = _string_value(node)
+    if value is None:
+        return None, False
+    return value, True
+
+
+def _is_array(node) -> bool:
+    return node is not None and node.type == "array_creation_expression"
+
+
+def _string_value(node) -> str | None:
+    """The text of a string literal, or None for anything that needs evaluating.
+
+    A concatenation, a constant or a variable all return None. Reading `self::PREFIX . '/x'`
+    as `/x` would put a path in the graph that the application never serves.
+    """
+    if node is None or node.type not in STRING_KINDS:
+        return None
+    parts = [c for c in node.children if c.is_named]
+    if len(parts) == 1 and parts[0].type == "string_content":
+        return nodes.node_text(parts[0])
+    if parts:
+        # An escape sequence or an interpolation: the value is not the source text, and the
+        # first `string_content` of `'/it\'s/{id}'` is `/it`, a path nothing serves.
+        return None
+    text = nodes.node_text(node)
+    return text[1:-1] if len(text) >= 2 and text[0] in "\"'" else text
+
+
+def _string_list(node) -> tuple[str, ...]:
+    """`methods: 'GET'` and `methods: ['GET', 'POST']` are both written in this codebase."""
+    if node is None:
+        return ()
+    single = _string_value(node)
+    if single is not None:
+        return (single,)
+    if not _is_array(node):
+        return ()
+    out = []
+    for element in node.children:
+        value = _string_value(element)
+        if value is None:
+            for inner in element.children:
+                value = _string_value(inner)
+                if value is not None:
+                    break
+        if value is not None:
+            out.append(value)
+    return tuple(out)

graphify_php-0.0.5.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.5
+Name: graphify-php
+Version: 0.0.5
+Summary: PHP member-call resolution for graphify: binds $this->service->method() to the method node it calls.
+Author: Andrii Afanasiev
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: call-graph,code-graph,graphify,php,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: lint
+Requires-Dist: ruff>=0.15; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: graphifyy>=0.9.66; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# graphify-php
+
+PHP member-call resolution for [graphify](https://github.com/OxCom/graphify). It binds
+`$this->emails->reminderSubmitWeek($user)` to the method node it actually calls, so a PHP graph
+has a call graph instead of a list of names.
+
+## The measurement
+
+graphify ships cross-file member-call resolvers for Swift, Python, Ruby, TypeScript, C#, Java
+and Rust, and none for PHP. Its PHP extractor marks `$obj->method()` as a member call and the
+shared cross-file pass then drops it, because a bare `method` collides across the corpus and a
+name-only match is not evidence.
+
+On a reference Symfony application (584 PHP files, not shipped with this package), measured
+from the published graph:
+
+| | |
+|---|---|
+| PHP callable nodes | 3426 |
+| `calls` edges in the whole graph | 2172 |
+| PHP callables with an outgoing `calls` edge | 24.4 % |
+| PHP callables with an incoming `calls` edge | 20.1 % |
+
+Three quarters of the PHP callables in that graph are connected to nothing they call. Every
+"what calls this", "what does this touch" and blast-radius question over PHP is answered from
+that quarter.
+
+## What it does
+
+The pass runs inside graphify's build, after extraction:
+
+1. collects every member call graphify left unresolved, from `per_file[*]["raw_calls"]`;
+2. hands the sources the PHP files graphify parsed as the `corpus` they may read declarations
+   from. A leaf service class has nothing unresolved in it, so it never appears among the sites,
+   and a source indexing only those files cannot tell whether it declares the method being
+   called on it. The set is bounded by the build, never by a filesystem walk;
+3. asks each configured **call target source** in precedence order for the receiver's class —
+   the precise source (a PHP type engine that already knows the project's types) first, the
+   tree-sitter parser second. A site the first source proves is never offered to the second, so
+   a weaker source can add reach but can never overwrite a stronger source's answer;
+4. maps each `(class FQN, method)` to a graphify node id;
+5. appends `calls` edges carrying the target's confidence (`EXTRACTED` when the type was read
+   from source, `INFERRED` when it was derived) and `_resolver: "graphify-php"`, which is how a
+   reader tells our edges from graphify's own and can drop them without a rebuild. `_via` names
+   the technique that proved each one (`tree_sitter:promoted-parameter`, `tree_sitter:self-scope`,
+   ...).
+
+The marker is not `_origin`: graphify overwrites that on every edge with `"ast"` after the
+resolvers run (`extract.py:8285-8289`), where it means the eviction tier rather than the author.
+
+### Scoped calls
+
+`self::`, `parent::`, `static::` and `Class::method()` reach graphify with `is_member_call`
+false and the **scope** as the callee — the method name is dropped
+(`extractors/engine.py:6147-6152`). The resolver recovers it without parsing PHP: it asks the
+graph which methods that class declares and offers each as a candidate, and the type source
+refuses every name not actually written on that line. A class with ten methods costs ten
+lookups and yields at most one edge.
+
+`Class::method()` additionally already has a coarse `caller -> Class` edge, because graphify
+resolves the scope name to the class node. Our method-level edge is a **second** edge between
+different endpoints, so both are published. The narrow one carries `_refines` naming the coarse
+one, so a consumer can collapse the pair instead of counting the call twice.
+
+A source returns a target only when it can prove it. Chained calls, dynamic names, `static::`
+and anything through `__call` are counted by reason, not guessed at: a wrong call edge is worse
+than a missing one, and every counted reason is a line on the next version's work list.
+
+## Install and register
+
+graphify-php is not on PyPI. Install a clone in editable mode into graphify's own environment;
+the PHPStan source needs the `php/` directory of the checkout, which the wheel does not ship:
+
+```bash
+git clone https://github.com/OxCom/graphify-php.git ~/src/graphify-php
+pipx inject --editable --include-apps graphifyy ~/src/graphify-php
+```
+
+The one runtime dependency is pyyaml. graphify and tree-sitter come from the environment that
+runs the build; pinning them here would fight graphify's own pins. Virtual environments,
+PHPStan, verification and troubleshooting: [docs/install.md](docs/install.md).
+
+Registration is one call, made before graphify builds:
+
+```python
+import graphify_php
+
+graphify_php.register()
+```
+
+It is idempotent and imports graphify lazily, so importing the package never requires graphify
+to be installed.
+
+## Run a build
+
+```bash
+graphify-php-build -- update .
+```
+
+Everything after `--` is passed to graphify unchanged; options before it belong to the wrapper:
+
+| Option | Meaning |
+|---|---|
+| `--graph PATH` | the graph artifact to protect (default `$GRAPHIFY_OUT/graph.json`) |
+| `--expect RESOLVER` | a resolver that must report; repeatable, defaults to `php_member_calls` |
+
+Exit codes:
+
+| Code | Meaning |
+|---|---|
+| 0 | every expected resolver reported `completed` or `skipped` |
+| 2 | an expected resolver reported `failed`, or never finished |
+| 3 | an expected resolver never reported at all |
+| other | graphify's own exit code, when graphify itself failed |
+
+The wrapper sets `PYTHONHASHSEED=0` before calling graphify. graphify re-execs itself to pin
+that seed for `update`, `extract`, `cluster-only` and `label` (`__main__.py:486-525`), and the
+re-exec would replace the process — losing both the registration and the gate. Setting the seed
+graphify would have set skips the re-exec and keeps its determinism guarantee.
+
+## Why the wrapper exists
+
+graphify runs registered resolvers like this:
+
+```python
+try:
+    resolver.resolve(per_file, all_nodes, all_edges)
+except Exception as exc:
+    _LOG.warning("%s resolution failed, skipping: %s", resolver.name, exc)
+```
+
+A resolver that raises is skipped and the build still publishes. A resolver that was never
+registered — because the seam moved in a graphify upgrade, or because an install left this
+package out — is not even logged. Both produce a valid graph with fewer `calls` edges, which is
+exactly the shape of the defect this package was written to fix. The failure would be invisible
+at the one moment it matters, and the warning goes to graphify's logger, which nothing running
+the build reads.
+
+So each resolver writes its own record — state, and counters that include the denominator,
+because "resolved 400 calls" says nothing without "out of how many" — and `graphify-php-build`
+reads that record and refuses to publish when an expected resolver did not complete. On a
+refusal the previous graph is restored and the exit code is non-zero.
+
+`skipped` with a reason is a success: a repository with no PHP type engine in `vendor/` is a
+normal skip, and conflating it with a failure is how a missing layer becomes noise. `failed`,
+and silence, are not.
+
+The record path defaults to `graphify-out/.graphify-php-status.json` and is overridable with
+`GRAPHIFY_PHP_STATUS`, so one machine can index many repositories without their builds sharing
+a file.
+
+## Routes
+
+A second registered pass publishes what `#[Route]` attributes declare. Each declaration becomes
+one node — labelled with the path template, carrying the route name, the HTTP methods and
+whether the path was composed whole — and one `handled_by` edge to the controller method that
+serves it. On the reference Symfony application: **156 route nodes, 156 edges, no refusals**.
+
+The node key is `Class::method#path`, so two controller methods declaring the same path stay two
+nodes. That is not hypothetical: the reference application declares 156 routes over 135 distinct
+path templates, the repeats being different HTTP verbs on one path.
+
+The relation is `handled_by`, not `routed_to` — the latter already means messenger transport
+routing, and merging the two would put HTTP paths and message transports in one query.
+
+A declaration whose controller method is missing from the graph still gets its node; only the
+edge is withheld, and the omission is counted under `controller_not_in_graph`. The path is a
+fact about the codebase either way.
+
+## Verifying it works
+
+```bash
+PYTHONPATH=src python -m pytest tests/test_cli_end_to_end.py -q
+```
+
+That test generates a small PHP project in a temporary directory, runs graphify over it twice —
+once plain, once with `register()` called first — and asserts the difference. On the generated
+fixture the plain build produces **1** `calls` edge and the registered build **5**. It needs no
+reference application and writes nothing outside `tmp_path`.
+
+## Extending
+
+Adding a third source — a language server, an LSIF index — means implementing one protocol,
+`CallTargetSource` in `ports.py`, and adding it to the factory in `__init__.py`. `resolver.py`
+depends on the protocols and nothing else, and does not change.
+
+## CI
+
+GitHub Actions runs three stages in order: **security** (gitleaks, trufflehog, pip-audit,
+`php -l` over `php/`), **tests** (ruff lint and format check, pytest on Python 3.10–3.14) and
+**build** (`python -m build`, then import and `graphify-php-build --help` from the installed
+wheel). The same checks locally: `pip install -e ".[test,lint]"`, then `ruff check .`,
+`ruff format --check .`, `python -m pytest`, and `for f in php/autoload.php php/src/CallGraph/*.php; do php -l "$f"; done`.
+
+## License
+
+Apache-2.0.

graphify_php-0.0.5.dist-info/RECORD

@@ -0,0 +1,50 @@
+graphify_php/__init__.py,sha256=4EDW1vFFduuzwPjNff8rcS8dMOG0pq0HUaApmQDRv2o,5451
+graphify_php/cli.py,sha256=hPfvX46J3XK0YZbZv12sjNC3Ol0a96K_MEc7ilK9PvY,14459
+graphify_php/config_resolver.py,sha256=d3azDRtheX9xAbz1viWyz_18DEjsqpAZJQGGQGWns68,7239
+graphify_php/graph_adapter.py,sha256=jXge2Tz9vrNpUi5ptLmKDaXLhrzZO8S56iZJGKyj-pw,24022
+graphify_php/ports.py,sha256=pC9yL3-ZtUzm3PXF7rU3Db_MElkA_Ea95_hvW7vTO2A,7390
+graphify_php/resolver.py,sha256=NXDq_Qw4jN4YkYFcZPt6RyW06_vh4ycAHISuZuC_Un0,22249
+graphify_php/shrink.py,sha256=QTT3ECHTFb4Arzsx5m0WdRrIiFfGzgTU0WDvGaA0n1Q,16114
+graphify_php/shrink_cli.py,sha256=uDdkRikil8NHAiaqkVSigpg2bqpU75aYIJCmJykCrvk,5085
+graphify_php/status.py,sha256=5-WMfwNzBtpdQe0olTKI006N-OOAvPfGr7KaujeVVLA,5804
+graphify_php/config/__init__.py,sha256=H1qLCXTkLCkBmmDslviNgdDI-e1Iwa45eRmaKxtJ27E,1709
+graphify_php/config/class_lookup.py,sha256=FJOIfXPQFfFmgyqRRojVug2-7sL5nKz8F-TYzhbNjnQ,3808
+graphify_php/config/discovery.py,sha256=rnrQDWEK-d_gqfwOlg8eLI5ogaHfMWilDt988OPZxbo,2198
+graphify_php/config/document.py,sha256=a2zFdO1FK0CDXQvzhNHXI1tOETC1azz0eArLc5ivVJc,1180
+graphify_php/config/emit.py,sha256=BbMFHAhE7ZgD3gFJOQU-_fH40gv_xb9N9P8--qHJ0Y8,4975
+graphify_php/config/environment.py,sha256=LA2VfQIKYxheYvdzwYU3Ejj2cnrnsaSGC9anEblrVWA,4737
+graphify_php/config/facts.py,sha256=jGYWz5QlWJs5_WUIMlSw3FkD9Wa1ZLgZ_s-m9y_0iCY,3121
+graphify_php/config/messaging.py,sha256=Mpv6Ip2GNRxGkx5Ey_c1HiXrR8fK34jj2u0Yv2HOA3E,5901
+graphify_php/config/ports.py,sha256=T5HzCkpaS7mJ6Zq4YW6D6e9T4LLsNiHmPWgqqUaZYR0,915
+graphify_php/config/safe_yaml.py,sha256=tIx1HtPrMkJ6s9m75giCZopRGVBFCqJLsFEng5fadak,5598
+graphify_php/container/__init__.py,sha256=dv1EgzTd1vC7IotzA80rBesm-nu9NlG73p1nhnF04xc,1639
+graphify_php/container/facts.py,sha256=GMEFdR91pycOccKdFgggj8ipyXO_3xSr2hsIWPIVI10,7441
+graphify_php/container/layer.py,sha256=dZ8vCWbNdIrnKwsgRZfdq2OCfxwJiGNGZLHyfYKbX2I,3013
+graphify_php/container/locator.py,sha256=whBDvP_oJ1deYTrxMjVw1W65ogdJjGQcT-kwahvtcjo,3075
+graphify_php/container/overlay.py,sha256=nw8ezCW8eVmfYXGtOFM2hoM4_qj-sFCiPl5n3qpfs5I,6452
+graphify_php/container/ports.py,sha256=fqzT-08PbsYJwfDN0jiUE3FWWvdAKSHXja8Mr94NPZ0,1447
+graphify_php/container/reader.py,sha256=Y4C3VDFshmkqw2SksBG8WNxoaPU1bYF7Nm7B1Eo9JAI,14223
+graphify_php/container/reasons.py,sha256=Hdz7PUJH3QIqUWJWIihHKWWqOZxefuy8OXWWEaYErF8,1516
+graphify_php/sources/phpstan_source.py,sha256=peueo3NLJBxmLREcfmoFc2yk8PSw-ue5kxoMoxkEvBU,25686
+graphify_php/sources/route_source.py,sha256=yRF7p1-9tuzaUjgO6fPuQUyhihFtXsFo6bci46oYbqQ,4402
+graphify_php/sources/tree_sitter_source.py,sha256=mBCovpIB6kq8ED6qxggjtzd_CaBFm6CZET42uTwOWas,20154
+graphify_php/syntax/call_sites.py,sha256=T4PAeDVDLad-oKb66IFNuSDRc4D6gQueCmy8v3nktAs,4863
+graphify_php/syntax/class_index.py,sha256=JCISHN86mrYPnhHwcXc7zeMDSKWYzmhetsLW7xHzjSY,4991
+graphify_php/syntax/collectors.py,sha256=E7BineMX1TD7caI02SVqY4PznOvQ1v-Clng5zrOt2R0,14668
+graphify_php/syntax/facts.py,sha256=nvH3g9fwHx_I3DCBbcppL458V1gUuPYfjMvre-uPoLQ,7058
+graphify_php/syntax/file_scan.py,sha256=KVgYGDOIkT1lg2exS7pRKLOY-jMxreniQT9250S6ofM,6807
+graphify_php/syntax/names.py,sha256=eEhTP1mzIzlZZsLDUIGA0B1OnaZ-ykaTeuybZqw13NE,1932
+graphify_php/syntax/nodes.py,sha256=N5FTloxczzuHi3Z7OyxlsCGA2hMS9JlhT7mBU93sF4o,7071
+graphify_php/syntax/routes.py,sha256=oNCThLjRlmtD-dPLZfVyCTTIZzo23ZYCpWVqqEWmg_Q,11307
+graphify_php/php/README.md,sha256=kYNfc5A5i2xT-zY97RTJiy9HOJOcTlFNWRtYxV4jdLo,5267
+graphify_php/php/autoload.php,sha256=Boy0ncV9-YgSlqw1RFPKmgI43UfH0WNF-7SeJkz0hfU,673
+graphify_php/php/src/CallGraph/CallEdge.php,sha256=CuX4y0xNbBuqpSZMEsrvCXosDKPF4RX314S1qrhDKJo,3130
+graphify_php/php/src/CallGraph/CallEdgeRule.php,sha256=CrGqil6sQwYhdpIC5zEGALxZG63I7MLsLIisWgpBehM,1739
+graphify_php/php/src/CallGraph/CallEdgeWriter.php,sha256=J0BqKmc8d9y1ffFSItSNw-KFrb46fspKBHBAOLneRfs,432
+graphify_php/php/src/CallGraph/JsonLinesWriter.php,sha256=JgbVFse96vac__70ZSHKWZpv35gYIYyxVuSsgFB2A6U,1675
+graphify_php/php/src/CallGraph/MethodCallCollector.php,sha256=cdlyz_49pD395lqPzAytKj2UQfz2gbURuewMA_Jw2IM,5593
+graphify_php-0.0.5.dist-info/METADATA,sha256=fIpYmHSky1WqOotDhL20ogbORq_mBcDr03uNT6SJuPs,10241
+graphify_php-0.0.5.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+graphify_php-0.0.5.dist-info/entry_points.txt,sha256=ex-KP3uMC0omVy6TCsQxScwhHGiawRtfAvucE3DaeN0,132
+graphify_php-0.0.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+graphify_php-0.0.5.dist-info/RECORD,,

graphify_php-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

graphify_php-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+graphify-php-build = graphify_php.cli:_console_main
+graphify-shrink-check = graphify_php.shrink_cli:_console_main