Changeset 5525

Show
Ignore:
Timestamp:
05/23/07 10:32:33 (1 year ago)
Author:
ryan
Message:

Add get_term_by() and taxonomy registration bits. Move more category stuff to taxonomy. see #4189

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/wp-includes/category.php

    r5521 r5525  
    88 
    99    if ( ! $cat_ids = wp_cache_get('all_category_ids', 'category') ) { 
    10         $cat_ids = $wpdb->get_col("SELECT cat_ID FROM $wpdb->categories"); 
     10        $cat_ids = get_terms('category', 'get=ids&hierarchical=0&hide_empty=0'); 
    1111        wp_cache_add('all_category_ids', $cat_ids, 'category'); 
    1212    } 
     
    1616 
    1717function &get_categories($args = '') { 
    18     global $wpdb, $category_links; 
    19      
    20     $defaults = array( 
    21         'type' => 'post', 'child_of' => 0,  
    22         'orderby' => 'name', 'order' => 'ASC',  
    23         'hide_empty' => true, 'include_last_update_time' => false,  
    24         'hierarchical' => 1, 'exclude' => '',  
    25         'include' => '', 'number' => '',  
    26         'pad_counts' => false 
    27     ); 
    28      
    29     $r = wp_parse_args( $args, $defaults ); 
    30      
    31     if ( $r['orderby'] == 'count' ) { 
    32         $r['orderby'] = 'category_count'; 
    33     } else { 
    34         $r['orderby'] = 'cat_' . $r['orderby']; 
    35     } 
    36      
    37     extract( $r ); 
    38  
    39     $key = md5( serialize( $r ) ); 
    40     if ( $cache = wp_cache_get( 'get_categories', 'category' ) ) 
    41         if ( isset( $cache[ $key ] ) ) 
    42             return apply_filters('get_categories', $cache[$key], $r); 
    43  
    44     $where = 'cat_ID > 0'; 
    45     $inclusions = ''; 
    46     if ( !empty($include) ) { 
    47         $child_of = 0; //ignore child_of and exclude params if using include 
    48         $exclude = ''; 
    49         $incategories = preg_split('/[\s,]+/',$include); 
    50         if ( count($incategories) ) { 
    51             foreach ( $incategories as $incat ) { 
    52                 if (empty($inclusions)) 
    53                     $inclusions = ' AND ( cat_ID = ' . intval($incat) . ' '; 
    54                 else 
    55                     $inclusions .= ' OR cat_ID = ' . intval($incat) . ' '; 
    56             } 
    57         } 
    58     } 
    59     if (!empty($inclusions)) 
    60         $inclusions .= ')'; 
    61     $where .= $inclusions; 
    62  
    63     $exclusions = ''; 
    64     if ( !empty($exclude) ) { 
    65         $excategories = preg_split('/[\s,]+/',$exclude); 
    66         if ( count($excategories) ) { 
    67             foreach ( $excategories as $excat ) { 
    68                 if (empty($exclusions)) 
    69                     $exclusions = ' AND ( cat_ID <> ' . intval($excat) . ' '; 
    70                 else 
    71                     $exclusions .= ' AND cat_ID <> ' . intval($excat) . ' '; 
    72                 // TODO: Exclude children of excluded cats?   Note: children are getting excluded 
    73             } 
    74         } 
    75     } 
    76     if (!empty($exclusions)) 
    77         $exclusions .= ')'; 
    78     $exclusions = apply_filters('list_cats_exclusions', $exclusions, $r ); 
    79     $where .= $exclusions; 
    80  
    81     if ( $hide_empty && !$hierarchical ) { 
    82         if ( 'link' == $type ) 
    83             $where .= ' AND link_count > 0'; 
    84         else 
    85             $where .= ' AND category_count > 0'; 
    86     } else { 
    87         $where .= ' AND ( type & ' . TAXONOMY_CATEGORY . ' != 0 ) '; 
    88     } 
    89  
    90      
    91  
    92     if ( !empty($number) ) 
    93         $number = 'LIMIT ' . $number; 
    94     else 
    95         $number = ''; 
    96  
    97     $categories = $wpdb->get_results("SELECT * FROM $wpdb->categories WHERE $where ORDER BY $orderby $order $number"); 
    98  
    99     if ( empty($categories) ) 
    100         return array(); 
    101  
    102     // TODO: Integrate this into the main query. 
    103     if ( $include_last_update_time ) { 
    104         $stamps = $wpdb->get_results("SELECT category_id, UNIX_TIMESTAMP( MAX(post_date) ) AS ts FROM $wpdb->posts, $wpdb->post2cat, $wpdb->categories 
    105                             WHERE post_status = 'publish' AND post_id = ID AND $where GROUP BY category_id"); 
    106         global $cat_stamps; 
    107         foreach ($stamps as $stamp) 
    108             $cat_stamps[$stamp->category_id] = $stamp->ts; 
    109         function stamp_cat($cat) { 
    110             global $cat_stamps; 
    111             $cat->last_update_timestamp = $cat_stamps[$cat->cat_ID]; 
    112             return $cat; 
    113         } 
    114         $categories = array_map('stamp_cat', $categories); 
    115         unset($cat_stamps); 
    116     } 
    117  
    118     if ( $child_of || $hierarchical ) { 
    119         $children = _get_category_hierarchy(); 
    120         if ( ! empty($children) ) 
    121             $categories = & _get_cat_children($child_of, $categories); 
    122     } 
    123  
    124     // Update category counts to include children. 
    125     if ( $pad_counts ) 
    126         _pad_category_counts($type, $categories); 
    127  
    128     // Make sure we show empty categories that have children. 
    129     if ( $hierarchical && $hide_empty ) { 
    130         foreach ( $categories as $k => $category ) { 
    131             if ( ! $category->{'link' == $type ? 'link_count' : 'category_count'} ) { 
    132                 $children = _get_cat_children($category->cat_ID, $categories); 
    133                 foreach ( $children as $child ) 
    134                     if ( $child->{'link' == $type ? 'link_count' : 'category_count'} ) 
    135                         continue 2; 
    136  
    137                 // It really is empty 
    138                 unset($categories[$k]); 
    139             } 
    140         } 
    141     } 
    142     reset ( $categories ); 
    143  
    144     $cache[ $key ] = $categories; 
    145     wp_cache_add( 'get_categories', $cache, 'category' ); 
    146  
    147     $categories = apply_filters('get_categories', $categories, $r); 
    148     return $categories; 
     18    // TODO Add back compat fields into each object. 
     19    return get_terms('category', $args); 
    14920} 
    15021 
     
    15223// Handles category caching. 
    15324function &get_category(&$category, $output = OBJECT) { 
    154     global $wpdb; 
    155  
    156     if ( empty($category) ) 
    157         return null; 
    158  
    159     if ( is_object($category) ) { 
    160         wp_cache_add($category->cat_ID, $category, 'category'); 
    161         $_category = $category; 
    162     } else { 
    163         $category = (int) $category; 
    164         if ( ! $_category = wp_cache_get($category, 'category') ) { 
    165             $_category = $wpdb->get_row("SELECT * FROM $wpdb->categories WHERE cat_ID = '$category' LIMIT 1"); 
    166             wp_cache_add($category, $_category, 'category'); 
    167         } 
    168     } 
    169  
    170     $_category = apply_filters('get_category', $_category); 
    171  
    172     if ( $output == OBJECT ) { 
    173         return $_category; 
    174     } elseif ( $output == ARRAY_A ) { 
    175         return get_object_vars($_category); 
    176     } elseif ( $output == ARRAY_N ) { 
    177         return array_values(get_object_vars($_category)); 
    178     } else { 
    179         return $_category; 
    180     } 
     25    return get_term($category, 'category', $output); 
    18126} 
    18227 
     
    19338        $full_path .= ( $pathdir != '' ? '/' : '' ) . sanitize_title($pathdir); 
    19439 
    195     $categories = $wpdb->get_results("SELECT cat_ID, category_nicename, category_parent FROM $wpdb->categories WHERE category_nicename = '$leaf_path'"); 
     40    $categories = get_terms('category', "slug=$leaf_path"); 
    19641 
    19742    if ( empty($categories) ) 
     
    20146        $path = '/' . $leaf_path; 
    20247        $curcategory = $category; 
    203         while ( ($curcategory->category_parent != 0) && ($curcategory->category_parent != $curcategory->cat_ID) ) { 
    204             $curcategory = $wpdb->get_row("SELECT cat_ID, category_nicename, category_parent FROM $wpdb->categories WHERE cat_ID = '$curcategory->category_parent'"); 
    205             $path = '/' . $curcategory->category_nicename . $path; 
     48        while ( ($curcategory->parent != 0) && ($curcategory->parent != $curcategory->term_id) ) { 
     49            $curcategory = get_term($curcategory->parent); 
     50            $path = '/' . $curcategory->slug . $path; 
    20651        } 
    20752 
    20853        if ( $path == $full_path ) 
    209             return get_category($category->cat_ID, $output); 
     54            return get_category($category->term_id, $output); 
    21055    } 
    21156 
    21257    // If full matching is not required, return the first cat that matches the leaf. 
    21358    if ( ! $full_match ) 
    214         return get_category($categories[0]->cat_ID, $output); 
     59        return get_category($categories[0]->term_id, $output); 
    21560 
    21661    return NULL; 
     
    21863 
    21964function get_category_by_slug( $slug  ) { 
    220     global $wpdb; 
    221     $slug = sanitize_title( $slug ); 
    222     if ( empty( $slug ) ) 
    223         return false; 
    224     $category = $wpdb->get_var( "SELECT * FROM $wpdb->categories WHERE category_nicename = '$slug' " ); 
    225     return get_category( $category ); 
     65    return get_term_by('slug', $slug, 'category'); 
    22666} 
    22767 
     
    23070    global $wpdb; 
    23171 
    232     $cid = $wpdb->get_var("SELECT cat_ID FROM $wpdb->categories WHERE cat_name='$cat_name'"); 
    233  
    234     return $cid?$cid:1; // default to cat 1 
     72    $cat = get_term_by('name', $cat_name, 'category'); 
     73    if ($cat) 
     74        return $cat->term_id; 
     75    return 0; 
    23576} 
    23677 
     
    25394        $cat2 = & get_category($cat2);  
    25495 
    255     if ( !$cat1->cat_ID || !$cat2->category_parent )  
     96    if ( !$cat1->term_id || !$cat2->parent )  
    25697        return false;  
    25798 
    258     if ( $cat2->category_parent == $cat1->cat_ID )  
     99    if ( $cat2->parent == $cat1->term_id )  
    259100        return true;  
    260101 
    261     return cat_is_ancestor_of($cat1, get_category($cat2->parent_category));  
     102    return cat_is_ancestor_of($cat1, get_category($cat2->parent));  
    262103}  
    263104 
  • trunk/wp-includes/taxonomy.php

    r5524 r5525  
    11<?php 
     2 
     3$wp_taxonomies = 
     4array('category' => array('object_type' => 'post', 'hierarchical' => true), 
     5'post_tag' => array('object_type' => 'post', 'hierarchical' => false), 
     6'link_category' => array('object_type' => 'link', 'hierarchical' => false)); 
     7 
     8function is_taxonomy( $taxonomy ) { 
     9    global $wp_taxonomies; 
     10 
     11    return isset($wp_taxonomies[$taxonomy]);     
     12} 
     13 
     14function get_taxonomy( $taxonomy ) { 
     15    global $wp_taxonomies; 
     16 
     17    if ( ! is_taxonomy($taxonomy) ) 
     18        return false; 
     19 
     20    return $wp_taxonomies[$taxonomy]; 
     21} 
     22 
     23function register_taxonomy( $taxonomy, $object_type, $args = array() ) { 
     24    global $wp_taxonomies; 
     25 
     26    $args['object_type'] = $object_type; 
     27    $wp_taxonomies[$taxonomy] = $args; 
     28} 
    229 
    330/** 
     
    936function wp_insert_term( $term, $taxonomy, $args = array() ) { 
    1037    global $wpdb; 
     38 
     39    if ( ! is_taxonomy($taxonomy) ) 
     40        return new WP_Error('invalid_taxonomy', __('Invalid taxonomy')); 
    1141 
    1242    $update = false; 
     
    258288    global $wpdb; 
    259289 
    260     if ( !is_array($taxonomies) ) 
     290    $single_taxonomy = false; 
     291    if ( !is_array($taxonomies) ) { 
     292        $single_taxonomy = true; 
    261293        $taxonomies = array($taxonomies); 
     294    } 
     295 
    262296    $in_taxonomies = "'" . implode("', '", $taxonomies) . "'"; 
    263297 
    264298    $defaults = array('orderby' => 'name', 'order' => 'ASC', 
    265299        'hide_empty' => true, 'exclude' => '', 'include' => '', 
    266         'number' => '', 'get' => 'everything'); 
     300        'number' => '', 'get' => 'everything', 'slug' => '', 'parent' => '', 
     301        'hierarchical' => true, 'child_of' => 0); 
    267302    $args = wp_parse_args( $args, $defaults ); 
    268303    $args['number'] = (int) $args['number']; 
     304    if ( ! $single_taxonomy ) { 
     305        $args['child_of'] = 0; 
     306        $args['hierarchical'] = false; 
     307    } else { 
     308        $tax = get_taxonomy($taxonomy); 
     309        if ( !$tax['hierarchical'] ) { 
     310            $args['child_of'] = 0; 
     311            $args['hierarchical'] = false;   
     312        } 
     313    } 
    269314    extract($args); 
     315 
     316    $key = md5( serialize( $args ) . serialize( $taxonomies ) ); 
     317    if ( $cache = wp_cache_get( 'get_terms', 'terms' ) ) { 
     318        if ( isset( $cache[ $key ] ) ) 
     319            return apply_filters('get_terms', $cache[$key], $taxonomies, $args); 
     320    } 
    270321 
    271322    if ( 'count' == $orderby ) 
     
    273324    else if ( 'name' == $orderby ) 
    274325        $orderby = 't.name'; 
     326    else 
     327        $orderby = 't.term_id'; 
    275328 
    276329    $where = ''; 
     
    311364    $where .= $exclusions; 
    312365 
    313     if ( $hide_empty ) 
     366    if ( !empty($slug) ) { 
     367        $slug = sanitize_title($slug); 
     368        $where = " AND t.slug = '$slug'"; 
     369    } 
     370 
     371    if ( !empty($parent) ) { 
     372        $parent = (int) $parent; 
     373        $where = " AND tt.parent = '$parent'"; 
     374    } 
     375 
     376    if ( $hide_empty && !$hierarchical ) 
    314377        $where .= ' AND tt.count > 0'; 
    315378 
     
    334397        return array(); 
    335398 
     399    if ( $child_of || $hierarchical ) { 
     400        $children = _get_term_hierarchy($taxonomies[0]); 
     401        if ( ! empty($children) ) 
     402            $terms = & _get_term_children($child_of, $terms); 
     403    } 
     404 
     405    /* 
     406    // Update category counts to include children. 
     407    if ( $pad_counts ) 
     408        _pad_category_counts($type, $categories); 
     409 
     410    // Make sure we show empty categories that have children. 
     411    if ( $hierarchical && $hide_empty ) { 
     412        foreach ( $categories as $k => $category ) { 
     413            if ( ! $category->{'link' == $type ? 'link_count' : 'category_count'} ) { 
     414                $children = _get_cat_children($category->cat_ID, $categories); 
     415                foreach ( $children as $child ) 
     416                    if ( $child->{'link' == $type ? 'link_count' : 'category_count'} ) 
     417                        continue 2; 
     418 
     419                // It really is empty 
     420                unset($categories[$k]); 
     421            } 
     422        } 
     423    } 
     424    reset ( $categories ); 
     425    */ 
     426 
     427    $cache[ $key ] = $terms; 
     428    wp_cache_add( 'get_terms', $cache, 'terms' ); 
     429 
    336430    $terms = apply_filters('get_terms', $terms, $taxonomies, $args); 
    337431    return $terms; 
     
    345439 
    346440    if ( is_object($term) ) { 
    347         wp_cache_add($term->term_id, $term, "term:$taxonomy"); 
     441        wp_cache_add($term->term_id, $term, $taxonomy); 
    348442        $_term = $term; 
    349443    } else { 
    350444        $term = (int) $term; 
    351         if ( ! $_term = wp_cache_get($term, "term:$taxonomy") ) { 
     445        if ( ! $_term = wp_cache_get($term, $taxonomy) ) { 
    352446            $_term = $wpdb->get_row("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 = '$taxonomy' AND t.term_id = '$term' LIMIT 1"); 
    353             wp_cache_add($term, $_term, "term:$taxonomy"); 
     447            wp_cache_add($term, $_term, $taxonomy); 
    354448        } 
    355449    } 
    356450 
    357451    $_term = apply_filters('get_term', $_term, $taxonomy); 
     452    $_term = apply_filters("get_$taxonomy", $_term, $taxonomy); 
    358453 
    359454    if ( $output == OBJECT ) { 
     
    368463} 
    369464 
     465function get_term_by($field, $value, $taxonomy, $output = OBJECT) { 
     466    global $wpdb; 
     467 
     468    if ( ! is_taxonomy($taxonomy) ) 
     469        return false; 
     470 
     471    if ( 'slug' == $field ) { 
     472        $field = 't.slug'; 
     473        $value = sanitize_title($field); 
     474        if ( empty($value) ) 
     475            return false; 
     476    } else if ( 'name' == $field ) { 
     477        // Assume already escaped 
     478        $field = 't.name'; 
     479    } else { 
     480        $field = 't.term_id'; 
     481        $value = (int) $value; 
     482    } 
     483 
     484    $term = $wpdb->get_row("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 = '$taxonomy' AND $field = '$value' LIMIT 1"); 
     485    if ( !$term ) 
     486        return false; 
     487 
     488    wp_cache_add($term->term_id, $term, $taxonomy); 
     489 
     490    if ( $output == OBJECT ) { 
     491        return $term; 
     492    } elseif ( $output == ARRAY_A ) { 
     493        return get_object_vars($term); 
     494    } elseif ( $output == ARRAY_N ) { 
     495        return array_values(get_object_vars($term)); 
     496    } else { 
     497        return $term; 
     498    } 
     499} 
     500 
     501function _get_term_hierarchy($taxonomy) { 
     502    // TODO Make sure taxonomy is hierarchical 
     503    $children = get_option("{$taxonomy}_children"); 
     504    if ( is_array($children) ) 
     505        return $children; 
     506 
     507    $children = array(); 
     508    $terms = get_terms('category', 'hide_empty=0&hierarchical=0'); 
     509    foreach ( $terms as $term ) { 
     510        if ( $term->parent > 0 ) 
     511            $children[$cterm->parent][] = $term->term_id; 
     512    } 
     513    update_option("{$taxonomy}_children", $children); 
     514 
     515    return $children; 
     516} 
     517 
     518function &_get_term_children($term_id, $terms) { 
     519    if ( empty($terms) ) 
     520        return array(); 
     521 
     522    $term_list = array(); 
     523    $has_children = _get_term_hierarchy(); 
     524 
     525    if  ( ( 0 != $term_id ) && ! isset($has_children[$term_id]) ) 
     526        return array(); 
     527 
     528    foreach ( $terms as $term ) { 
     529        if ( $term->term_id == $term_id ) 
     530            continue; 
     531 
     532        if ( $term->parent == $term_id ) { 
     533            $term_list[] = $term; 
     534 
     535            if ( !isset($has_children[$term->term_id]) ) 
     536                continue; 
     537 
     538            if ( $children = _get_cat_children($term->term_id, $terms) ) 
     539                $term_list = array_merge($term_list, $children); 
     540        } 
     541    } 
     542 
     543    return $term_list; 
     544} 
     545 
    370546?>