WordPress.org
Get WordPress

Make WordPress Core

Changeset 48306


Ignore:
Timestamp:
07/05/2020 12:13:37 AM (6 years ago)
Author:
TimothyBlynJacobs
Message:

REST API: Make multi-typed schemas more robust.

A multi-type schema is a schema where the type keyword is an array of possible types instead of a single type. For instance, [ 'object', 'string' ] would allow objects or string values.

In [46249] basic support for these schemas was introduced. The validator would loop over each schema type trying to find a version that matched. This worked for valid values, but for invalid values it provided unhelpful error messages. The sanitizer also had its utility restricted.

In this commit, the validators and sanitizers will first determine the best type of the passed value and then apply the schema with that set type. In the case that a value could match multiple types, the schema of the first matching type will be used.

To maintain backward compatibility, if unsupported schema types are used, the value will always pass validation. A doing it wrong notice is issued in this case.

Fixes #50300.
Props pentatonicfunk, dlh, TimothyBlynJacobs.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r48302 r48306  
    987987
    988988/**
    989  * Parses an RFC3339 time into a Unix timestamp.
    990  *
    991  * @since 4.4.0
    992  *
    993  * @param string $date      RFC3339 timestamp.
    994  * @param bool   $force_utc Optional. Whether to force UTC timezone instead of using
    995  *                          the timestamp's timezone. Default false.
    996  * @return int Unix timestamp.
    997  */
    998 function rest_parse_date( $date, $force_utc = false ) {
    999         if ( $force_utc ) {
    1000                 $date = preg_replace( '/[+-]\d+:?\d+$/', '+00:00', $date );
    1001         }
    1002 
    1003         $regex = '#^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::\d{2})?)?$#';
    1004 
    1005         if ( ! preg_match( $regex, $date, $matches ) ) {
    1006                 return false;
    1007         }
    1008 
    1009         return strtotime( $date );
    1010 }
    1011 
    1012 /**
    1013  * Parses a 3 or 6 digit hex color (with #).
    1014  *
    1015  * @since 5.4.0
    1016  *
    1017  * @param string $color 3 or 6 digit hex color (with #).
    1018  * @return string|false
    1019  */
    1020 function rest_parse_hex_color( $color ) {
    1021         $regex = '|^#([A-Fa-f0-9]{3}){1,2}$|';
    1022         if ( ! preg_match( $regex, $color, $matches ) ) {
    1023                 return false;
    1024         }
    1025 
    1026         return $color;
    1027 }
    1028 
    1029 /**
    1030  * Parses a date into both its local and UTC equivalent, in MySQL datetime format.
    1031  *
    1032  * @since 4.4.0
    1033  *
    1034  * @see rest_parse_date()
    1035  *
    1036  * @param string $date   RFC3339 timestamp.
    1037  * @param bool   $is_utc Whether the provided date should be interpreted as UTC. Default false.
    1038  * @return array|null Local and UTC datetime strings, in MySQL datetime format (Y-m-d H:i:s),
    1039  *                    null on failure.
    1040  */
    1041 function rest_get_date_with_gmt( $date, $is_utc = false ) {
    1042         /*
    1043          * Whether or not the original date actually has a timezone string
    1044          * changes the way we need to do timezone conversion.
    1045          * Store this info before parsing the date, and use it later.
    1046          */
    1047         $has_timezone = preg_match( '#(Z|[+-]\d{2}(:\d{2})?)$#', $date );
    1048 
    1049         $date = rest_parse_date( $date );
    1050 
    1051         if ( empty( $date ) ) {
    1052                 return null;
    1053         }
    1054 
    1055         /*
    1056          * At this point $date could either be a local date (if we were passed
    1057          * a *local* date without a timezone offset) or a UTC date (otherwise).
    1058          * Timezone conversion needs to be handled differently between these two cases.
    1059          */
    1060         if ( ! $is_utc && ! $has_timezone ) {
    1061                 $local = gmdate( 'Y-m-d H:i:s', $date );
    1062                 $utc   = get_gmt_from_date( $local );
    1063         } else {
    1064                 $utc   = gmdate( 'Y-m-d H:i:s', $date );
    1065                 $local = get_date_from_gmt( $utc );
    1066         }
    1067 
    1068         return array( $local, $utc );
    1069 }
    1070 
    1071 /**
    1072  * Returns a contextual HTTP error code for authorization failure.
    1073  *
    1074  * @since 4.7.0
    1075  *
    1076  * @return integer 401 if the user is not logged in, 403 if the user is logged in.
    1077  */
    1078 function rest_authorization_required_code() {
    1079         return is_user_logged_in() ? 403 : 401;
    1080 }
    1081 
    1082 /**
    1083  * Validate a request argument based on details registered to the route.
    1084  *
    1085  * @since 4.7.0
    1086  *
    1087  * @param mixed           $value
    1088  * @param WP_REST_Request $request
    1089  * @param string          $param
    1090  * @return true|WP_Error
    1091  */
    1092 function rest_validate_request_arg( $value, $request, $param ) {
    1093         $attributes = $request->get_attributes();
    1094         if ( ! isset( $attributes['args'][ $param ] ) || ! is_array( $attributes['args'][ $param ] ) ) {
    1095                 return true;
    1096         }
    1097         $args = $attributes['args'][ $param ];
    1098 
    1099         return rest_validate_value_from_schema( $value, $args, $param );
    1100 }
    1101 
    1102 /**
    1103  * Sanitize a request argument based on details registered to the route.
    1104  *
    1105  * @since 4.7.0
    1106  *
    1107  * @param mixed           $value
    1108  * @param WP_REST_Request $request
    1109  * @param string          $param
    1110  * @return mixed
    1111  */
    1112 function rest_sanitize_request_arg( $value, $request, $param ) {
    1113         $attributes = $request->get_attributes();
    1114         if ( ! isset( $attributes['args'][ $param ] ) || ! is_array( $attributes['args'][ $param ] ) ) {
    1115                 return $value;
    1116         }
    1117         $args = $attributes['args'][ $param ];
    1118 
    1119         return rest_sanitize_value_from_schema( $value, $args );
    1120 }
    1121 
    1122 /**
    1123  * Parse a request argument based on details registered to the route.
    1124  *
    1125  * Runs a validation check and sanitizes the value, primarily to be used via
    1126  * the `sanitize_callback` arguments in the endpoint args registration.
    1127  *
    1128  * @since 4.7.0
    1129  *
    1130  * @param mixed           $value
    1131  * @param WP_REST_Request $request
    1132  * @param string          $param
    1133  * @return mixed
    1134  */
    1135 function rest_parse_request_arg( $value, $request, $param ) {
    1136         $is_valid = rest_validate_request_arg( $value, $request, $param );
    1137 
    1138         if ( is_wp_error( $is_valid ) ) {
    1139                 return $is_valid;
    1140         }
    1141 
    1142         $value = rest_sanitize_request_arg( $value, $request, $param );
    1143 
    1144         return $value;
    1145 }
    1146 
    1147 /**
    1148  * Determines if an IP address is valid.
    1149  *
    1150  * Handles both IPv4 and IPv6 addresses.
    1151  *
    1152  * @since 4.7.0
    1153  *
    1154  * @param string $ip IP address.
    1155  * @return string|false The valid IP address, otherwise false.
    1156  */
    1157 function rest_is_ip_address( $ip ) {
    1158         $ipv4_pattern = '/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/';
    1159 
    1160         if ( ! preg_match( $ipv4_pattern, $ip ) && ! Requests_IPv6::check_ipv6( $ip ) ) {
    1161                 return false;
    1162         }
    1163 
    1164         return $ip;
    1165 }
    1166 
    1167 /**
    1168  * Changes a boolean-like value into the proper boolean value.
    1169  *
    1170  * @since 4.7.0
    1171  *
    1172  * @param bool|string|int $value The value being evaluated.
    1173  * @return boolean Returns the proper associated boolean value.
    1174  */
    1175 function rest_sanitize_boolean( $value ) {
    1176         // String values are translated to `true`; make sure 'false' is false.
    1177         if ( is_string( $value ) ) {
    1178                 $value = strtolower( $value );
    1179                 if ( in_array( $value, array( 'false', '0' ), true ) ) {
    1180                         $value = false;
    1181                 }
    1182         }
    1183 
    1184         // Everything else will map nicely to boolean.
    1185         return (bool) $value;
    1186 }
    1187 
    1188 /**
    1189  * Determines if a given value is boolean-like.
    1190  *
    1191  * @since 4.7.0
    1192  *
    1193  * @param bool|string $maybe_bool The value being evaluated.
    1194  * @return boolean True if a boolean, otherwise false.
    1195  */
    1196 function rest_is_boolean( $maybe_bool ) {
    1197         if ( is_bool( $maybe_bool ) ) {
    1198                 return true;
    1199         }
    1200 
    1201         if ( is_string( $maybe_bool ) ) {
    1202                 $maybe_bool = strtolower( $maybe_bool );
    1203 
    1204                 $valid_boolean_values = array(
    1205                         'false',
    1206                         'true',
    1207                         '0',
    1208                         '1',
    1209                 );
    1210 
    1211                 return in_array( $maybe_bool, $valid_boolean_values, true );
    1212         }
    1213 
    1214         if ( is_int( $maybe_bool ) ) {
    1215                 return in_array( $maybe_bool, array( 0, 1 ), true );
    1216         }
    1217 
    1218         return false;
    1219 }
    1220 
    1221 /**
    1222989 * Retrieves the avatar urls in various sizes.
    1223990 *
    … …  
    12641031
    12651032/**
     1033 * Parses an RFC3339 time into a Unix timestamp.
     1034 *
     1035 * @since 4.4.0
     1036 *
     1037 * @param string $date      RFC3339 timestamp.
     1038 * @param bool   $force_utc Optional. Whether to force UTC timezone instead of using
     1039 *                          the timestamp's timezone. Default false.
     1040 * @return int Unix timestamp.
     1041 */
     1042function rest_parse_date( $date, $force_utc = false ) {
     1043        if ( $force_utc ) {
     1044                $date = preg_replace( '/[+-]\d+:?\d+$/', '+00:00', $date );
     1045        }
     1046
     1047        $regex = '#^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}(?::\d{2})?)?$#';
     1048
     1049        if ( ! preg_match( $regex, $date, $matches ) ) {
     1050                return false;
     1051        }
     1052
     1053        return strtotime( $date );
     1054}
     1055
     1056/**
     1057 * Parses a 3 or 6 digit hex color (with #).
     1058 *
     1059 * @since 5.4.0
     1060 *
     1061 * @param string $color 3 or 6 digit hex color (with #).
     1062 * @return string|false
     1063 */
     1064function rest_parse_hex_color( $color ) {
     1065        $regex = '|^#([A-Fa-f0-9]{3}){1,2}$|';
     1066        if ( ! preg_match( $regex, $color, $matches ) ) {
     1067                return false;
     1068        }
     1069
     1070        return $color;
     1071}
     1072
     1073/**
     1074 * Parses a date into both its local and UTC equivalent, in MySQL datetime format.
     1075 *
     1076 * @since 4.4.0
     1077 *
     1078 * @see rest_parse_date()
     1079 *
     1080 * @param string $date   RFC3339 timestamp.
     1081 * @param bool   $is_utc Whether the provided date should be interpreted as UTC. Default false.
     1082 * @return array|null Local and UTC datetime strings, in MySQL datetime format (Y-m-d H:i:s),
     1083 *                    null on failure.
     1084 */
     1085function rest_get_date_with_gmt( $date, $is_utc = false ) {
     1086        /*
     1087         * Whether or not the original date actually has a timezone string
     1088         * changes the way we need to do timezone conversion.
     1089         * Store this info before parsing the date, and use it later.
     1090         */
     1091        $has_timezone = preg_match( '#(Z|[+-]\d{2}(:\d{2})?)$#', $date );
     1092
     1093        $date = rest_parse_date( $date );
     1094
     1095        if ( empty( $date ) ) {
     1096                return null;
     1097        }
     1098
     1099        /*
     1100         * At this point $date could either be a local date (if we were passed
     1101         * a *local* date without a timezone offset) or a UTC date (otherwise).
     1102         * Timezone conversion needs to be handled differently between these two cases.
     1103         */
     1104        if ( ! $is_utc && ! $has_timezone ) {
     1105                $local = gmdate( 'Y-m-d H:i:s', $date );
     1106                $utc   = get_gmt_from_date( $local );
     1107        } else {
     1108                $utc   = gmdate( 'Y-m-d H:i:s', $date );
     1109                $local = get_date_from_gmt( $utc );
     1110        }
     1111
     1112        return array( $local, $utc );
     1113}
     1114
     1115/**
     1116 * Returns a contextual HTTP error code for authorization failure.
     1117 *
     1118 * @since 4.7.0
     1119 *
     1120 * @return integer 401 if the user is not logged in, 403 if the user is logged in.
     1121 */
     1122function rest_authorization_required_code() {
     1123        return is_user_logged_in() ? 403 : 401;
     1124}
     1125
     1126/**
     1127 * Validate a request argument based on details registered to the route.
     1128 *
     1129 * @since 4.7.0
     1130 *
     1131 * @param mixed           $value
     1132 * @param WP_REST_Request $request
     1133 * @param string          $param
     1134 * @return true|WP_Error
     1135 */
     1136function rest_validate_request_arg( $value, $request, $param ) {
     1137        $attributes = $request->get_attributes();
     1138        if ( ! isset( $attributes['args'][ $param ] ) || ! is_array( $attributes['args'][ $param ] ) ) {
     1139                return true;
     1140        }
     1141        $args = $attributes['args'][ $param ];
     1142
     1143        return rest_validate_value_from_schema( $value, $args, $param );
     1144}
     1145
     1146/**
     1147 * Sanitize a request argument based on details registered to the route.
     1148 *
     1149 * @since 4.7.0
     1150 *
     1151 * @param mixed           $value
     1152 * @param WP_REST_Request $request
     1153 * @param string          $param
     1154 * @return mixed
     1155 */
     1156function rest_sanitize_request_arg( $value, $request, $param ) {
     1157        $attributes = $request->get_attributes();
     1158        if ( ! isset( $attributes['args'][ $param ] ) || ! is_array( $attributes['args'][ $param ] ) ) {
     1159                return $value;
     1160        }
     1161        $args = $attributes['args'][ $param ];
     1162
     1163        return rest_sanitize_value_from_schema( $value, $args, $param );
     1164}
     1165
     1166/**
     1167 * Parse a request argument based on details registered to the route.
     1168 *
     1169 * Runs a validation check and sanitizes the value, primarily to be used via
     1170 * the `sanitize_callback` arguments in the endpoint args registration.
     1171 *
     1172 * @since 4.7.0
     1173 *
     1174 * @param mixed           $value
     1175 * @param WP_REST_Request $request
     1176 * @param string          $param
     1177 * @return mixed
     1178 */
     1179function rest_parse_request_arg( $value, $request, $param ) {
     1180        $is_valid = rest_validate_request_arg( $value, $request, $param );
     1181
     1182        if ( is_wp_error( $is_valid ) ) {
     1183                return $is_valid;
     1184        }
     1185
     1186        $value = rest_sanitize_request_arg( $value, $request, $param );
     1187
     1188        return $value;
     1189}
     1190
     1191/**
     1192 * Determines if an IP address is valid.
     1193 *
     1194 * Handles both IPv4 and IPv6 addresses.
     1195 *
     1196 * @since 4.7.0
     1197 *
     1198 * @param string $ip IP address.
     1199 * @return string|false The valid IP address, otherwise false.
     1200 */
     1201function rest_is_ip_address( $ip ) {
     1202        $ipv4_pattern = '/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/';
     1203
     1204        if ( ! preg_match( $ipv4_pattern, $ip ) && ! Requests_IPv6::check_ipv6( $ip ) ) {
     1205                return false;
     1206        }
     1207
     1208        return $ip;
     1209}
     1210
     1211/**
     1212 * Changes a boolean-like value into the proper boolean value.
     1213 *
     1214 * @since 4.7.0
     1215 *
     1216 * @param bool|string|int $value The value being evaluated.
     1217 * @return boolean Returns the proper associated boolean value.
     1218 */
     1219function rest_sanitize_boolean( $value ) {
     1220        // String values are translated to `true`; make sure 'false' is false.
     1221        if ( is_string( $value ) ) {
     1222                $value = strtolower( $value );
     1223                if ( in_array( $value, array( 'false', '0' ), true ) ) {
     1224                        $value = false;
     1225                }
     1226        }
     1227
     1228        // Everything else will map nicely to boolean.
     1229        return (bool) $value;
     1230}
     1231
     1232/**
     1233 * Determines if a given value is boolean-like.
     1234 *
     1235 * @since 4.7.0
     1236 *
     1237 * @param bool|string $maybe_bool The value being evaluated.
     1238 * @return boolean True if a boolean, otherwise false.
     1239 */
     1240function rest_is_boolean( $maybe_bool ) {
     1241        if ( is_bool( $maybe_bool ) ) {
     1242                return true;
     1243        }
     1244
     1245        if ( is_string( $maybe_bool ) ) {
     1246                $maybe_bool = strtolower( $maybe_bool );
     1247
     1248                $valid_boolean_values = array(
     1249                        'false',
     1250                        'true',
     1251                        '0',
     1252                        '1',
     1253                );
     1254
     1255                return in_array( $maybe_bool, $valid_boolean_values, true );
     1256        }
     1257
     1258        if ( is_int( $maybe_bool ) ) {
     1259                return in_array( $maybe_bool, array( 0, 1 ), true );
     1260        }
     1261
     1262        return false;
     1263}
     1264
     1265/**
     1266 * Determines if a given value is integer-like.
     1267 *
     1268 * @since 5.5.0
     1269 *
     1270 * @param mixed $maybe_integer The value being evaluated.
     1271 * @return bool True if an integer, otherwise false.
     1272 */
     1273function rest_is_integer( $maybe_integer ) {
     1274        return round( floatval( $maybe_integer ) ) === floatval( $maybe_integer );
     1275}
     1276
     1277/**
     1278 * Determines if a given value is array-like.
     1279 *
     1280 * @since 5.5.0
     1281 *
     1282 * @param mixed $maybe_array The value being evaluated.
     1283 * @return bool
     1284 */
     1285function rest_is_array( $maybe_array ) {
     1286        if ( is_scalar( $maybe_array ) ) {
     1287                $maybe_array = wp_parse_list( $maybe_array );
     1288        }
     1289
     1290        return wp_is_numeric_array( $maybe_array );
     1291}
     1292
     1293/**
     1294 * Converts an array-like value to an array.
     1295 *
     1296 * @since 5.5.0
     1297 *
     1298 * @param mixed $maybe_array The value being evaluated.
     1299 * @return array Returns the array extracted from the value.
     1300 */
     1301function rest_sanitize_array( $maybe_array ) {
     1302        if ( is_scalar( $maybe_array ) ) {
     1303                return wp_parse_list( $maybe_array );
     1304        }
     1305
     1306        if ( ! is_array( $maybe_array ) ) {
     1307                return array();
     1308        }
     1309
     1310        // Normalize to numeric array so nothing unexpected is in the keys.
     1311        return array_values( $maybe_array );
     1312}
     1313
     1314/**
     1315 * Determines if a given value is object-like.
     1316 *
     1317 * @since 5.5.0
     1318 *
     1319 * @param mixed $maybe_object The value being evaluated.
     1320 * @return bool True if object like, otherwise false.
     1321 */
     1322function rest_is_object( $maybe_object ) {
     1323        if ( '' === $maybe_object ) {
     1324                return true;
     1325        }
     1326
     1327        if ( $maybe_object instanceof stdClass ) {
     1328                return true;
     1329        }
     1330
     1331        if ( $maybe_object instanceof JsonSerializable ) {
     1332                $maybe_object = $maybe_object->jsonSerialize();
     1333        }
     1334
     1335        return is_array( $maybe_object );
     1336}
     1337
     1338/**
     1339 * Converts an object-like value to an object.
     1340 *
     1341 * @since 5.5.0
     1342 *
     1343 * @param mixed $maybe_object The value being evaluated.
     1344 * @return array Returns the object extracted from the value.
     1345 */
     1346function rest_sanitize_object( $maybe_object ) {
     1347        if ( '' === $maybe_object ) {
     1348                return array();
     1349        }
     1350
     1351        if ( $maybe_object instanceof stdClass ) {
     1352                return (array) $maybe_object;
     1353        }
     1354
     1355        if ( $maybe_object instanceof JsonSerializable ) {
     1356                $maybe_object = $maybe_object->jsonSerialize();
     1357        }
     1358
     1359        if ( ! is_array( $maybe_object ) ) {
     1360                return array();
     1361        }
     1362
     1363        return $maybe_object;
     1364}
     1365
     1366/**
     1367 * Gets the best type for a value.
     1368 *
     1369 * @since 5.5.0
     1370 *
     1371 * @param mixed $value The value to check.
     1372 * @param array $types The list of possible types.
     1373 * @return string The best matching type, an empty string if no types match.
     1374 */
     1375function rest_get_best_type_for_value( $value, $types ) {
     1376        static $checks = array(
     1377                'array'   => 'rest_is_array',
     1378                'object'  => 'rest_is_object',
     1379                'integer' => 'rest_is_integer',
     1380                'number'  => 'is_numeric',
     1381                'boolean' => 'rest_is_boolean',
     1382                'string'  => 'is_string',
     1383                'null'    => 'is_null',
     1384        );
     1385
     1386        // Both arrays and objects allow empty strings to be converted to their types.
     1387        // But the best answer for this type is a string.
     1388        if ( '' === $value && in_array( 'string', $types, true ) ) {
     1389                return 'string';
     1390        }
     1391
     1392        foreach ( $types as $type ) {
     1393                if ( isset( $checks[ $type ] ) && $checks[ $type ]( $value ) ) {
     1394                        return $type;
     1395                }
     1396        }
     1397
     1398        return '';
     1399}
     1400
     1401/**
     1402 * Handles getting the best type for a multi-type schema.
     1403 *
     1404 * This is a wrapper for {@see rest_get_best_type_for_value()} that handles
     1405 * backward compatibility for schemas that use invalid types.
     1406 *
     1407 * @since 5.5.0
     1408 *
     1409 * @param mixed  $value The value to check.
     1410 * @param array  $args  The schema array to use.
     1411 * @param string $param The parameter name, used in error messages.
     1412 * @return string
     1413 */
     1414function rest_handle_multi_type_schema( $value, $args, $param = '' ) {
     1415        $allowed_types = array( 'array', 'object', 'string', 'number', 'integer', 'boolean', 'null' );
     1416        $invalid_types = array_diff( $args['type'], $allowed_types );
     1417
     1418        if ( $invalid_types ) {
     1419                _doing_it_wrong(
     1420                        __FUNCTION__,
     1421                        /* translators: 1. Parameter. 2. List of allowed types. */
     1422                        wp_sprintf( __( 'The "type" schema keyword for %1$s can only contain the built-in types: %2$l.' ), $param, $allowed_types ),
     1423                        '5.5.0'
     1424                );
     1425        }
     1426
     1427        $best_type = rest_get_best_type_for_value( $value, $args['type'] );
     1428
     1429        if ( ! $best_type ) {
     1430                if ( ! $invalid_types ) {
     1431                        return '';
     1432                }
     1433
     1434                // Backward compatibility for previous behavior which allowed the value if there was an invalid type used.
     1435                $best_type = reset( $invalid_types );
     1436        }
     1437
     1438        return $best_type;
     1439}
     1440
     1441/**
    12661442 * Validate a value based on a schema.
    12671443 *
    … …  
    12851461
    12861462        if ( ! isset( $args['type'] ) ) {
    1287                 _doing_it_wrong( __FUNCTION__, __( 'The "type" schema keyword is required.' ), '5.5.0' );
     1463                /* translators: 1. Parameter */
     1464                _doing_it_wrong( __FUNCTION__, sprintf( __( 'The "type" schema keyword for %s is required.' ), $param ), '5.5.0' );
    12881465        }
    12891466
    12901467        if ( is_array( $args['type'] ) ) {
    1291                 foreach ( $args['type'] as $type ) {
    1292                         $type_args         = $args;
    1293                         $type_args['type'] = $type;
    1294 
    1295                         if ( true === rest_validate_value_from_schema( $value, $type_args, $param ) ) {
    1296                                 return true;
    1297                         }
    1298                 }
    1299 
    1300                 /* translators: 1: Parameter, 2: List of types. */
    1301                 return new WP_Error( 'rest_invalid_param', sprintf( __( '%1$s is not of type %2$s.' ), $param, implode( ',', $args['type'] ) ) );
     1468                $best_type = rest_handle_multi_type_schema( $value, $args, $param );
     1469
     1470                if ( ! $best_type ) {
     1471                        /* translators: 1: Parameter, 2: List of types. */
     1472                        return new WP_Error( 'rest_invalid_param', sprintf( __( '%1$s is not of type %2$s.' ), $param, implode( ',', $args['type'] ) ) );
     1473                }
     1474
     1475                $args['type'] = $best_type;
    13021476        }
    13031477
    … …  
    13051479                _doing_it_wrong(
    13061480                        __FUNCTION__,
    1307                         /* translators: 1. The list of allowed types. */
    1308                         wp_sprintf( __( 'The "type" schema keyword can only be on of the built-in types: %l.' ), $allowed_types ),
     1481                        /* translators: 1. Parameter 2. The list of allowed types. */
     1482                        wp_sprintf( __( 'The "type" schema keyword for %1$s can only be on of the built-in types: %2$l.' ), $param, $allowed_types ),
    13091483                        '5.5.0'
    13101484                );
    … …  
    13121486
    13131487        if ( 'array' === $args['type'] ) {
    1314                 if ( ! is_null( $value ) ) {
    1315                         $value = wp_parse_list( $value );
    1316                 }
    1317 
    1318                 if ( ! wp_is_numeric_array( $value ) ) {
     1488                if ( ! rest_is_array( $value ) ) {
    13191489                        /* translators: 1: Parameter, 2: Type name. */
    13201490                        return new WP_Error( 'rest_invalid_param', sprintf( __( '%1$s is not of type %2$s.' ), $param, 'array' ) );
    13211491                }
     1492
     1493                $value = rest_sanitize_array( $value );
    13221494
    13231495                foreach ( $value as $index => $v ) {
    … …  
    13401512
    13411513        if ( 'object' === $args['type'] ) {
    1342                 if ( '' === $value ) {
    1343                         $value = array();
    1344                 }
    1345 
    1346                 if ( $value instanceof stdClass ) {
    1347                         $value = (array) $value;
    1348                 }
    1349 
    1350                 if ( $value instanceof JsonSerializable ) {
    1351                         $value = $value->jsonSerialize();
    1352                 }
    1353 
    1354                 if ( ! is_array( $value ) ) {
     1514                if ( ! rest_is_object( $value ) ) {
    13551515                        /* translators: 1: Parameter, 2: Type name. */
    13561516                        return new WP_Error( 'rest_invalid_param', sprintf( __( '%1$s is not of type %2$s.' ), $param, 'object' ) );
    13571517                }
     1518
     1519                $value = rest_sanitize_object( $value );
    13581520
    13591521                if ( isset( $args['required'] ) && is_array( $args['required'] ) ) { // schema version 4
    … …  
    14161578        }
    14171579
    1418         if ( 'integer' === $args['type'] && round( floatval( $value ) ) !== floatval( $value ) ) {
     1580        if ( 'integer' === $args['type'] && ! rest_is_integer( $value ) ) {
    14191581                /* translators: 1: Parameter, 2: Type name. */
    14201582                return new WP_Error( 'rest_invalid_param', sprintf( __( '%1$s is not of type %2$s.' ), $param, 'integer' ) );
    … …  
    15521714 *
    15531715 * @since 4.7.0
    1554  *
    1555  * @param mixed $value The value to sanitize.
    1556  * @param array $args  Schema array to use for sanitization.
     1716 * @since 5.5.0 Added the `$param` parameter.
     1717 *
     1718 * @param mixed  $value The value to sanitize.
     1719 * @param array  $args  Schema array to use for sanitization.
     1720 * @param string $param The parameter name, used in error messages.
    15571721 * @return true|WP_Error
    15581722 */
    1559 function rest_sanitize_value_from_schema( $value, $args ) {
     1723function rest_sanitize_value_from_schema( $value, $args, $param = '' ) {
    15601724        $allowed_types = array( 'array', 'object', 'string', 'number', 'integer', 'boolean', 'null' );
    15611725
    15621726        if ( ! isset( $args['type'] ) ) {
    1563                 _doing_it_wrong( __FUNCTION__, __( 'The "type" schema keyword is required.' ), '5.5.0' );
     1727                /* translators: 1. Parameter */
     1728                _doing_it_wrong( __FUNCTION__, sprintf( __( 'The "type" schema keyword for %s is required.' ), $param ), '5.5.0' );
    15641729        }
    15651730
    15661731        if ( is_array( $args['type'] ) ) {
    1567                 // Determine which type the value was validated against,
    1568                 // and use that type when performing sanitization.
    1569                 $validated_type = '';
    1570 
    1571                 foreach ( $args['type'] as $type ) {
    1572                         $type_args         = $args;
    1573                         $type_args['type'] = $type;
    1574 
    1575                         if ( ! is_wp_error( rest_validate_value_from_schema( $value, $type_args ) ) ) {
    1576                                 $validated_type = $type;
    1577                                 break;
    1578                         }
    1579                 }
    1580 
    1581                 if ( ! $validated_type ) {
     1732                $best_type = rest_handle_multi_type_schema( $value, $args, $param );
     1733
     1734                if ( ! $best_type ) {
    15821735                        return null;
    15831736                }
    15841737
    1585                 $args['type'] = $validated_type;
     1738                $args['type'] = $best_type;
    15861739        }
    15871740
    … …  
    15891742                _doing_it_wrong(
    15901743                        __FUNCTION__,
    1591                         /* translators: 1. The list of allowed types. */
    1592                         wp_sprintf( __( 'The "type" schema keyword can only be on of the built-in types: %l.' ), $allowed_types ),
     1744                        /* translators: 1. Parameter. 2. The list of allowed types. */
     1745                        wp_sprintf( __( 'The "type" schema keyword for %1$s can only be on of the built-in types: %2$l.' ), $param, $allowed_types ),
    15931746                        '5.5.0'
    15941747                );
    … …  
    15961749
    15971750        if ( 'array' === $args['type'] ) {
     1751                $value = rest_sanitize_array( $value );
     1752
    15981753                if ( empty( $args['items'] ) ) {
    1599                         return (array) $value;
    1600                 }
    1601 
    1602                 $value = wp_parse_list( $value );
     1754                        return $value;
     1755                }
     1756
    16031757                foreach ( $value as $index => $v ) {
    1604                         $value[ $index ] = rest_sanitize_value_from_schema( $v, $args['items'] );
    1605                 }
    1606 
    1607                 // Normalize to numeric array so nothing unexpected is in the keys.
    1608                 $value = array_values( $value );
     1758                        $value[ $index ] = rest_sanitize_value_from_schema( $v, $args['items'], $param . '[' . $index . ']' );
     1759                }
     1760
    16091761                return $value;
    16101762        }
    16111763
    16121764        if ( 'object' === $args['type'] ) {
    1613                 if ( $value instanceof stdClass ) {
    1614                         $value = (array) $value;
    1615                 }
    1616 
    1617                 if ( $value instanceof JsonSerializable ) {
    1618                         $value = $value->jsonSerialize();
    1619                 }
    1620 
    1621                 if ( ! is_array( $value ) ) {
    1622                         return array();
    1623                 }
     1765                $value = rest_sanitize_object( $value );
    16241766
    16251767                foreach ( $value as $property => $v ) {
    16261768                        if ( isset( $args['properties'][ $property ] ) ) {
    1627                                 $value[ $property ] = rest_sanitize_value_from_schema( $v, $args['properties'][ $property ] );
     1769                                $value[ $property ] = rest_sanitize_value_from_schema( $v, $args['properties'][ $property ], $param . '[' . $property . ']' );
    16281770                        } elseif ( isset( $args['additionalProperties'] ) ) {
    16291771                                if ( false === $args['additionalProperties'] ) {
    16301772                                        unset( $value[ $property ] );
    16311773                                } elseif ( is_array( $args['additionalProperties'] ) ) {
    1632                                         $value[ $property ] = rest_sanitize_value_from_schema( $v, $args['additionalProperties'] );
     1774                                        $value[ $property ] = rest_sanitize_value_from_schema( $v, $args['additionalProperties'], $param . '[' . $property . ']' );
    16331775                                }
    16341776                        }

  • trunk/tests/phpunit/tests/rest-api.php

    r48273 r48306  
    99require_once ABSPATH . 'wp-admin/includes/admin.php';
    1010require_once ABSPATH . WPINC . '/rest-api.php';
     11require_once __DIR__ . '/../includes/class-jsonserializable-object.php';
    1112
    1213/**
    … …  
    14581459                $this->assertEquals( '/wp/v2/tags/' . $term->term_id, rest_get_route_for_term( $term->term_id ) );
    14591460        }
     1461
     1462        /**
     1463         * @dataProvider _dp_rest_is_object
     1464         * @ticket 50300
     1465         * @param bool  $expected Expected result of the check.
     1466         * @param mixed $value    The value to check.
     1467         */
     1468        public function test_rest_is_object( $expected, $value ) {
     1469                $is_object = rest_is_object( $value );
     1470
     1471                if ( $expected ) {
     1472                        $this->assertTrue( $is_object );
     1473                } else {
     1474                        $this->assertFalse( $is_object );
     1475                }
     1476        }
     1477
     1478        public function _dp_rest_is_object() {
     1479                return array(
     1480                        array(
     1481                                true,
     1482                                '',
     1483                        ),
     1484                        array(
     1485                                true,
     1486                                new stdClass(),
     1487                        ),
     1488                        array(
     1489                                true,
     1490                                new JsonSerializable_Object( array( 'hi' => 'there' ) ),
     1491                        ),
     1492                        array(
     1493                                true,
     1494                                array( 'hi' => 'there' ),
     1495                        ),
     1496                        array(
     1497                                true,
     1498                                array(),
     1499                        ),
     1500                        array(
     1501                                true,
     1502                                array( 'a', 'b' ),
     1503                        ),
     1504                        array(
     1505                                false,
     1506                                new Basic_Object(),
     1507                        ),
     1508                        array(
     1509                                false,
     1510                                new JsonSerializable_Object( 'str' ),
     1511                        ),
     1512                        array(
     1513                                false,
     1514                                'str',
     1515                        ),
     1516                        array(
     1517                                false,
     1518                                5,
     1519                        ),
     1520                );
     1521        }
     1522
     1523        /**
     1524         * @dataProvider _dp_rest_sanitize_object
     1525         * @ticket       50300
     1526         * @param array $expected Expected sanitized version.
     1527         * @param mixed $value    The value to sanitize.
     1528         */
     1529        public function test_rest_sanitize_object( $expected, $value ) {
     1530                $sanitized = rest_sanitize_object( $value );
     1531                $this->assertEquals( $expected, $sanitized );
     1532        }
     1533
     1534        public function _dp_rest_sanitize_object() {
     1535                return array(
     1536                        array(
     1537                                array(),
     1538                                '',
     1539                        ),
     1540                        array(
     1541                                array( 'a' => '1' ),
     1542                                (object) array( 'a' => '1' ),
     1543                        ),
     1544                        array(
     1545                                array( 'hi' => 'there' ),
     1546                                new JsonSerializable_Object( array( 'hi' => 'there' ) ),
     1547                        ),
     1548                        array(
     1549                                array( 'hi' => 'there' ),
     1550                                array( 'hi' => 'there' ),
     1551                        ),
     1552                        array(
     1553                                array(),
     1554                                array(),
     1555                        ),
     1556                        array(
     1557                                array( 'a', 'b' ),
     1558                                array( 'a', 'b' ),
     1559                        ),
     1560                        array(
     1561                                array(),
     1562                                new Basic_Object(),
     1563                        ),
     1564                        array(
     1565                                array(),
     1566                                new JsonSerializable_Object( 'str' ),
     1567                        ),
     1568                        array(
     1569                                array(),
     1570                                'str',
     1571                        ),
     1572                        array(
     1573                                array(),
     1574                                5,
     1575                        ),
     1576                );
     1577        }
     1578
     1579        /**
     1580         * @dataProvider _dp_rest_is_array
     1581         * @ticket 50300
     1582         * @param bool  $expected Expected result of the check.
     1583         * @param mixed $value    The value to check.
     1584         */
     1585        public function test_rest_is_array( $expected, $value ) {
     1586                $is_array = rest_is_array( $value );
     1587
     1588                if ( $expected ) {
     1589                        $this->assertTrue( $is_array );
     1590                } else {
     1591                        $this->assertFalse( $is_array );
     1592                }
     1593        }
     1594
     1595        public function _dp_rest_is_array() {
     1596                return array(
     1597                        array(
     1598                                true,
     1599                                '',
     1600                        ),
     1601                        array(
     1602                                true,
     1603                                array( 'a', 'b' ),
     1604                        ),
     1605                        array(
     1606                                true,
     1607                                array(),
     1608                        ),
     1609                        array(
     1610                                true,
     1611                                'a,b,c',
     1612                        ),
     1613                        array(
     1614                                true,
     1615                                'a',
     1616                        ),
     1617                        array(
     1618                                true,
     1619                                5,
     1620                        ),
     1621                        array(
     1622                                false,
     1623                                new stdClass(),
     1624                        ),
     1625                        array(
     1626                                false,
     1627                                new JsonSerializable_Object( array( 'hi' => 'there' ) ),
     1628                        ),
     1629                        array(
     1630                                false,
     1631                                array( 'hi' => 'there' ),
     1632                        ),
     1633                        array(
     1634                                false,
     1635                                new Basic_Object(),
     1636                        ),
     1637                        array(
     1638                                false,
     1639                                new JsonSerializable_Object( 'str' ),
     1640                        ),
     1641                        array(
     1642                                false,
     1643                                null,
     1644                        ),
     1645                );
     1646        }
     1647
     1648        /**
     1649         * @dataProvider _dp_rest_sanitize_array
     1650         * @ticket       50300
     1651         * @param array $expected Expected sanitized version.
     1652         * @param mixed $value    The value to sanitize.
     1653         */
     1654        public function test_rest_sanitize_array( $expected, $value ) {
     1655                $sanitized = rest_sanitize_array( $value );
     1656                $this->assertEquals( $expected, $sanitized );
     1657        }
     1658
     1659        public function _dp_rest_sanitize_array() {
     1660                return array(
     1661                        array(
     1662                                array(),
     1663                                '',
     1664                        ),
     1665                        array(
     1666                                array( 'a', 'b' ),
     1667                                array( 'a', 'b' ),
     1668                        ),
     1669                        array(
     1670                                array(),
     1671                                array(),
     1672                        ),
     1673                        array(
     1674                                array( 'a', 'b', 'c' ),
     1675                                'a,b,c',
     1676                        ),
     1677                        array(
     1678                                array( 'a' ),
     1679                                'a',
     1680                        ),
     1681                        array(
     1682                                array( 'a', 'b' ),
     1683                                'a,b,',
     1684                        ),
     1685                        array(
     1686                                array( '5' ),
     1687                                5,
     1688                        ),
     1689                        array(
     1690                                array(),
     1691                                new stdClass(),
     1692                        ),
     1693                        array(
     1694                                array(),
     1695                                new JsonSerializable_Object( array( 'hi' => 'there' ) ),
     1696                        ),
     1697                        array(
     1698                                array( 'there' ),
     1699                                array( 'hi' => 'there' ),
     1700                        ),
     1701                        array(
     1702                                array(),
     1703                                new Basic_Object(),
     1704                        ),
     1705                        array(
     1706                                array(),
     1707                                new JsonSerializable_Object( 'str' ),
     1708                        ),
     1709                        array(
     1710                                array(),
     1711                                null,
     1712                        ),
     1713                );
     1714        }
     1715
     1716        /**
     1717         * @dataProvider _dp_get_best_type_for_value
     1718         * @ticket 50300
     1719         * @param string $expected The expected best type.
     1720         * @param mixed  $value    The value to test.
     1721         * @param array  $types    The list of available types.
     1722         */
     1723        public function test_get_best_type_for_value( $expected, $value, $types ) {
     1724                $this->assertEquals( $expected, rest_get_best_type_for_value( $value, $types ) );
     1725        }
     1726
     1727        public function _dp_get_best_type_for_value() {
     1728                return array(
     1729                        array(
     1730                                'array',
     1731                                array( 'hi' ),
     1732                                array( 'array' ),
     1733                        ),
     1734                        array(
     1735                                'object',
     1736                                array( 'hi' => 'there' ),
     1737                                array( 'object' ),
     1738                        ),
     1739                        array(
     1740                                'integer',
     1741                                5,
     1742                                array( 'integer' ),
     1743                        ),
     1744                        array(
     1745                                'number',
     1746                                4.0,
     1747                                array( 'number' ),
     1748                        ),
     1749                        array(
     1750                                'boolean',
     1751                                true,
     1752                                array( 'boolean' ),
     1753                        ),
     1754                        array(
     1755                                'string',
     1756                                'str',
     1757                                array( 'string' ),
     1758                        ),
     1759                        array(
     1760                                'null',
     1761                                null,
     1762                                array( 'null' ),
     1763                        ),
     1764                        array(
     1765                                'string',
     1766                                '',
     1767                                array( 'array', 'string' ),
     1768                        ),
     1769                        array(
     1770                                'string',
     1771                                '',
     1772                                array( 'object', 'string' ),
     1773                        ),
     1774                        array(
     1775                                'string',
     1776                                'Hello',
     1777                                array( 'object', 'string' ),
     1778                        ),
     1779                        array(
     1780                                'object',
     1781                                array( 'hello' => 'world' ),
     1782                                array( 'object', 'string' ),
     1783                        ),
     1784                        array(
     1785                                'number',
     1786                                '5.0',
     1787                                array( 'number', 'string' ),
     1788                        ),
     1789                        array(
     1790                                'string',
     1791                                '5.0',
     1792                                array( 'string', 'number' ),
     1793                        ),
     1794                        array(
     1795                                'boolean',
     1796                                'false',
     1797                                array( 'boolean', 'string' ),
     1798                        ),
     1799                        array(
     1800                                'string',
     1801                                'false',
     1802                                array( 'string', 'boolean' ),
     1803                        ),
     1804                        array(
     1805                                'string',
     1806                                'a,b',
     1807                                array( 'string', 'array' ),
     1808                        ),
     1809                        array(
     1810                                'array',
     1811                                'a,b',
     1812                                array( 'array', 'string' ),
     1813                        ),
     1814                );
     1815        }
    14601816}

  • trunk/tests/phpunit/tests/rest-api/rest-schema-sanitization.php

    r48300 r48306  
    342342                $this->assertNull( rest_sanitize_value_from_schema( null, $schema ) );
    343343                $this->assertEquals( '2019-09-19T18:00:00', rest_sanitize_value_from_schema( '2019-09-19T18:00:00', $schema ) );
    344                 $this->assertNull( rest_sanitize_value_from_schema( 'lalala', $schema ) );
     344                $this->assertEquals( 'lalala', rest_sanitize_value_from_schema( 'lalala', $schema ) );
    345345        }
    346346
    … …  
    395395                $this->assertEquals( 'My Value', rest_sanitize_value_from_schema( 'My Value', $schema ) );
    396396                $this->assertEquals( array( 'raw' => 'My Value' ), rest_sanitize_value_from_schema( array( 'raw' => 'My Value' ), $schema ) );
    397                 $this->assertNull( rest_sanitize_value_from_schema( array( 'raw' => 1 ), $schema ) );
     397                $this->assertEquals( array( 'raw' => '1' ), rest_sanitize_value_from_schema( array( 'raw' => 1 ), $schema ) );
    398398        }
    399399
    … …  
    424424                $this->assertEquals( array( 'raw' => false ), rest_sanitize_value_from_schema( array( 'raw' => 0 ), $schema ) );
    425425
    426                 $this->assertNull( rest_sanitize_value_from_schema( array( 'raw' => 'something non boolean' ), $schema ) );
     426                $this->assertEquals( array( 'raw' => true ), rest_sanitize_value_from_schema( array( 'raw' => 'something non boolean' ), $schema ) );
     427        }
     428
     429        /**
     430         * @ticket 50300
     431         */
     432        public function test_multi_type_with_no_known_types() {
     433                $this->setExpectedIncorrectUsage( 'rest_handle_multi_type_schema' );
     434                $this->setExpectedIncorrectUsage( 'rest_sanitize_value_from_schema' );
     435
     436                $schema = array(
     437                        'type' => array( 'invalid', 'type' ),
     438                );
     439
     440                $this->assertEquals( 'My Value', rest_sanitize_value_from_schema( 'My Value', $schema ) );
     441        }
     442
     443        /**
     444         * @ticket 50300
     445         */
     446        public function test_multi_type_with_some_unknown_types() {
     447                $this->setExpectedIncorrectUsage( 'rest_handle_multi_type_schema' );
     448                $this->setExpectedIncorrectUsage( 'rest_sanitize_value_from_schema' );
     449
     450                $schema = array(
     451                        'type' => array( 'object', 'type' ),
     452                );
     453
     454                $this->assertEquals( 'My Value', rest_sanitize_value_from_schema( 'My Value', $schema ) );
     455        }
     456
     457        /**
     458         * @ticket 50300
     459         */
     460        public function test_multi_type_returns_null_if_no_valid_type() {
     461                $schema = array(
     462                        'type' => array( 'number', 'string' ),
     463                );
     464
     465                $this->assertNull( rest_sanitize_value_from_schema( array( 'Hello!' ), $schema ) );
    427466        }
    428467}

  • trunk/tests/phpunit/tests/rest-api/rest-schema-validation.php

    r48300 r48306  
    388388                $this->assertTrue( rest_validate_value_from_schema( null, $schema ) );
    389389                $this->assertTrue( rest_validate_value_from_schema( '2019-09-19T18:00:00', $schema ) );
    390                 $this->assertWPError( rest_validate_value_from_schema( 'some random string', $schema ) );
     390
     391                $error = rest_validate_value_from_schema( 'some random string', $schema );
     392                $this->assertWPError( $error );
     393                $this->assertEquals( 'Invalid date.', $error->get_error_message() );
    391394        }
    392395
    … …  
    403406                $this->assertTrue( rest_validate_value_from_schema( 'My Value', $schema ) );
    404407                $this->assertTrue( rest_validate_value_from_schema( array( 'raw' => 'My Value' ), $schema ) );
    405                 $this->assertWPError( rest_validate_value_from_schema( array( 'raw' => array( 'a list' ) ), $schema ) );
     408
     409                $error = rest_validate_value_from_schema( array( 'raw' => array( 'a list' ) ), $schema );
     410                $this->assertWPError( $error );
     411                $this->assertEquals( '[raw] is not of type string.', $error->get_error_message() );
     412        }
     413
     414        /**
     415         * @ticket 50300
     416         */
     417        public function test_null_or_integer() {
     418                $schema = array(
     419                        'type'    => array( 'null', 'integer' ),
     420                        'minimum' => 10,
     421                        'maximum' => 20,
     422                );
     423
     424                $this->assertTrue( rest_validate_value_from_schema( null, $schema ) );
     425                $this->assertTrue( rest_validate_value_from_schema( 15, $schema ) );
     426                $this->assertTrue( rest_validate_value_from_schema( '15', $schema ) );
     427
     428                $error = rest_validate_value_from_schema( 30, $schema, 'param' );
     429                $this->assertWPError( $error );
     430                $this->assertEquals( 'param must be between 10 (inclusive) and 20 (inclusive)', $error->get_error_message() );
     431        }
     432
     433        /**
     434         * @ticket 50300
     435         */
     436        public function test_multi_type_with_no_known_types() {
     437                $this->setExpectedIncorrectUsage( 'rest_handle_multi_type_schema' );
     438                $this->setExpectedIncorrectUsage( 'rest_validate_value_from_schema' );
     439
     440                $schema = array(
     441                        'type' => array( 'invalid', 'type' ),
     442                );
     443
     444                $this->assertTrue( rest_validate_value_from_schema( 'My Value', $schema ) );
     445        }
     446
     447        /**
     448         * @ticket 50300
     449         */
     450        public function test_multi_type_with_some_unknown_types() {
     451                $this->setExpectedIncorrectUsage( 'rest_handle_multi_type_schema' );
     452                $this->setExpectedIncorrectUsage( 'rest_validate_value_from_schema' );
     453
     454                $schema = array(
     455                        'type' => array( 'object', 'type' ),
     456                );
     457
     458                $this->assertTrue( rest_validate_value_from_schema( 'My Value', $schema ) );
    406459        }
    407460
Note: See TracChangeset for help on using the changeset viewer.