@barefootjs/php 0.1.0

package/tests/test_props_attr.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * `BarefootJS::props_attr` -- the `bf-p` hydration-payload attribute.
+ *
+ * The encoded JSON is embedded in a SINGLE-quoted attribute, so it must be
+ * attribute-escaped: a raw `'` inside a string value (e.g. a blog paragraph)
+ * terminates the attribute early and the client hydrates from truncated JSON
+ * (empty island text; found via the shared blog-ssr e2e). Same fix across
+ * the Perl, Python, Ruby, Rust, and PHP runtimes (#2086) -- keep the five
+ * tests in sync.
+ */
+
+require_once __DIR__ . '/_harness.php';
+bf_require_runtime();
+bf_reset();
+
+use Barefoot\BarefootJS;
+use Barefoot\Json;
+
+$backend = new class {
+    public function encode_json($value): string
+    {
+        return Json::canonicalEncode($value);
+    }
+};
+
+function bfp_with($props): BarefootJS
+{
+    global $backend;
+    $bf = new BarefootJS(null, ['backend' => $backend]);
+    if ($props !== null) {
+        $bf->_props($props);
+    }
+    return $bf;
+}
+
+bf_test('empty props emit nothing', function () {
+    bf_assert_eq(bfp_with(null)->props_attr(), '');
+    bf_assert_eq(bfp_with([])->props_attr(), '');
+});
+
+bf_test('json is attribute-escaped', function () {
+    $attr = bfp_with(['note' => "it's <b> & co"])->props_attr();
+    bf_assert_eq($attr, " bf-p='{&#34;note&#34;:&#34;it&#39;s &lt;b&gt; &amp; co&#34;}'");
+});
+
+bf_test('attribute round-trips through entity decoding', function () {
+    $attr = bfp_with(['note' => "it's <b> & co"])->props_attr();
+    if (!preg_match("/bf-p='([^']*)'/", $attr, $m)) {
+        throw new RuntimeException('bf-p attribute not found in: ' . $attr);
+    }
+    $decoded = str_replace(
+        ['&#34;', '&#39;', '&lt;', '&gt;', '&amp;'],
+        ['"', "'", '<', '>', '&'],
+        $m[1]
+    );
+    bf_assert_eq(json_decode($decoded, true), ['note' => "it's <b> & co"]);
+});
+
+return bf_finish();

package/tests/test_query.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * `BarefootJS::query` -- ported from packages/adapter-perl/t/query.t (see
+ * also the Python port's test_query.py).
+ *
+ * The full CROSS-BACKEND behaviour (control flow + form-encoding parity
+ * with the browser's URLSearchParams) is defined ONCE in the shared golden
+ * helper vectors and run by test_helper_vectors.php. This file keeps a few
+ * representative cases for always-on coverage plus the PHP-runtime-SPECIFIC
+ * defensive behaviour the golden vectors can't express: a `null` value
+ * (JSON has no `undefined`; this runtime coerces `null` to '' and omits the
+ * empty pair, mirroring the Perl/Python ports' documented `undef`/`None`
+ * handling).
+ */
+
+require_once __DIR__ . '/_harness.php';
+bf_require_runtime();
+bf_reset();
+
+use Barefoot\BarefootJS;
+
+$bf = new BarefootJS(null, ['backend' => null]);
+
+bf_test('order preserved; repeated key overwrites at first position', function () use ($bf) {
+    bf_assert_eq(
+        $bf->query('/blog', true, 'sort', 'title', true, 'tag', 'go', true, 'sort', 'date'),
+        '/blog?sort=date&tag=go'
+    );
+});
+
+bf_test('form encoding: tilde, star, space', function () use ($bf) {
+    bf_assert_eq($bf->query('/s', true, 't', 'a~b *c'), '/s?t=a%7Eb+*c');
+});
+
+bf_test('array value appends one pair per non-empty member', function () use ($bf) {
+    bf_assert_eq($bf->query('/list', true, 'tag', ['a', '', 'b']), '/list?tag=a&tag=b');
+});
+
+bf_test('null value coerces to empty and is omitted', function () use ($bf) {
+    bf_assert_eq($bf->query('/list', true, 'tag', null), '/list');
+    bf_assert_eq($bf->query('/list', true, 'tag', null, true, 'keep', 'me'), '/list?keep=me');
+});
+
+return bf_finish();

package/tests/test_render_child.php

@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * `render_child` renderer-invocation contract, ported from
+ * packages/adapter-perl/t/render_child.t (see also the Python port's
+ * test_render_child.py).
+ *
+ * Renderer contract (#1897): the renderer is invoked with `(props,
+ * invoking_bf)` so nested renders can chain scope/slot identity off the
+ * caller, not the registrant. Uses a StubBackend (no engine dependency).
+ */
+
+require_once __DIR__ . '/_harness.php';
+bf_require_runtime();
+bf_reset();
+
+use Barefoot\BarefootJS;
+
+$stubBackend = new class {
+    public function materialize($value)
+    {
+        return is_callable($value) ? $value() : $value;
+    }
+
+    /** Identity -- this stub is engine-agnostic (no reserved-word set of its
+     * own). The Twig-specific reserved-word mangling behaviour (`for` ->
+     * `for_`) is exercised end-to-end via the real `TwigBackend` in
+     * `packages/adapter-twig/php/tests/test_render.php`. */
+    public function ident(string $name): string
+    {
+        return $name;
+    }
+};
+
+function bfrc_new_bf(): BarefootJS
+{
+    global $stubBackend;
+    return new BarefootJS(null, ['backend' => $stubBackend]);
+}
+
+bf_test('renderer receives the invoking instance', function () {
+    $bf = bfrc_new_bf();
+    $bf->_scope_id('Root_test');
+
+    $seen = [];
+    $probe = function ($props, $caller) use (&$seen) {
+        $seen['props'] = $props;
+        $seen['caller'] = $caller;
+        return 'ok';
+    };
+    $bf->register_child_renderer('probe', $probe);
+
+    bf_assert_eq($bf->render_child('probe', 'value', 1), 'ok');
+    bf_assert_eq($seen['props']['value'], 1);
+    bf_assert($seen['caller'] === $bf, 'expected the caller to be the invoking bf');
+
+    // A nested invocation from a different instance passes THAT instance.
+    $child = bfrc_new_bf();
+    $child->_scope_id('Root_test_s0');
+    $child->_child_renderers($bf->_child_renderers());
+    $child->render_child('probe');
+    bf_assert($seen['caller'] === $child, 'expected the caller to be the nested child instance');
+});
+
+bf_test('renderer exceptions propagate', function () {
+    $bf = bfrc_new_bf();
+    $bf->register_child_renderer('boom', function ($props, $caller) {
+        throw new \RuntimeException('renderer exploded');
+    });
+
+    try {
+        $bf->render_child('boom');
+        bf_assert(false, 'expected an exception to propagate');
+    } catch (\RuntimeException $e) {
+        bf_assert_eq($e->getMessage(), 'renderer exploded');
+    }
+});
+
+bf_test('single-array form', function () {
+    // Mirrors the Perl port's hashref form for callers that can't splat a
+    // hash into positional/keyword args.
+    $bf = bfrc_new_bf();
+    $seen = [];
+    $bf->register_child_renderer('probe', function ($props, $caller) use (&$seen) {
+        $seen['props'] = $props;
+        return 'ok';
+    });
+    $bf->render_child('probe', ['value' => 42]);
+    bf_assert_eq($seen['props']['value'], 42);
+});
+
+bf_test('missing renderer raises', function () {
+    $bf = bfrc_new_bf();
+    try {
+        $bf->render_child('missing');
+        bf_assert(false, 'expected a RuntimeException');
+    } catch (\RuntimeException $e) {
+        bf_assert(str_contains($e->getMessage(), 'missing'), 'expected the message to name the missing renderer');
+    }
+});
+
+bf_test('prop keys are routed through backend->ident (identity in this stub)', function () {
+    // `render_child` delegates key-mangling to the backend's `ident()` (the
+    // fifth backend-contract method) rather than hard-coding an
+    // engine-specific reserved-word set here. This stub's `ident()` is the
+    // identity function, so keys pass through unchanged -- the Twig-specific
+    // mangling behaviour (`for` -> `for_`) is exercised end-to-end via the
+    // real `TwigBackend` in
+    // packages/adapter-twig/php/tests/test_render.php.
+    $bf = bfrc_new_bf();
+    $seen = [];
+    $bf->register_child_renderer('probe', function ($props, $caller) use (&$seen) {
+        $seen['props'] = $props;
+        return 'ok';
+    });
+    $bf->render_child('probe', ['for' => 'x', 'id' => 'y']);
+    bf_assert_eq($seen['props']['for'], 'x');
+    bf_assert_eq($seen['props']['id'], 'y');
+});
+
+return bf_finish();

package/tests/test_search_params.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * `BarefootJS::SearchParams` -- PHP-specific concerns, ported from
+ * packages/adapter-perl/t/search_params.t (see also the Python port's
+ * test_search_params.py).
+ *
+ * The cross-language VALUE semantics of `get` are owned by the
+ * language-independent golden vectors (`search_params_get` in
+ * test_helper_vectors.php), so Go/Perl/Python/PHP parity there is
+ * mechanical. This file covers only what those value vectors can't: the
+ * lazy factory seam, lenient parsing (never raises), and UTF-8 decoding.
+ */
+
+require_once __DIR__ . '/_harness.php';
+bf_require_runtime();
+bf_reset();
+
+use Barefoot\BarefootJS;
+use Barefoot\SearchParams;
+
+bf_test('lazy factory', function () {
+    $sp = BarefootJS::search_params('sort=price');
+    bf_assert($sp instanceof SearchParams, 'expected a SearchParams instance');
+    bf_assert_eq($sp->get('sort'), 'price');
+    bf_assert(BarefootJS::search_params() instanceof SearchParams, 'expected a SearchParams instance for the default query');
+});
+
+bf_test('null-ish composition coalesces only an absent key', function () {
+    // The adapter lowers `searchParams().get(k) ?? d` to Twig's native `??`,
+    // which coalesces only `null` (not a bare `or`, which would also
+    // default a present-but-empty value) -- so an absent key falls back to
+    // the author's default while a present-but-empty value keeps ''.
+    $absent = BarefootJS::search_params('other=x');
+    $got = $absent->get('sort');
+    bf_assert_eq($got ?? 'none', 'none');
+
+    $empty = BarefootJS::search_params('sort=');
+    $got = $empty->get('sort');
+    bf_assert_eq($got ?? 'none', '');
+});
+
+bf_test('UTF-8 percent-decoding', function () {
+    $sp = BarefootJS::search_params('q=%E2%9C%93');
+    bf_assert_eq($sp->get('q'), "\xE2\x9C\x93"); // U+2713 CHECK MARK
+});
+
+bf_test('lenient parsing never raises', function () {
+    BarefootJS::search_params(''); // should not raise
+    bf_assert_eq(BarefootJS::search_params('&&&')->get('x'), null);
+    bf_assert_eq(BarefootJS::search_params('=novalue')->get('x'), null);
+});
+
+return bf_finish();

package/tests/test_spread_attrs.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * `BarefootJS::spread_attrs` -- ported from
+ * packages/adapter-perl/t/spread_attrs.t (see also the Python port's
+ * test_spread_attrs.py).
+ *
+ * JSX intrinsic-element spread runtime helper (#1407 follow-up). Mirrors
+ * the JS `spreadAttrs` runtime and the Go/Perl/Python adapters' equivalents
+ * so SSR output stays byte-equal across every adapter -- cross-adapter
+ * parity regressions surface here first.
+ */
+
+require_once __DIR__ . '/_harness.php';
+bf_require_runtime();
+bf_reset();
+
+use Barefoot\BarefootJS;
+
+$backend = new class {
+    public function mark_raw($s)
+    {
+        return $s;
+    }
+};
+
+function bfs_run($bag): string
+{
+    global $backend;
+    $bf = new BarefootJS(null, ['backend' => $backend]);
+    return (string) $bf->spread_attrs($bag);
+}
+
+bf_test('basic shapes', function () {
+    bf_assert_eq(bfs_run(null), '');
+    bf_assert_eq(bfs_run([]), '');
+    bf_assert_eq(bfs_run('not a hash'), '');
+    bf_assert_eq(bfs_run(['id' => 'a']), 'id="a"');
+});
+
+bf_test('alphabetic key order', function () {
+    bf_assert_eq(bfs_run(['id' => 'a', 'class' => 'on']), 'class="on" id="a"');
+});
+
+bf_test('key remapping', function () {
+    bf_assert_eq(bfs_run(['className' => 'foo']), 'class="foo"');
+    bf_assert_eq(bfs_run(['htmlFor' => 'x']), 'for="x"');
+    bf_assert_eq(bfs_run(['dataPriority' => 'high']), 'data-priority="high"');
+    // SVG XML attrs are case-sensitive -- preserve verbatim.
+    bf_assert_eq(bfs_run(['viewBox' => '0 0 10 10']), 'viewBox="0 0 10 10"');
+    bf_assert_eq(bfs_run(['clipPathUnits' => 'userSpaceOnUse']), 'clipPathUnits="userSpaceOnUse"');
+    // JS-reference parity (#1411): a leading uppercase letter emits a leading dash.
+    bf_assert_eq(bfs_run(['XData' => 'x']), '-x-data="x"');
+});
+
+bf_test('event handlers -- JS predicate parity', function () {
+    bf_assert_eq(bfs_run(['onClick' => 'fn', 'id' => 'a']), 'id="a"');
+    bf_assert_eq(bfs_run(['on_custom' => 'fn', 'id' => 'a']), 'id="a"');
+    bf_assert_eq(bfs_run(['on0' => 'fn', 'id' => 'a']), 'id="a"');
+    bf_assert_eq(bfs_run(['oncology' => 'x']), 'oncology="x"');
+});
+
+bf_test('children skipped, ref passed through', function () {
+    bf_assert_eq(bfs_run(['children' => 'x', 'id' => 'a']), 'id="a"');
+    // JS `spreadAttrs` does NOT filter `ref` (`applyRestAttrs` does -- a
+    // separate divergence).
+    bf_assert_eq(bfs_run(['ref' => 'x', 'id' => 'a']), 'id="a" ref="x"');
+});
+
+bf_test('boolean values', function () {
+    // Contract: callers MUST pass a real PHP bool for boolean attributes --
+    // no sentinel object is needed (PHP has a real boolean type).
+    bf_assert_eq(bfs_run(['hidden' => true, 'id' => 'a']), 'hidden id="a"');
+    bf_assert_eq(bfs_run(['hidden' => false, 'id' => 'a']), 'id="a"');
+    // Plain numeric 0 renders as a value (matches `tabindex="0"`).
+    bf_assert_eq(bfs_run(['tabindex' => 0]), 'tabindex="0"');
+});
+
+bf_test('nullish skip', function () {
+    bf_assert_eq(bfs_run(['a' => null, 'b' => 'x']), 'b="x"');
+});
+
+bf_test('HTML escape', function () {
+    bf_assert_eq(bfs_run(['title' => '<b>"x"</b>']), 'title="&lt;b&gt;&#34;x&#34;&lt;/b&gt;"');
+    bf_assert_eq(bfs_run(['alt' => 'tom & jerry']), 'alt="tom &amp; jerry"');
+});
+
+bf_test('style object lowering', function () {
+    bf_assert_eq(
+        bfs_run(['style' => ['backgroundColor' => 'red', 'color' => 'white']]),
+        'style="background-color:red;color:white"'
+    );
+    bf_assert_eq(bfs_run(['style' => 'color:red']), 'style="color:red"');
+});
+
+return bf_finish();