WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
10/21/2025 12:07:16 PM (4 months ago)
Author:
luisherranz
Message:

Interactivity API: Support unique IDs in server-side directives processing.

Server-side logic to support unique IDs in the Interactivity API directives to match what the client is doing (​https://github.com/WordPress/gutenberg/pull/72161).

Props santosguillamot, darerodz, luisherranz.
Fixes #64106.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tests/phpunit/tests/interactivity-api/wpInteractivityAPI.php

    r61019 r61020  
    379379                // Multiple evaluations should be serialized only once.
    380380                $this->set_internal_namespace_stack( 'pluginWithInvokedDerivedState' );
    381                 $this->evaluate( 'state.derivedProp' );
    382                 $this->evaluate( 'state.derivedProp' );
    383                 $this->evaluate( 'state.nested.derivedProp' );
    384                 $this->evaluate( 'state.nested.derivedProp' );
     381                $this->evaluate(
     382                    array(
     383                        'namespace' => 'pluginWithInvokedDerivedState',
     384                        'value'     => 'state.derivedProp',
     385                    )
     386                );
     387                $this->evaluate(
     388                    array(
     389                        'namespace' => 'pluginWithInvokedDerivedState',
     390                        'value'     => 'state.derivedProp',
     391                    )
     392                );
     393                $this->evaluate(
     394                    array(
     395                        'namespace' => 'pluginWithInvokedDerivedState',
     396                        'value'     => 'state.nested.derivedProp',
     397                    )
     398                );
     399                $this->evaluate(
     400                    array(
     401                        'namespace' => 'pluginWithInvokedDerivedState',
     402                        'value'     => 'state.nested.derivedProp',
     403                    )
     404                );
    385405
    386406                // Only the path part that points to a derived state prop should be serialized.
    387407                $this->set_internal_namespace_stack( 'pluginWithInvokedDerivedStateReturningArray' );
    388                 $this->evaluate( 'state.nested.derivedProp.prop' );
     408                $this->evaluate(
     409                    array(
     410                        'namespace' => 'pluginWithInvokedDerivedStateReturningArray',
     411                        'value'     => 'state.nested.derivedProp',
     412                    )
     413                );
    389414            }
    390415        );
    … …  
    820845     * name.
    821846     *
    822      * @ticket 60356
    823      *
    824      * @covers ::extract_prefix_and_suffix
    825      */
    826     public function test_extract_prefix_and_suffix() {
    827         $extract_prefix_and_suffix = new ReflectionMethod( $this->interactivity, 'extract_prefix_and_suffix' );
     847     * @ticket 64106
     848     *
     849     * @covers ::parse_directive_name
     850     */
     851    public function test_parse_directive_name() {
     852        $parse_directive_name = new ReflectionMethod( $this->interactivity, 'parse_directive_name' );
    828853        if ( PHP_VERSION_ID < 80100 ) {
    829             $extract_prefix_and_suffix->setAccessible( true );
     854            $parse_directive_name->setAccessible( true );
    830855        }
    831856
    832         $result = $extract_prefix_and_suffix->invoke( $this->interactivity, 'data-wp-interactive' );
    833         $this->assertSame( array( 'data-wp-interactive' ), $result );
    834 
    835         $result = $extract_prefix_and_suffix->invoke( $this->interactivity, 'data-wp-bind--src' );
    836         $this->assertSame( array( 'data-wp-bind', 'src' ), $result );
    837 
    838         $result = $extract_prefix_and_suffix->invoke( $this->interactivity, 'data-wp-foo--and--bar' );
    839         $this->assertSame( array( 'data-wp-foo', 'and--bar' ), $result );
     857        // Should parse directives without suffix or unique ID.
     858        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test' );
     859        $this->assertSame( 'test', $result['prefix'] );
     860        $this->assertNull( $result['suffix'] );
     861        $this->assertNull( $result['unique_id'] );
     862
     863        // Should parse directives with suffix only.
     864        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test--one' );
     865        $this->assertSame( 'test', $result['prefix'] );
     866        $this->assertSame( 'one', $result['suffix'] );
     867        $this->assertNull( $result['unique_id'] );
     868
     869        // Should parse directives with unique ID only.
     870        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test---unique-id' );
     871        $this->assertSame( 'test', $result['prefix'] );
     872        $this->assertNull( $result['suffix'] );
     873        $this->assertSame( 'unique-id', $result['unique_id'] );
     874
     875        // Should parse directives with suffix and unique ID.
     876        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test--suffix---unique-id' );
     877        $this->assertSame( 'test', $result['prefix'] );
     878        $this->assertSame( 'suffix', $result['suffix'] );
     879        $this->assertSame( 'unique-id', $result['unique_id'] );
     880
     881        // Should handle empty suffix (just two dashes).
     882        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test--' );
     883        $this->assertSame( 'test', $result['prefix'] );
     884        $this->assertNull( $result['suffix'] );
     885        $this->assertNull( $result['unique_id'] );
     886
     887        // Should handle empty unique ID (just three dashes).
     888        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test---' );
     889        $this->assertSame( 'test', $result['prefix'] );
     890        $this->assertNull( $result['suffix'] );
     891        $this->assertNull( $result['unique_id'] );
     892
     893        // Should handle only dashes (4 or more dashes).
     894        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test----' );
     895        $this->assertSame( 'test', $result['prefix'] );
     896        $this->assertSame( '--', $result['suffix'] );
     897        $this->assertNull( $result['unique_id'] );
     898
     899        // Should handle suffix starting with 4 or more dashes but containing valid characters.
     900        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test------custom-suffix' );
     901        $this->assertSame( 'test', $result['prefix'] );
     902        $this->assertSame( '----custom-suffix', $result['suffix'] );
     903        $this->assertNull( $result['unique_id'] );
     904
     905        // Should handle complex pattern with multiple dashes.
     906        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test--complex--suffix---complex--unique---id' );
     907        $this->assertSame( 'test', $result['prefix'] );
     908        $this->assertSame( 'complex--suffix', $result['suffix'] );
     909        $this->assertSame( 'complex--unique---id', $result['unique_id'] );
     910
     911        // Should handle suffix with dashes followed by unique ID.
     912        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test----suffix---unique-id' );
     913        $this->assertSame( 'test', $result['prefix'] );
     914        $this->assertSame( '--suffix', $result['suffix'] );
     915        $this->assertSame( 'unique-id', $result['unique_id'] );
     916
     917        // Should handle unique IDs followed by suffix in wrong order.
     918        $result = $parse_directive_name->invoke( $this->interactivity, 'data-wp-test---unique-id--wrong-suffix' );
     919        $this->assertSame( 'test', $result['prefix'] );
     920        $this->assertNull( $result['suffix'] );
     921        $this->assertSame( 'unique-id--wrong-suffix', $result['unique_id'] );
     922    }
     923
     924    /**
     925     * Tests the ability to get the valid entries of a specific directive in an HTML element.
     926     *
     927     * @ticket 64106
     928     *
     929     * @covers ::get_directive_entries
     930     */
     931    public function test_get_directive_entries() {
     932        $get_directive_entries = new ReflectionMethod( $this->interactivity, 'get_directive_entries' );
     933        if ( PHP_VERSION_ID < 80100 ) {
     934            $get_directive_entries->setAccessible( true );
     935        }
     936        $this->set_internal_namespace_stack( 'myPlugin' );
     937
     938        // Should process simple directives.
     939        $html = '<div data-wp-test="test value"></div>';
     940        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     941        $p->next_tag();
     942        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     943        $this->assertCount( 1, $results );
     944        $result = $results[0];
     945        $this->assertSame( 'myPlugin', $result['namespace'] );
     946        $this->assertSame( 'test value', $result['value'] );
     947        $this->assertNull( $result['suffix'] );
     948        $this->assertNull( $result['unique_id'] );
     949
     950        // Should process directives without value.
     951        $html = '<div data-wp-test></div>';
     952        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     953        $p->next_tag();
     954        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     955        $this->assertNull( $results[0]['value'] );
     956
     957        // Should parse JSON values in directives.
     958        $html = '<div data-wp-test=\'{"key": "value"}\'></div>';
     959        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     960        $p->next_tag();
     961        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     962        $this->assertSame( array( 'key' => 'value' ), $results[0]['value'] );
     963
     964        // Should handle malformed JSON and keep as string.
     965        $html = '<div data-wp-test="{malformed: json}"></div>';
     966        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     967        $p->next_tag();
     968        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     969        $this->assertSame( '{malformed: json}', $results[0]['value'] );
     970
     971        // Should process directives with a custom namespace.
     972        $html = '<div data-wp-test="my-namespace::test value"></div>';
     973        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     974        $p->next_tag();
     975        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     976        $this->assertSame( 'my-namespace', $results[0]['namespace'] );
     977        $this->assertSame( 'test value', $results[0]['value'] );
     978
     979        // Should parse JSON values with a custom namespace.
     980        $html = '<div data-wp-test=\'my-namespace::{"key": "value"}\'></div>';
     981        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     982        $p->next_tag();
     983        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     984        $this->assertSame( 'my-namespace', $results[0]['namespace'] );
     985        $this->assertSame( array( 'key' => 'value' ), $results[0]['value'] );
     986
     987        // Should handle multiple directives with different unique IDs.
     988        $html = '
     989            <div
     990                data-wp-test---plugin-a="value-a"
     991                data-wp-test---plugin-b="value-b"
     992                data-wp-test---plugin-c="value-c"
     993            ></div>';
     994        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     995        $p->next_tag();
     996        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     997        $this->assertCount( 3, $results );
     998        $this->assertSame(
     999            array(
     1000                'namespace' => 'myPlugin',
     1001                'value'     => 'value-a',
     1002                'suffix'    => null,
     1003                'unique_id' => 'plugin-a',
     1004            ),
     1005            $results[0]
     1006        );
     1007        $this->assertSame(
     1008            array(
     1009                'namespace' => 'myPlugin',
     1010                'value'     => 'value-b',
     1011                'suffix'    => null,
     1012                'unique_id' => 'plugin-b',
     1013            ),
     1014            $results[1]
     1015        );
     1016        $this->assertSame(
     1017            array(
     1018                'namespace' => 'myPlugin',
     1019                'value'     => 'value-c',
     1020                'suffix'    => null,
     1021                'unique_id' => 'plugin-c',
     1022            ),
     1023            $results[2]
     1024        );
     1025
     1026        // Should handle mix of different suffixes and unique IDs.
     1027        $html = '
     1028            <div
     1029                data-wp-test--suffix-a---id-1="value1"
     1030                data-wp-test--suffix-a---id-2="value2"
     1031                data-wp-test--suffix-b---id-1="value3"
     1032                data-wp-test--suffix-c---id-1="value4"
     1033            ></div>';
     1034        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     1035        $p->next_tag();
     1036        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     1037        $this->assertCount( 4, $results );
     1038        $this->assertSame(
     1039            array(
     1040                'namespace' => 'myPlugin',
     1041                'value'     => 'value1',
     1042                'suffix'    => 'suffix-a',
     1043                'unique_id' => 'id-1',
     1044            ),
     1045            $results[0]
     1046        );
     1047        $this->assertSame(
     1048            array(
     1049                'namespace' => 'myPlugin',
     1050                'value'     => 'value2',
     1051                'suffix'    => 'suffix-a',
     1052                'unique_id' => 'id-2',
     1053            ),
     1054            $results[1]
     1055        );
     1056        $this->assertSame(
     1057            array(
     1058                'namespace' => 'myPlugin',
     1059                'value'     => 'value3',
     1060                'suffix'    => 'suffix-b',
     1061                'unique_id' => 'id-1',
     1062            ),
     1063            $results[2]
     1064        );
     1065        $this->assertSame(
     1066            array(
     1067                'namespace' => 'myPlugin',
     1068                'value'     => 'value4',
     1069                'suffix'    => 'suffix-c',
     1070                'unique_id' => 'id-1',
     1071            ),
     1072            $results[3]
     1073        );
     1074
     1075        // Should handle unique ID with namespace.
     1076        $html = '<div data-wp-test---unique-id="my-namespace::test value"></div>';
     1077        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     1078        $p->next_tag();
     1079        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     1080        $this->assertSame( 'my-namespace', $results[0]['namespace'] );
     1081        $this->assertSame( 'test value', $results[0]['value'] );
     1082        $this->assertSame( 'unique-id', $results[0]['unique_id'] );
     1083
     1084        // Should handle multiple directives with different namespaces and unique IDs.
     1085        $html = '
     1086            <div
     1087                data-wp-test---id-a="namespace-a::value1"
     1088                data-wp-test---id-b="namespace-b::value2"
     1089            ></div>';
     1090        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     1091        $p->next_tag();
     1092        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     1093        $this->assertCount( 2, $results );
     1094        $this->assertSame(
     1095            array(
     1096                'namespace' => 'namespace-a',
     1097                'value'     => 'value1',
     1098                'suffix'    => null,
     1099                'unique_id' => 'id-a',
     1100            ),
     1101            $results[0]
     1102        );
     1103        $this->assertSame(
     1104            array(
     1105                'namespace' => 'namespace-b',
     1106                'value'     => 'value2',
     1107                'suffix'    => null,
     1108                'unique_id' => 'id-b',
     1109            ),
     1110            $results[1]
     1111        );
     1112        // Should sort directives by suffix and uniqueId for stable ordering.
     1113        $html = '
     1114            <div
     1115                data-wp-test---z
     1116                data-wp-test---a
     1117                data-wp-test--b---z
     1118                data-wp-test--b---a
     1119                data-wp-test--a
     1120                data-wp-test
     1121            ></div>';
     1122        $p    = new WP_Interactivity_API_Directives_Processor( $html );
     1123        $p->next_tag();
     1124        $results = $get_directive_entries->invoke( $this->interactivity, $p, 'test' );
     1125        $this->assertCount( 6, $results );
     1126        $this->assertEquals(
     1127            array(
     1128                array( null, null ),
     1129                array( null, 'a' ),
     1130                array( null, 'z' ),
     1131                array( 'a', null ),
     1132                array( 'b', 'a' ),
     1133                array( 'b', 'z' ),
     1134            ),
     1135            array_map(
     1136                function ( $d ) {
     1137                    return array( $d['suffix'], $d['unique_id'] );
     1138                },
     1139                $results
     1140            )
     1141        );
    8401142    }
    8411143
    … …  
    9251227     * @dataProvider data_html_with_unbalanced_tags
    9261228     *
    927      * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    928      *
    9291229     * @param string $html HTML containing unbalanced tags and also a directive.
    9301230     */
    … …  
    10881388     * Invokes the private `evaluate` method of WP_Interactivity_API class.
    10891389     *
    1090      * @param string $directive_value   The directive attribute value to evaluate.
     1390     * @param string $entry The entry array containing namespace, value, suffix, and unique ID.
    10911391     * @return mixed The result of the evaluate method.
    10921392     */
    1093     private function evaluate( $directive_value ) {
     1393    private function evaluate( $entry ) {
    10941394        /*
    10951395         * The global WP_Interactivity_API instance is momentarily replaced to
    … …  
    11061406        }
    11071407
    1108         $result = $evaluate->invokeArgs( $this->interactivity, array( $directive_value ) );
     1408        $result = $evaluate->invokeArgs( $this->interactivity, array( $entry ) );
    11091409
    11101410        // Restore the original WP_Interactivity_API instance.
    … …  
    11521452            )
    11531453        );
    1154         $this->set_internal_namespace_stack( 'myPlugin' );
    1155 
    1156         $result = $this->evaluate( 'state.key' );
     1454        $default_ns = 'myPlugin';
     1455        $this->set_internal_namespace_stack( $default_ns );
     1456
     1457        $result = $this->evaluate(
     1458            array(
     1459                'namespace' => $default_ns,
     1460                'value'     => 'state.key',
     1461            )
     1462        );
    11571463        $this->assertSame( 'myPlugin-state', $result );
    11581464
    1159         $result = $this->evaluate( 'context.key' );
     1465        $result = $this->evaluate(
     1466            array(
     1467                'namespace' => $default_ns,
     1468                'value'     => 'context.key',
     1469            )
     1470        );
    11601471        $this->assertSame( 'myPlugin-context', $result );
    11611472
    1162         $result = $this->evaluate( 'otherPlugin::state.key' );
     1473        $result = $this->evaluate(
     1474            array(
     1475                'namespace' => 'otherPlugin',
     1476                'value'     => 'state.key',
     1477            )
     1478        );
    11631479        $this->assertSame( 'otherPlugin-state', $result );
    11641480
    1165         $result = $this->evaluate( 'otherPlugin::context.key' );
     1481        $result = $this->evaluate(
     1482            array(
     1483                'namespace' => 'otherPlugin',
     1484                'value'     => 'context.key',
     1485            )
     1486        );
    11661487        $this->assertSame( 'otherPlugin-context', $result );
    11671488
    1168         $result = $this->evaluate( 'state.obj.prop' );
     1489        $result = $this->evaluate(
     1490            array(
     1491                'namespace' => $default_ns,
     1492                'value'     => 'state.obj.prop',
     1493            )
     1494        );
    11691495        $this->assertSame( 'object property', $result );
    11701496
    1171         $result = $this->evaluate( 'state.arrAccess.1' );
     1497        $result = $this->evaluate(
     1498            array(
     1499                'namespace' => $default_ns,
     1500                'value'     => 'state.arrAccess.1',
     1501            )
     1502        );
    11721503        $this->assertSame( '1', $result );
    11731504    }
    … …  
    11901521            )
    11911522        );
    1192         $this->set_internal_namespace_stack( 'myPlugin' );
    1193 
    1194         $result = $this->evaluate( '!state.key' );
     1523        $default_ns = 'myPlugin';
     1524        $this->set_internal_namespace_stack( $default_ns );
     1525
     1526        $result = $this->evaluate(
     1527            array(
     1528                'namespace' => $default_ns,
     1529                'value'     => '!state.key',
     1530            )
     1531        );
    11951532        $this->assertFalse( $result );
    11961533
    1197         $result = $this->evaluate( '!context.key' );
     1534        $result = $this->evaluate(
     1535            array(
     1536                'namespace' => $default_ns,
     1537                'value'     => '!context.key',
     1538            )
     1539        );
    11981540        $this->assertFalse( $result );
    11991541
    1200         $result = $this->evaluate( 'otherPlugin::!state.key' );
     1542        $result = $this->evaluate(
     1543            array(
     1544                'namespace' => 'otherPlugin',
     1545                'value'     => '!state.key',
     1546            )
     1547        );
    12011548        $this->assertFalse( $result );
    12021549
    1203         $result = $this->evaluate( 'otherPlugin::!context.key' );
     1550        $result = $this->evaluate(
     1551            array(
     1552                'namespace' => 'otherPlugin',
     1553                'value'     => '!context.key',
     1554            )
     1555        );
    12041556        $this->assertFalse( $result );
    12051557    }
    … …  
    12221574            )
    12231575        );
    1224         $this->set_internal_namespace_stack( 'myPlugin' );
    1225 
    1226         $result = $this->evaluate( '!state.missing' );
     1576        $default_ns = 'myPlugin';
     1577        $this->set_internal_namespace_stack( $default_ns );
     1578
     1579        $result = $this->evaluate(
     1580            array(
     1581                'namespace' => $default_ns,
     1582                'value'     => '!state.missing',
     1583            )
     1584        );
    12271585        $this->assertTrue( $result );
    12281586
    1229         $result = $this->evaluate( '!context.missing' );
     1587        $result = $this->evaluate(
     1588            array(
     1589                'namespace' => $default_ns,
     1590                'value'     => '!context.missing',
     1591            )
     1592        );
    12301593        $this->assertTrue( $result );
    12311594
    1232         $result = $this->evaluate( 'otherPlugin::!state.deeply.nested.missing' );
     1595        $result = $this->evaluate(
     1596            array(
     1597                'namespace' => 'otherPlugin',
     1598                'value'     => '!state.deeply.nested.missing',
     1599            )
     1600        );
    12331601        $this->assertTrue( $result );
    12341602
    1235         $result = $this->evaluate( 'otherPlugin::!context.deeply.nested.missing' );
     1603        $result = $this->evaluate(
     1604            array(
     1605                'namespace' => 'otherPlugin',
     1606                'value'     => '!context.deeply.nested.missing',
     1607            )
     1608        );
    12361609        $this->assertTrue( $result );
    12371610    }
    … …  
    12531626            )
    12541627        );
    1255         $this->set_internal_namespace_stack( 'myPlugin' );
    1256 
    1257         $result = $this->evaluate( 'state.nonExistentKey' );
     1628        $default_ns = 'myPlugin';
     1629        $this->set_internal_namespace_stack( $default_ns );
     1630
     1631        $result = $this->evaluate(
     1632            array(
     1633                'namespace' => $default_ns,
     1634                'value'     => 'state.nonExistentKey',
     1635            )
     1636        );
    12581637        $this->assertNull( $result );
    12591638
    1260         $result = $this->evaluate( 'context.nonExistentKey' );
     1639        $result = $this->evaluate(
     1640            array(
     1641                'namespace' => $default_ns,
     1642                'value'     => 'context.nonExistentKey',
     1643            )
     1644        );
    12611645        $this->assertNull( $result );
    12621646
    1263         $result = $this->evaluate( 'otherPlugin::state.nonExistentKey' );
     1647        $result = $this->evaluate(
     1648            array(
     1649                'namespace' => 'otherPlugin',
     1650                'value'     => 'state.nonExistentKey',
     1651            )
     1652        );
    12641653        $this->assertNull( $result );
    12651654
    1266         $result = $this->evaluate( 'otherPlugin::context.nonExistentKey' );
     1655        $result = $this->evaluate(
     1656            array(
     1657                'namespace' => 'otherPlugin',
     1658                'value'     => 'context.nonExistentKey',
     1659            )
     1660        );
    12671661        $this->assertNull( $result );
    12681662
    1269         $result = $this->evaluate( ' state.key' ); // Extra space.
     1663        $result = $this->evaluate(
     1664            array(
     1665                'namespace' => $default_ns,
     1666                'value'     => ' state.key',  // Extra space.
     1667            )
     1668        );
    12701669        $this->assertNull( $result );
    12711670
    1272         $result = $this->evaluate( 'otherPlugin:: state.key' ); // Extra space.
     1671        $result = $this->evaluate(
     1672            array(
     1673                'namespace' => 'otherPlugin',
     1674                'value'     => ' state.key',  // Extra space.
     1675            )
     1676        );
    12731677        $this->assertNull( $result );
    12741678    }
    … …  
    13041708            )
    13051709        );
    1306         $this->set_internal_namespace_stack( 'myPlugin' );
    1307 
    1308         $result = $this->evaluate( 'state.nested.key' );
     1710        $default_ns = 'myPlugin';
     1711        $this->set_internal_namespace_stack( $default_ns );
     1712
     1713        $result = $this->evaluate(
     1714            array(
     1715                'namespace' => $default_ns,
     1716                'value'     => 'state.nested.key',
     1717            )
     1718        );
    13091719        $this->assertSame( 'myPlugin-state-nested', $result );
    13101720
    1311         $result = $this->evaluate( 'context.nested.key' );
     1721        $result = $this->evaluate(
     1722            array(
     1723                'namespace' => $default_ns,
     1724                'value'     => 'context.nested.key',
     1725            )
     1726        );
    13121727        $this->assertSame( 'myPlugin-context-nested', $result );
    13131728
    1314         $result = $this->evaluate( 'otherPlugin::state.nested.key' );
     1729        $result = $this->evaluate(
     1730            array(
     1731                'namespace' => 'otherPlugin',
     1732                'value'     => 'state.nested.key',
     1733            )
     1734        );
    13151735        $this->assertSame( 'otherPlugin-state-nested', $result );
    13161736
    1317         $result = $this->evaluate( 'otherPlugin::context.nested.key' );
     1737        $result = $this->evaluate(
     1738            array(
     1739                'namespace' => 'otherPlugin',
     1740                'value'     => 'context.nested.key',
     1741            )
     1742        );
    13181743        $this->assertSame( 'otherPlugin-context-nested', $result );
    13191744    }
    … …  
    13311756        $this->set_internal_namespace_stack();
    13321757
    1333         $result = $this->evaluate( 'path', 'null' );
     1758        $result = $this->evaluate(
     1759            array(
     1760                'namespace' => 'null',
     1761                'value'     => 'path',
     1762            )
     1763        );
    13341764        $this->assertNull( $result );
    13351765
    1336         $result = $this->evaluate( 'path', '' );
     1766        $result = $this->evaluate(
     1767            array(
     1768                'namespace' => '',
     1769                'value'     => 'path',
     1770            )
     1771        );
    13371772        $this->assertNull( $result );
    13381773
    1339         $result = $this->evaluate( 'path', '{}' );
     1774        $result = $this->evaluate(
     1775            array(
     1776                'namespace' => '{}',
     1777                'value'     => 'path',
     1778            )
     1779        );
    13401780        $this->assertNull( $result );
    13411781    }
    … …  
    13751815        $this->set_internal_namespace_stack( 'myPlugin' );
    13761816
    1377         $result = $this->evaluate( 'state.derived' );
     1817        $result = $this->evaluate(
     1818            array(
     1819                'namespace' => 'myPlugin',
     1820                'value'     => 'state.derived',
     1821            )
     1822        );
    13781823        $this->assertSame( "Derived state: myPlugin-state\nDerived context: myPlugin-context", $result );
    13791824    }
    … …  
    14181863        $this->set_internal_namespace_stack( 'myPlugin' );
    14191864
    1420         $result = $this->evaluate( 'state.derived' );
     1865        $result = $this->evaluate(
     1866            array(
     1867                'namespace' => 'myPlugin',
     1868                'value'     => 'state.derived',
     1869            )
     1870        );
    14211871        $this->assertSame( "Derived state: otherPlugin-state\nDerived context: otherPlugin-context", $result );
    14221872    }
    … …  
    14611911        $this->set_internal_namespace_stack( 'myPlugin' );
    14621912
    1463         $result = $this->evaluate( 'otherPlugin::state.derived' );
     1913        $result = $this->evaluate(
     1914            array(
     1915                'namespace' => 'otherPlugin',
     1916                'value'     => 'state.derived',
     1917            )
     1918        );
    14641919        $this->assertSame( "Derived state: otherPlugin-state\nDerived context: otherPlugin-context", $result );
    14651920    }
    … …  
    14851940        $this->set_internal_namespace_stack( 'myPlugin' );
    14861941
    1487         $result = $this->evaluate( 'state.derivedThatThrows' );
     1942        $result = $this->evaluate(
     1943            array(
     1944                'namespace' => 'myPlugin',
     1945                'value'     => 'state.derivedThatThrows',
     1946            )
     1947        );
    14881948        $this->assertNull( $result );
    14891949    }
    … …  
    15081968        $this->set_internal_namespace_stack( 'myPlugin' );
    15091969
    1510         $result = $this->evaluate( 'state.derivedState.property' );
     1970        $result = $this->evaluate(
     1971            array(
     1972                'namespace' => 'myPlugin',
     1973                'value'     => 'state.derivedState.property',
     1974            )
     1975        );
    15111976        $this->assertSame( 'value', $result );
    15121977    }
Note: See TracChangeset for help on using the changeset viewer.