@barefootjs/perl 0.16.0 → 0.17.1

package/t/helper_vectors.t

@@ -9,6 +9,12 @@ use Scalar::Util qw(looks_like_number);
 use lib "$FindBin::Bin/../lib";
 use BarefootJS;
 
+# vectors.json is UTF-8 (string args like "café"; `≡` in some notes). Decode it
+# as UTF-8 (below) and route TAP through a UTF-8 layer so wide test names don't
+# trigger "Wide character in print".
+binmode Test::More->builder->$_, ':encoding(UTF-8)'
+    for qw(output failure_output todo_output);
+
 # Pure-Perl backend (core JSON::PP only) so this test runs with zero
 # Mojo present — same pattern as t/template_primitives.t.
 {
@@ -37,7 +43,10 @@ plan skip_all => 'golden vectors not available outside the monorepo checkout'
 my $doc = do {
     open my $fh, '<:raw', $vectors_path or die "open $vectors_path: $!";
     local $/;
-    JSON::PP->new->decode(<$fh>);
+    # ->utf8 decodes the file's UTF-8 bytes into Perl characters, so a value
+    # like "café" round-trips to a single é (U+00E9) instead of its two raw
+    # bytes — otherwise _form_escape would re-encode them and double-escape.
+    JSON::PP->new->utf8->decode(scalar <$fh>);
 };
 
 # One binding per canonical helper id in the spec catalogue, bound to
@@ -99,6 +108,11 @@ my %bindings = (
     # and '' for present-but-empty, so the Perl backend matches JS exactly.
     search_params_get => sub { BarefootJS->search_params($_[0])->get($_[1]) },
 
+    # queryHref SSR builder (#2042): (base, include, key, value, …) → URL. The
+    # include flags arrive as JSON booleans (JSON::PP::Boolean, truthy/falsy
+    # under `next unless`); the helper form-encodes to match URLSearchParams.
+    query => sub { $bf->query(@_) },
+
     # Higher-order entries arrive in the canonical projection form
     # (spec: items + field [+ value]); the closures below rebuild the
     # predicate the adapters compile (`i => i.field === value`,
@@ -210,10 +224,6 @@ my %DIVERGENCES = (
         expect => '0.3',
         reason => 'Perl stringifies doubles via %.15g',
     },
-    'includes/cross-type probe is strict-equality false' => {
-        expect => 1,
-        reason => 'bf->includes scans with eq (string equality), so 2 eq "2" matches',
-    },
     'filter_truthy/the string "0" is truthy' => {
         expect => ['x'],
         reason => 'Perl truthiness treats the string "0" as false',

package/t/query.t

@@ -0,0 +1,49 @@
+use Test2::V0;
+use utf8;
+
+# BarefootJS->query — the `queryHref(base, { … })` URL-query builder helper
+# (#2042).
+#
+# The full CROSS-BACKEND behaviour (control flow + form-encoding parity with the
+# browser's URLSearchParams) is defined ONCE in the shared golden helper vectors
+# — packages/adapter-tests/helper-vectors/vectors.json, fn "query" — and run
+# here by t/helper_vectors.t and by the Go runtime's TestHelperVectors, so the
+# Perl and Go expectations can't drift apart.
+#
+# This file keeps a few representative cases for always-on coverage (the golden
+# file is monorepo-only, absent from the CPAN dist) plus the Perl-runtime-
+# SPECIFIC defensive behaviour the golden vectors can't express: an `undef`
+# value. JSON has no `undefined`, and a JSON `null` stringifies to "null" under
+# JS `String()`, so it can't be a shared vector; Perl coerces `undef` to '' and
+# omits the empty pair.
+
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+
+use BarefootJS;
+
+# `query` is a pure helper (no backend / controller), so a bare blessed stub is
+# enough — mirroring t/helper_vectors.t. Triples are (include, key, value).
+my $bf = bless {}, 'BarefootJS';
+
+# Representative control flow: a repeated key overwrites at its first position
+# (URLSearchParams.set), surrounding order preserved.
+is $bf->query('/blog', 1, 'sort', 'title', 1, 'tag', 'go', 1, 'sort', 'date'),
+    '/blog?sort=date&tag=go', 'order preserved, repeated key overwrites at first position';
+
+# Representative form-encoding: space → '+', '~' → %7E, '*' kept (URLSearchParams,
+# not Go's url.QueryEscape).
+is $bf->query('/s', 1, 't', 'a~b *c'), '/s?t=a%7Eb+*c', 'form-encode: ~ → %7E, * kept, space → +';
+
+# Representative array value: an array ref appends one pair per non-empty member
+# (#2048), skipping empties.
+is $bf->query('/list', 1, 'tag', ['a', '', 'b']), '/list?tag=a&tag=b',
+    'array value appends a pair per non-empty member';
+
+# Perl-specific: an `undef` value is coerced to '' and then omitted, without
+# disturbing the surrounding pairs.
+is $bf->query('/list', 1, 'tag', undef), '/list', 'undef value coerced to empty → omitted';
+is $bf->query('/list', 1, 'tag', undef, 1, 'keep', 'me'), '/list?keep=me',
+    'undef value dropped, surrounding pairs intact';
+
+done_testing;

package/t/template_primitives.t

@@ -81,11 +81,16 @@ subtest 'floor / ceil / round — Math.* mirrors; propagate NaN' => sub {
 # `Array.prototype.includes(x)` + `String.prototype.includes(sub)` lower
 # to the same `$bf->includes($recv, $elem)` shape — see #1448 Tier A.
 # The Perl helper dispatches on `ref()`: ARRAY ref scans elements with
-# `eq`; scalar falls back to `index(..., ...) != -1`. Anything else
-# (HASH ref, code ref) returns false to match the JS semantic that
-# `.includes` is only defined on Array / TypedArray / String.
+# `BarefootJS::Evaluator::_same_value_zero` (SameValueZero — no cross-type
+# coercion, NaN matches NaN), matching the evaluator's serialized-callback
+# `.includes` path so both positions agree; scalar falls back to
+# `index(..., ...) != -1`. Anything else (HASH ref, code ref) returns
+# false to match the JS semantic that `.includes` is only defined on
+# Array / TypedArray / String.
 subtest 'includes — array + string + non-array/string dispatch' => sub {
-    # Array receiver: element-wise `eq` (handles defined/undef parity).
+    # Array receiver: SameValueZero element search (handles defined/undef
+    # parity, and no numeric/string coercion — see the cross-type cases
+    # below).
     ok  $bf->includes(['a', 'b', 'c'], 'b'), 'array contains element → 1';
     ok !$bf->includes(['a', 'b', 'c'], 'z'), 'array does not contain → 0';
     ok  $bf->includes([1, 2, 3], 2),         'numeric element';
@@ -93,6 +98,12 @@ subtest 'includes — array + string + non-array/string dispatch' => sub {
     ok  $bf->includes([undef, 'a'], undef),  'undef element matches undef needle';
     ok !$bf->includes(['a', 'b'], undef),    'undef needle, no undef element → 0';
 
+    # SameValueZero never coerces across types — pins the divergence from
+    # the old stringy `eq` scan (where `[2].includes("2")` was true).
+    ok !$bf->includes([2], '2'),   '[2].includes("2") → 0 (no numeric→string coercion)';
+    ok  $bf->includes([2], 2),     '[2].includes(2) → 1';
+    ok  $bf->includes(['2'], '2'), '["2"].includes("2") → 1 (string vs string still matches)';
+
     # String receiver: substring search.
     ok  $bf->includes('hello world', 'world'), 'substring present → 1';
     ok !$bf->includes('hello world', 'earth'), 'substring absent → 0';