@barefootjs/perl 0.8.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@barefootjs/perl",
+  "version": "0.8.0",
+  "description": "BarefootJS engine-agnostic Perl runtime (BarefootJS.pm) — pluggable rendering backend; the shared basis for Mojolicious and other Perl framework integrations",
+  "type": "module",
+  "files": [
+    "lib",
+    "t",
+    "README.md"
+  ],
+  "keywords": [
+    "perl",
+    "barefoot",
+    "ssr",
+    "runtime",
+    "template"
+  ],
+  "author": "kobaken <kentafly88@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/piconic-ai/barefootjs",
+    "directory": "packages/adapter-perl"
+  }
+}

package/t/controller_cycle.t

@@ -0,0 +1,79 @@
+use strict;
+use warnings;
+
+# Per-request reference-cycle regression test.
+#
+# The Mojolicious plugin stashes the bf instance under
+# `$c->stash->{'bf.instance'}`, so any strong bf -> controller back-reference
+# (held by the bf instance, its backend, or a child-renderer closure) closes a
+# cycle that Perl's refcount GC cannot reclaim — leaking one controller + bf +
+# closures per request. BarefootJS / BarefootJS::Backend::Mojo therefore hold
+# the controller weakly, and `register_components_from_manifest` reaches the
+# controller through the weak `$parent` rather than capturing it strongly.
+#
+# This test reproduces the plugin's wiring with a pure-Perl controller +
+# backend (no Mojolicious dependency, so it runs anywhere) and asserts the
+# whole graph is freed once the request-scope lexicals drop.
+
+use Test2::V0;
+use Scalar::Util qw(weaken);
+
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+
+use BarefootJS;
+
+# Controller stand-in that owns a stash, like a Mojolicious controller.
+{
+    package FakeController;
+    sub new   { bless { stash => {} }, shift }
+    sub stash { $_[0]{stash} }
+}
+
+# Pure-Perl backend mirroring the fixed BarefootJS::Backend::Mojo: it holds the
+# controller weakly so it never contributes a strong edge to the cycle.
+{
+    package WeakBackend;
+    use Scalar::Util qw(weaken);
+    sub new {
+        my ($class, %args) = @_;
+        my $self = bless {%args}, $class;
+        weaken($self->{c}) if $self->{c};
+        return $self;
+    }
+    sub c           { $_[0]{c} }
+    sub encode_json { '{}' }
+    sub mark_raw    { $_[1] }
+    sub materialize { $_[1] }
+    sub render_named { '' }
+}
+
+my ($probe_bf, $probe_c);
+{
+    my $c  = FakeController->new;
+    my $bf = BarefootJS->new($c, { backend => WeakBackend->new(c => $c) });
+
+    # Mimic Mojolicious::Plugin::BarefootJS: the `bf` helper stashes the
+    # instance on the controller (the edge that closes the cycle).
+    $c->stash->{'bf.instance'} = $bf;
+    $bf->_scope_id('root');
+
+    # The manifest path registers child-renderer closures onto $bf. These must
+    # not capture the controller strongly.
+    $bf->register_components_from_manifest({
+        'ui/button/index' => {
+            markedTemplate => 'templates/ui/button/index.html.ep',
+            ssrDefaults    => {},
+        },
+    });
+
+    weaken($probe_bf = $bf);
+    weaken($probe_c  = $c);
+}    # request-scope lexicals ($c, $bf) drop here
+
+is $probe_bf, undef,
+    'parent bf is reclaimed at request end (no controller reference cycle)';
+is $probe_c, undef,
+    'controller is reclaimed at request end (no controller reference cycle)';
+
+done_testing;

package/t/dev_reload.t

