WordPress 4.0
[autoinstalls/wordpress.git] / wp-includes / taxonomy.php
index df209a50e14bab487b2e40579cfc49112ee06fdd..5846844631f49aaed2cdc9fa1841f9d7cbc1ed6f 100644 (file)
@@ -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[] = "<a href='" . esc_attr( get_term_link($term) ) . "'>$term->name</a>";
-
-               if ( $links )
-                       $taxonomies[$taxonomy] = wp_sprintf($t['template'], $t['label'], $links, $terms);
+               foreach ( $terms as $term ) {
+                       $links[] = "<a href='" . esc_attr( get_term_link( $term ) ) . "'>$term->name</a>";
+               }
+               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
+}