WordPress.org

Make WordPress Core

Ticket #15242: 15242.2.diff

File 15242.2.diff, 48.4 KB (added by wpmuguru, 3 years ago)

patch after [16056]

  • wp-includes/taxonomy.php

     
    2121                'query_var' => 'category_name', 
    2222                'rewrite' => array( 
    2323                                        'hierarchical' => true, 
    24                                         'slug' => get_option('category_base') ? get_option('category_base') : 'category', 
    25                                         'with_front' => false), 
     24                                        'slug' => get_option( 'category_base' ) ? get_option( 'category_base' ) : 'category', 
     25                                        'with_front' => false 
     26                ), 
    2627                'public' => true, 
    2728                'show_ui' => true, 
    2829                '_builtin' => true, 
     
    3334                'update_count_callback' => '_update_post_term_count', 
    3435                'query_var' => 'tag', 
    3536                'rewrite' => array( 
    36                                         'slug' => get_option('tag_base') ? get_option('tag_base') : 'tag' , 
    37                                         'with_front' => false), 
     37                                        'slug' => get_option( 'tag_base' ) ? get_option( 'tag_base' ) : 'tag', 
     38                                        'with_front' => false 
     39                ), 
    3840                'public' => true, 
    3941                'show_ui' => true, 
    4042                '_builtin' => true, 
     
    5254                'show_ui' => false, 
    5355                '_builtin' => true, 
    5456                'show_in_nav_menus' => false, 
    55         ) ) ; 
     57        ) ); 
    5658 
    5759        register_taxonomy( 'link_category', 'link', array( 
    5860                'hierarchical' => false, 
     
    7577                'public' => false, 
    7678                'show_ui' => false, 
    7779                '_builtin' => true, 
    78         ) ) ; 
     80        ) ); 
    7981 
    80         register_taxonomy( 'post_format', array('post', 'page', 'attachment'), array( 
     82        register_taxonomy( 'post_format', array( 'post', 'page', 'attachment' ), array( 
    8183                'public' => false, 
    8284                'hierarchical' => false, 
    8385                'labels' => array( 
     
    8991                'show_ui' => false, 
    9092                '_builtin' => true, 
    9193                'show_in_nav_menus' => false, 
    92         ) ) ; 
     94        ) ); 
    9395} 
    9496add_action( 'init', 'create_initial_taxonomies', 0 ); // highest priority 
    9597 
     
    111113function get_taxonomies( $args = array(), $output = 'names', $operator = 'and' ) { 
    112114        global $wp_taxonomies; 
    113115 
    114         $field = ('names' == $output) ? 'name' : false; 
     116        $field = ( 'names' == $output ) ? 'name' : false; 
    115117 
    116         return wp_filter_object_list($wp_taxonomies, $args, $operator, $field); 
     118        return wp_filter_object_list( $wp_taxonomies, $args, $operator, $field ); 
    117119} 
    118120 
    119121 
     
    136138 * @param string $output The type of output to return, either taxonomy 'names' or 'objects'. 'names' is the default. 
    137139 * @return array The names of all taxonomy of $object_type. 
    138140 */ 
    139 function get_object_taxonomies($object, $output = 'names') { 
     141function get_object_taxonomies( $object, $output = 'names' ) { 
    140142        global $wp_taxonomies; 
    141143 
    142         if ( is_object($object) ) { 
     144        if ( is_object( $object ) ) { 
    143145                if ( $object->post_type == 'attachment' ) 
    144                         return get_attachment_taxonomies($object); 
     146                        return get_attachment_taxonomies( $object ); 
    145147                $object = $object->post_type; 
    146148        } 
    147149 
     
    149151 
    150152        $taxonomies = array(); 
    151153        foreach ( (array) $wp_taxonomies as $tax_name => $tax_obj ) { 
    152                 if ( array_intersect($object, (array) $tax_obj->object_type) ) { 
     154                if ( array_intersect( $object, (array) $tax_obj->object_type ) ) { 
    153155                        if ( 'names' == $output ) 
    154156                                $taxonomies[] = $tax_name; 
    155157                        else 
     
    223225 * @param string $taxonomy Name of taxonomy object 
    224226 * @return bool Whether the taxonomy is hierarchical 
    225227 */ 
    226 function is_taxonomy_hierarchical($taxonomy) { 
    227         if ( ! taxonomy_exists($taxonomy) ) 
     228function is_taxonomy_hierarchical( $taxonomy ) { 
     229        if ( ! taxonomy_exists( $taxonomy ) ) 
    228230                return false; 
    229231 
    230         $taxonomy = get_taxonomy($taxonomy); 
     232        $taxonomy = get_taxonomy( $taxonomy ); 
    231233        return $taxonomy->hierarchical; 
    232234} 
    233235 
     
    286288function register_taxonomy( $taxonomy, $object_type, $args = array() ) { 
    287289        global $wp_taxonomies, $wp_rewrite, $wp; 
    288290 
    289         if ( ! is_array($wp_taxonomies) ) 
     291        if ( ! is_array( $wp_taxonomies ) ) 
    290292                $wp_taxonomies = array(); 
    291293 
    292294        $defaults = array(      'hierarchical' => false, 
     
    301303                                                'capabilities' => array(), 
    302304                                                'show_in_nav_menus' => null, 
    303305                                        ); 
    304         $args = wp_parse_args($args, $defaults); 
     306        $args = wp_parse_args( $args, $defaults ); 
    305307 
    306         if ( false !== $args['query_var'] && !empty($wp) ) { 
     308        if ( false !== $args['query_var'] && !empty( $wp ) ) { 
    307309                if ( true === $args['query_var'] ) 
    308310                        $args['query_var'] = $taxonomy; 
    309                 $args['query_var'] = sanitize_title_with_dashes($args['query_var']); 
    310                 $wp->add_query_var($args['query_var']); 
     311                $args['query_var'] = sanitize_title_with_dashes( $args['query_var'] ); 
     312                $wp->add_query_var( $args['query_var'] ); 
    311313        } 
    312314 
    313         if ( false !== $args['rewrite'] && '' != get_option('permalink_structure') && !empty($wp_rewrite) ) { 
    314                 $args['rewrite'] = wp_parse_args($args['rewrite'], array( 
    315                         'slug' => sanitize_title_with_dashes($taxonomy), 
     315        if ( false !== $args['rewrite'] && '' != get_option( 'permalink_structure' ) && !empty( $wp_rewrite ) ) { 
     316                $args['rewrite'] = wp_parse_args( $args['rewrite'], array( 
     317                        'slug' => sanitize_title_with_dashes( $taxonomy ), 
    316318                        'with_front' => true, 
    317319                        'hierarchical' => false 
    318                 )); 
     320                ) ); 
    319321 
    320322                if ( $args['hierarchical'] && $args['rewrite']['hierarchical'] ) 
    321323                        $tag = '(.+?)'; 
    322324                else 
    323325                        $tag = '([^/]+)'; 
    324326 
    325                 $wp_rewrite->add_rewrite_tag("%$taxonomy%", $tag, $args['query_var'] ? "{$args['query_var']}=" : "taxonomy=$taxonomy&term="); 
    326                 $wp_rewrite->add_permastruct($taxonomy, "{$args['rewrite']['slug']}/%$taxonomy%", $args['rewrite']['with_front']); 
     327                $wp_rewrite->add_rewrite_tag( "%$taxonomy%", $tag, $args['query_var'] ? "{$args['query_var']}=" : "taxonomy=$taxonomy&term=" ); 
     328                $wp_rewrite->add_permastruct( $taxonomy, "{$args['rewrite']['slug']}/%$taxonomy%", $args['rewrite']['with_front'] ); 
    327329        } 
    328330 
    329         if ( is_null($args['show_ui']) ) 
     331        if ( is_null( $args['show_ui'] ) ) 
    330332                $args['show_ui'] = $args['public']; 
    331333 
    332334        // Whether to show this type in nav-menus.php. Defaults to the setting for public. 
    333335        if ( null === $args['show_in_nav_menus'] ) 
    334336                $args['show_in_nav_menus'] = $args['public']; 
    335337 
    336         if ( is_null($args['show_tagcloud']) ) 
     338        if ( is_null( $args['show_tagcloud'] ) ) 
    337339                $args['show_tagcloud'] = $args['show_ui']; 
    338340 
    339341        $default_caps = array( 
     
    354356        $wp_taxonomies[$taxonomy] = (object) $args; 
    355357 
    356358        // register callback handling for metabox 
    357         add_filter('wp_ajax_add-' . $taxonomy, '_wp_ajax_add_hierarchical_term'); 
     359        add_filter( 'wp_ajax_add-' . $taxonomy, '_wp_ajax_add_hierarchical_term' ); 
    358360} 
    359361 
    360362/** 
     
    419421 * @param array|string $object_type Name of the object type 
    420422 * @return bool True if successful, false if not 
    421423 */ 
    422 function register_taxonomy_for_object_type( $taxonomy, $object_type) { 
     424function register_taxonomy_for_object_type( $taxonomy, $object_type ) { 
    423425        global $wp_taxonomies; 
    424426 
    425         if ( !isset($wp_taxonomies[$taxonomy]) ) 
     427        if ( !isset( $wp_taxonomies[$taxonomy] ) ) 
    426428                return false; 
    427429 
    428         if ( ! get_post_type_object($object_type) ) 
     430        if ( ! get_post_type_object( $object_type ) ) 
    429431                return false; 
    430432 
    431433        $wp_taxonomies[$taxonomy]->object_type[] = $object_type; 
     
    536538                        foreach ( $terms as $i => $term ) { 
    537539                                $terms[$i] = sanitize_title_for_query( $term ); 
    538540                        } 
    539                         $terms = array_filter($terms); 
     541                        $terms = array_filter( $terms ); 
    540542 
    541543                        $terms = "'" . implode( "','", $terms ) . "'"; 
    542544                        $sql = " 
     
    593595 * @return mixed|null|WP_Error Term Row from database. Will return null if $term is empty. If taxonomy does not 
    594596 * exist then WP_Error will be returned. 
    595597 */ 
    596 function &get_term($term, $taxonomy, $output = OBJECT, $filter = 'raw') { 
     598function &get_term( $term, $taxonomy, $output = OBJECT, $filter = 'raw' ) { 
    597599        global $wpdb; 
    598600        $null = null; 
    599601 
    600         if ( empty($term) ) { 
    601                 $error = new WP_Error('invalid_term', __('Empty Term')); 
     602        if ( empty( $term ) ) { 
     603                $error = new WP_Error( 'invalid_term', __( 'Empty Term' ) ); 
    602604                return $error; 
    603605        } 
    604606 
    605         if ( ! taxonomy_exists($taxonomy) ) { 
    606                 $error = new WP_Error('invalid_taxonomy', __('Invalid Taxonomy')); 
     607        if ( ! taxonomy_exists( $taxonomy ) ) { 
     608                $error = new WP_Error( 'invalid_taxonomy', __( 'Invalid Taxonomy' ) ); 
    607609                return $error; 
    608610        } 
    609611 
    610         if ( is_object($term) && empty($term->filter) ) { 
    611                 wp_cache_add($term->term_id, $term, $taxonomy); 
     612        if ( is_object( $term ) && empty( $term->filter ) ) { 
     613                wp_cache_add( $term->term_id, $term, $taxonomy ); 
    612614                $_term = $term; 
    613615        } else { 
    614                 if ( is_object($term) ) 
     616                if ( is_object( $term ) ) 
    615617                        $term = $term->term_id; 
    616618                $term = (int) $term; 
    617                 if ( ! $_term = wp_cache_get($term, $taxonomy) ) { 
    618                         $_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND t.term_id = %s LIMIT 1", $taxonomy, $term) ); 
     619                if ( ! $_term = wp_cache_get( $term, $taxonomy ) ) { 
     620                        $_term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND t.term_id = %s LIMIT 1", $taxonomy, $term ) ); 
    619621                        if ( ! $_term ) 
    620622                                return $null; 
    621                         wp_cache_add($term, $_term, $taxonomy); 
     623                        wp_cache_add( $term, $_term, $taxonomy ); 
    622624                } 
    623625        } 
    624626 
    625         $_term = apply_filters('get_term', $_term, $taxonomy); 
    626         $_term = apply_filters("get_$taxonomy", $_term, $taxonomy); 
    627         $_term = sanitize_term($_term, $taxonomy, $filter); 
     627        $_term = apply_filters( 'get_term', $_term, $taxonomy ); 
     628        $_term = apply_filters( "get_$taxonomy", $_term, $taxonomy ); 
     629        $_term = sanitize_term( $_term, $taxonomy, $filter ); 
    628630 
    629631        if ( $output == OBJECT ) { 
    630632                return $_term; 
    631633        } elseif ( $output == ARRAY_A ) { 
    632                 $__term = get_object_vars($_term); 
     634                $__term = get_object_vars( $_term ); 
    633635                return $__term; 
    634636        } elseif ( $output == ARRAY_N ) { 
    635                 $__term = array_values(get_object_vars($_term)); 
     637                $__term = array_values( get_object_vars( $_term ) ); 
    636638                return $__term; 
    637639        } else { 
    638640                return $_term; 
     
    666668 * @param string $filter Optional, default is raw or no WordPress defined filter will applied. 
    667669 * @return mixed Term Row from database. Will return false if $taxonomy does not exist or $term was not found. 
    668670 */ 
    669 function get_term_by($field, $value, $taxonomy, $output = OBJECT, $filter = 'raw') { 
     671function get_term_by( $field, $value, $taxonomy, $output = OBJECT, $filter = 'raw' ) { 
    670672        global $wpdb; 
    671673 
    672         if ( ! taxonomy_exists($taxonomy) ) 
     674        if ( ! taxonomy_exists( $taxonomy ) ) 
    673675                return false; 
    674676 
    675677        if ( 'slug' == $field ) { 
    676678                $field = 't.slug'; 
    677                 $value = sanitize_title($value); 
    678                 if ( empty($value) ) 
     679                $value = sanitize_title( $value ); 
     680                if ( empty( $value ) ) 
    679681                        return false; 
    680682        } else if ( 'name' == $field ) { 
    681683                // Assume already escaped 
    682                 $value = stripslashes($value); 
     684                $value = stripslashes( $value ); 
    683685                $field = 't.name'; 
    684686        } else { 
    685                 return get_term( (int) $value, $taxonomy, $output, $filter); 
     687                return get_term( (int) $value, $taxonomy, $output, $filter ); 
    686688        } 
    687689 
    688         $term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND $field = %s LIMIT 1", $taxonomy, $value) ); 
     690        $term = $wpdb->get_row( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy = %s AND $field = %s LIMIT 1", $taxonomy, $value ) ); 
    689691        if ( !$term ) 
    690692                return false; 
    691693 
    692         wp_cache_add($term->term_id, $term, $taxonomy); 
     694        wp_cache_add( $term->term_id, $term, $taxonomy ); 
    693695 
    694         $term = apply_filters('get_term', $term, $taxonomy); 
    695         $term = apply_filters("get_$taxonomy", $term, $taxonomy); 
    696         $term = sanitize_term($term, $taxonomy, $filter); 
     696        $term = apply_filters( 'get_term', $term, $taxonomy ); 
     697        $term = apply_filters( "get_$taxonomy", $term, $taxonomy ); 
     698        $term = sanitize_term( $term, $taxonomy, $filter ); 
    697699 
    698700        if ( $output == OBJECT ) { 
    699701                return $term; 
    700702        } elseif ( $output == ARRAY_A ) { 
    701                 return get_object_vars($term); 
     703                return get_object_vars( $term ); 
    702704        } elseif ( $output == ARRAY_N ) { 
    703                 return array_values(get_object_vars($term)); 
     705                return array_values( get_object_vars( $term ) ); 
    704706        } else { 
    705707                return $term; 
    706708        } 
     
    727729 * @return array|WP_Error List of Term Objects. WP_Error returned if $taxonomy does not exist 
    728730 */ 
    729731function get_term_children( $term_id, $taxonomy ) { 
    730         if ( ! taxonomy_exists($taxonomy) ) 
    731                 return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy')); 
     732        if ( ! taxonomy_exists( $taxonomy ) ) 
     733                return new WP_Error( 'invalid_taxonomy', __( 'Invalid Taxonomy' ) ); 
    732734 
    733735        $term_id = intval( $term_id ); 
    734736 
    735         $terms = _get_term_hierarchy($taxonomy); 
     737        $terms = _get_term_hierarchy( $taxonomy ); 
    736738 
    737         if ( ! isset($terms[$term_id]) ) 
     739        if ( ! isset( $terms[$term_id] ) ) 
    738740                return array(); 
    739741 
    740742        $children = $terms[$term_id]; 
    741743 
    742744        foreach ( (array) $terms[$term_id] as $child ) { 
    743                 if ( isset($terms[$child]) ) 
    744                         $children = array_merge($children, get_term_children($child, $taxonomy)); 
     745                if ( isset( $terms[$child] ) ) 
     746                        $children = array_merge( $children, get_term_children( $child, $taxonomy ) ); 
    745747        } 
    746748 
    747749        return $children; 
     
    769771function get_term_field( $field, $term, $taxonomy, $context = 'display' ) { 
    770772        $term = (int) $term; 
    771773        $term = get_term( $term, $taxonomy ); 
    772         if ( is_wp_error($term) ) 
     774        if ( is_wp_error( $term ) ) 
    773775                return $term; 
    774776 
    775         if ( !is_object($term) ) 
     777        if ( !is_object( $term ) ) 
    776778                return ''; 
    777779 
    778         if ( !isset($term->$field) ) 
     780        if ( !isset( $term->$field ) ) 
    779781                return ''; 
    780782 
    781         return sanitize_term_field($field, $term->$field, $term->term_id, $taxonomy, $context); 
     783        return sanitize_term_field( $field, $term->$field, $term->term_id, $taxonomy, $context ); 
    782784} 
    783785 
    784786/** 
     
    800802function get_term_to_edit( $id, $taxonomy ) { 
    801803        $term = get_term( $id, $taxonomy ); 
    802804 
    803         if ( is_wp_error($term) ) 
     805        if ( is_wp_error( $term ) ) 
    804806                return $term; 
    805807 
    806         if ( !is_object($term) ) 
     808        if ( !is_object( $term ) ) 
    807809                return ''; 
    808810 
    809         return sanitize_term($term, $taxonomy, 'edit'); 
     811        return sanitize_term( $term, $taxonomy, 'edit' ); 
    810812} 
    811813 
    812814/** 
     
    901903 * @param string|array $args The values of what to search for when returning terms 
    902904 * @return array|WP_Error List of Term Objects and their children. Will return WP_Error, if any of $taxonomies do not exist. 
    903905 */ 
    904 function &get_terms($taxonomies, $args = '') { 
     906function &get_terms( $taxonomies, $args = '' ) { 
    905907        global $wpdb; 
    906908        $empty_array = array(); 
    907909 
    908910        $single_taxonomy = false; 
    909         if ( !is_array($taxonomies) ) { 
     911        if ( !is_array( $taxonomies ) ) { 
    910912                $single_taxonomy = true; 
    911                 $taxonomies = array($taxonomies); 
     913                $taxonomies = array( $taxonomies ); 
    912914        } 
    913915 
    914916        foreach ( (array) $taxonomies as $taxonomy ) { 
    915                 if ( ! taxonomy_exists($taxonomy) ) { 
    916                         $error = & new WP_Error('invalid_taxonomy', __('Invalid Taxonomy')); 
     917                if ( ! taxonomy_exists( $taxonomy ) ) { 
     918                        $error = & new WP_Error( 'invalid_taxonomy', __( 'Invalid Taxonomy' ) ); 
    917919                        return $error; 
    918920                } 
    919921        } 
    920922 
    921         $in_taxonomies = "'" . implode("', '", $taxonomies) . "'"; 
     923        $in_taxonomies = "'" . implode( "', '", $taxonomies ) . "'"; 
    922924 
    923         $defaults = array('orderby' => 'name', 'order' => 'ASC', 
     925        $defaults = array( 'orderby' => 'name', 'order' => 'ASC', 
    924926                'hide_empty' => true, 'exclude' => array(), 'exclude_tree' => array(), 'include' => array(), 
    925927                'number' => '', 'fields' => 'all', 'slug' => '', 'parent' => '', 
    926928                'hierarchical' => true, 'child_of' => 0, 'get' => '', 'name__like' => '', 
    927                 'pad_counts' => false, 'offset' => '', 'search' => ''); 
     929                'pad_counts' => false, 'offset' => '', 'search' => '' 
     930        ); 
    928931        $args = wp_parse_args( $args, $defaults ); 
    929932        $args['number'] = absint( $args['number'] ); 
    930933        $args['offset'] = absint( $args['offset'] ); 
    931         if ( !$single_taxonomy || !is_taxonomy_hierarchical($taxonomies[0]) || 
     934        if ( !$single_taxonomy || !is_taxonomy_hierarchical( $taxonomies[0] ) || 
    932935                '' !== $args['parent'] ) { 
    933936                $args['child_of'] = 0; 
    934937                $args['hierarchical'] = false; 
     
    941944                $args['hierarchical'] = false; 
    942945                $args['pad_counts'] = false; 
    943946        } 
    944         extract($args, EXTR_SKIP); 
     947        extract( $args, EXTR_SKIP ); 
    945948 
    946949        if ( $child_of ) { 
    947                 $hierarchy = _get_term_hierarchy($taxonomies[0]); 
    948                 if ( !isset($hierarchy[$child_of]) ) 
     950                $hierarchy = _get_term_hierarchy( $taxonomies[0] ); 
     951                if ( !isset( $hierarchy[$child_of] ) ) 
    949952                        return $empty_array; 
    950953        } 
    951954 
    952955        if ( $parent ) { 
    953                 $hierarchy = _get_term_hierarchy($taxonomies[0]); 
    954                 if ( !isset($hierarchy[$parent]) ) 
     956                $hierarchy = _get_term_hierarchy( $taxonomies[0] ); 
     957                if ( !isset( $hierarchy[$parent] ) ) 
    955958                        return $empty_array; 
    956959        } 
    957960 
    958961        // $args can be whatever, only use the args defined in defaults to compute the key 
    959         $filter_key = ( has_filter('list_terms_exclusions') ) ? serialize($GLOBALS['wp_filter']['list_terms_exclusions']) : ''; 
    960         $key = md5( serialize( compact(array_keys($defaults)) ) . serialize( $taxonomies ) . $filter_key ); 
    961         $last_changed = wp_cache_get('last_changed', 'terms'); 
     962        $filter_key = ( has_filter( 'list_terms_exclusions' ) ) ? serialize( $GLOBALS['wp_filter']['list_terms_exclusions'] ) : ''; 
     963        $key = md5( serialize( compact( array_keys( $defaults ) ) ) . serialize( $taxonomies ) . $filter_key ); 
     964        $last_changed = wp_cache_get( 'last_changed', 'terms' ); 
    962965        if ( !$last_changed ) { 
    963966                $last_changed = time(); 
    964                 wp_cache_set('last_changed', $last_changed, 'terms'); 
     967                wp_cache_set( 'last_changed', $last_changed, 'terms' ); 
    965968        } 
    966969        $cache_key = "get_terms:$key:$last_changed"; 
    967970        $cache = wp_cache_get( $cache_key, 'terms' ); 
    968971        if ( false !== $cache ) { 
    969                 $cache = apply_filters('get_terms', $cache, $taxonomies, $args); 
     972                $cache = apply_filters( 'get_terms', $cache, $taxonomies, $args ); 
    970973                return $cache; 
    971974        } 
    972975 
    973         $_orderby = strtolower($orderby); 
     976        $_orderby = strtolower( $orderby ); 
    974977        if ( 'count' == $_orderby ) 
    975978                $orderby = 'tt.count'; 
    976979        else if ( 'name' == $_orderby ) 
     
    981984                $orderby = 't.term_group'; 
    982985        else if ( 'none' == $_orderby ) 
    983986                $orderby = ''; 
    984         elseif ( empty($_orderby) || 'id' == $_orderby ) 
     987        elseif ( empty( $_orderby ) || 'id' == $_orderby ) 
    985988                $orderby = 't.term_id'; 
    986989 
    987990        $orderby = apply_filters( 'get_terms_orderby', $orderby, $args ); 
    988991 
    989         if ( !empty($orderby) ) 
     992        if ( !empty( $orderby ) ) 
    990993                $orderby = "ORDER BY $orderby"; 
    991994        else 
    992995                $order = ''; 
    993996 
    994997        $where = ''; 
    995998        $inclusions = ''; 
    996         if ( !empty($include) ) { 
     999        if ( !empty( $include ) ) { 
    9971000                $exclude = ''; 
    9981001                $exclude_tree = ''; 
    999                 $interms = wp_parse_id_list($include); 
     1002                $interms = wp_parse_id_list( $include ); 
    10001003                foreach ( $interms as $interm ) { 
    1001                         if ( empty($inclusions) ) 
    1002                                 $inclusions = ' AND ( t.term_id = ' . intval($interm) . ' '; 
     1004                        if ( empty( $inclusions ) ) 
     1005                                $inclusions = ' AND ( t.term_id = ' . intval( $interm ) . ' '; 
    10031006                        else 
    1004                                 $inclusions .= ' OR t.term_id = ' . intval($interm) . ' '; 
     1007                                $inclusions .= ' OR t.term_id = ' . intval( $interm ) . ' '; 
    10051008                } 
    10061009        } 
    10071010 
    1008         if ( !empty($inclusions) ) 
     1011        if ( !empty( $inclusions ) ) 
    10091012                $inclusions .= ')'; 
    10101013        $where .= $inclusions; 
    10111014 
    10121015        $exclusions = ''; 
    10131016        if ( !empty( $exclude_tree ) ) { 
    1014                 $excluded_trunks = wp_parse_id_list($exclude_tree); 
     1017                $excluded_trunks = wp_parse_id_list( $exclude_tree ); 
    10151018                foreach ( $excluded_trunks as $extrunk ) { 
    1016                         $excluded_children = (array) get_terms($taxonomies[0], array('child_of' => intval($extrunk), 'fields' => 'ids', 'hide_empty' => 0)); 
     1019                        $excluded_children = (array) get_terms( $taxonomies[0], array( 'child_of' => intval( $extrunk ), 'fields' => 'ids', 'hide_empty' => 0 ) ); 
    10171020                        $excluded_children[] = $extrunk; 
    10181021                        foreach( $excluded_children as $exterm ) { 
    1019                                 if ( empty($exclusions) ) 
    1020                                         $exclusions = ' AND ( t.term_id <> ' . intval($exterm) . ' '; 
     1022                                if ( empty( $exclusions ) ) 
     1023                                        $exclusions = ' AND ( t.term_id <> ' . intval( $exterm ) . ' '; 
    10211024                                else 
    1022                                         $exclusions .= ' AND t.term_id <> ' . intval($exterm) . ' '; 
     1025                                        $exclusions .= ' AND t.term_id <> ' . intval( $exterm ) . ' '; 
    10231026                        } 
    10241027                } 
    10251028        } 
    10261029 
    1027         if ( !empty($exclude) ) { 
    1028                 $exterms = wp_parse_id_list($exclude); 
     1030        if ( !empty( $exclude ) ) { 
     1031                $exterms = wp_parse_id_list( $exclude ); 
    10291032                foreach ( $exterms as $exterm ) { 
    1030                         if ( empty($exclusions) ) 
    1031                                 $exclusions = ' AND ( t.term_id <> ' . intval($exterm) . ' '; 
     1033                        if ( empty( $exclusions ) ) 
     1034                                $exclusions = ' AND ( t.term_id <> ' . intval( $exterm ) . ' '; 
    10321035                        else 
    1033                                 $exclusions .= ' AND t.term_id <> ' . intval($exterm) . ' '; 
     1036                                $exclusions .= ' AND t.term_id <> ' . intval( $exterm ) . ' '; 
    10341037                } 
    10351038        } 
    10361039 
    1037         if ( !empty($exclusions) ) 
     1040        if ( !empty( $exclusions ) ) 
    10381041                $exclusions .= ')'; 
    1039         $exclusions = apply_filters('list_terms_exclusions', $exclusions, $args ); 
     1042        $exclusions = apply_filters( 'list_terms_exclusions', $exclusions, $args ); 
    10401043        $where .= $exclusions; 
    10411044 
    1042         if ( !empty($slug) ) { 
    1043                 $slug = sanitize_title($slug); 
     1045        if ( !empty( $slug ) ) { 
     1046                $slug = sanitize_title( $slug ); 
    10441047                $where .= " AND t.slug = '$slug'"; 
    10451048        } 
    10461049 
    1047         if ( !empty($name__like) ) 
     1050        if ( !empty( $name__like ) ) 
    10481051                $where .= " AND t.name LIKE '{$name__like}%'"; 
    10491052 
    10501053        if ( '' !== $parent ) { 
     
    10561059                $where .= ' AND tt.count > 0'; 
    10571060 
    10581061        // don't limit the query results when we have to descend the family tree 
    1059         if ( ! empty($number) && ! $hierarchical && empty( $child_of ) && '' === $parent ) { 
     1062        if ( ! empty( $number ) && ! $hierarchical && empty( $child_of ) && '' === $parent ) { 
    10601063                if ( $offset ) 
    10611064                        $limit = 'LIMIT ' . $offset . ',' . $number; 
    10621065                else 
     
    10651068                $limit = ''; 
    10661069        } 
    10671070 
    1068         if ( !empty($search) ) { 
    1069                 $search = like_escape($search); 
     1071        if ( !empty( $search ) ) { 
     1072                $search = like_escape( $search ); 
    10701073                $where .= " AND (t.name LIKE '%$search%')"; 
    10711074        } 
    10721075 
    10731076        $selects = array(); 
    10741077        switch ( $fields ) { 
    10751078                case 'all': 
    1076                         $selects = array('t.*', 'tt.*'); 
     1079                        $selects = array( 't.*', 'tt.*' ); 
    10771080                        break; 
    10781081                case 'ids': 
    10791082                case 'id=>parent': 
    1080                         $selects = array('t.term_id', 'tt.parent', 'tt.count'); 
     1083                        $selects = array( 't.term_id', 'tt.parent', 'tt.count' ); 
    10811084                        break; 
    10821085                case 'names': 
    1083                         $selects = array('t.term_id', 'tt.parent', 'tt.count', 't.name'); 
     1086                        $selects = array( 't.term_id', 'tt.parent', 'tt.count', 't.name' ); 
    10841087                        break; 
    10851088                case 'count': 
    10861089                        $orderby = ''; 
    10871090                        $order = ''; 
    1088                         $selects = array('COUNT(*)'); 
     1091                        $selects = array( 'COUNT(*)' ); 
    10891092        } 
    1090         $select_this = implode(', ', apply_filters( 'get_terms_fields', $selects, $args )); 
     1093        $select_this = implode( ', ', apply_filters( 'get_terms_fields', $selects, $args ) ); 
    10911094 
    10921095        $query = "SELECT $select_this FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE tt.taxonomy IN ($in_taxonomies) $where $orderby $order $limit"; 
    10931096 
    10941097        if ( 'count' == $fields ) { 
    1095                 $term_count = $wpdb->get_var($query); 
     1098                $term_count = $wpdb->get_var( $query ); 
    10961099                return $term_count; 
    10971100        } 
    10981101 
    1099         $terms = $wpdb->get_results($query); 
     1102        $terms = $wpdb->get_results( $query ); 
    11001103        if ( 'all' == $fields ) { 
    1101                 update_term_cache($terms); 
     1104                update_term_cache( $terms ); 
    11021105        } 
    11031106 
    1104         if ( empty($terms) ) { 
     1107        if ( empty( $terms ) ) { 
    11051108                wp_cache_add( $cache_key, array(), 'terms', 86400 ); // one day 
    1106                 $terms = apply_filters('get_terms', array(), $taxonomies, $args); 
     1109                $terms = apply_filters( 'get_terms', array(), $taxonomies, $args ); 
    11071110                return $terms; 
    11081111        } 
    11091112 
    11101113        if ( $child_of ) { 
    1111                 $children = _get_term_hierarchy($taxonomies[0]); 
    1112                 if ( ! empty($children) ) 
    1113                         $terms = & _get_term_children($child_of, $terms, $taxonomies[0]); 
     1114                $children = _get_term_hierarchy( $taxonomies[0] ); 
     1115                if ( ! empty( $children ) ) 
     1116                        $terms = & _get_term_children( $child_of, $terms, $taxonomies[0] ); 
    11141117        } 
    11151118 
    11161119        // Update term counts to include children. 
    11171120        if ( $pad_counts && 'all' == $fields ) 
    1118                 _pad_term_counts($terms, $taxonomies[0]); 
     1121                _pad_term_counts( $terms, $taxonomies[0] ); 
    11191122 
    11201123        // Make sure we show empty categories that have children. 
    1121         if ( $hierarchical && $hide_empty && is_array($terms) ) { 
     1124        if ( $hierarchical && $hide_empty && is_array( $terms ) ) { 
    11221125                foreach ( $terms as $k => $term ) { 
    11231126                        if ( ! $term->count ) { 
    1124                                 $children = _get_term_children($term->term_id, $terms, $taxonomies[0]); 
    1125                                 if ( is_array($children) ) 
     1127                                $children = _get_term_children( $term->term_id, $terms, $taxonomies[0] ); 
     1128                                if ( is_array( $children ) ) 
    11261129                                        foreach ( $children as $child ) 
    11271130                                                if ( $child->count ) 
    11281131                                                        continue 2; 
    11291132 
    11301133                                // It really is empty 
    1131                                 unset($terms[$k]); 
     1134                                unset( $terms[$k] ); 
    11321135                        } 
    11331136                } 
    11341137        } 
     
    11361139 
    11371140        $_terms = array(); 
    11381141        if ( 'id=>parent' == $fields ) { 
    1139                 while ( $term = array_shift($terms) ) 
     1142                while ( $term = array_shift( $terms ) ) 
    11401143                        $_terms[$term->term_id] = $term->parent; 
    11411144                $terms = $_terms; 
    11421145        } elseif ( 'ids' == $fields ) { 
    1143                 while ( $term = array_shift($terms) ) 
     1146                while ( $term = array_shift( $terms ) ) 
    11441147                        $_terms[] = $term->term_id; 
    11451148                $terms = $_terms; 
    11461149        } elseif ( 'names' == $fields ) { 
    1147                 while ( $term = array_shift($terms) ) 
     1150                while ( $term = array_shift( $terms ) ) 
    11481151                        $_terms[] = $term->name; 
    11491152                $terms = $_terms; 
    11501153        } 
    11511154 
    1152         if ( 0 < $number && intval(@count($terms)) > $number ) { 
    1153                 $terms = array_slice($terms, $offset, $number); 
     1155        if ( 0 < $number && intval( @count( $terms ) ) > $number ) { 
     1156                $terms = array_slice( $terms, $offset, $number ); 
    11541157        } 
    11551158 
    11561159        wp_cache_add( $cache_key, $terms, 'terms', 86400 ); // one day 
    11571160 
    1158         $terms = apply_filters('get_terms', $terms, $taxonomies, $args); 
     1161        $terms = apply_filters( 'get_terms', $terms, $taxonomies, $args ); 
    11591162        return $terms; 
    11601163} 
    11611164 
     
    11771180 * @param int $parent ID of parent term under which to confine the exists search. 
    11781181 * @return mixed Get the term id or Term Object, if exists. 
    11791182 */ 
    1180 function term_exists($term, $taxonomy = '', $parent = 0) { 
     1183function term_exists( $term, $taxonomy = '', $parent = 0 ) { 
    11811184        global $wpdb; 
    11821185 
    11831186        $select = "SELECT term_id FROM $wpdb->terms as t WHERE "; 
    11841187        $tax_select = "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE "; 
    11851188 
    1186         if ( is_int($term) ) { 
     1189        if ( is_int( $term ) ) { 
    11871190                if ( 0 == $term ) 
    11881191                        return 0; 
    11891192                $where = 't.term_id = %d'; 
    1190                 if ( !empty($taxonomy) ) 
     1193                if ( !empty( $taxonomy ) ) 
    11911194                        return $wpdb->get_row( $wpdb->prepare( $tax_select . $where . " AND tt.taxonomy = %s", $term, $taxonomy ), ARRAY_A ); 
    11921195                else 
    11931196                        return $wpdb->get_var( $wpdb->prepare( $select . $where, $term ) ); 
     
    11951198 
    11961199        $term = trim( stripslashes( $term ) ); 
    11971200 
    1198         if ( '' === $slug = sanitize_title($term) ) 
     1201        if ( '' === $slug = sanitize_title( $term ) ) 
    11991202                return 0; 
    12001203 
    12011204        $where = 't.slug = %s'; 
    12021205        $else_where = 't.name = %s'; 
    1203         $where_fields = array($slug); 
    1204         $else_where_fields = array($term); 
    1205         if ( !empty($taxonomy) ) { 
     1206        $where_fields = array( $slug ); 
     1207        $else_where_fields = array( $term ); 
     1208        if ( !empty( $taxonomy ) ) { 
    12061209                $parent = (int) $parent; 
    12071210                if ( $parent > 0 ) { 
    12081211                        $where_fields[] = $parent; 
     
    12141217                $where_fields[] = $taxonomy; 
    12151218                $else_where_fields[] = $taxonomy; 
    12161219 
    1217                 if ( $result = $wpdb->get_row( $wpdb->prepare("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s", $where_fields), ARRAY_A) ) 
     1220                if ( $result = $wpdb->get_row( $wpdb->prepare("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s", $where_fields ), ARRAY_A ) ) 
    12181221                        return $result; 
    12191222 
    1220                 return $wpdb->get_row( $wpdb->prepare("SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s", $else_where_fields), ARRAY_A); 
     1223                return $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s", $else_where_fields ), ARRAY_A ); 
    12211224        } 
    12221225 
    1223         if ( $result = $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $where", $where_fields) ) ) 
     1226        if ( $result = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $where", $where_fields ) ) ) 
    12241227                return $result; 
    12251228 
    1226         return $wpdb->get_var( $wpdb->prepare("SELECT term_id FROM $wpdb->terms as t WHERE $else_where", $else_where_fields) ); 
     1229        return $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $else_where", $else_where_fields ) ); 
    12271230} 
    12281231 
    12291232/** 
     
    12461249 * @param string $context Default is 'display'. 
    12471250 * @return array|object Term with all fields sanitized 
    12481251 */ 
    1249 function sanitize_term($term, $taxonomy, $context = 'display') { 
     1252function sanitize_term( $term, $taxonomy, $context = 'display' ) { 
    12501253 
    12511254        if ( 'raw' == $context ) 
    12521255                return $term; 
    12531256 
    1254         $fields = array('term_id', 'name', 'description', 'slug', 'count', 'parent', 'term_group'); 
     1257        $fields = array( 'term_id', 'name', 'description', 'slug', 'count', 'parent', 'term_group' ); 
    12551258 
    12561259        $do_object = false; 
    1257         if ( is_object($term) ) 
     1260        if ( is_object( $term ) ) 
    12581261                $do_object = true; 
    12591262 
    1260         $term_id = $do_object ? $term->term_id : (isset($term['term_id']) ? $term['term_id'] : 0); 
     1263        $term_id = $do_object ? $term->term_id : ( isset( $term['term_id'] ) ? $term['term_id'] : 0 ); 
    12611264 
    12621265        foreach ( (array) $fields as $field ) { 
    12631266                if ( $do_object ) { 
    1264                         if ( isset($term->$field) ) 
    1265                                 $term->$field = sanitize_term_field($field, $term->$field, $term_id, $taxonomy, $context); 
     1267                        if ( isset( $term->$field ) ) 
     1268                                $term->$field = sanitize_term_field( $field, $term->$field, $term_id, $taxonomy, $context ); 
    12661269                } else { 
    1267                         if ( isset($term[$field]) ) 
    1268                                 $term[$field] = sanitize_term_field($field, $term[$field], $term_id, $taxonomy, $context); 
     1270                        if ( isset( $term[$field] ) ) 
     1271                                $term[$field] = sanitize_term_field( $field, $term[$field], $term_id, $taxonomy, $context ); 
    12691272                } 
    12701273        } 
    12711274 
     
    13031306 * @param string $context Either edit, db, display, attribute, or js. 
    13041307 * @return mixed sanitized field 
    13051308 */ 
    1306 function sanitize_term_field($field, $value, $term_id, $taxonomy, $context) { 
     1309function sanitize_term_field( $field, $value, $term_id, $taxonomy, $context ) { 
    13071310        if ( 'parent' == $field  || 'term_id' == $field || 'count' == $field || 'term_group' == $field ) { 
    13081311                $value = (int) $value; 
    13091312                if ( $value < 0 ) 
     
    13141317                return $value; 
    13151318 
    13161319        if ( 'edit' == $context ) { 
    1317                 $value = apply_filters("edit_term_$field", $value, $term_id, $taxonomy); 
    1318                 $value = apply_filters("edit_${taxonomy}_$field", $value, $term_id); 
     1320                $value = apply_filters( "edit_term_$field", $value, $term_id, $taxonomy ); 
     1321                $value = apply_filters( "edit_${taxonomy}_$field", $value, $term_id ); 
    13191322                if ( 'description' == $field ) 
    1320                         $value = format_to_edit($value); 
     1323                        $value = format_to_edit( $value ); 
    13211324                else 
    1322                         $value = esc_attr($value); 
     1325                        $value = esc_attr( $value ); 
    13231326        } else if ( 'db' == $context ) { 
    1324                 $value = apply_filters("pre_term_$field", $value, $taxonomy); 
    1325                 $value = apply_filters("pre_${taxonomy}_$field", $value); 
     1327                $value = apply_filters( "pre_term_$field", $value, $taxonomy ); 
     1328                $value = apply_filters( "pre_${taxonomy}_$field", $value ); 
    13261329                // Back compat filters 
    13271330                if ( 'slug' == $field ) 
    1328                         $value = apply_filters('pre_category_nicename', $value); 
     1331                        $value = apply_filters( 'pre_category_nicename', $value ); 
    13291332 
    13301333        } else if ( 'rss' == $context ) { 
    1331                 $value = apply_filters("term_${field}_rss", $value, $taxonomy); 
    1332                 $value = apply_filters("${taxonomy}_${field}_rss", $value); 
     1334                $value = apply_filters( "term_${field}_rss", $value, $taxonomy ); 
     1335                $value = apply_filters( "${taxonomy}_${field}_rss", $value ); 
    13331336        } else { 
    13341337                // Use display filters by default. 
    1335                 $value = apply_filters("term_$field", $value, $term_id, $taxonomy, $context); 
    1336                 $value = apply_filters("${taxonomy}_$field", $value, $term_id, $context); 
     1338                $value = apply_filters( "term_$field", $value, $term_id, $taxonomy, $context ); 
     1339                $value = apply_filters( "${taxonomy}_$field", $value, $term_id, $context ); 
    13371340        } 
    13381341 
    13391342        if ( 'attribute' == $context ) 
    1340                 $value = esc_attr($value); 
     1343                $value = esc_attr( $value ); 
    13411344        else if ( 'js' == $context ) 
    1342                 $value = esc_js($value); 
     1345                $value = esc_js( $value ); 
    13431346 
    13441347        return $value; 
    13451348} 
     
    13611364 * @return int How many terms are in $taxonomy 
    13621365 */ 
    13631366function wp_count_terms( $taxonomy, $args = array() ) { 
    1364         $defaults = array('hide_empty' => false); 
    1365         $args = wp_parse_args($args, $defaults); 
     1367        $defaults = array( 'hide_empty' => false ); 
     1368        $args = wp_parse_args( $args, $defaults ); 
    13661369 
    13671370        // backwards compatibility 
    1368         if ( isset($args['ignore_empty']) ) { 
     1371        if ( isset( $args['ignore_empty'] ) ) { 
    13691372                $args['hide_empty'] = $args['ignore_empty']; 
    1370                 unset($args['ignore_empty']); 
     1373                unset( $args['ignore_empty'] ); 
    13711374        } 
    13721375 
    13731376        $args['fields'] = 'count'; 
    13741377 
    1375         return get_terms($taxonomy, $args); 
     1378        return get_terms( $taxonomy, $args ); 
    13761379} 
    13771380 
    13781381/** 
     
    13951398 
    13961399        $object_id = (int) $object_id; 
    13971400 
    1398         if ( !is_array($taxonomies) ) 
    1399                 $taxonomies = array($taxonomies); 
     1401        if ( !is_array( $taxonomies ) ) 
     1402                $taxonomies = array( $taxonomies ); 
    14001403 
    14011404        foreach ( (array) $taxonomies as $taxonomy ) { 
    1402                 $tt_ids = wp_get_object_terms($object_id, $taxonomy, array('fields' => 'tt_ids')); 
    1403                 $in_tt_ids = "'" . implode("', '", $tt_ids) . "'"; 
     1405                $tt_ids = wp_get_object_terms( $object_id, $taxonomy, array( 'fields' => 'tt_ids' ) ); 
     1406                $in_tt_ids = "'" . implode( "', '", $tt_ids ) . "'"; 
    14041407                do_action( 'delete_term_relationships', $object_id, $tt_ids ); 
    1405                 $wpdb->query( $wpdb->prepare("DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id) ); 
     1408                $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id ) ); 
    14061409                do_action( 'deleted_term_relationships', $object_id, $tt_ids ); 
    1407                 wp_update_term_count($tt_ids, $taxonomy); 
     1410                wp_update_term_count( $tt_ids, $taxonomy ); 
    14081411        } 
    14091412} 
    14101413 
     
    14381441 
    14391442        $term = (int) $term; 
    14401443 
    1441         if ( ! $ids = term_exists($term, $taxonomy) ) 
     1444        if ( ! $ids = term_exists( $term, $taxonomy ) ) 
    14421445                return false; 
    14431446        if ( is_wp_error( $ids ) ) 
    14441447                return $ids; 
     
    14531456                        return 0; // Don't delete the default category 
    14541457        } 
    14551458 
    1456         $args = wp_parse_args($args, $defaults); 
    1457         extract($args, EXTR_SKIP); 
     1459        $args = wp_parse_args( $args, $defaults ); 
     1460        extract( $args, EXTR_SKIP ); 
    14581461 
    14591462        if ( isset( $default ) ) { 
    14601463                $default = (int) $default; 
    1461                 if ( ! term_exists($default, $taxonomy) ) 
    1462                         unset($default); 
     1464                if ( ! term_exists( $default, $taxonomy ) ) 
     1465                        unset( $default ); 
    14631466        } 
    14641467 
    14651468        // Update children to point to new parent 
    1466         if ( is_taxonomy_hierarchical($taxonomy) ) { 
    1467                 $term_obj = get_term($term, $taxonomy); 
     1469        if ( is_taxonomy_hierarchical( $taxonomy ) ) { 
     1470                $term_obj = get_term( $term, $taxonomy ); 
    14681471                if ( is_wp_error( $term_obj ) ) 
    14691472                        return $term_obj; 
    14701473                $parent = $term_obj->parent; 
    14711474 
    14721475                $edit_tt_ids = $wpdb->get_col( "SELECT `term_taxonomy_id` FROM $wpdb->term_taxonomy WHERE `parent` = " . (int)$term_obj->term_id ); 
    14731476                do_action( 'edit_term_taxonomies', $edit_tt_ids ); 
    1474                 $wpdb->update( $wpdb->term_taxonomy, compact( 'parent' ), array( 'parent' => $term_obj->term_id) + compact( 'taxonomy' ) ); 
     1477                $wpdb->update( $wpdb->term_taxonomy, compact( 'parent' ), array( 'parent' => $term_obj->term_id ) + compact( 'taxonomy' ) ); 
    14751478                do_action( 'edited_term_taxonomies', $edit_tt_ids ); 
    14761479        } 
    14771480 
    14781481        $objects = $wpdb->get_col( $wpdb->prepare( "SELECT object_id FROM $wpdb->term_relationships WHERE term_taxonomy_id = %d", $tt_id ) ); 
    14791482 
    14801483        foreach ( (array) $objects as $object ) { 
    1481                 $terms = wp_get_object_terms($object, $taxonomy, array('fields' => 'ids', 'orderby' => 'none')); 
    1482                 if ( 1 == count($terms) && isset($default) ) { 
    1483                         $terms = array($default); 
     1484                $terms = wp_get_object_terms( $object, $taxonomy, array( 'fields' => 'ids', 'orderby' => 'none' ) ); 
     1485                if ( 1 == count( $terms ) && isset( $default ) ) { 
     1486                        $terms = array( $default ); 
    14841487                } else { 
    1485                         $terms = array_diff($terms, array($term)); 
    1486                         if (isset($default) && isset($force_default) && $force_default) 
    1487                                 $terms = array_merge($terms, array($default)); 
     1488                        $terms = array_diff( $terms, array( $term ) ); 
     1489                        if ( isset( $default ) && isset( $force_default ) && $force_default ) 
     1490                                $terms = array_merge( $terms, array( $default ) ); 
    14881491                } 
    1489                 $terms = array_map('intval', $terms); 
    1490                 wp_set_object_terms($object, $terms, $taxonomy); 
     1492                $terms = array_map( 'intval', $terms ); 
     1493                wp_set_object_terms( $object, $terms, $taxonomy ); 
    14911494        } 
    14921495 
    14931496        do_action( 'delete_term_taxonomy', $tt_id ); 
     
    14951498        do_action( 'deleted_term_taxonomy', $tt_id ); 
    14961499 
    14971500        // Delete the term if no taxonomies use it. 
    1498         if ( !$wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term) ) ) 
    1499                 $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->terms WHERE term_id = %d", $term) ); 
     1501        if ( !$wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy WHERE term_id = %d", $term ) ) ) 
     1502                $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->terms WHERE term_id = %d", $term ) ); 
    15001503 
    1501         clean_term_cache($term, $taxonomy); 
     1504        clean_term_cache( $term, $taxonomy ); 
    15021505 
    1503         do_action('delete_term', $term, $tt_id, $taxonomy); 
    1504         do_action("delete_$taxonomy", $term, $tt_id); 
     1506        do_action( 'delete_term', $term, $tt_id, $taxonomy ); 
     1507        do_action( "delete_$taxonomy", $term, $tt_id ); 
    15051508 
    15061509        return true; 
    15071510} 
     
    15521555 * @param array|string $args Change what is returned 
    15531556 * @return array|WP_Error The requested term data or empty array if no terms found. WP_Error if $taxonomy does not exist. 
    15541557 */ 
    1555 function wp_get_object_terms($object_ids, $taxonomies, $args = array()) { 
     1558function wp_get_object_terms( $object_ids, $taxonomies, $args = array() ) { 
    15561559        global $wpdb; 
    15571560 
    1558         if ( !is_array($taxonomies) ) 
    1559                 $taxonomies = array($taxonomies); 
     1561        if ( !is_array( $taxonomies ) ) 
     1562                $taxonomies = array( $taxonomies ); 
    15601563 
    15611564        foreach ( (array) $taxonomies as $taxonomy ) { 
    1562                 if ( ! taxonomy_exists($taxonomy) ) 
    1563                         return new WP_Error('invalid_taxonomy', __('Invalid Taxonomy')); 
     1565                if ( ! taxonomy_exists( $taxonomy ) ) 
     1566                        return new WP_Error( 'invalid_taxonomy', __( 'Invalid Taxonomy' ) ); 
    15641567        } 
    15651568 
    1566         if ( !is_array($object_ids) ) 
    1567                 $object_ids = array($object_ids); 
    1568         $object_ids = array_map('intval', $object_ids); 
     1569        if ( !is_array( $object_ids ) ) 
     1570                $object_ids = array( $object_ids ); 
     1571        $object_ids = array_map( 'intval', $object_ids ); 
    15691572 
    1570         $defaults = array('orderby' => 'name', 'order' => 'ASC', 'fields' => 'all'); 
     1573        $defaults = array( 'orderby' => 'name', 'order' => 'ASC', 'fields' => 'all' ); 
    15711574        $args = wp_parse_args( $args, $defaults ); 
    15721575 
    15731576        $terms = array(); 
    1574         if ( count($taxonomies) > 1 ) { 
     1577        if ( count( $taxonomies ) > 1 ) { 
    15751578                foreach ( $taxonomies as $index => $taxonomy ) { 
    1576                         $t = get_taxonomy($taxonomy); 
    1577                         if ( isset($t->args) && is_array($t->args) && $args != array_merge($args, $t->args) ) { 
    1578                                 unset($taxonomies[$index]); 
    1579                                 $terms = array_merge($terms, wp_get_object_terms($object_ids, $taxonomy, array_merge($args, $t->args))); 
     1579                        $t = get_taxonomy( $taxonomy ); 
     1580                        if ( isset( $t->args ) && is_array( $t->args ) && $args != array_merge( $args, $t->args ) ) { 
     1581                                unset( $taxonomies[$index] ); 
     1582                                $terms = array_merge( $terms, wp_get_object_terms( $object_ids, $taxonomy, array_merge( $args, $t->args ) ) ); 
    15801583                        } 
    15811584                } 
    15821585        } else { 
    1583                 $t = get_taxonomy($taxonomies[0]); 
    1584                 if ( isset($t->args) && is_array($t->args) ) 
    1585                         $args = array_merge($args, $t->args); 
     1586                $t = get_taxonomy( $taxonomies[0] ); 
     1587                if ( isset( $t->args ) && is_array( $t->args ) ) 
     1588                        $args = array_merge( $args, $t->args ); 
    15861589        } 
    15871590 
    1588         extract($args, EXTR_SKIP); 
     1591        extract( $args, EXTR_SKIP ); 
    15891592 
    15901593        if ( 'count' == $orderby ) 
    15911594                $orderby = 'tt.count'; 
     
    16051608        } 
    16061609 
    16071610        // tt_ids queries can only be none or tr.term_taxonomy_id 
    1608         if ( ('tt_ids' == $fields) && !empty($orderby) ) 
     1611        if ( ( 'tt_ids' == $fields ) && !empty( $orderby ) ) 
    16091612                $orderby = 'tr.term_taxonomy_id'; 
    16101613 
    1611         if ( !empty($orderby) ) 
     1614        if ( !empty( $orderby ) ) 
    16121615                $orderby = "ORDER BY $orderby"; 
    16131616 
    1614         $taxonomies = "'" . implode("', '", $taxonomies) . "'"; 
    1615         $object_ids = implode(', ', $object_ids); 
     1617        $taxonomies = "'" . implode( "', '", $taxonomies ) . "'"; 
     1618        $object_ids = implode( ', ', $object_ids ); 
    16161619 
    16171620        $select_this = ''; 
    16181621        if ( 'all' == $fields ) 
     
    16271630        $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"; 
    16281631 
    16291632        if ( 'all' == $fields || 'all_with_object_id' == $fields ) { 
    1630                 $terms = array_merge($terms, $wpdb->get_results($query)); 
    1631                 update_term_cache($terms); 
     1633                $terms = array_merge( $terms, $wpdb->get_results( $query ) ); 
     1634                update_term_cache( $terms ); 
    16321635        } else if ( 'ids' == $fields || 'names' == $fields ) { 
    1633                 $terms = array_merge($terms, $wpdb->get_col($query)); 
     1636                $terms = array_merge( $terms, $wpdb->get_col( $query ) ); 
    16341637        } else if ( 'tt_ids' == $fields ) { 
    1635                 $terms = $wpdb->get_col("SELECT tr.term_taxonomy_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tr.object_id IN ($object_ids) AND tt.taxonomy IN ($taxonomies) $orderby $order"); 
     1638                $terms = $wpdb->get_col( "SELECT tr.term_taxonomy_id FROM $wpdb->term_relationships AS tr INNER JOIN $wpdb->term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id WHERE tr.object_id IN ($object_ids) AND tt.taxonomy IN ($taxonomies) $orderby $order" ); 
    16361639        } 
    16371640 
    16381641        if ( ! $terms ) 
    16391642                $terms = array(); 
    16401643 
    1641         return apply_filters('wp_get_object_terms', $terms, $object_ids, $taxonomies, $args); 
     1644        return apply_filters( 'wp_get_object_terms', $terms, $object_ids, $taxonomies, $args ); 
    16421645} 
    16431646 
    16441647/** 
     
    16971700function wp_insert_term( $term, $taxonomy, $args = array() ) { 
    16981701        global $wpdb; 
    16991702 
    1700         if ( ! taxonomy_exists($taxonomy) ) 
    1701                 return new WP_Error('invalid_taxonomy', __('Invalid taxonomy')); 
     1703        if ( ! taxonomy_exists( $taxonomy ) ) 
     1704                return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy' ) ); 
    17021705 
    17031706        $term = apply_filters( 'pre_insert_term', $term, $taxonomy ); 
    17041707                if ( is_wp_error( $term ) ) 
    17051708                        return $term; 
    17061709 
    1707         if ( is_int($term) && 0 == $term ) 
    1708                 return new WP_Error('invalid_term_id', __('Invalid term ID')); 
     1710        if ( is_int( $term ) && 0 == $term ) 
     1711                return new WP_Error( 'invalid_term_id', __( 'Invalid term ID' ) ); 
    17091712 
    1710         if ( '' == trim($term) ) 
    1711                 return new WP_Error('empty_term_name', __('A name is required for this term')); 
     1713        if ( '' == trim( $term ) ) 
     1714                return new WP_Error( 'empty_term_name', __( 'A name is required for this term' ) ); 
    17121715 
    1713         $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => ''); 
    1714         $args = wp_parse_args($args, $defaults); 
     1716        $defaults = array( 'alias_of' => '', 'description' => '', 'parent' => 0, 'slug' => '' ); 
     1717        $args = wp_parse_args( $args, $defaults ); 
    17151718        $args['name'] = $term; 
    17161719        $args['taxonomy'] = $taxonomy; 
    1717         $args = sanitize_term($args, $taxonomy, 'db'); 
    1718         extract($args, EXTR_SKIP); 
     1720        $args = sanitize_term( $args, $taxonomy, 'db' ); 
     1721        extract( $args, EXTR_SKIP ); 
    17191722 
    17201723        // expected_slashed ($name) 
    1721         $name = stripslashes($name); 
    1722         $description = stripslashes($description); 
     1724        $name = stripslashes( $name ); 
     1725        $description = stripslashes( $description ); 
    17231726 
    1724         if ( empty($slug) ) 
    1725                 $slug = sanitize_title($name); 
     1727        if ( empty( $slug ) ) 
     1728                $slug = sanitize_title( $name ); 
    17261729 
    17271730        $term_group = 0; 
    17281731        if ( $alias_of ) { 
    1729                 $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of) ); 
     1732                $alias = $wpdb->get_row( $wpdb->prepare( "SELECT term_id, term_group FROM $wpdb->terms WHERE slug = %s", $alias_of ) ); 
    17301733                if ( $alias->term_group ) { 
    17311734                        // The alias we want is already in a group, so let's use that one. 
    17321735                        $term_group = $alias->term_group; 
    17331736                } else { 
    17341737                        // The alias isn't in a group, so let's create a new one and firstly add the alias term to it. 
    1735                         $term_group = $wpdb->get_var("SELECT MAX(term_group) FROM $wpdb->terms") + 1; 
     1738                        $term_group = $wpdb->get_var( "SELECT MAX(term_group) FROM $wpdb->terms" ) + 1; 
    17361739                        do_action( 'edit_terms', $alias->term_id ); 
    1737                         $wpdb->update($wpdb->terms, compact('term_group'), array('term_id' => $alias->term_id) ); 
     1740                        $wpdb->update( $wpdb->terms, compact( 'term_group' ), array( 'term_id' => $alias->term_id ) ); 
    17381741                        do_action( 'edited_terms', $alias->term_id ); 
    17391742                } 
    17401743        } 
    17411744 
    1742         if ( $term_id = term_exists($slug) ) { 
    1743                 $existing_term = $wpdb->get_row( $wpdb->prepare( "SELECT name FROM $wpdb->terms WHERE term_id = %d", $term_id), ARRAY_A ); 
     1745        if ( $term_id = term_exists( $slug ) ) { 
     1746                $existing_term = $wpdb->get_row( $wpdb->prepare( "SELECT name FROM $wpdb->terms WHERE term_id = %d", $term_id ), ARRAY_A ); 
    17441747                // We've got an existing term in the same taxonomy, which matches the name of the new term: 
    1745                 if ( is_taxonomy_hierarchical($taxonomy) && $existing_term['name'] == $name && $exists = term_exists( (int) $term_id, $taxonomy ) ) { 
     1748                if ( is_taxonomy_hierarchical( $taxonomy ) && $existing_term['name'] == $name && $exists = term_exists( (int) $term_id, $taxonomy ) ) { 
    17461749                        // Hierarchical, and it matches an existing term, Do not allow same "name" in the same level. 
    1747                         $siblings = get_terms($taxonomy, array('fields' => 'names', 'get' => 'all', 'parent' => (int)$parent) ); 
    1748                         if ( in_array($name, $siblings) ) { 
    1749                                 return new WP_Error('term_exists', __('A term with the name provided already exists with this parent.'), $exists['term_id']); 
     1750                        $siblings = get_terms( $taxonomy, array( 'fields' => 'names', 'get' => 'all', 'parent' => (int)$parent ) ); 
     1751                        if ( in_array( $name, $siblings ) ) { 
     1752                                return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $exists['term_id'] ); 
    17501753                        } else { 
    1751                                 $slug = wp_unique_term_slug($slug, (object) $args); 
     1754                                $slug = wp_unique_term_slug( $slug, (object) $args ); 
    17521755                                if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) 
    1753                                         return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); 
     1756                                        return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database' ), $wpdb->last_error ); 
    17541757                                $term_id = (int) $wpdb->insert_id; 
    17551758                        } 
    17561759                } elseif ( $existing_term['name'] != $name ) { 
    17571760                        // We've got an existing term, with a different name, Create the new term. 
    1758                         $slug = wp_unique_term_slug($slug, (object) $args); 
     1761                        $slug = wp_unique_term_slug( $slug, (object) $args ); 
    17591762                        if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) 
    1760                                 return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); 
     1763                                return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database' ), $wpdb->last_error ); 
    17611764                        $term_id = (int) $wpdb->insert_id; 
    17621765                } elseif ( $exists = term_exists( (int) $term_id, $taxonomy ) )  { 
    17631766                        // Same name, same slug. 
    1764                         return new WP_Error('term_exists', __('A term with the name provided already exists.'), $exists['term_id']); 
     1767                        return new WP_Error( 'term_exists', __( 'A term with the name provided already exists.' ), $exists['term_id'] ); 
    17651768                } 
    17661769        } else { 
    17671770                // This term does not exist at all in the database, Create it. 
    1768                 $slug = wp_unique_term_slug($slug, (object) $args); 
     1771                $slug = wp_unique_term_slug( $slug, (object) $args ); 
    17691772                if ( false === $wpdb->insert( $wpdb->terms, compact( 'name', 'slug', 'term_group' ) ) ) 
    1770                         return new WP_Error('db_insert_error', __('Could not insert term into the database'), $wpdb->last_error); 
     1773                        return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database' ), $wpdb->last_error ); 
    17711774                $term_id = (int) $wpdb->insert_id; 
    17721775        } 
    17731776 
    17741777        // Seems unreachable, However, Is used in the case that a term name is provided, which sanitizes to an empty string. 
    1775         if ( empty($slug) ) { 
    1776                 $slug = sanitize_title($slug, $term_id); 
     1778        if ( empty( $slug ) ) { 
     1779                $slug = sanitize_title( $slug, $term_id ); 
    17771780                do_action( 'edit_terms', $term_id ); 
    17781781                $wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) ); 
    17791782                do_action( 'edited_terms', $term_id ); 
     
    17811784 
    17821785        $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 ) ); 
    17831786 
    1784         if ( !empty($tt_id) ) 
    1785                 return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id); 
     1787        if ( !empty( $tt_id ) ) 
     1788                return array( 'term_id' => $term_id, 'term_taxonomy_id' => $tt_id ); 
    17861789 
    17871790        $wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent') + array( 'count' => 0 ) ); 
    17881791        $tt_id = (int) $wpdb->insert_id; 
    17891792 
    1790         do_action("create_term", $term_id, $tt_id, $taxonomy); 
    1791         do_action("create_$taxonomy", $term_id, $tt_id); 
     1793        do_action( "create_term", $term_id, $tt_id, $taxonomy ); 
     1794        do_action( "create_$taxonomy", $term_id, $tt_id ); 
    17921795 
    1793         $term_id = apply_filters('term_id_filter', $term_id, $tt_id); 
     1796        $term_id = apply_filters( 'term_id_filter', $term_id, $tt_id ); 
    17941797 
    1795         clean_term_cache($term_id, $taxonomy); 
     1798        clean_term_cache( $term_id, $taxonomy ); 
    17961799 
    1797         do_action("created_term", $term_id, $tt_id, $taxonomy); 
    1798         do_action("created_$taxonomy", $term_id, $tt_id); 
     1800        do_action( "created_term", $term_id, $tt_id, $taxonomy ); 
     1801        do_action( "created_$taxonomy", $term_id, $tt_id ); 
    17991802 
    1800         return array('term_id' => $term_id, 'term_taxonomy_id' => $tt_id); 
     1803        return array( 'term_id' => $term_id, 'term_taxonomy_id' => $tt_id ); 
    18011804} 
    18021805 
    18031806/**