@@ -0,0 +1,58 @@
+use Test2::V0;
+use File::Temp qw(tempdir);
+
+use BarefootJS::DevReload;
+
+# --- browser snippet ---------------------------------------------------------
+my $snip = BarefootJS::DevReload->snippet('/_bf/reload');
+like $snip, qr/new EventSource\("\/_bf\/reload"\)/, 'snippet wires EventSource to the endpoint';
+like $snip, qr/window\.__bfDevReload/, 'snippet is idempotent across duplicate mounts';
+like $snip, qr/location\.reload\(\)/, 'snippet reloads on the `reload` event';
+
+# --- build-id sentinel -------------------------------------------------------
+my $dir  = tempdir(CLEANUP => 1);
+my $path = BarefootJS::DevReload->build_id_path($dir);
+like $path, qr/\.dev.+build-id$/, 'build_id_path points at <dist>/.dev/build-id';
+is(BarefootJS::DevReload->read_build_id($path), '', 'missing sentinel reads as empty');
+
+BarefootJS::DevReload->ensure_dev_dir($dir);
+open my $fh, '>', $path or die $!;
+print $fh "abc123\n";
+close $fh;
+is(BarefootJS::DevReload->read_build_id($path), 'abc123', 'sentinel is read and trimmed');
+
+# --- PSGI streaming app ------------------------------------------------------
+# Drive the streaming coderef with a fake responder/writer; break the otherwise
+# infinite poll loop by throwing from write() after the initial events.
+{
+    package FakeWriter;
+    sub new   { bless { n => 0, lines => [] }, shift }
+    sub write { my ($s, $d) = @_; push @{ $s->{lines} }, $d; die "stop\n" if ++$s->{n} >= 2 }
+    sub close { }
+}
+
+my $app = BarefootJS::DevReload->to_app(dist_dir => $dir);
+
+is $app->({ 'psgi.streaming' => 0 })->[0], 500, 'requires a psgi.streaming server';
+
+my $stream = $app->({ 'psgi.streaming' => 1, HTTP_LAST_EVENT_ID => '' });
+is ref $stream, 'CODE', 'streaming response is a delayed coderef';
+
+my $writer = FakeWriter->new;
+my ($status, $headers);
+$stream->(sub { ($status, $headers) = @{ $_[0] }[0, 1]; return $writer });
+
+is $status, 200, 'streams 200';
+my %h = @$headers;
+is $h{'Content-Type'}, 'text/event-stream', 'SSE content-type';
+my $out = join '', @{ $writer->{lines} };
+like $out, qr/retry: 1000/,  'sets the SSE retry hint';
+like $out, qr/event: hello/, 'emits hello with the current build-id at connect';
+
+# A stale Last-Event-ID means a rebuild was missed → reload immediately.
+my $stream2 = $app->({ 'psgi.streaming' => 1, HTTP_LAST_EVENT_ID => 'STALE' });
+my $w2 = FakeWriter->new;
+$stream2->(sub { return $w2 });
+like join('', @{ $w2->{lines} }), qr/event: reload/, 'stale Last-Event-ID triggers reload';
+
+done_testing;

package/t/spread_attrs.t

