WordPress.org
Get WordPress

Make WordPress Core

Changeset 58327


Ignore:
Timestamp:
06/04/2024 10:59:01 AM (4 months ago)
Author:
gziolo
Message:

Interactivity API: Directives cannot derive state on the server

The Interactivity API has a concept of "derived state" but it only worked on the client (JavaScript). This is the implementation that mirrors it, so derived state has good server-side solution.

Props jonsurrell, darerodz, gziolo, luisherranz, cbravobernal.
Fixes #61037.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wp-includes/interactivity-api/class-wp-interactivity-api.php

    r58321 r58327  
    7575
    7676    /**
     77     * Stack of namespaces defined by `data-wp-interactive` directives, in
     78     * the order they are processed.
     79     *
     80     * This is only available during directive processing, otherwise it is `null`.
     81     *
     82     * @since 6.6.0
     83     * @var array<string>|null
     84     */
     85    private $namespace_stack = null;
     86
     87    /**
     88     * Stack of contexts defined by `data-wp-context` directives, in
     89     * the order they are processed.
     90     *
     91     * This is only available during directive processing, otherwise it is `null`.
     92     *
     93     * @since 6.6.0
     94     * @var array<array<mixed>>|null
     95     */
     96    private $context_stack = null;
     97
     98    /**
    7799     * Gets and/or sets the initial state of an Interactivity API store for a
    78100     * given namespace.
    … …  
    81103     * provided state with the existing one.
    82104     *
    83      * @since 6.5.0
    84      *
    85      * @param string $store_namespace The unique store namespace identifier.
     105     * When no namespace is specified, it returns the state defined for the
     106     * current value in the internal namespace stack during a `process_directives` call.
     107     *
     108     * @since 6.5.0
     109     * @since 6.6.0 The `$store_namespace` param is optional.
     110     *
     111     * @param string $store_namespace Optional. The unique store namespace identifier.
    86112     * @param array  $state           Optional. The array that will be merged with the existing state for the specified
    87113     *                                store namespace.
    … …  
    89115     *               argument was provided.
    90116     */
    91     public function state( string $store_namespace, array $state = array() ): array {
     117    public function state( ?string $store_namespace = null, ?array $state = null ): array {
     118        if ( ! $store_namespace ) {
     119            if ( $state ) {
     120                _doing_it_wrong(
     121                    __METHOD__,
     122                    __( 'The namespace is required when state data is passed.' ),
     123                    '6.6.0'
     124                );
     125                return array();
     126            }
     127            if ( null !== $store_namespace ) {
     128                _doing_it_wrong(
     129                    __METHOD__,
     130                    __( 'The namespace should be a non-empty string.' ),
     131                    '6.6.0'
     132                );
     133                return array();
     134            }
     135            if ( null === $this->namespace_stack ) {
     136                _doing_it_wrong(
     137                    __METHOD__,
     138                    __( 'The namespace can only be omitted during directive processing.' ),
     139                    '6.6.0'
     140                );
     141                return array();
     142            }
     143
     144            $store_namespace = end( $this->namespace_stack );
     145        }
    92146        if ( ! isset( $this->state_data[ $store_namespace ] ) ) {
    93147            $this->state_data[ $store_namespace ] = array();
    … …  
    213267
    214268    /**
     269     * Returns the latest value on the context stack with the passed namespace.
     270     *
     271     * When the namespace is omitted, it uses the current namespace on the
     272     * namespace stack during a `process_directives` call.
     273     *
     274     * @since 6.6.0
     275     *
     276     * @param string $store_namespace Optional. The unique store namespace identifier.
     277     */
     278    public function get_context( ?string $store_namespace = null ): array {
     279        if ( null === $this->context_stack ) {
     280            _doing_it_wrong(
     281                __METHOD__,
     282                __( 'The context can only be read during directive processing.' ),
     283                '6.6.0'
     284            );
     285            return array();
     286        }
     287
     288        if ( ! $store_namespace ) {
     289            if ( null !== $store_namespace ) {
     290                _doing_it_wrong(
     291                    __METHOD__,
     292                    __( 'The namespace should be a non-empty string.' ),
     293                    '6.6.0'
     294                );
     295                return array();
     296            }
     297
     298            $store_namespace = end( $this->namespace_stack );
     299        }
     300
     301        $context = end( $this->context_stack );
     302
     303        return ( $store_namespace && $context && isset( $context[ $store_namespace ] ) )
     304            ? $context[ $store_namespace ]
     305            : array();
     306    }
     307
     308    /**
    215309     * Registers the `@wordpress/interactivity` script modules.
    216310     *
    … …  
    259353        }
    260354
    261         $context_stack   = array();
    262         $namespace_stack = array();
    263         $result          = $this->process_directives_args( $html, $context_stack, $namespace_stack );
     355        $this->namespace_stack = array();
     356        $this->context_stack   = array();
     357
     358        $result = $this->_process_directives( $html );
     359
     360        $this->namespace_stack = null;
     361        $this->context_stack   = null;
     362
    264363        return null === $result ? $html : $result;
    265364    }
    … …  
    269368     * and updates the markup accordingly.
    270369     *
    271      * It needs the context and namespace stacks to be passed by reference, and
    272      * it returns null if the HTML contains unbalanced tags.
    273      *
    274      * @since 6.5.0
    275      * @since 6.6.0 The function displays a warning message when the HTML contains unbalanced tags or a directive appears in a MATH or SVG tag.
    276      *
    277      * @param string $html            The HTML content to process.
    278      * @param array  $context_stack   The reference to the array used to keep track of contexts during processing.
    279      * @param array  $namespace_stack The reference to the array used to manage namespaces during processing.
     370     * It uses the WP_Interactivity_API instance's context and namespace stacks,
     371     * which are shared between all calls.
     372     *
     373     * This method returns null if the HTML contains unbalanced tags.
     374     *
     375     * @since 6.6.0
     376     *
     377     * @param string $html The HTML content to process.
    280378     * @return string|null The processed HTML content. It returns null when the HTML contains unbalanced tags.
    281379     */
    282     private function process_directives_args( string $html, array &$context_stack, array &$namespace_stack ) {
     380    private function _process_directives( string $html ) {
    283381        $p          = new WP_Interactivity_API_Directives_Processor( $html );
    284382        $tag_stack  = array();
    … …  
    287385        $directive_processor_prefixes          = array_keys( self::$directive_processors );
    288386        $directive_processor_prefixes_reversed = array_reverse( $directive_processor_prefixes );
     387
     388        /*
     389         * Save the current size for each stack to restore them in case
     390         * the processing finds unbalanced tags.
     391         */
     392        $namespace_stack_size = count( $this->namespace_stack );
     393        $context_stack_size   = count( $this->context_stack );
    289394
    290395        while ( $p->next_tag( array( 'tag_closers' => 'visit' ) ) ) {
    … …  
    299404                if ( $p->get_attribute_names_with_prefix( 'data-wp-' ) ) {
    300405                    /* translators: 1: SVG or MATH HTML tag, 2: Namespace of the interactive block. */
    301                     $message = sprintf( __( 'Interactivity directives were detected on an incompatible %1$s tag when processing "%2$s". These directives will be ignored in the server side render.' ), $tag_name, end( $namespace_stack ) );
     406                    $message = sprintf( __( 'Interactivity directives were detected on an incompatible %1$s tag when processing "%2$s". These directives will be ignored in the server side render.' ), $tag_name, end( $this->namespace_stack ) );
    302407                    _doing_it_wrong( __METHOD__, $message, '6.6.0' );
    303408                }
    … …  
    382487                        : array( $this, self::$directive_processors[ $directive_prefix ] );
    383488
    384                     call_user_func_array(
    385                         $func,
    386                         array( $p, $mode, &$context_stack, &$namespace_stack, &$tag_stack )
    387                     );
    388                 }
    389             }
    390         }
     489                    call_user_func_array( $func, array( $p, $mode, &$tag_stack ) );
     490                }
     491            }
     492        }
     493
     494        if ( $unbalanced ) {
     495            // Reset the namespace and context stacks to their previous values.
     496            array_splice( $this->namespace_stack, $namespace_stack_size );
     497            array_splice( $this->context_stack, $context_stack_size );
     498        }
     499
    391500        /*
    392501         * It returns null if the HTML is unbalanced because unbalanced HTML is
    … …  
    398507            $tag_errored = 0 < count( $tag_stack ) ? end( $tag_stack )[0] : $tag_name;
    399508            /* translators: %1s: Namespace processed, %2s: The tag that caused the error; could be any HTML tag.  */
    400             $message = sprintf( __( 'Interactivity directives failed to process in "%1$s" due to a missing "%2$s" end tag.' ), end( $namespace_stack ), $tag_errored );
     509            $message = sprintf( __( 'Interactivity directives failed to process in "%1$s" due to a missing "%2$s" end tag.' ), end( $this->namespace_stack ), $tag_errored );
    401510            _doing_it_wrong( __METHOD__, $message, '6.6.0' );
    402511            return null;
    … …  
    412521     * @since 6.5.0
    413522     * @since 6.6.0 The function now adds a warning when the namespace is null, falsy, or the directive value is empty.
    414      *
    415      * @param string|true $directive_value   The directive attribute value string or `true` when it's a boolean attribute.
    416      * @param string      $default_namespace The default namespace to use if none is explicitly defined in the directive
    417      *                                       value.
    418      * @param array|false $context           The current context for evaluating the directive or false if there is no
    419      *                                       context.
     523     * @since 6.6.0 Removed `default_namespace` and `context` arguments.
     524     *
     525     * @param string|true $directive_value The directive attribute value string or `true` when it's a boolean attribute.
    420526     * @return mixed|null The result of the evaluation. Null if the reference path doesn't exist or the namespace is falsy.
    421527     */
    422     private function evaluate( $directive_value, string $default_namespace, $context = false ) {
     528    private function evaluate( $directive_value ) {
     529        $default_namespace = end( $this->namespace_stack );
     530        $context           = end( $this->context_stack );
     531
    423532        list( $ns, $path ) = $this->extract_directive_value( $directive_value, $default_namespace );
    424533        if ( ! $ns || ! $path ) {
    … …  
    451560        }
    452561
     562        if ( $current instanceof Closure ) {
     563            /*
     564             * This state getter's namespace is added to the stack so that
     565             * `state()` or `get_config()` read that namespace when called
     566             * without specifying one.
     567             */
     568            array_push( $this->namespace_stack, $ns );
     569            try {
     570                $current = $current();
     571            } catch ( Throwable $e ) {
     572                _doing_it_wrong(
     573                    __METHOD__,
     574                    sprintf(
     575                        /* translators: 1: Path pointing to an Interactivity API state property, 2: Namespace for an Interactivity API store. */
     576                        __( 'Uncaught error executing a derived state callback with path "%1$s" and namespace "%2$s".' ),
     577                        $path,
     578                        $ns
     579                    ),
     580                    '6.6.0'
     581                );
     582                return null;
     583            } finally {
     584                // Remove the property's namespace from the stack.
     585                array_pop( $this->namespace_stack );
     586            }
     587        }
     588
    453589        // Returns the opposite if it contains a negation operator (!).
    454590        return $should_negate_value ? ! $current : $current;
    … …  
    552688     * @since 6.5.0
    553689     *
    554      * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    555      * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    556      * @param array                                     $context_stack   The reference to the context stack.
    557      * @param array                                     $namespace_stack The reference to the store namespace stack.
    558      */
    559     private function data_wp_interactive_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     690     * @param WP_Interactivity_API_Directives_Processor $p    The directives processor instance.
     691     * @param string                                    $mode Whether the processing is entering or exiting the tag.
     692     */
     693    private function data_wp_interactive_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    560694        // When exiting tags, it removes the last namespace from the stack.
    561695        if ( 'exit' === $mode ) {
    562             array_pop( $namespace_stack );
     696            array_pop( $this->namespace_stack );
    563697            return;
    564698        }
    … …  
    584718            }
    585719        }
    586         $namespace_stack[] = ( $new_namespace && 1 === preg_match( '/^([\w\-_\/]+)/', $new_namespace ) )
     720        $this->namespace_stack[] = ( $new_namespace && 1 === preg_match( '/^([\w\-_\/]+)/', $new_namespace ) )
    587721            ? $new_namespace
    588             : end( $namespace_stack );
     722            : end( $this->namespace_stack );
    589723    }
    590724
    … …  
    599733     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    600734     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    601      * @param array                                     $context_stack   The reference to the context stack.
    602      * @param array                                     $namespace_stack The reference to the store namespace stack.
    603      */
    604     private function data_wp_context_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     735     */
     736    private function data_wp_context_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    605737        // When exiting tags, it removes the last context from the stack.
    606738        if ( 'exit' === $mode ) {
    607             array_pop( $context_stack );
     739            array_pop( $this->context_stack );
    608740            return;
    609741        }
    610742
    611743        $attribute_value = $p->get_attribute( 'data-wp-context' );
    612         $namespace_value = end( $namespace_stack );
     744        $namespace_value = end( $this->namespace_stack );
    613745
    614746        // Separates the namespace from the context JSON object.
    … …  
    622754         */
    623755        if ( is_string( $namespace_value ) ) {
    624             $context_stack[] = array_replace_recursive(
    625                 end( $context_stack ) !== false ? end( $context_stack ) : array(),
     756            $this->context_stack[] = array_replace_recursive(
     757                end( $this->context_stack ) !== false ? end( $this->context_stack ) : array(),
    626758                array( $namespace_value => is_array( $decoded_json ) ? $decoded_json : array() )
    627759            );
    … …  
    632764             * from the stack whenever it finds a `data-wp-context`'s closing tag.
    633765             */
    634             $context_stack[] = end( $context_stack );
     766            $this->context_stack[] = end( $this->context_stack );
    635767        }
    636768    }
    … …  
    646778     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    647779     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    648      * @param array                                     $context_stack   The reference to the context stack.
    649      * @param array                                     $namespace_stack The reference to the store namespace stack.
    650      */
    651     private function data_wp_bind_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     780     */
     781    private function data_wp_bind_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    652782        if ( 'enter' === $mode ) {
    653783            $all_bind_directives = $p->get_attribute_names_with_prefix( 'data-wp-bind--' );
    … …  
    660790
    661791                $attribute_value = $p->get_attribute( $attribute_name );
    662                 $result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
     792                $result          = $this->evaluate( $attribute_value );
    663793
    664794                if (
    … …  
    700830     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    701831     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    702      * @param array                                     $context_stack   The reference to the context stack.
    703      * @param array                                     $namespace_stack The reference to the store namespace stack.
    704      */
    705     private function data_wp_class_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     832     */
     833    private function data_wp_class_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    706834        if ( 'enter' === $mode ) {
    707835            $all_class_directives = $p->get_attribute_names_with_prefix( 'data-wp-class--' );
    … …  
    714842
    715843                $attribute_value = $p->get_attribute( $attribute_name );
    716                 $result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
     844                $result          = $this->evaluate( $attribute_value );
    717845
    718846                if ( $result ) {
    … …  
    735863     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    736864     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    737      * @param array                                     $context_stack   The reference to the context stack.
    738      * @param array                                     $namespace_stack The reference to the store namespace stack.
    739      */
    740     private function data_wp_style_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     865     */
     866    private function data_wp_style_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    741867        if ( 'enter' === $mode ) {
    742868            $all_style_attributes = $p->get_attribute_names_with_prefix( 'data-wp-style--' );
    … …  
    749875
    750876                $directive_attribute_value = $p->get_attribute( $attribute_name );
    751                 $style_property_value      = $this->evaluate( $directive_attribute_value, end( $namespace_stack ), end( $context_stack ) );
     877                $style_property_value      = $this->evaluate( $directive_attribute_value );
    752878                $style_attribute_value     = $p->get_attribute( 'style' );
    753879                $style_attribute_value     = ( $style_attribute_value && ! is_bool( $style_attribute_value ) ) ? $style_attribute_value : '';
    … …  
    828954     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    829955     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    830      * @param array                                     $context_stack   The reference to the context stack.
    831      * @param array                                     $namespace_stack The reference to the store namespace stack.
    832      */
    833     private function data_wp_text_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack ) {
     956     */
     957    private function data_wp_text_processor( WP_Interactivity_API_Directives_Processor $p, string $mode ) {
    834958        if ( 'enter' === $mode ) {
    835959            $attribute_value = $p->get_attribute( 'data-wp-text' );
    836             $result          = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
     960            $result          = $this->evaluate( $attribute_value );
    837961
    838962            /*
    … …  
    9661090     * @param WP_Interactivity_API_Directives_Processor $p               The directives processor instance.
    9671091     * @param string                                    $mode            Whether the processing is entering or exiting the tag.
    968      * @param array                                     $context_stack   The reference to the context stack.
    969      * @param array                                     $namespace_stack The reference to the store namespace stack.
    9701092     * @param array                                     $tag_stack       The reference to the tag stack.
    9711093     */
    972     private function data_wp_each_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$context_stack, array &$namespace_stack, array &$tag_stack ) {
     1094    private function data_wp_each_processor( WP_Interactivity_API_Directives_Processor $p, string $mode, array &$tag_stack ) {
    9731095        if ( 'enter' === $mode && 'TEMPLATE' === $p->get_tag() ) {
    9741096            $attribute_name   = $p->get_attribute_names_with_prefix( 'data-wp-each' )[0];
    … …  
    9761098            $item_name        = isset( $extracted_suffix[1] ) ? $this->kebab_to_camel_case( $extracted_suffix[1] ) : 'item';
    9771099            $attribute_value  = $p->get_attribute( $attribute_name );
    978             $result           = $this->evaluate( $attribute_value, end( $namespace_stack ), end( $context_stack ) );
     1100            $result           = $this->evaluate( $attribute_value );
    9791101
    9801102            // Gets the content between the template tags and leaves the cursor in the closer tag.
    … …  
    10101132
    10111133            // Extracts the namespace from the directive attribute value.
    1012             $namespace_value         = end( $namespace_stack );
     1134            $namespace_value         = end( $this->namespace_stack );
    10131135            list( $namespace_value ) = is_string( $attribute_value ) && ! empty( $attribute_value )
    10141136                ? $this->extract_directive_value( $attribute_value, $namespace_value )
    … …  
    10191141            foreach ( $result as $item ) {
    10201142                // Creates a new context that includes the current item of the array.
    1021                 $context_stack[] = array_replace_recursive(
    1022                     end( $context_stack ) !== false ? end( $context_stack ) : array(),
     1143                $this->context_stack[] = array_replace_recursive(
     1144                    end( $this->context_stack ) !== false ? end( $this->context_stack ) : array(),
    10231145                    array( $namespace_value => array( $item_name => $item ) )
    10241146                );
    10251147
    10261148                // Processes the inner content with the new context.
    1027                 $processed_item = $this->process_directives_args( $inner_content, $context_stack, $namespace_stack );
     1149                $processed_item = $this->_process_directives( $inner_content );
    10281150
    10291151                if ( null === $processed_item ) {
    10301152                    // If the HTML is unbalanced, stop processing it.
    1031                     array_pop( $context_stack );
     1153                    array_pop( $this->context_stack );
    10321154                    return;
    10331155                }
    … …  
    10421164
    10431165                // Removes the current context from the stack.
    1044                 array_pop( $context_stack );
     1166                array_pop( $this->context_stack );
    10451167            }
    10461168

  • trunk/src/wp-includes/interactivity-api/interactivity-api.php

    r58234 r58327  
    4848 * provided state with the existing one.
    4949 *
     50 * The namespace can be omitted inside derived state getters, using the
     51 * namespace where the getter is defined.
     52 *
    5053 * @since 6.5.0
     54 * @since 6.6.0 The namespace can be omitted when called inside derived state getters.
    5155 *
    5256 * @param string $store_namespace The unique store namespace identifier.
    … …  
    5660 *               provided.
    5761 */
    58 function wp_interactivity_state( string $store_namespace, array $state = array() ): array {
     62function wp_interactivity_state( ?string $store_namespace = null, array $state = array() ): array {
    5963    return wp_interactivity()->state( $store_namespace, $state );
    6064}
    … …  
    104108        '\'';
    105109}
     110
     111/**
     112 * Gets the current Interactivity API context for a given namespace.
     113 *
     114 * The function should be used only during directive processing. If the
     115 * `$store_namespace` parameter is omitted, it uses the current namespace value
     116 * on the internal namespace stack.
     117 *
     118 * It returns an empty array when the specified namespace is not defined.
     119 *
     120 * @since 6.6.0
     121 *
     122 * @param string $store_namespace Optional. The unique store namespace identifier.
     123 * @return array The context for the specified store namespace.
     124 */
     125function wp_interactivity_get_context( ?string $store_namespace = null ): array {
     126    return wp_interactivity()->get_context( $store_namespace );
     127}

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

    r58321 r58327  
    582582     * @covers ::process_directives
    583583     *
    584      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     584     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    585585     */
    586586    public function test_wp_each_unbalanced_tags() {
    … …  
    602602     * @covers ::process_directives
    603603     *
    604      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     604     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    605605     */
    606606    public function test_wp_each_unbalanced_tags_in_nested_template_tags() {

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

    r58321 r58327  
    133133     * @covers ::process_directives
    134134     *
    135      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     135     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    136136     */
    137137    public function test_wp_text_fails_with_unbalanced_and_same_tags_inside_content() {

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

    r58321 r58327  
    3333
    3434    /**
     35     * Modifies the internal namespace stack as if the WP_Interactivity_API
     36     * instance had found `data-wp-interactive` directives during
     37     * `process_directives` execution.
     38     *
     39     * @param array<string> $stack Values for the internal namespace stack.
     40     */
     41    private function set_internal_namespace_stack( ...$stack ) {
     42        $interactivity   = new ReflectionClass( $this->interactivity );
     43        $namespace_stack = $interactivity->getProperty( 'namespace_stack' );
     44        $namespace_stack->setAccessible( true );
     45        $namespace_stack->setValue( $this->interactivity, $stack );
     46    }
     47
     48    /**
     49     * Modifies the internal context stack as if the WP_Interactivity_API
     50     * instance had found `data-wp-context` directives during
     51     * `process_directives` execution.
     52     *
     53     * @param array<array<mixed>> $stack Values for the internal context stack.
     54     */
     55    private function set_internal_context_stack( ...$stack ) {
     56        $interactivity = new ReflectionClass( $this->interactivity );
     57        $context_stack = $interactivity->getProperty( 'context_stack' );
     58        $context_stack->setAccessible( true );
     59        $context_stack->setValue( $this->interactivity, $stack );
     60    }
     61
     62    /**
    3563     * Tests that the state and config methods return an empty array at the
    3664     * beginning.
    … …  
    424452JSON;
    425453        $this->assertEquals( $expected, $interactivity_data_string[1] );
     454    }
     455
     456    /**
     457     * Test that calling state without a namespace arg returns the state data
     458     * for the current namespace in the internal namespace stack.
     459     *
     460     * @ticket 61037
     461     *
     462     * @covers ::state
     463     */
     464    public function test_state_without_namespace() {
     465        $this->set_internal_namespace_stack( 'myPlugin' );
     466
     467        $this->interactivity->state( 'myPlugin', array( 'a' => 1 ) );
     468        $this->interactivity->state( 'otherPlugin', array( 'b' => 2 ) );
     469
     470        $this->assertEquals(
     471            array( 'a' => 1 ),
     472            $this->interactivity->state()
     473        );
     474    }
     475
     476    /**
     477     * Test that passing state data without a valid namespace does nothing and
     478     * just returns an empty array.
     479     *
     480     * @ticket 61037
     481     *
     482     * @covers ::state
     483     * @expectedIncorrectUsage WP_Interactivity_API::state
     484     */
     485    public function test_state_with_data_and_invalid_namespace() {
     486        $this->set_internal_namespace_stack( 'myPlugin' );
     487
     488        $this->interactivity->state( 'myPlugin', array( 'a' => 1 ) );
     489        $this->interactivity->state( 'otherPlugin', array( 'b' => 2 ) );
     490
     491        $this->assertEquals(
     492            array(),
     493            $this->interactivity->state( null, array( 'newProp' => 'value' ) )
     494        );
     495    }
     496
     497    /**
     498     * Test that calling state with an empty string as namespace is not allowed.
     499     *
     500     * @ticket 61037
     501     *
     502     * @covers ::state
     503     * @expectedIncorrectUsage WP_Interactivity_API::state
     504     */
     505    public function test_state_with_empty_string_as_namespace() {
     506        $this->set_internal_namespace_stack( 'myPlugin' );
     507
     508        $this->interactivity->state( 'myPlugin', array( 'a' => 1 ) );
     509        $this->interactivity->state( 'otherPlugin', array( 'b' => 2 ) );
     510
     511        $this->assertEquals(
     512            array(),
     513            $this->interactivity->state( '' )
     514        );
     515    }
     516
     517    /**
     518     * Tests that calling state without namespace outside of
     519     * `process_directives` execution is not allowed.
     520     *
     521     * @ticket 61037
     522     *
     523     * @covers ::state
     524     * @expectedIncorrectUsage WP_Interactivity_API::state
     525     */
     526    public function test_state_without_namespace_outside_directive_processing() {
     527        $this->assertEquals(
     528            array(),
     529            $this->interactivity->state()
     530        );
     531    }
     532
     533    /**
     534     * Test that `get_context` returns the latest context value for the given
     535     * namespace.
     536     *
     537     * @ticket 61037
     538     *
     539     * @covers ::get_context
     540     */
     541    public function test_get_context_with_namespace() {
     542        $this->set_internal_namespace_stack( 'myPlugin' );
     543        $this->set_internal_context_stack(
     544            array(
     545                'myPlugin' => array( 'a' => 0 ),
     546            ),
     547            array(
     548                'myPlugin'    => array( 'a' => 1 ),
     549                'otherPlugin' => array( 'b' => 2 ),
     550            )
     551        );
     552
     553        $this->assertEquals(
     554            array( 'a' => 1 ),
     555            $this->interactivity->get_context( 'myPlugin' )
     556        );
     557        $this->assertEquals(
     558            array( 'b' => 2 ),
     559            $this->interactivity->get_context( 'otherPlugin' )
     560        );
     561    }
     562
     563    /**
     564     * Test that `get_context` uses the current namespace in the internal
     565     * namespace stack when the parameter is omitted.
     566     *
     567     * @ticket 61037
     568     *
     569     * @covers ::get_context
     570     */
     571    public function test_get_context_without_namespace() {
     572        $this->set_internal_namespace_stack( 'myPlugin' );
     573        $this->set_internal_context_stack(
     574            array(
     575                'myPlugin' => array( 'a' => 0 ),
     576            ),
     577            array(
     578                'myPlugin'    => array( 'a' => 1 ),
     579                'otherPlugin' => array( 'b' => 2 ),
     580            )
     581        );
     582
     583        $this->assertEquals(
     584            array( 'a' => 1 ),
     585            $this->interactivity->get_context()
     586        );
     587    }
     588
     589    /**
     590     * Test that `get_context` returns an empty array when the context stack is
     591     * empty.
     592     *
     593     * @ticket 61037
     594     *
     595     * @covers ::get_context
     596     */
     597    public function test_get_context_with_empty_context_stack() {
     598        $this->set_internal_namespace_stack( 'myPlugin' );
     599        $this->set_internal_context_stack();
     600
     601        $this->assertEquals(
     602            array(),
     603            $this->interactivity->get_context( 'myPlugin' )
     604        );
     605    }
     606
     607    /**
     608     * Test that `get_context` returns an empty array if the given namespace is
     609     * not defined.
     610     *
     611     * @ticket 61037
     612     *
     613     * @covers ::get_context
     614     */
     615    public function test_get_context_with_undefined_namespace() {
     616        $this->set_internal_namespace_stack( 'myPlugin' );
     617        $this->set_internal_context_stack(
     618            array(
     619                'myPlugin' => array( 'a' => 0 ),
     620            ),
     621            array(
     622                'myPlugin' => array( 'a' => 1 ),
     623            )
     624        );
     625
     626        $this->assertEquals(
     627            array(),
     628            $this->interactivity->get_context( 'otherPlugin' )
     629        );
     630    }
     631
     632    /**
     633     * Test that `get_context` should not be called with an empty string.
     634     *
     635     * @ticket 61037
     636     *
     637     * @covers ::get_context
     638     * @expectedIncorrectUsage WP_Interactivity_API::get_context
     639     */
     640    public function test_get_context_with_empty_namespace() {
     641        $this->set_internal_namespace_stack( 'myPlugin' );
     642        $this->set_internal_context_stack(
     643            array(
     644                'myPlugin' => array( 'a' => 0 ),
     645            ),
     646            array(
     647                'myPlugin' => array( 'a' => 1 ),
     648            )
     649        );
     650
     651        $this->assertEquals(
     652            array(),
     653            $this->interactivity->get_context( '' )
     654        );
     655    }
     656
     657
     658    /**
     659     * Tests that `get_context` should not be called outside of
     660     * `process_directives` execution.
     661     *
     662     * @ticket 61037
     663     *
     664     * @covers ::get_context
     665     * @expectedIncorrectUsage WP_Interactivity_API::get_context
     666     */
     667    public function test_get_context_outside_of_directive_processing() {
     668        $context = $this->interactivity->get_context();
     669        $this->assertEquals( array(), $context );
    426670    }
    427671
    … …  
    650894     * @dataProvider data_html_with_unbalanced_tags
    651895     *
    652      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     896     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    653897     *
    654898     * @param string $html HTML containing unbalanced tags and also a directive.
    … …  
    749993     *
    750994     * @covers ::process_directives
    751      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     995     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    752996     */
    753997    public function test_process_directives_change_html_if_contains_math() {
    … …  
    7841028     *
    7851029     * @covers ::process_directives
    786      * @expectedIncorrectUsage WP_Interactivity_API::process_directives_args
     1030     * @expectedIncorrectUsage WP_Interactivity_API::_process_directives
    7871031     * @expectedIncorrectUsage WP_Interactivity_API_Directives_Processor::skip_to_tag_closer
    7881032     */
    … …  
    8141058     *
    8151059     * @param string $directive_value   The directive attribute value to evaluate.
    816      * @param string $default_namespace The default namespace used with directives.
    8171060     * @return mixed The result of the evaluate method.
    8181061     */
    819     private function evaluate( $directive_value, $default_namespace = 'myPlugin' ) {
    820         $generate_state = function ( $name ) {
    821             $obj       = new stdClass();
    822             $obj->prop = $name;
    823             return array(
    824                 'key'       => $name,
    825                 'nested'    => array( 'key' => $name . '-nested' ),
     1062    private function evaluate( $directive_value ) {
     1063        /*
     1064         * The global WP_Interactivity_API instance is momentarily replaced to
     1065         * make global functions like `wp_interactivity_state` and
     1066         * `wp_interactivity_get_config` work as expected.
     1067         */
     1068        global $wp_interactivity;
     1069        $wp_interactivity_prev = $wp_interactivity;
     1070        $wp_interactivity      = $this->interactivity;
     1071
     1072        $evaluate = new ReflectionMethod( $this->interactivity, 'evaluate' );
     1073        $evaluate->setAccessible( true );
     1074
     1075        $result = $evaluate->invokeArgs( $this->interactivity, array( $directive_value ) );
     1076
     1077        // Restore the original WP_Interactivity_API instance.
     1078        $wp_interactivity = $wp_interactivity_prev;
     1079
     1080        return $result;
     1081    }
     1082
     1083    /**
     1084     * Tests that the `evaluate` method operates correctly for valid expressions.
     1085     *
     1086     * @ticket 60356
     1087     *
     1088     * @covers ::evaluate
     1089     */
     1090    public function test_evaluate_value() {
     1091        $obj       = new stdClass();
     1092        $obj->prop = 'object property';
     1093        $this->interactivity->state(
     1094            'myPlugin',
     1095            array(
     1096                'key'       => 'myPlugin-state',
    8261097                'obj'       => $obj,
    8271098                'arrAccess' => new class() implements ArrayAccess {
    828                     #[\ReturnTypeWillChange]
    829                     public function offsetExists( $offset ) {
     1099                    public function offsetExists( $offset ): bool {
    8301100                        return true;
    8311101                    }
    8321102
    833                     public function offsetGet( $offset ): string {
     1103                    #[\ReturnTypeWillChange]
     1104                    public function offsetGet( $offset ) {
    8341105                        return $offset;
    8351106                    }
    … …  
    8391110                    public function offsetUnset( $offset ): void {}
    8401111                },
    841             );
    842         };
    843         $this->interactivity->state( 'myPlugin', $generate_state( 'myPlugin-state' ) );
    844         $this->interactivity->state( 'otherPlugin', $generate_state( 'otherPlugin-state' ) );
    845         $context  = array(
    846             'myPlugin'    => $generate_state( 'myPlugin-context' ),
    847             'otherPlugin' => $generate_state( 'otherPlugin-context' ),
    848             'obj'         => new stdClass(),
    849         );
    850         $evaluate = new ReflectionMethod( $this->interactivity, 'evaluate' );
    851         $evaluate->setAccessible( true );
    852         return $evaluate->invokeArgs( $this->interactivity, array( $directive_value, $default_namespace, $context ) );
    853     }
    854 
    855     /**
    856      * Tests that the `evaluate` method operates correctly for valid expressions.
    857      *
    858      * @ticket 60356
    859      *
    860      * @covers ::evaluate
    861      */
    862     public function test_evaluate_value() {
     1112            )
     1113        );
     1114        $this->interactivity->state( 'otherPlugin', array( 'key' => 'otherPlugin-state' ) );
     1115        $this->set_internal_context_stack(
     1116            array(
     1117                'myPlugin'    => array( 'key' => 'myPlugin-context' ),
     1118                'otherPlugin' => array( 'key' => 'otherPlugin-context' ),
     1119            )
     1120        );
     1121        $this->set_internal_namespace_stack( 'myPlugin' );
     1122
    8631123        $result = $this->evaluate( 'state.key' );
    8641124        $this->assertEquals( 'myPlugin-state', $result );
    … …  
    8741134
    8751135        $result = $this->evaluate( 'state.obj.prop' );
    876         $this->assertSame( 'myPlugin-state', $result );
     1136        $this->assertSame( 'object property', $result );
    8771137
    8781138        $result = $this->evaluate( 'state.arrAccess.1' );
    … …  
    8891149     */
    8901150    public function test_evaluate_value_negation() {
     1151        $this->interactivity->state( 'myPlugin', array( 'key' => 'myPlugin-state' ) );
     1152        $this->interactivity->state( 'otherPlugin', array( 'key' => 'otherPlugin-state' ) );
     1153        $this->set_internal_context_stack(
     1154            array(
     1155                'myPlugin'    => array( 'key' => 'myPlugin-context' ),
     1156                'otherPlugin' => array( 'key' => 'otherPlugin-context' ),
     1157            )
     1158        );
     1159        $this->set_internal_namespace_stack( 'myPlugin' );
     1160
    8911161        $result = $this->evaluate( '!state.key' );
    8921162        $this->assertFalse( $result );
    … …  
    9101180     */
    9111181    public function test_evaluate_non_existent_path() {
     1182        $this->interactivity->state( 'myPlugin', array( 'key' => 'myPlugin-state' ) );
     1183        $this->interactivity->state( 'otherPlugin', array( 'key' => 'otherPlugin-state' ) );
     1184        $this->set_internal_context_stack(
     1185            array(
     1186                'myPlugin'    => array( 'key' => 'myPlugin-context' ),
     1187                'otherPlugin' => array( 'key' => 'otherPlugin-context' ),
     1188            )
     1189        );
     1190        $this->set_internal_namespace_stack( 'myPlugin' );
     1191
    9121192        $result = $this->evaluate( 'state.nonExistentKey' );
    9131193        $this->assertNull( $result );
    … …  
    9371217     */
    9381218    public function test_evaluate_nested_value() {
     1219        $this->interactivity->state(
     1220            'myPlugin',
     1221            array(
     1222                'nested' => array( 'key' => 'myPlugin-state-nested' ),
     1223            )
     1224        );
     1225        $this->interactivity->state(
     1226            'otherPlugin',
     1227            array(
     1228                'nested' => array( 'key' => 'otherPlugin-state-nested' ),
     1229            )
     1230        );
     1231        $this->set_internal_context_stack(
     1232            array(
     1233                'myPlugin'    => array(
     1234                    'nested' => array( 'key' => 'myPlugin-context-nested' ),
     1235                ),
     1236                'otherPlugin' => array(
     1237                    'nested' => array( 'key' => 'otherPlugin-context-nested' ),
     1238                ),
     1239            )
     1240        );
     1241        $this->set_internal_namespace_stack( 'myPlugin' );
     1242
    9391243        $result = $this->evaluate( 'state.nested.key' );
    9401244        $this->assertEquals( 'myPlugin-state-nested', $result );
    … …  
    9591263     */
    9601264    public function test_evaluate_unvalid_namespaces() {
     1265        $this->set_internal_context_stack( array() );
     1266        $this->set_internal_namespace_stack();
     1267
    9611268        $result = $this->evaluate( 'path', 'null' );
    9621269        $this->assertNull( $result );
    … …  
    9661273
    9671274        $result = $this->evaluate( 'path', '{}' );
     1275        $this->assertNull( $result );
     1276    }
     1277
     1278    /**
     1279     * Tests the `evaluate` method for derived state functions.
     1280     *
     1281     * @ticket 61037
     1282     *
     1283     * @covers ::evaluate
     1284     * @covers wp_interactivity_state
     1285     * @covers wp_interactivity_get_context
     1286     */
     1287    public function test_evaluate_derived_state() {
     1288        $this->interactivity->state(
     1289            'myPlugin',
     1290            array(
     1291                'key'     => 'myPlugin-state',
     1292                'derived' => function () {
     1293                    $state   = wp_interactivity_state();
     1294                    $context = wp_interactivity_get_context();
     1295                    return 'Derived state: ' .
     1296                        $state['key'] .
     1297                        "\n" .
     1298                        'Derived context: ' .
     1299                        $context['key'];
     1300                },
     1301            )
     1302        );
     1303        $this->set_internal_context_stack(
     1304            array(
     1305                'myPlugin' => array(
     1306                    'key' => 'myPlugin-context',
     1307                ),
     1308            )
     1309        );
     1310        $this->set_internal_namespace_stack( 'myPlugin' );
     1311
     1312        $result = $this->evaluate( 'state.derived' );
     1313        $this->assertSame( "Derived state: myPlugin-state\nDerived context: myPlugin-context", $result );
     1314    }
     1315
     1316    /**
     1317     * Tests the `evaluate` method for derived state functions accessing a
     1318     * different namespace.
     1319     *
     1320     * @ticket 61037
     1321     *
     1322     * @covers ::evaluate
     1323     * @covers wp_interactivity_state
     1324     * @covers wp_interactivity_get_context
     1325     */
     1326    public function test_evaluate_derived_state_accessing_different_namespace() {
     1327        $this->interactivity->state(
     1328            'myPlugin',
     1329            array(
     1330                'key'     => 'myPlugin-state',
     1331                'derived' => function () {
     1332                    $state   = wp_interactivity_state( 'otherPlugin' );
     1333                    $context = wp_interactivity_get_context( 'otherPlugin' );
     1334                    return 'Derived state: ' .
     1335                        $state['key'] .
     1336                        "\n" .
     1337                        'Derived context: ' .
     1338                        $context['key'];
     1339                },
     1340            )
     1341        );
     1342        $this->interactivity->state( 'otherPlugin', array( 'key' => 'otherPlugin-state' ) );
     1343        $this->set_internal_context_stack(
     1344            array(
     1345                'myPlugin'    => array(
     1346                    'key' => 'myPlugin-context',
     1347                ),
     1348                'otherPlugin' => array(
     1349                    'key' => 'otherPlugin-context',
     1350                ),
     1351            )
     1352        );
     1353        $this->set_internal_namespace_stack( 'myPlugin' );
     1354
     1355        $result = $this->evaluate( 'state.derived' );
     1356        $this->assertSame( "Derived state: otherPlugin-state\nDerived context: otherPlugin-context", $result );
     1357    }
     1358
     1359    /**
     1360     * Tests the `evaluate` method for derived state functions defined in a
     1361     * different namespace.
     1362     *
     1363     * @ticket 61037
     1364     *
     1365     * @covers ::evaluate
     1366     * @covers wp_interactivity_state
     1367     * @covers wp_interactivity_get_context
     1368     */
     1369    public function test_evaluate_derived_state_defined_in_different_namespace() {
     1370        $this->interactivity->state( 'myPlugin', array( 'key' => 'myPlugin-state' ) );
     1371        $this->interactivity->state(
     1372            'otherPlugin',
     1373            array(
     1374                'key'     => 'otherPlugin-state',
     1375                'derived' => function () {
     1376                    $state   = wp_interactivity_state();
     1377                    $context = wp_interactivity_get_context();
     1378                    return 'Derived state: ' .
     1379                        $state['key'] .
     1380                        "\n" .
     1381                        'Derived context: ' .
     1382                        $context['key'];
     1383                },
     1384            )
     1385        );
     1386        $this->set_internal_context_stack(
     1387            array(
     1388                'myPlugin'    => array(
     1389                    'key' => 'myPlugin-context',
     1390                ),
     1391                'otherPlugin' => array(
     1392                    'key' => 'otherPlugin-context',
     1393                ),
     1394            )
     1395        );
     1396        $this->set_internal_namespace_stack( 'myPlugin' );
     1397
     1398        $result = $this->evaluate( 'otherPlugin::state.derived' );
     1399        $this->assertSame( "Derived state: otherPlugin-state\nDerived context: otherPlugin-context", $result );
     1400    }
     1401
     1402
     1403    /**
     1404     * Tests the `evaluate` method for derived state functions that throw.
     1405     *
     1406     * @ticket 61037
     1407     *
     1408     * @covers ::evaluate
     1409     * @expectedIncorrectUsage WP_Interactivity_API::evaluate
     1410     */
     1411    public function test_evaluate_derived_state_that_throws() {
     1412        $this->interactivity->state(
     1413            'myPlugin',
     1414            array(
     1415                'derivedThatThrows' => function () {
     1416                    throw new Error( 'Something bad happened.' );
     1417                },
     1418            )
     1419        );
     1420        $this->set_internal_context_stack();
     1421        $this->set_internal_namespace_stack( 'myPlugin' );
     1422
     1423        $result = $this->evaluate( 'state.derivedThatThrows' );
    9681424        $this->assertNull( $result );
    9691425    }
Note: See TracChangeset for help on using the changeset viewer.