%s
', esc_html__( 'Warning: There is content which fails AMP validation; it will be stripped when served as AMP.', 'amp' ) ); + echo ''; + esc_html_e( 'Warning: There is content which fails AMP validation; it will be stripped when served as AMP.', 'amp' ); + if ( $validation_status_post || $url ) { + if ( $validation_status_post ) { + echo sprintf( + ' %s', + esc_url( get_edit_post_link( $validation_status_post ) ), + esc_html__( 'Details', 'amp' ) + ); + } + if ( $url ) { + if ( $validation_status_post ) { + echo ' | '; + } + echo sprintf( + ' %s', + esc_url( self::get_debug_url( $url ) ), + esc_attr__( 'Validate URL on frontend but without invalid elements/attributes removed', 'amp' ), + esc_html__( 'Debug', 'amp' ) + ); + } + } + echo '
'; + + $results = self::summarize_validation_errors( array_unique( $validation_errors, SORT_REGULAR ) ); $removed_sets = array(); - if ( ! empty( $response['removed_elements'] ) && is_array( $response['removed_elements'] ) ) { + if ( ! empty( $results[ self::REMOVED_ELEMENTS ] ) && is_array( $results[ self::REMOVED_ELEMENTS ] ) ) { $removed_sets[] = array( 'label' => __( 'Invalid elements:', 'amp' ), - 'names' => array_map( 'sanitize_key', $response['removed_elements'] ), + 'names' => array_map( 'sanitize_key', $results[ self::REMOVED_ELEMENTS ] ), ); } - if ( ! empty( $response['removed_attributes'] ) && is_array( $response['removed_attributes'] ) ) { + if ( ! empty( $results[ self::REMOVED_ATTRIBUTES ] ) && is_array( $results[ self::REMOVED_ATTRIBUTES ] ) ) { $removed_sets[] = array( 'label' => __( 'Invalid attributes:', 'amp' ), - 'names' => array_map( 'sanitize_key', $response['removed_attributes'] ), + 'names' => array_map( 'sanitize_key', $results[ self::REMOVED_ATTRIBUTES ] ), ); } + // @todo There are other kinds of errors other than REMOVED_ELEMENTS and REMOVED_ATTRIBUTES. foreach ( $removed_sets as $removed_set ) { printf( '%s ', esc_html( $removed_set['label'] ) );
- $items = array();
- foreach ( $removed_set['names'] as $name => $count ) {
- if ( 1 === intval( $count ) ) {
- $items[] = sprintf( '%s', esc_html( $name ) );
+ self::output_removed_set( $removed_set['names'] );
+ echo '
%s (%d)', esc_html( $name ), $count );
+ unset( $source['closing'] );
+ $sources[] = $source;
}
}
- echo implode( ', ', $items ); // WPCS: XSS OK.
- echo '';
}
- echo '';
+ return $sources;
+ }
+
+ /**
+ * Remove source comments.
+ *
+ * @param DOMDocument $dom Document.
+ */
+ public static function remove_source_comments( $dom ) {
+ $xpath = new DOMXPath( $dom );
+ $comments = array();
+ foreach ( $xpath->query( '//comment()[ contains( ., "amp-source-stack:" ) ]' ) as $comment ) {
+ if ( self::parse_source_comment( $comment ) ) {
+ $comments[] = $comment;
+ }
+ }
+ foreach ( $comments as $comment ) {
+ $comment->parentNode->removeChild( $comment );
+ }
+ }
+
+ /**
+ * Wraps callbacks in comments to indicate to the sanitizer which extension added them.
+ *
+ * Iterates through all of the registered callbacks for actions and filters.
+ * If a callback is from a plugin and outputs markup, this wraps the markup in comments.
+ * Later, the sanitizer can identify which theme or plugin the illegal markup is from.
+ *
+ * @global array $wp_filter
+ * @return void
+ */
+ public static function callback_wrappers() {
+ global $wp_filter;
+ $pending_wrap_callbacks = array();
+ foreach ( $wp_filter as $filter_tag => $wp_hook ) {
+ foreach ( $wp_hook->callbacks as $priority => $callbacks ) {
+ foreach ( $callbacks as $callback ) {
+ $source_data = self::get_source( $callback['function'] );
+ if ( isset( $source_data ) ) {
+ $pending_wrap_callbacks[ $filter_tag ][] = array_merge(
+ $callback,
+ $source_data,
+ array(
+ 'hook' => $filter_tag,
+ ),
+ compact( 'priority' )
+ );
+ }
+ }
+ }
+ }
+
+ // Iterate over hooks to replace after iterating over all to begin with to prevent infinite loop in PHP<=5.4.
+ foreach ( $pending_wrap_callbacks as $hook => $callbacks ) {
+ foreach ( $callbacks as $callback ) {
+ remove_action( $hook, $callback['function'], $callback['priority'] );
+ $wrapped_callback = self::wrapped_callback( $callback );
+ add_action( $hook, $wrapped_callback, $callback['priority'], $callback['accepted_args'] );
+ }
+ }
+ }
+
+ /**
+ * Filters the output created by a shortcode callback.
+ *
+ * @since 0.7
+ *
+ * @param string $output Shortcode output.
+ * @param string $tag Shortcode name.
+ * @return string Output.
+ * @global array $shortcode_tags
+ */
+ public static function decorate_shortcode_source( $output, $tag ) {
+ global $shortcode_tags;
+ if ( ! isset( $shortcode_tags[ $tag ] ) ) {
+ return $output;
+ }
+ $source = self::get_source( $shortcode_tags[ $tag ] );
+ if ( empty( $source ) ) {
+ return $output;
+ }
+ $output = implode( '', array(
+ self::get_source_comment_start( $source['type'], $source['name'], array( 'shortcode' => $tag ) ),
+ $output,
+ self::get_source_comment_end( $source['type'], $source['name'] ),
+ ) );
+ return $output;
+ }
+
+ /**
+ * Gets the plugin or theme of the callback, if one exists.
+ *
+ * @param string|array $callback The callback for which to get the plugin.
+ * @return array|null {
+ * The source data.
+ *
+ * @type string $type Source type.
+ * @type string $name Source name.
+ * }
+ */
+ public static function get_source( $callback ) {
+ try {
+ if ( is_string( $callback ) && is_callable( $callback ) ) {
+ // The $callback is a function or static method.
+ $exploded_callback = explode( '::', $callback );
+ if ( count( $exploded_callback ) > 1 ) {
+ $reflection = new ReflectionClass( $exploded_callback[0] );
+ } else {
+ $reflection = new ReflectionFunction( $callback );
+ }
+ } elseif ( is_array( $callback ) && isset( $callback[0], $callback[1] ) && method_exists( $callback[0], $callback[1] ) ) {
+ // The $callback is a method.
+ $reflection = new ReflectionClass( $callback[0] );
+ } elseif ( is_object( $callback ) && ( 'Closure' === get_class( $callback ) ) ) {
+ $reflection = new ReflectionFunction( $callback );
+ }
+ } catch ( Exception $e ) {
+ return null;
+ }
+
+ $file = isset( $reflection ) ? $reflection->getFileName() : null;
+ if ( ! isset( $file ) ) {
+ return null;
+ }
+ $file = wp_normalize_path( $file );
+
+ $slug_pattern = '([^/]+)';
+ if ( preg_match( ':' . preg_quote( trailingslashit( wp_normalize_path( WP_PLUGIN_DIR ) ), ':' ) . $slug_pattern . ':s', $file, $matches ) ) {
+ $type = 'plugin';
+ $name = $matches[1];
+ } elseif ( preg_match( ':' . preg_quote( trailingslashit( wp_normalize_path( get_theme_root() ) ), ':' ) . $slug_pattern . ':s', $file, $matches ) ) {
+ $type = 'theme';
+ $name = $matches[1];
+ } elseif ( preg_match( ':' . preg_quote( trailingslashit( wp_normalize_path( WPMU_PLUGIN_DIR ) ), ':' ) . $slug_pattern . ':s', $file, $matches ) ) {
+ $type = 'mu-plugin';
+ $name = $matches[1];
+ }
+
+ if ( isset( $type, $name ) ) {
+ return compact( 'type', 'name' );
+ }
+ return null;
+ }
+
+ /**
+ * Wraps a callback in comments if it outputs markup.
+ *
+ * If the sanitizer removes markup,
+ * this indicates which plugin it was from.
+ * The call_user_func_array() logic is mainly copied from WP_Hook:apply_filters().
+ *
+ * @param array $callback {
+ * The callback data.
+ *
+ * @type callable $function
+ * @type int $accepted_args
+ * @type string $type
+ * @type string $source
+ * @type string $hook
+ * }
+ * @return closure $wrapped_callback The callback, wrapped in comments.
+ */
+ public static function wrapped_callback( $callback ) {
+ return function() use ( $callback ) {
+ global $wp_styles, $wp_scripts;
+
+ $function = $callback['function'];
+ $accepted_args = $callback['accepted_args'];
+ $args = func_get_args();
+
+ $before_styles_enqueued = array();
+ if ( isset( $wp_styles ) && isset( $wp_styles->queue ) ) {
+ $before_styles_enqueued = $wp_styles->queue;
+ }
+ $before_scripts_enqueued = array();
+ if ( isset( $wp_scripts ) && isset( $wp_scripts->queue ) ) {
+ $before_scripts_enqueued = $wp_scripts->queue;
+ }
+
+ ob_start();
+ $result = call_user_func_array( $function, array_slice( $args, 0, intval( $accepted_args ) ) );
+ $output = ob_get_clean();
+
+ // Keep track of which source enqueued the styles.
+ if ( isset( $wp_styles ) && isset( $wp_styles->queue ) ) {
+ foreach ( array_diff( $wp_styles->queue, $before_styles_enqueued ) as $handle ) {
+ $source = array_merge(
+ wp_array_slice_assoc( $callback, array( 'type', 'name' ) ),
+ array(
+ 'args' => array(
+ 'hook' => $callback['hook'],
+ ),
+ )
+ );
+
+ AMP_Validation_Utils::$enqueued_style_sources[ $handle ][] = $source;
+ }
+ }
+
+ // Keep track of which source enqueued the scripts, and immediately report validity .
+ if ( isset( $wp_scripts ) && isset( $wp_scripts->queue ) ) {
+ foreach ( array_diff( $wp_scripts->queue, $before_scripts_enqueued ) as $handle ) {
+ $source = array_merge(
+ wp_array_slice_assoc( $callback, array( 'type', 'name' ) ),
+ array(
+ 'args' => array(
+ 'hook' => $callback['hook'],
+ ),
+ )
+ );
+
+ AMP_Validation_Utils::$enqueued_script_sources[ $handle ][] = $source;
+
+ if ( isset( $wp_scripts->registered[ $handle ] ) ) {
+ self::add_validation_error( array(
+ 'code' => self::ENQUEUED_SCRIPT_CODE,
+ 'handle' => $handle,
+ 'dependency' => $wp_scripts->registered[ $handle ],
+ 'sources' => array(
+ $source,
+ ),
+ ) );
+ }
+ }
+ }
+
+ // Wrap output that contains HTML tags (as opposed to actions that trigger in HTML attributes).
+ if ( ! empty( $output ) && preg_match( '/<.+?>/s', $output ) ) {
+ echo AMP_Validation_Utils::get_source_comment_start( $callback['type'], $callback['name'], array( 'hook' => $callback['hook'] ) ); // WPCS: XSS ok.
+ echo $output; // WPCS: XSS ok.
+ echo AMP_Validation_Utils::get_source_comment_end( $callback['type'], $callback['name'] ); // WPCS: XSS ok.
+ }
+ return $result;
+ };
+ }
+
+ /**
+ * Output a removed set, each wrapped in %s', esc_html( $name ) );
+ } else {
+ $items[] = sprintf( '%s (%d)', esc_html( $name ), $count );
+ }
+ }
+ echo implode( ', ', $items ); // WPCS: XSS OK.
+ }
+
+ /**
+ * Whether to validate the front end response.
+ *
+ * Either the user has the capability and the query var is present.
+ *
+ * @return boolean Whether to validate.
+ */
+ public static function should_validate_response() {
+ return self::has_cap() && isset( $_GET[ self::VALIDATE_QUERY_VAR ] ); // WPCS: CSRF ok.
+ }
+
+ /**
+ * Finalize validation.
+ *
+ * @param DOMDocument $dom Document.
+ * @param array $args {
+ * Args.
+ *
+ * @type bool $remove_source_comments Whether source comments should be removed. Defaults to true.
+ * @type bool $send_validation_errors_header Whether the X-AMP-Validation-Errors header should be sent. Defaults to true.
+ * @type bool $append_validation_status_comment Whether the validation errors should be appended as an HTML comment. Defaults to true.
+ * }
+ */
+ public static function finalize_validation( DOMDocument $dom, $args = array() ) {
+ $args = array_merge(
+ array(
+ 'send_validation_errors_header' => true,
+ 'remove_source_comments' => true,
+ 'append_validation_status_comment' => true,
+ ),
+ $args
+ );
+
+ if ( $args['send_validation_errors_header'] && ! headers_sent() ) {
+ self::send_validation_errors_header();
+ }
+
+ if ( $args['remove_source_comments'] ) {
+ self::remove_source_comments( $dom );
+ }
+
+ if ( $args['append_validation_status_comment'] ) {
+ $report = "\n# Validation Status\n";
+ $report .= "\n## Summary\n";
+ $report .= wp_json_encode( self::summarize_validation_errors( self::$validation_errors ), 128 /* JSON_PRETTY_PRINT */ ) . "\n";
+ $report .= "\n## Details\n";
+ $report .= wp_json_encode( self::$validation_errors, 128 /* JSON_PRETTY_PRINT */ ) . "\n";
+ $comment = $dom->createComment( $report );
+ $body = $dom->getElementsByTagName( 'body' )->item( 0 );
+ if ( $body ) {
+ $body->appendChild( $comment );
+ }
+ }
+ }
+
+ /**
+ * Adds the validation callback if front-end validation is needed.
+ *
+ * @param array $sanitizers The AMP sanitizers.
+ * @return array $sanitizers The filtered AMP sanitizers.
+ */
+ public static function add_validation_callback( $sanitizers ) {
+ foreach ( $sanitizers as $sanitizer => $args ) {
+ $sanitizers[ $sanitizer ] = array_merge(
+ $args,
+ array(
+ 'validation_error_callback' => __CLASS__ . '::add_validation_error',
+ )
+ );
+ }
+ return $sanitizers;
+ }
+
+ /**
+ * Registers the post type to store the validation errors.
+ *
+ * @return void.
+ */
+ public static function register_post_type() {
+ $post_type = register_post_type(
+ self::POST_TYPE_SLUG,
+ array(
+ 'labels' => array(
+ 'name' => _x( 'Validation Status', 'post type general name', 'amp' ),
+ 'singular_name' => __( 'validation error', 'amp' ),
+ 'not_found' => __( 'No validation errors found', 'amp' ),
+ 'not_found_in_trash' => __( 'No validation errors found in trash', 'amp' ),
+ 'search_items' => __( 'Search statuses', 'amp' ),
+ 'edit_item' => __( 'Validation Status', 'amp' ),
+ ),
+ 'supports' => false,
+ 'public' => false,
+ 'show_ui' => true,
+ 'show_in_menu' => AMP_Options_Manager::OPTION_NAME,
+ )
+ );
+
+ // Hide the add new post link.
+ $post_type->cap->create_posts = 'do_not_allow';
+ }
+
+ /**
+ * Send validation errors back in response header.
+ */
+ public static function send_validation_errors_header() {
+ header( self::VALIDATION_ERRORS_RESPONSE_HEADER_NAME . ': ' . wp_json_encode( self::$validation_errors ) );
+ }
+
+ /**
+ * Stores the validation errors.
+ *
+ * After the preprocessors run, this gets the validation response if the query var is present.
+ * It then stores the response in a custom post type.
+ * If there's already an error post for the URL, but there's no error anymore, it deletes it.
+ *
+ * @param array $validation_errors Validation errors.
+ * @param string $url URL on which the validation errors occurred.
+ * @return int|null $post_id The post ID of the custom post type used, or null.
+ * @global WP $wp
+ */
+ public static function store_validation_errors( $validation_errors, $url ) {
+ $post_for_this_url = self::get_validation_status_post( $url );
+
+ // Since there are no validation errors and there is an existing $existing_post_id, just delete the post.
+ if ( empty( $validation_errors ) ) {
+ if ( $post_for_this_url ) {
+ wp_delete_post( $post_for_this_url->ID, true );
+ }
+ return null;
+ }
+
+ $encoded_errors = wp_json_encode( $validation_errors );
+ $post_name = md5( $encoded_errors );
+
+ // If the post name is unchanged then the errors are the same and there is nothing to do.
+ if ( $post_for_this_url && $post_for_this_url->post_name === $post_name ) {
+ return $post_for_this_url->ID;
+ }
+
+ // If there already exists a post for the given validation errors, just amend the $url to the existing post.
+ $post_for_other_url = get_page_by_path( $post_name, OBJECT, self::POST_TYPE_SLUG );
+ if ( ! $post_for_other_url ) {
+ $post_for_other_url = get_page_by_path( $post_name . '__trashed', OBJECT, self::POST_TYPE_SLUG );
+ }
+ if ( $post_for_other_url ) {
+ if ( 'trash' === $post_for_other_url->post_status ) {
+ wp_untrash_post( $post_for_other_url->ID );
+ }
+ if ( ! in_array( $url, get_post_meta( $post_for_other_url->ID, self::AMP_URL_META, false ), true ) ) {
+ add_post_meta( $post_for_other_url->ID, self::AMP_URL_META, wp_slash( $url ), false );
+ }
+ return $post_for_other_url->ID;
+ }
+
+ // Otherwise, create a new validation status post, or update the existing one.
+ $post_id = wp_insert_post( wp_slash( array(
+ 'ID' => $post_for_this_url ? $post_for_this_url->ID : null,
+ 'post_type' => self::POST_TYPE_SLUG,
+ 'post_title' => $url,
+ 'post_name' => $post_name,
+ 'post_content' => $encoded_errors,
+ 'post_status' => 'publish',
+ ) ) );
+ if ( ! $post_id ) {
+ return null;
+ }
+ if ( ! in_array( $url, get_post_meta( $post_id, self::AMP_URL_META, false ), true ) ) {
+ add_post_meta( $post_id, self::AMP_URL_META, wp_slash( $url ), false );
+ }
+ return $post_id;
+ }
+
+ /**
+ * Gets the existing custom post that stores errors for the $url, if it exists.
+ *
+ * @param string $url The URL of the post.
+ * @return WP_Post|null The post of the existing custom post, or null.
+ */
+ public static function get_validation_status_post( $url ) {
+ $query = new WP_Query( array(
+ 'post_type' => self::POST_TYPE_SLUG,
+ 'post_status' => 'publish',
+ 'posts_per_page' => 1,
+ 'meta_query' => array(
+ array(
+ 'key' => self::AMP_URL_META,
+ 'value' => $url,
+ ),
+ ),
+ ) );
+ return array_shift( $query->posts );
+ }
+
+ /**
+ * Validates the latest published post.
+ *
+ * @return array|WP_Error The validation errors, or WP_Error.
+ */
+ public static function validate_after_plugin_activation() {
+ $url = amp_admin_get_preview_permalink();
+ if ( ! $url ) {
+ return new WP_Error( 'no_published_post_url_available' );
+ }
+ $validation_errors = self::validate_url( $url );
+ if ( is_array( $validation_errors ) && count( $validation_errors ) > 0 ) {
+ self::store_validation_errors( $validation_errors, $url );
+ set_transient( self::PLUGIN_ACTIVATION_VALIDATION_ERRORS_TRANSIENT_KEY, $validation_errors, 60 );
+ } else {
+ delete_transient( self::PLUGIN_ACTIVATION_VALIDATION_ERRORS_TRANSIENT_KEY );
+ }
+ return $validation_errors;
+ }
+
+ /**
+ * Validates a given URL.
+ *
+ * The validation errors will be stored in the validation status custom post type,
+ * as well as in a transient.
+ *
+ * @param string $url The URL to validate.
+ * @return array|WP_Error The validation errors, or WP_Error on error.
+ */
+ public static function validate_url( $url ) {
+ $validation_url = add_query_arg(
+ array(
+ self::VALIDATE_QUERY_VAR => 1,
+ self::CACHE_BUST_QUERY_VAR => wp_rand(),
+ ),
+ $url
+ );
+
+ $r = wp_remote_get( $validation_url, array(
+ 'cookies' => wp_unslash( $_COOKIE ),
+ 'sslverify' => false,
+ 'headers' => array(
+ 'Cache-Control' => 'no-cache',
+ ),
+ ) );
+ if ( is_wp_error( $r ) ) {
+ return $r;
+ }
+ if ( wp_remote_retrieve_response_code( $r ) >= 400 ) {
+ return new WP_Error(
+ wp_remote_retrieve_response_code( $r ),
+ wp_remote_retrieve_response_message( $r )
+ );
+ }
+ $json = wp_remote_retrieve_header( $r, self::VALIDATION_ERRORS_RESPONSE_HEADER_NAME );
+ if ( ! $json ) {
+ return new WP_Error( 'response_header_absent' );
+ }
+ $validation_errors = json_decode( $json, true );
+ if ( ! is_array( $validation_errors ) ) {
+ return new WP_Error( 'malformed_json_validation_errors' );
+ }
+
+ return $validation_errors;
+ }
+
+ /**
+ * On activating a plugin, display a notice if a plugin causes an AMP validation error.
+ *
+ * @return void
+ */
+ public static function plugin_notice() {
+ global $pagenow;
+ if ( ( 'plugins.php' === $pagenow ) && ( ! empty( $_GET['activate'] ) || ! empty( $_GET['activate-multi'] ) ) ) { // WPCS: CSRF ok.
+ $validation_errors = get_transient( self::PLUGIN_ACTIVATION_VALIDATION_ERRORS_TRANSIENT_KEY );
+ if ( empty( $validation_errors ) || ! is_array( $validation_errors ) ) {
+ return;
+ }
+ delete_transient( self::PLUGIN_ACTIVATION_VALIDATION_ERRORS_TRANSIENT_KEY );
+ $errors = self::summarize_validation_errors( $validation_errors );
+ $invalid_plugins = isset( $errors[ self::SOURCES_INVALID_OUTPUT ]['plugin'] ) ? array_unique( $errors[ self::SOURCES_INVALID_OUTPUT ]['plugin'] ) : null;
+ if ( isset( $invalid_plugins ) ) {
+ $reported_plugins = array();
+ foreach ( $invalid_plugins as $plugin ) {
+ $reported_plugins[] = sprintf( '%s', esc_html( $plugin ) );
+ }
+
+ $more_details_link = sprintf(
+ '%s',
+ esc_url( add_query_arg(
+ 'post_type',
+ self::POST_TYPE_SLUG,
+ admin_url( 'edit.php' )
+ ) ),
+ __( 'More details', 'amp' )
+ );
+ printf(
+ '%s %s %s
%s', esc_html( $type ), esc_html( $name ) );
+ }
+ }
+ echo implode( ', ', $sources ); // WPCS: XSS ok.
+ }
+ break;
+ }
+ }
+
+ /**
+ * Adds a 'Recheck' link to the edit.php row actions.
+ *
+ * The logic to add the new action is mainly copied from WP_Posts_List_Table::handle_row_actions().
+ *
+ * @param array $actions The actions in the edit.php page.
+ * @param WP_Post $post The post for the actions.
+ * @return array $actions The filtered actions.
+ */
+ public static function filter_row_actions( $actions, $post ) {
+ if ( self::POST_TYPE_SLUG !== $post->post_type ) {
+ return $actions;
+ }
+
+ $actions['edit'] = sprintf(
+ '%s',
+ esc_url( get_edit_post_link( $post ) ),
+ esc_html__( 'Details', 'amp' )
+ );
+ unset( $actions['inline hide-if-no-js'] );
+ $url = get_post_meta( $post->ID, self::AMP_URL_META, true );
+
+ if ( ! empty( $url ) ) {
+ $actions[ self::RECHECK_ACTION ] = self::get_recheck_link( $post, get_edit_post_link( $post->ID, 'raw' ), $url );
+ $actions[ self::DEBUG_QUERY_VAR ] = sprintf(
+ '%s',
+ esc_url( self::get_debug_url( $url ) ),
+ esc_attr__( 'Validate URL on frontend but without invalid elements/attributes removed', 'amp' ),
+ esc_html__( 'Debug', 'amp' )
+ );
+ }
+
+ return $actions;
+ }
+
+ /**
+ * Adds a 'Recheck' bulk action to the edit.php page.
+ *
+ * @param array $actions The bulk actions in the edit.php page.
+ * @return array $actions The filtered bulk actions.
+ */
+ public static function add_bulk_action( $actions ) {
+ unset( $actions['edit'] );
+ $actions[ self::RECHECK_ACTION ] = esc_html__( 'Recheck', 'amp' );
+ return $actions;
+ }
+
+ /**
+ * Handles the 'Recheck' bulk action on the edit.php page.
+ *
+ * @param string $redirect The URL of the redirect.
+ * @param string $action The action.
+ * @param array $items The items on which to take the action.
+ * @return string $redirect The filtered URL of the redirect.
+ */
+ public static function handle_bulk_action( $redirect, $action, $items ) {
+ if ( self::RECHECK_ACTION !== $action ) {
+ return $redirect;
+ }
+ $remaining_invalid_urls = array();
+ foreach ( $items as $item ) {
+ $url = get_post_meta( $item, self::AMP_URL_META, true );
+ if ( empty( $url ) ) {
+ continue;
+ }
+
+ $validation_errors = self::validate_url( $url );
+ if ( ! is_array( $validation_errors ) ) {
+ continue;
+ }
+
+ self::store_validation_errors( $validation_errors, $url );
+ if ( ! empty( $validation_errors ) ) {
+ $remaining_invalid_urls[] = $url;
+ }
+ }
+
+ // Get the URLs that still have errors after rechecking.
+ $args = array(
+ self::URLS_TESTED => count( $items ),
+ self::REMAINING_ERRORS => empty( $remaining_invalid_urls ) ? '0' : '1',
+ );
+
+ return add_query_arg( $args, $redirect );
+ }
+
+ /**
+ * Outputs an admin notice after rechecking URL(s) on the custom post page.
+ *
+ * @return void
+ */
+ public static function remaining_error_notice() {
+ if ( ! isset( $_GET[ self::REMAINING_ERRORS ] ) || self::POST_TYPE_SLUG !== get_current_screen()->post_type ) { // WPCS: CSRF ok.
+ return;
+ }
+
+ $count_urls_tested = isset( $_GET[ self::URLS_TESTED ] ) ? intval( $_GET[ self::URLS_TESTED ] ) : 1; // WPCS: CSRF ok.
+ $errors_remain = ! empty( $_GET[ self::REMAINING_ERRORS ] ); // WPCS: CSRF ok.
+ if ( $errors_remain ) {
+ $class = 'notice-warning';
+ $message = _n( 'The rechecked URL still has validation errors.', 'The rechecked URLs still have validation errors.', $count_urls_tested, 'amp' );
+ } else {
+ $message = _n( 'The rechecked URL has no validation errors.', 'The rechecked URLs have no validation errors.', $count_urls_tested, 'amp' );
+ $class = 'updated';
+ }
+
+ printf(
+ '%s
+ ', $error['parent_name'] ) );
+ }
+ ?>
+
+ $value ) {
+ printf( ' %s="%s"', esc_html( $key ), esc_html( $value ) );
+ }
+ }
+ echo esc_html( '>…' );
+ ?>
+
+
+
+ $value ) {
+ if ( $key === $error['node_name'] ) {
+ echo '';
+ }
+ printf( ' %s="%s"', esc_html( $key ), esc_html( $value ) );
+ if ( $key === $error['node_name'] ) {
+ echo '';
+ }
+ }
+ echo esc_html( '>' );
+ ?>
+
+