@@ -0,0 +1,134 @@
+use Test2::V0;
+
+# spread_attrs — JSX intrinsic-element spread runtime helper (#1407
+# follow-up). Mirrors the JS `spreadAttrs` in
+# packages/client/src/runtime/spread-attrs.ts and the Go adapter's
+# `bf.SpreadAttrs` so SSR output stays byte-equal across the three
+# adapters. Cross-adapter parity regressions surface here first.
+
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+
+use BarefootJS;
+
+# Boolean sentinels via core JSON::PP (not Mojo::JSON) so this engine-agnostic
+# test runs with zero Mojo present. `spread_attrs` recognises the
+# JSON::PP::Boolean ref the same way it recognises Mojo::JSON's sentinel.
+use JSON::PP ();
+sub true  { JSON::PP::true }
+sub false { JSON::PP::false }
+
+# Minimal pure-Perl backend: `spread_attrs` only reaches the backend for
+# `mark_raw` (raw-string marking), which is the identity here.
+{
+    package PureBackend;
+    sub new      { bless {}, shift }
+    sub mark_raw { $_[1] }
+}
+
+# The runtime spread helper is a pure function of $self + bag; a bare blessed
+# hash with an injected pure backend is sufficient.
+my $bf = bless { c => undef, config => {}, backend => PureBackend->new }, 'BarefootJS';
+
+# spread_attrs returns Mojo::ByteStream so callers can `<%==` it
+# without re-escaping. Stringify here for assertion convenience.
+sub run { return "" . $bf->spread_attrs(@_) }
+
+subtest 'basic shapes' => sub {
+    is run(undef),       '', 'undef bag → empty';
+    is run({}),          '', 'empty bag → empty';
+    is run('not a hash'), '', 'non-hash scalar → empty';
+    is run({id => 'a'}), 'id="a"', 'single string';
+};
+
+subtest 'alphabetic key order (deterministic SSR)' => sub {
+    is run({id => 'a', class => 'on'}),
+       'class="on" id="a"',
+       'sorted by key name';
+};
+
+subtest 'key remapping' => sub {
+    is run({className => 'foo'}), 'class="foo"',  'className → class';
+    is run({htmlFor   => 'x'}),   'for="x"',      'htmlFor → for';
+    is run({dataPriority => 'high'}),
+       'data-priority="high"',
+       'camelCase → kebab-case';
+    # SVG XML attrs are case-sensitive — preserve verbatim.
+    is run({viewBox => '0 0 10 10'}),
+       'viewBox="0 0 10 10"',
+       'SVG viewBox preserved';
+    is run({clipPathUnits => 'userSpaceOnUse'}),
+       'clipPathUnits="userSpaceOnUse"',
+       'SVG clipPathUnits preserved';
+    # JS-reference parity (#1411): a leading uppercase letter
+    # emits a leading dash. The resulting HTML attribute name is
+    # invalid in both the JS and Perl/Go runtimes, but the byte-
+    # equal output across the three adapters matters more.
+    is run({XData => 'x'}),
+       '-x-data="x"',
+       'leading-uppercase emits leading dash (JS-reference parity)';
+};
+
+subtest 'event handlers — JS predicate parity' => sub {
+    # JS: `key.startsWith('on') && key.length > 2 && key[2] === key[2].toUpperCase()`.
+    is run({onClick => 'fn', id => 'a'}), 'id="a"',
+       'onClick skipped (uppercase third char)';
+    is run({on_custom => 'fn', id => 'a'}), 'id="a"',
+       'on_custom skipped (underscore third char)';
+    is run({on0 => 'fn', id => 'a'}), 'id="a"',
+       'on0 skipped (digit third char)';
+    is run({oncology => 'x'}), 'oncology="x"',
+       'on + lowercase letter NOT treated as event';
+};
+
+subtest 'children skipped, ref passed through (JS-reference parity)' => sub {
+    is run({children => 'x', id => 'a'}), 'id="a"',
+       'children skipped';
+    # JS `spreadAttrs` does NOT filter `ref` (`applyRestAttrs` does
+    # — that's a separate divergence). Match the JS reference so
+    # SSR stays byte-equal with Hono / Go.
+    is run({ref => 'x', id => 'a'}), 'id="a" ref="x"',
+       'ref passes through';
+};
+
+subtest 'boolean values via Mojo::JSON sentinels' => sub {
+    # The contract: callers MUST use Mojo::JSON::true/false for
+    # booleans. Plain scalar 0/1 render as numeric values.
+    is run({hidden => true, id => 'a'}),
+       'hidden id="a"',
+       'true → bare attribute';
+    is run({hidden => false, id => 'a'}),
+       'id="a"',
+       'false → omitted';
+    # Plain numeric 0 renders as a value (matches HTML
+    # `tabindex="0"` use case).
+    is run({tabindex => 0}),
+       'tabindex="0"',
+       'plain scalar 0 → numeric attribute value';
+};
+
+subtest 'nullish skip' => sub {
+    is run({a => undef, b => 'x'}),
+       'b="x"',
+       'undef value omitted';
+};
+
+subtest 'HTML escape' => sub {
+    is run({title => '<b>"x"</b>'}),
+       'title="&lt;b&gt;&#34;x&#34;&lt;/b&gt;"',
+       'angle brackets and quotes escaped';
+    is run({alt => "tom & jerry"}),
+       'alt="tom &amp; jerry"',
+       'ampersand escaped';
+};
+
+subtest 'style object lowering' => sub {
+    is run({style => {backgroundColor => 'red', color => 'white'}}),
+       'style="background-color:red;color:white"',
+       'style hashref → CSS string';
+    is run({style => 'color:red'}),
+       'style="color:red"',
+       'style scalar passthrough';
+};
+
+done_testing;