WordPress.org
Get WordPress

Make WordPress Core


Ignore:
Timestamp:
10/21/2025 12:07:16 PM (11 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.