X-Git-Url: https://scripts.mit.edu/gitweb/autoinstalls/wordpress.git/blobdiff_plain/0461a5f2e55c8d5f1fde96ca2e83117152573c7d..9e77185fafaf4e60e2b73821e0e4b9b1a11fb85f:/wp-includes/taxonomy.php diff --git a/wp-includes/taxonomy.php b/wp-includes/taxonomy.php index df209a50..58468446 100644 --- a/wp-includes/taxonomy.php +++ b/wp-includes/taxonomy.php @@ -276,9 +276,9 @@ function is_taxonomy_hierarchical($taxonomy) { * - public - If the taxonomy should be publicly queryable; //@TODO not implemented. * * Defaults to true. * - hierarchical - Whether the taxonomy is hierarchical (e.g. category). Defaults to false. - * - show_ui -Whether to generate a default UI for managing this taxonomy in the admin. + * - show_ui - Whether to generate a default UI for managing this taxonomy in the admin. * * If not set, the default is inherited from public. - * - show_in_menu - Where to show the taxonomy in the admin menu. + * - show_in_menu - Whether to show the taxonomy in the admin menu. * * If true, the taxonomy is shown as a submenu of the object type menu. * * If false, no menu is shown. * * show_ui must be true. @@ -346,8 +346,10 @@ function register_taxonomy( $taxonomy, $object_type, $args = array() ) { ); $args = wp_parse_args( $args, $defaults ); - if ( strlen( $taxonomy ) > 32 ) + if ( strlen( $taxonomy ) > 32 ) { + _doing_it_wrong( __FUNCTION__, __( 'Taxonomies cannot exceed 32 characters in length' ), '4.0' ); return new WP_Error( 'taxonomy_too_long', __( 'Taxonomies cannot exceed 32 characters in length' ) ); + } if ( false !== $args['query_var'] && ! empty( $wp ) ) { if ( true === $args['query_var'] ) @@ -427,7 +429,7 @@ function register_taxonomy( $taxonomy, $object_type, $args = array() ) { * * @param string $taxonomy Taxonomy slug. * @param array|string $object_type Object type or array of object types. - * @param array|string $args Array or string of taxonomy registration arguments. + * @param array $args Array of taxonomy registration arguments. */ do_action( 'registered_taxonomy', $taxonomy, $object_type, $args ); } @@ -576,22 +578,22 @@ function unregister_taxonomy_for_object_type( $taxonomy, $object_type ) { function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) { global $wpdb; - if ( ! is_array( $term_ids ) ) + if ( ! is_array( $term_ids ) ) { $term_ids = array( $term_ids ); - - if ( ! is_array( $taxonomies ) ) + } + if ( ! is_array( $taxonomies ) ) { $taxonomies = array( $taxonomies ); - + } foreach ( (array) $taxonomies as $taxonomy ) { - if ( ! taxonomy_exists( $taxonomy ) ) + if ( ! taxonomy_exists( $taxonomy ) ) { return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) ); + } } $defaults = array( 'order' => 'ASC' ); $args = wp_parse_args( $args, $defaults ); - extract( $args, EXTR_SKIP ); - $order = ( 'desc' == strtolower( $order ) ) ? 'DESC' : 'ASC'; + $order = ( 'desc' == strtolower( $args['order'] ) ) ? 'DESC' : 'ASC'; $term_ids = array_map('intval', $term_ids ); @@ -600,9 +602,9 @@ function get_objects_in_term( $term_ids, $taxonomies, $args = array() ) { $object_ids = $wpdb->get_col("SELECT tr.object_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tt.term_id IN ($term_ids) ORDER BY tr.object_id $order"); - if ( ! $object_ids ) + if ( ! $object_ids ){ return array(); - + } return $object_ids; } @@ -632,15 +634,15 @@ class WP_Tax_Query { /** * List of taxonomy queries. A single taxonomy query is an associative array: - * - 'taxonomy' string The taxonomy being queried + * - 'taxonomy' string The taxonomy being queried. Optional when using the term_taxonomy_id field. * - 'terms' string|array The list of terms * - 'field' string (optional) Which term field is being used. - * Possible values: 'term_id', 'slug' or 'name' + * Possible values: 'term_id', 'slug', 'name', or 'term_taxonomy_id' * Default: 'term_id' * - 'operator' string (optional) * Possible values: 'AND', 'IN' or 'NOT IN'. * Default: 'IN' - * - 'include_children' bool (optional) Whether to include child terms. + * - 'include_children' bool (optional) Whether to include child terms. Requires that a taxonomy be specified. * Default: true * * @since 3.1.0 @@ -738,17 +740,20 @@ class WP_Tax_Query { foreach ( $this->queries as $index => $query ) { $this->clean_query( $query ); - if ( is_wp_error( $query ) ) + if ( is_wp_error( $query ) ) { return self::$no_results; + } - extract( $query ); + $terms = $query['terms']; + $operator = strtoupper( $query['operator'] ); if ( 'IN' == $operator ) { if ( empty( $terms ) ) { if ( 'OR' == $this->relation ) { - if ( ( $index + 1 === $count ) && empty( $where ) ) + if ( ( $index + 1 === $count ) && empty( $where ) ) { return self::$no_results; + } continue; } else { return self::$no_results; @@ -766,8 +771,9 @@ class WP_Tax_Query { $where[] = "$alias.term_taxonomy_id $operator ($terms)"; } elseif ( 'NOT IN' == $operator ) { - if ( empty( $terms ) ) + if ( empty( $terms ) ) { continue; + } $terms = implode( ',', $terms ); @@ -778,8 +784,9 @@ class WP_Tax_Query { )"; } elseif ( 'AND' == $operator ) { - if ( empty( $terms ) ) + if ( empty( $terms ) ) { continue; + } $num_terms = count( $terms ); @@ -796,11 +803,11 @@ class WP_Tax_Query { $i++; } - if ( ! empty( $where ) ) + if ( ! empty( $where ) ) { $where = ' AND ( ' . implode( " $this->relation ", $where ) . ' )'; - else + } else { $where = ''; - + } return compact( 'join', 'where' ); } @@ -813,7 +820,15 @@ class WP_Tax_Query { * @param array &$query The single query */ private function clean_query( &$query ) { - if ( ! taxonomy_exists( $query['taxonomy'] ) ) { + if ( empty( $query['taxonomy'] ) ) { + if ( 'term_taxonomy_id' !== $query['field'] ) { + $query = new WP_Error( 'Invalid taxonomy' ); + return; + } + + // so long as there are shared terms, include_children requires that a taxonomy is set + $query['include_children'] = false; + } elseif ( ! taxonomy_exists( $query['taxonomy'] ) ) { $query = new WP_Error( 'Invalid taxonomy' ); return; } @@ -1196,91 +1211,65 @@ function get_term_to_edit( $id, $taxonomy ) { * The 'get_terms_fields' filter passes the fields for the SELECT query * along with the $args array. * - * The list of arguments that $args can contain, which will overwrite the defaults: - * - * orderby - Default is 'name'. Can be name, count, term_group, slug or nothing - * (will use term_id), Passing a custom value other than these will cause it to - * order based on the custom value. - * - * order - Default is ASC. Can use DESC. - * - * hide_empty - Default is true. Will not return empty terms, which means - * terms whose count is 0 according to the given taxonomy. - * - * exclude - Default is an empty array. An array, comma- or space-delimited string - * of term ids to exclude from the return array. If 'include' is non-empty, - * 'exclude' is ignored. - * - * exclude_tree - Default is an empty array. An array, comma- or space-delimited - * string of term ids to exclude from the return array, along with all of their - * descendant terms according to the primary taxonomy. If 'include' is non-empty, - * 'exclude_tree' is ignored. - * - * include - Default is an empty array. An array, comma- or space-delimited string - * of term ids to include in the return array. - * - * number - The maximum number of terms to return. Default is to return them all. - * - * offset - The number by which to offset the terms query. - * - * fields - Default is 'all', which returns an array of term objects. - * If 'fields' is 'ids' or 'names', returns an array of - * integers or strings, respectively. - * - * slug - Returns terms whose "slug" matches this value. Default is empty string. - * - * hierarchical - Whether to include terms that have non-empty descendants - * (even if 'hide_empty' is set to true). - * - * search - Returned terms' names will contain the value of 'search', - * case-insensitive. Default is an empty string. - * - * name__like - Returned terms' names will contain the value of 'name__like', - * case-insensitive. Default is empty string. - * - * description__like - Returned terms' descriptions will contain the value of - * 'description__like', case-insensitive. Default is empty string. - * - * The argument 'pad_counts', if set to true will include the quantity of a term's - * children in the quantity of each term's "count" object variable. - * - * The 'get' argument, if set to 'all' instead of its default empty string, - * returns terms regardless of ancestry or whether the terms are empty. - * - * The 'child_of' argument, when used, should be set to the integer of a term ID. Its default - * is 0. If set to a non-zero value, all returned terms will be descendants - * of that term according to the given taxonomy. Hence 'child_of' is set to 0 - * if more than one taxonomy is passed in $taxonomies, because multiple taxonomies - * make term ancestry ambiguous. - * - * The 'parent' argument, when used, should be set to the integer of a term ID. Its default is - * the empty string '', which has a different meaning from the integer 0. - * If set to an integer value, all returned terms will have as an immediate - * ancestor the term whose ID is specified by that integer according to the given taxonomy. - * The 'parent' argument is different from 'child_of' in that a term X is considered a 'parent' - * of term Y only if term X is the father of term Y, not its grandfather or great-grandfather, etc. - * - * The 'cache_domain' argument enables a unique cache key to be produced when this query is stored - * in object cache. For instance, if you are using one of this function's filters to modify the - * query (such as 'terms_clauses'), setting 'cache_domain' to a unique value will not overwrite - * the cache for similar queries. Default value is 'core'. - * * @since 2.3.0 * - * @uses $wpdb - * @uses wp_parse_args() Merges the defaults with those defined by $args and allows for strings. + * @global wpdb $wpdb WordPress database access abstraction object. * - * @param string|array $taxonomies Taxonomy name or list of Taxonomy names - * @param string|array $args The values of what to search for when returning terms - * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies do not exist. + * @param string|array $taxonomies Taxonomy name or list of Taxonomy names. + * @param array|string $args { + * Optional. Array or string of arguments to get terms. + * + * @type string $orderby Field(s) to order terms by. Accepts term fields, though + * empty defaults to 'term_id'. Default 'name'. + * @type string $order Whether to order terms in ascending or descending order. + * Accepts 'ASC' (ascending) or 'DESC' (descending). + * Default 'ASC'. + * @type bool|int $hide_empty Whether to hide terms not assigned to any posts. Accepts + * 1|true or 0|false. Default 1|true. + * @type array|string $include Array or comma/space-separated string of term ids to include. + * Default empty array. + * @type array|string $exclude Array or comma/space-separated string of term ids to exclude. + * If $include is non-empty, $exclude is ignored. + * Default empty array. + * @type array|string $exclude_tree Array or comma/space-separated string of term ids to exclude + * along with all of their descendant terms. If $include is + * non-empty, $exclude_tree is ignored. Default empty array. + * @type int $number Maximum number of terms to return. Accepts 1+ or -1 (all). + * Default -1. + * @type int $offset The number by which to offset the terms query. Default empty. + * @type string $fields Term fields to query for. Accepts 'all' (returns an array of + * term objects), 'ids' or 'names' (returns an array of integers + * or strings, respectively. Default 'all'. + * @type string $slug Slug to return term(s) for. Default empty. + * @type bool $hierarchical Whether to include terms that have non-empty descendants (even + * if $hide_empty is set to true). Default true. + * @type string $search Search criteria to match terms. Will be SQL-formatted with + * wildcards before and after. Default empty. + * @type string $name__like Retrieve terms with criteria by which a term is LIKE $name__like. + * Default empty. + * @type string $description__like Retrieve terms where the description is LIKE $description__like. + * Default empty. + * @type bool $pad_counts Whether to pad the quantity of a term's children in the quantity + * of each term's "count" object variable. Default false. + * @type string $get Whether to return terms regardless of ancestry or whether the terms + * are empty. Accepts 'all' or empty (disabled). Default empty. + * @type int $child_of Term ID to retrieve child terms of. If multiple taxonomies + * are passed, $child_of is ignored. Default 0. + * @type int|string $parent Parent term ID to retrieve direct-child terms of. Default empty. + * @type string $cache_domain Unique cache key to be produced when this query is stored in an + * object cache. Default is 'core'. + * } + * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies + * do not exist. */ -function get_terms($taxonomies, $args = '') { +function get_terms( $taxonomies, $args = '' ) { global $wpdb; $empty_array = array(); $single_taxonomy = ! is_array( $taxonomies ) || 1 === count( $taxonomies ); - if ( ! is_array( $taxonomies ) ) + if ( ! is_array( $taxonomies ) ) { $taxonomies = array( $taxonomies ); + } foreach ( $taxonomies as $taxonomy ) { if ( ! taxonomy_exists($taxonomy) ) { @@ -1321,23 +1310,25 @@ function get_terms($taxonomies, $args = '') { */ $args = apply_filters( 'get_terms_args', $args, $taxonomies ); - extract($args, EXTR_SKIP); - + $child_of = $args['child_of']; if ( $child_of ) { $hierarchy = _get_term_hierarchy( reset( $taxonomies ) ); - if ( ! isset( $hierarchy[ $child_of ] ) ) + if ( ! isset( $hierarchy[ $child_of ] ) ) { return $empty_array; + } } + $parent = $args['parent']; if ( $parent ) { $hierarchy = _get_term_hierarchy( reset( $taxonomies ) ); - if ( ! isset( $hierarchy[ $parent ] ) ) + if ( ! isset( $hierarchy[ $parent ] ) ) { return $empty_array; + } } // $args can be whatever, only use the args defined in defaults to compute the key $filter_key = ( has_filter('list_terms_exclusions') ) ? serialize($GLOBALS['wp_filter']['list_terms_exclusions']) : ''; - $key = md5( serialize( compact(array_keys($defaults)) ) . serialize( $taxonomies ) . $filter_key ); + $key = md5( serialize( wp_array_slice_assoc( $args, array_keys( $defaults ) ) ) . serialize( $taxonomies ) . $filter_key ); $last_changed = wp_cache_get( 'last_changed', 'terms' ); if ( ! $last_changed ) { $last_changed = microtime(); @@ -1360,22 +1351,22 @@ function get_terms($taxonomies, $args = '') { return $cache; } - $_orderby = strtolower($orderby); - if ( 'count' == $_orderby ) + $_orderby = strtolower( $args['orderby'] ); + if ( 'count' == $_orderby ) { $orderby = 'tt.count'; - else if ( 'name' == $_orderby ) + } else if ( 'name' == $_orderby ) { $orderby = 't.name'; - else if ( 'slug' == $_orderby ) + } else if ( 'slug' == $_orderby ) { $orderby = 't.slug'; - else if ( 'term_group' == $_orderby ) + } else if ( 'term_group' == $_orderby ) { $orderby = 't.term_group'; - else if ( 'none' == $_orderby ) + } else if ( 'none' == $_orderby ) { $orderby = ''; - elseif ( empty($_orderby) || 'id' == $_orderby ) + } elseif ( empty($_orderby) || 'id' == $_orderby ) { $orderby = 't.term_id'; - else + } else { $orderby = 't.name'; - + } /** * Filter the ORDERBY clause of the terms query. * @@ -1387,16 +1378,23 @@ function get_terms($taxonomies, $args = '') { */ $orderby = apply_filters( 'get_terms_orderby', $orderby, $args, $taxonomies ); - if ( !empty($orderby) ) + $order = strtoupper( $args['order'] ); + if ( ! empty( $orderby ) ) { $orderby = "ORDER BY $orderby"; - else + } else { $order = ''; + } - $order = strtoupper( $order ); - if ( '' !== $order && !in_array( $order, array( 'ASC', 'DESC' ) ) ) + if ( '' !== $order && ! in_array( $order, array( 'ASC', 'DESC' ) ) ) { $order = 'ASC'; + } $where = "tt.taxonomy IN ('" . implode("', '", $taxonomies) . "')"; + + $exclude = $args['exclude']; + $exclude_tree = $args['exclude_tree']; + $include = $args['include']; + $inclusions = ''; if ( ! empty( $include ) ) { $exclude = ''; @@ -1409,7 +1407,6 @@ function get_terms($taxonomies, $args = '') { $where .= $inclusions; } - $exclusions = ''; if ( ! empty( $exclude_tree ) ) { $exclude_tree = wp_parse_id_list( $exclude_tree ); $excluded_children = $exclude_tree; @@ -1420,18 +1417,22 @@ function get_terms($taxonomies, $args = '') { ); } $exclusions = implode( ',', array_map( 'intval', $excluded_children ) ); + } else { + $exclusions = ''; } if ( ! empty( $exclude ) ) { $exterms = wp_parse_id_list( $exclude ); - if ( empty( $exclusions ) ) + if ( empty( $exclusions ) ) { $exclusions = implode( ',', $exterms ); - else + } else { $exclusions .= ', ' . implode( ',', $exterms ); + } } - if ( ! empty( $exclusions ) ) + if ( ! empty( $exclusions ) ) { $exclusions = ' AND t.term_id NOT IN (' . $exclusions . ')'; + } /** * Filter the terms to exclude from the terms query. @@ -1444,22 +1445,21 @@ function get_terms($taxonomies, $args = '') { */ $exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args, $taxonomies ); - if ( ! empty( $exclusions ) ) + if ( ! empty( $exclusions ) ) { $where .= $exclusions; + } - if ( !empty($slug) ) { - $slug = sanitize_title($slug); + if ( ! empty( $args['slug'] ) ) { + $slug = sanitize_title( $args['slug'] ); $where .= " AND t.slug = '$slug'"; } - if ( !empty($name__like) ) { - $name__like = like_escape( $name__like ); - $where .= $wpdb->prepare( " AND t.name LIKE %s", '%' . $name__like . '%' ); + if ( ! empty( $args['name__like'] ) ) { + $where .= $wpdb->prepare( " AND t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' ); } - if ( ! empty( $description__like ) ) { - $description__like = like_escape( $description__like ); - $where .= $wpdb->prepare( " AND tt.description LIKE %s", '%' . $description__like . '%' ); + if ( ! empty( $args['description__like'] ) ) { + $where .= $wpdb->prepare( " AND tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' ); } if ( '' !== $parent ) { @@ -1467,29 +1467,35 @@ function get_terms($taxonomies, $args = '') { $where .= " AND tt.parent = '$parent'"; } - if ( 'count' == $fields ) + $hierarchical = $args['hierarchical']; + if ( 'count' == $args['fields'] ) { $hierarchical = false; - - if ( $hide_empty && !$hierarchical ) + } + if ( $args['hide_empty'] && !$hierarchical ) { $where .= ' AND tt.count > 0'; + } + + $number = $args['number']; + $offset = $args['offset']; // don't limit the query results when we have to descend the family tree if ( $number && ! $hierarchical && ! $child_of && '' === $parent ) { - if ( $offset ) + if ( $offset ) { $limits = 'LIMIT ' . $offset . ',' . $number; - else + } else { $limits = 'LIMIT ' . $number; + } } else { $limits = ''; } - if ( ! empty( $search ) ) { - $search = like_escape( $search ); - $where .= $wpdb->prepare( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))', '%' . $search . '%', '%' . $search . '%' ); + if ( ! empty( $args['search'] ) ) { + $like = '%' . $wpdb->esc_like( $args['search'] ) . '%'; + $where .= $wpdb->prepare( ' AND ((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like ); } $selects = array(); - switch ( $fields ) { + switch ( $args['fields'] ) { case 'all': $selects = array( 't.*', 'tt.*' ); break; @@ -1513,7 +1519,7 @@ function get_terms($taxonomies, $args = '') { break; } - $_fields = $fields; + $_fields = $args['fields']; /** * Filter the fields to select in the terms query. @@ -1540,20 +1546,22 @@ function get_terms($taxonomies, $args = '') { * @param array $args An array of terms query arguments. */ $clauses = apply_filters( 'terms_clauses', compact( $pieces ), $taxonomies, $args ); - foreach ( $pieces as $piece ) - $$piece = isset( $clauses[ $piece ] ) ? $clauses[ $piece ] : ''; + $fields = isset( $clauses[ 'fields' ] ) ? $clauses[ 'fields' ] : ''; + $join = isset( $clauses[ 'join' ] ) ? $clauses[ 'join' ] : ''; + $where = isset( $clauses[ 'where' ] ) ? $clauses[ 'where' ] : ''; + $orderby = isset( $clauses[ 'orderby' ] ) ? $clauses[ 'orderby' ] : ''; + $order = isset( $clauses[ 'order' ] ) ? $clauses[ 'order' ] : ''; + $limits = isset( $clauses[ 'limits' ] ) ? $clauses[ 'limits' ] : ''; $query = "SELECT $fields FROM $wpdb->terms AS t $join WHERE $where $orderby $order $limits"; - $fields = $_fields; - - if ( 'count' == $fields ) { + if ( 'count' == $_fields ) { $term_count = $wpdb->get_var($query); return $term_count; } $terms = $wpdb->get_results($query); - if ( 'all' == $fields ) { + if ( 'all' == $_fields ) { update_term_cache($terms); } @@ -1567,16 +1575,17 @@ function get_terms($taxonomies, $args = '') { if ( $child_of ) { $children = _get_term_hierarchy( reset( $taxonomies ) ); - if ( ! empty( $children ) ) + if ( ! empty( $children ) ) { $terms = _get_term_children( $child_of, $terms, reset( $taxonomies ) ); + } } // Update term counts to include children. - if ( $pad_counts && 'all' == $fields ) + if ( $args['pad_counts'] && 'all' == $_fields ) { _pad_term_counts( $terms, reset( $taxonomies ) ); - + } // Make sure we show empty categories that have children. - if ( $hierarchical && $hide_empty && is_array( $terms ) ) { + if ( $hierarchical && $args['hide_empty'] && is_array( $terms ) ) { foreach ( $terms as $k => $term ) { if ( ! $term->count ) { $children = get_term_children( $term->term_id, reset( $taxonomies ) ); @@ -1597,28 +1606,35 @@ function get_terms($taxonomies, $args = '') { reset( $terms ); $_terms = array(); - if ( 'id=>parent' == $fields ) { - while ( $term = array_shift( $terms ) ) + if ( 'id=>parent' == $_fields ) { + while ( $term = array_shift( $terms ) ) { $_terms[$term->term_id] = $term->parent; - } elseif ( 'ids' == $fields ) { - while ( $term = array_shift( $terms ) ) + } + } elseif ( 'ids' == $_fields ) { + while ( $term = array_shift( $terms ) ) { $_terms[] = $term->term_id; - } elseif ( 'names' == $fields ) { - while ( $term = array_shift( $terms ) ) + } + } elseif ( 'names' == $_fields ) { + while ( $term = array_shift( $terms ) ) { $_terms[] = $term->name; - } elseif ( 'id=>name' == $fields ) { - while ( $term = array_shift( $terms ) ) + } + } elseif ( 'id=>name' == $_fields ) { + while ( $term = array_shift( $terms ) ) { $_terms[$term->term_id] = $term->name; - } elseif ( 'id=>slug' == $fields ) { - while ( $term = array_shift( $terms ) ) + } + } elseif ( 'id=>slug' == $_fields ) { + while ( $term = array_shift( $terms ) ) { $_terms[$term->term_id] = $term->slug; + } } - if ( ! empty( $_terms ) ) + if ( ! empty( $_terms ) ) { $terms = $_terms; + } - if ( $number && is_array( $terms ) && count( $terms ) > $number ) + if ( $number && is_array( $terms ) && count( $terms ) > $number ) { $terms = array_slice( $terms, $offset, $number ); + } wp_cache_add( $cache_key, $terms, 'terms', DAY_IN_SECONDS ); @@ -1640,7 +1656,8 @@ function get_terms($taxonomies, $args = '') { * @param string $taxonomy The taxonomy name to use * @param int $parent ID of parent term under which to confine the exists search. * @return mixed Returns 0 if the term does not exist. Returns the term ID if no taxonomy is specified - * and the term ID exists. Returns an array of the term ID and the taxonomy if the pairing exists. + * and the term ID exists. Returns an array of the term ID and the term taxonomy ID + * if the taxonomy is specified and the pairing exists. */ function term_exists($term, $taxonomy = '', $parent = 0) { global $wpdb; @@ -2028,12 +2045,16 @@ function wp_delete_term( $term, $taxonomy, $args = array() ) { } $args = wp_parse_args($args, $defaults); - extract($args, EXTR_SKIP); - if ( isset( $default ) ) { - $default = (int) $default; - if ( ! term_exists($default, $taxonomy) ) - unset($default); + if ( isset( $args['default'] ) ) { + $default = (int) $args['default']; + if ( ! term_exists( $default, $taxonomy ) ) { + unset( $default ); + } + } + + if ( isset( $args['force_default'] ) ) { + $force_default = $args['force_default']; } // Update children to point to new parent @@ -2224,7 +2245,9 @@ function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { $args = array_merge($args, $t->args); } - extract($args, EXTR_SKIP); + $orderby = $args['orderby']; + $order = $args['order']; + $fields = $args['fields']; if ( 'count' == $orderby ) $orderby = 'tt.count'; @@ -2271,6 +2294,7 @@ function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { $query = "SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON tt.term_id = t.term_id INNER JOIN $wpdb->term_relationships AS tr ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tt.taxonomy IN ($taxonomies) AND tr.object_id IN ($object_ids) $orderby $order"; + $objects = false; if ( 'all' == $fields || 'all_with_object_id' == $fields ) { $_terms = $wpdb->get_results( $query ); foreach ( $_terms as $key => $term ) { @@ -2278,6 +2302,7 @@ function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { } $terms = array_merge( $terms, $_terms ); update_term_cache( $terms ); + $objects = true; } else if ( 'ids' == $fields || 'names' == $fields || 'slugs' == $fields ) { $_terms = $wpdb->get_col( $query ); $_field = ( 'ids' == $fields ) ? 'term_id' : 'name'; @@ -2292,9 +2317,23 @@ function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { } } - if ( ! $terms ) + if ( ! $terms ) { $terms = array(); + } elseif ( $objects && 'all_with_object_id' !== $fields ) { + $_tt_ids = array(); + $_terms = array(); + foreach ( $terms as $term ) { + if ( in_array( $term->term_taxonomy_id, $_tt_ids ) ) { + continue; + } + $_tt_ids[] = $term->term_taxonomy_id; + $_terms[] = $term; + } + $terms = $_terms; + } elseif ( ! $objects ) { + $terms = array_values( array_unique( $terms ) ); + } /** * Filter the terms for a given object or objects. * @@ -2357,9 +2396,9 @@ function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { function wp_insert_term( $term, $taxonomy, $args = array() ) { global $wpdb; - if ( ! taxonomy_exists($taxonomy) ) + if ( ! taxonomy_exists($taxonomy) ) { return new WP_Error('invalid_taxonomy', __('Invalid taxonomy')); - + } /** * Filter a term before it is sanitized and inserted into the database. * @@ -2369,34 +2408,46 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { * @param string $taxonomy Taxonomy slug. */ $term = apply_filters( 'pre_insert_term', $term, $taxonomy ); - if ( is_wp_error( $term ) ) - return $term; - - if ( is_int($term) && 0 == $term ) + if ( is_wp_error( $term ) ) { + return $term; + } + if ( is_int($term) && 0 == $term ) { return new WP_Error('invalid_term_id', __('Invalid term ID')); - - if ( '' == trim($term) ) + } + if ( '' == trim($term) ) { return new WP_Error('empty_term_name', __('A name is required for this term')); - + } $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => ''); - $args = wp_parse_args($args, $defaults); + $args = wp_parse_args( $args, $defaults ); + + if ( $args['parent'] > 0 && ! term_exists( (int) $args['parent'] ) ) { + return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) ); + } $args['name'] = $term; $args['taxonomy'] = $taxonomy; $args = sanitize_term($args, $taxonomy, 'db'); - extract($args, EXTR_SKIP); // expected_slashed ($name) - $name = wp_unslash($name); - $description = wp_unslash($description); + $name = wp_unslash( $args['name'] ); + $description = wp_unslash( $args['description'] ); + $parent = (int) $args['parent']; - $slug_provided = ! empty( $slug ); + $slug_provided = ! empty( $args['slug'] ); if ( ! $slug_provided ) { - $slug = sanitize_title($name); + $_name = trim( $name ); + $existing_term = get_term_by( 'name', $_name, $taxonomy ); + if ( $existing_term ) { + $slug = $existing_term->slug; + } else { + $slug = sanitize_title( $name ); + } + } else { + $slug = $args['slug']; } $term_group = 0; - if ( $alias_of ) { - $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) ); + if ( $args['alias_of'] ) { + $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $args['alias_of'] ) ); if ( $alias->term_group ) { // The alias we want is already in a group, so let's use that one. $term_group = $alias->term_group; @@ -2432,7 +2483,7 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { // We've got an existing term in the same taxonomy, which matches the name of the new term: if ( is_taxonomy_hierarchical($taxonomy) && $existing_term['name'] == $name && $exists = term_exists( (int) $term_id, $taxonomy ) ) { // Hierarchical, and it matches an existing term, Do not allow same "name" in the same level. - $siblings = get_terms($taxonomy, array('fields' => 'names', 'get' => 'all', 'parent' => (int)$parent) ); + $siblings = get_terms($taxonomy, array('fields' => 'names', 'get' => 'all', 'parent' => $parent ) ); if ( in_array($name, $siblings) ) { if ( $slug_provided ) { return new WP_Error( 'term_exists', __( 'A term with the name and slug provided already exists with this parent.' ), $exists['term_id'] ); @@ -2441,15 +2492,17 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { } } else { $slug = wp_unique_term_slug($slug, (object) $args); - if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) + if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) { return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); + } $term_id = (int) $wpdb->insert_id; } } elseif ( $existing_term['name'] != $name ) { // We've got an existing term, with a different name, Create the new term. $slug = wp_unique_term_slug($slug, (object) $args); - if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) + if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) { return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); + } $term_id = (int) $wpdb->insert_id; } elseif ( $exists = term_exists( (int) $term_id, $taxonomy ) ) { // Same name, same slug. @@ -2458,8 +2511,9 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { } else { // This term does not exist at all in the database, Create it. $slug = wp_unique_term_slug($slug, (object) $args); - if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) + if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) { return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); + } $term_id = (int) $wpdb->insert_id; } @@ -2477,9 +2531,9 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { $tt_id = $wpdb->get_var( $wpdb->prepare( "SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d", $taxonomy, $term_id ) ); - if ( !empty($tt_id) ) + if ( !empty($tt_id) ) { return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id); - + } $wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent') + array( 'count' => 0 ) ); $tt_id = (int) $wpdb->insert_id; @@ -2554,14 +2608,14 @@ function wp_insert_term( $term, $taxonomy, $args = array() ) { * @since 2.3.0 * @uses wp_remove_object_terms() * - * @param int $object_id The object to relate to. - * @param array|int|string $terms The slug or id of the term, will replace all existing - * related terms in this taxonomy. - * @param array|string $taxonomy The context in which to relate the term to the object. - * @param bool $append If false will delete difference of terms. - * @return array|WP_Error Affected Term IDs + * @param int $object_id The object to relate to. + * @param array|int|string $terms A single term slug, single term id, or array of either term slugs or ids. + * Will replace all existing related terms in this taxonomy. + * @param array|string $taxonomy The context in which to relate the term to the object. + * @param bool $append Optional. If false will delete difference of terms. Default false. + * @return array|WP_Error Affected Term IDs. */ -function wp_set_object_terms($object_id, $terms, $taxonomy, $append = false) { +function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) { global $wpdb; $object_id = (int) $object_id; @@ -2881,23 +2935,31 @@ function wp_update_term( $term_id, $taxonomy, $args = array() ) { $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => ''); $args = wp_parse_args($args, $defaults); $args = sanitize_term($args, $taxonomy, 'db'); - extract($args, EXTR_SKIP); + $parsed_args = $args; // expected_slashed ($name) - $name = wp_unslash($name); - $description = wp_unslash($description); + $name = wp_unslash( $args['name'] ); + $description = wp_unslash( $args['description'] ); + + $parsed_args['name'] = $name; + $parsed_args['description'] = $description; if ( '' == trim($name) ) return new WP_Error('empty_term_name', __('A name is required for this term')); $empty_slug = false; - if ( empty($slug) ) { + if ( empty( $args['slug'] ) ) { $empty_slug = true; $slug = sanitize_title($name); + } else { + $slug = $args['slug']; } - if ( $alias_of ) { - $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) ); + $parsed_args['slug'] = $slug; + + $term_group = isset( $parsed_args['term_group'] ) ? $parsed_args['term_group'] : 0; + if ( $args['alias_of'] ) { + $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $args['alias_of'] ) ); if ( $alias->term_group ) { // The alias we want is already in a group, so let's use that one. $term_group = $alias->term_group; @@ -2912,6 +2974,8 @@ function wp_update_term( $term_id, $taxonomy, $args = array() ) { /** This action is documented in wp-includes/taxonomy.php */ do_action( 'edited_terms', $alias->term_id, $taxonomy ); } + + $parsed_args['term_group'] = $term_group; } /** @@ -2921,13 +2985,13 @@ function wp_update_term( $term_id, $taxonomy, $args = array() ) { * * @since 3.1.0 * - * @param int $parent ID of the parent term. - * @param int $term_id Term ID. - * @param string $taxonomy Taxonomy slug. - * @param array $args Compacted array of update arguments for the given term. - * @param array $args An array of update arguments for the given term. + * @param int $parent ID of the parent term. + * @param int $term_id Term ID. + * @param string $taxonomy Taxonomy slug. + * @param array $parsed_args An array of potentially altered update arguments for the given term. + * @param array $args An array of update arguments for the given term. */ - $parent = apply_filters( 'wp_update_term_parent', $parent, $term_id, $taxonomy, compact( array_keys( $args ) ), $args ); + $parent = apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args ); // Check for duplicate slug $id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms WHERE slug = %s", $slug ) ); @@ -3110,8 +3174,6 @@ function wp_update_term_count( $terms, $taxonomy, $do_deferred=false ) { * @return bool Always true when complete. */ function wp_update_term_count_now( $terms, $taxonomy ) { - global $wpdb; - $terms = array_map('intval', $terms); $taxonomy = get_taxonomy($taxonomy); @@ -3685,19 +3747,19 @@ function get_term_link( $term, $taxonomy = '') { * * @param array $args Override the defaults. */ -function the_taxonomies($args = array()) { +function the_taxonomies( $args = array() ) { $defaults = array( 'post' => 0, 'before' => '', 'sep' => ' ', 'after' => '', - 'template' => '%s: %l.' + /* translators: %s: taxonomy label, %l: list of term links */ + 'template' => __( '%s: %l.' ) ); $r = wp_parse_args( $args, $defaults ); - extract( $r, EXTR_SKIP ); - echo $before . join($sep, get_the_taxonomies($post, $r)) . $after; + echo $r['before'] . join( $r['sep'], get_the_taxonomies( $r['post'], $r ) ) . $r['after']; } /** @@ -3708,43 +3770,48 @@ function the_taxonomies($args = array()) { * * @since 2.5.0 * - * @param int|WP_Post $post Optional. Post ID or post object. + * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post. * @param array $args Override the defaults. - * @return array + * @return array List of taxonomies. */ -function get_the_taxonomies($post = 0, $args = array() ) { +function get_the_taxonomies( $post = 0, $args = array() ) { $post = get_post( $post ); $args = wp_parse_args( $args, array( - 'template' => '%s: %l.', + /* translators: %s: taxonomy label, %l: list of term links */ + 'template' => __( '%s: %l.' ), ) ); - extract( $args, EXTR_SKIP ); $taxonomies = array(); - if ( !$post ) + if ( ! $post ) { return $taxonomies; + } - foreach ( get_object_taxonomies($post) as $taxonomy ) { - $t = (array) get_taxonomy($taxonomy); - if ( empty($t['label']) ) + foreach ( get_object_taxonomies( $post ) as $taxonomy ) { + $t = (array) get_taxonomy( $taxonomy ); + if ( empty( $t['label'] ) ) { $t['label'] = $taxonomy; - if ( empty($t['args']) ) + } + if ( empty( $t['args'] ) ) { $t['args'] = array(); - if ( empty($t['template']) ) - $t['template'] = $template; - - $terms = get_object_term_cache($post->ID, $taxonomy); - if ( false === $terms ) - $terms = wp_get_object_terms($post->ID, $taxonomy, $t['args']); + } + if ( empty( $t['template'] ) ) { + $t['template'] = $args['template']; + } + $terms = get_object_term_cache( $post->ID, $taxonomy ); + if ( false === $terms ) { + $terms = wp_get_object_terms( $post->ID, $taxonomy, $t['args'] ); + } $links = array(); - foreach ( $terms as $term ) - $links[] = "$term->name"; - - if ( $links ) - $taxonomies[$taxonomy] = wp_sprintf($t['template'], $t['label'], $links, $terms); + foreach ( $terms as $term ) { + $links[] = "$term->name"; + } + if ( $links ) { + $taxonomies[$taxonomy] = wp_sprintf( $t['template'], $t['label'], $links, $terms ); + } } return $taxonomies; } @@ -3753,12 +3820,13 @@ function get_the_taxonomies($post = 0, $args = array() ) { * Retrieve all taxonomies of a post with just the names. * * @since 2.5.0 + * * @uses get_object_taxonomies() * - * @param int|WP_Post $post Optional. Post ID or post object. + * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post. * @return array */ -function get_post_taxonomies($post = 0) { +function get_post_taxonomies( $post = 0 ) { $post = get_post( $post ); return get_object_taxonomies($post); @@ -3931,4 +3999,4 @@ function wp_check_term_hierarchy_for_loops( $parent, $term_id, $taxonomy ) { wp_update_term( $loop_member, $taxonomy, array( 'parent' => 0 ) ); return $parent; -} \ No newline at end of file +}