Introduction

One of the flexible features of Drupal is its taxonomy system. It provides the ability to structure your Web site; you can then use that structure to support organization and navigation. Many people say this is one of the features that helps distinguish Drupal from other content management systems.

Information in this article should not be interpreted as a rigid set of development guidelines that must be followed, but rather as a place to start when providing structure to your own Web site.

Classification

Taxonomies in Drupal are used to associate your content with categories. This collects similar content into named groups that can be used in a variety of ways. Common uses include site navigation, content organization, styling of content, and more specialized searching. A good taxonomy will let you navigate to similar content very easily and organize that content into groups that are presented to your users.

Drupal's taxonomy allows Web site administrators to create a way to classify the content on the Web site and use that classification for several features that will enhance the user's experience. In general, there are two ways to provide classification: with a predefined set of fixed categories or by allowing the users to use free tagging and create the categories on the fly.

Fixed categories

If you decide to use a fixed set of categories, it's important that you understand your users and how they will use the information on your Web site. One big advantage of a fixed category set is that it is controlled and ideally, maps to how the information will be organized and accessed. It is well controlled but rigid.

Controlled vocabulary is a list of terms that have been enumerated explicitly. This list is controlled by and is available from a controlled vocabulary registration authority. All terms in a controlled vocabulary should have an unambiguous, nonredundant definition. This is a design goal, but may not be true in practice.

Free tagging

Drupal also lets the user community use free tagging, which allows arbitrary terms for classifying content. By letting users classify or tag content themselves, they define their own categorization schemes. Users can use the categorization that is familiar to them. The hope is other users will converge on the same set of categories so that associations between content can easily be found. However, this does not always work, and it can increase the possibility that similar content maybe tagged differently and not appear together within the navigation provided by the taxonomy system. This is the compromise between free-form classification and the reliable application of fixed categories for all users.

Web sites that allow their community of users to freely tag their data are commonly known as folksonomies. Many Web sites today allow users to classify, or tag, the content they create. Flickr and del.icio.us are two early Web sites that popularized this technique for images and bookmarks, respectively. Folksonomies enable their communities to create an informal set of tags for their content and users can pick the descriptions that best suite them. However, one user's terminology may not be consistent with another. This is an active area, with many interesting discussions about the pros and cons of this approach. (See Peter Merholz and Louis Rosenfeld.)

For example, del.icio.us is a Web site for storing your bookmarks. While storing your bookmarks and accessing them from any Web browser is nice, the power of the system comes from the ability to see other people's bookmarks and access them through a common tagging system. The tags allow people to use as many words as necessary to identify their content. del.icio.us describes classification, or tagging, as:

"A tag is simply a word you use to describe a bookmark. Unlike folders, you make up tags when you need them and you can use as many as you like. The result is a better way to organize your bookmarks and a great way to discover interesting things on the Web."

Whether using a fixed set of categories or enabling free tagging, the classification of content can greatly enhance the user experience. Not only can users find their own content more easily, but they can also find related information in the community that would otherwise not be possible.

A pragmatic approach

Using the taxonomy system effectively on your site takes some effort on the administrator's part during the initial vocabulary definition and subsequent content creation tasks. However, once the initial definition is complete, you can quickly see the results as you explore content that has been classified, revealing similar information.

Initially, we did not use the taxonomy system for the IBC Web site. When beginning with Drupal, it's not one of the first things you try to understand. Instead, we mapped the information architecture described in Part 2 to the node types we thought were needed, then created modules to cater to each node type. For the purposes of this article, we'll redesign and reimplement the announcement module to take advantage of the taxonomy system. This approach will allow users to quickly find announcements on a specific topic area and easily see related announcements.

Many purists promote a "right" way to classify content. However, from a practical standpoint, using any taxonomy, even if incomplete or inconsistent, can substantially enhance your Web site. It's not as important to be precise as it is to just get started.

The rest of this article describes Drupal terminology related to taxonomies and how it implements them. We'll use the Drupal administrative interface to create a vocabulary and its terms. Then, with this newly defined taxonomy, we enhance our announcement module with customized navigation and organization. We also describe some programmatic ways of interacting with the taxonomy system and using it for the styling of content.

Taxonomies in Drupal

According to Drupal, there are three main tasks related to taxonomies on Web sites:

• Managing categories within the system
• Organizing content by categories so users can see similar content
• Navigating to similarly tagged content

An administrative interface allows users with permissions to easily create the taxonomy. Content creators can then tag the nodes during the editing process with the appropriate taxonomy categories. Drupal also has a number of modules that support and extend the core taxonomy system.

Vocabularies and terms

The base taxonomy structure in Drupal is the vocabulary. Vocabularies are collections that contain the properties and relationships that are used when classifying your content. An individual entry in the vocabulary is a term. Terms represent the categories of the content in your site. When you create content you can associate it with one or more terms, which can then be used elsewhere by your users, administrators, or a Drupal module. The taxonomy system supports many vocabularies, each with its own distinct set of terms. This allows content to be classified according to multiple vocabularies, giving you great flexibility in how you present, interact, and manage information.

Within a vocabulary, there are two types of inter-term relationships:

• Hierarchical (vertical), which is the standard parent-child relationship. Hierarchical relationships are enabled by the administrator and chosen by the term editor.
• Associative (horizontal), with similarity between terms, as in a thesaurus. Associative relationships are created by creating synonyms between terms.

Figure 1 shows related terms in a hierarchical relationship in a vocabulary with black lines, while associative relationships are shown in blue.

Vocabulary attributes

When defining your vocabulary there are a few attributes you can modify, including:

Hierarchy

Lets you specify a tree structure for your vocabulary. You can disable hierarchies and have a flat structure. If enabled there are two choices: single or multiple. A single hierarchy, such as the file system browser, is what most users are familiar with. Multiple hierarchies allow a term to have more than one parent. The term would then appear in multiple places in the tree structure; for example, as a short cut or symbolically linked folder or file appearing in multiple places in the file browser. This provides greater access to the term and its content, but also adds the risk of confusing inexperienced users.

Related terms

Related terms, or synonyms, are used to link different terms to each other in your vocabulary. It acts just like in a thesaurus. The glossary module is an example of the use of synonyms.

Free tagging

Free tagging can be enabled for your vocabulary. When this attribute is selected, classifications are created by the user typing in term names instead of selecting from a predefined list of terms.

Multiple select

A nice feature of this system is that you can classify content by enabling multiple select in your vocabulary. Using this method of multiple classifications, you can access and display the content from multiple perspectives. This gives added flexibility in how users can navigate and view content. To enable this feature, check the "multiple select" checkbox when editing your vocabulary. This is always true when you enable free tagging for your vocabulary.

Required

During editing of nodes, every node type associated with this vocabulary will have to specify a term if the required attribute is selected. This will enforce that all nodes get tagged during the editing process.

Term attributes

There are a couple relevant attributes when defining a new term:

Parent

You can specify the parent term for this term. The presentation of this attribute depends on how you defined the vocabulary. If the vocabulary has the hierarchy disabled, the choice for a parent is not displayed. If it is a single hierarchy, the choice will be from a drop-down list. If it is a multiple hierarchy, a list will be presented that you can Ctrl+Click to select multiple parent terms. If the term is at the top level, select <root> as the parent.

Synonyms

You can enter the names of the synonyms for this term. Some uses of synonyms include abbreviations or alternate spellings for the term. Synonyms are entered one per line in the dialog box. One possible use of these synonyms could be employed within the search hook of your module; you could check for similar keywords to the ones given to create a wider search result list.

Back to top

Creating a taxonomy

In this section, we will create our own vocabulary and terms. See Part 2 in this series for methods to create a commonly understood information architecture for your Web site, which can be used as the basis of your taxonomy. We will use the Drupal administrator's interface, shown in Figure 2, to create the vocabulary and terms. You get to this interface through the administer/categories menu (for example, http://ibc.development/admin/taxonomy). At this point, no vocabularies have been defined.

In this example, we will create the IBC vocabulary for organizing our announcements on the Web site. We start by selecting Add Vocabulary on this panel, which brings up the panel to begin to specify the attributes of your vocabulary. As shown in Figure 3, we'll name this vocabulary IBC, enable it for the Announcement node type, enable a Single hierarchy, and allow Multiple select of terms for a given node.

The administrator can also make the specification of a term from this vocabulary required when the editor creates a node. The description of the IBC vocabulary is also shown in Figure 3.

Once the vocabulary is created, it appears in the main listing as shown in Figure 4.

To begin adding terms for a particular vocabulary, select Add terms for that vocabulary on the main listing page. Figure 5 shows the interface that allows the entry of multiple terms. Here you can provide:

• A Parent term, the parent term in this vocabulary. (Choose <root> if at the top level.)
• A Name, the name of the term.
• A Description, used by other modules and feeds
• Any Synonyms, with variations in spelling, acronyms and other similar terms
• A Weight, terms with a lower weight will appear before those with a higher weight

For this example, our vocabulary will include the terms: General, Workgroup, Conference, Members and Website. These will be used to classify our announcements.

When all the terms have been added, you can list them for a specific vocabulary by selecting List, as shown in Figure 6. Here we have added the terms Conference, General, Members, Website and Workgroup.

Back to top

Taxonomy and content creation

Now, when you create an announcement for your Web site, you can associate that node with the terms within this vocabulary. A new section in the Edit view called Categories is shown in Figure 7. This section allows the announcement to be assigned to one or more terms from the IBC vocabulary. Here, we assign it to the term Conference.

If a particular announcement is associated with more than one category, we can select multiple terms using Shift+Click or Ctrl+Click, as shown in Figure 8. In this case, we assign it to the terms General and Website.

We now have our taxonomy defined and content associated with the various terms. The taxonomy system automatically will filter content for you based on a term ID. In Figure 9, we go to the URL http://ibc.development/taxonomy/term/13 to display all the content that has been tagged with the term Website. Unfortunately, you need to know the term ID in order to use this method of displaying content. There are, however, ways to alias the URL path so that the taxonomy term name can be used instead of the ID. You can also provide navigation links to go to the named categories.

In the next section, we'll provide a programmatic way to categorize announcements by terms using a new block module.

Back to top

Taxonomy functions

Once you've created your taxonomy and associated content with the appropriate terms, you can present customized content and support the user by creating more relevant presentations. In this section you will begin to see how you can programmatically interact with the taxonomy system.

There are several functions to programmatically work with taxonomy vocabularies and terms. The following functions help in accessing taxonomy information:

For saving vocabularies and terms, the following functions are available:

hook_taxonomy

A special hook, hook_taxonomy, allows modules to react to changes in the taxonomy. This hook is invoked when terms or vocabularies are modified. The type of action that is being done, and whether this action is on a vocabulary or term, is identified.

See Taxonomy functions for more information.

Back to top

Programmatically adding taxonomy terms to a node

The saving term and vocabulary functions just mentioned take an array argument to update or insert either a term or vocabulary element into the database. The array includes an ID (term or vocabulary ID), a name, description, and weight. For instance, it would be nice to be able to add or remove vocabulary terms when a node is added or deleted. Much like we dynamically build the workgroup or conference navigation menus, we could automatically add or remove workgroups or conferences as terms in the vocabulary using these functions.

Listing 1 shows how to dynamically create a term when a workgroup is saved for the first time. Similar code is necessary to remove the term when deleting a workgroup. When deleting a workgroup, you also want to remove any associations with nodes classified with this term in the term_node table.

function workgroup_insert($node) {
  ...  
  $voc  = taxonomy_get_vocabulary_by_name('IBC');
  $vid  = $voc->vid;
  $edit = array ("vid" => $vid, "name" => $node->title);
  $msg  = taxonomy_save_term($edit); 
}

// support function to get the vocabulary by its name (not vid)
function taxonomy_get_vocabulary_by_name ($name) {
  $results = db_query('SELECT * FROM {vocabulary} WHERE name = "%s"', $name);
	if (db_num_rows($results) > 0) {
	 	return db_fetch_object($results);
	}
	else {
		return null;
	}
}
    

The new taxonomy_get_vocabulary_by_name function should be appropriately placed in the taxonomy.module.

Back to top

Organizing and navigating content

Drupal will automatically create a view for all nodes tagged with a specific term. If you use the URL http://<yoursite>/taxonomy/term/13, it will display all nodes tagged with the term with ID of 13, as shown in Figure 9.

This is not a very easy interface to use. For a more user-friendly way to work with taxonomy navigation, we'll borrow from the taxonomy_dhtml module. We extend the announcement module by adding an extra block for displaying the IBC vocabulary, its terms, and the content that has been classified.

First let's enable the block. In Figure 10, the administer -> blocks panel (http://<yoursite>/admin/block) shows all possible blocks, including all the defined vocabularies. We enable the IBC vocabulary and add it to the right sidebar block with a weight of -9. This will put it high up in the display in the right sidebar just below the recently updated announcements.

Figure 11 shows the effect of selecting Website, term 13, in the sidebar. The sidebar lists the IBC vocabulary with each term. Next to the term is the number of classified nodes. Following each term is a list of a select number of this classified content.

We've made several assumptions for this demonstration. The IBC vocabulary is meant only to classify announcements, but could have easily been used to classify more node types. And, we are not using a hierarchy of terms in this example. In terms of the user interface, we would typically use either the recent announcements block or the announcements vocabulary block, but not both. Given these assumptions, the announcement block, originally defined in Part 6, Listing 9, is redefined in Listing 2.

function announcement_block($op = 'list', $delta = 0, $edit = array()) {
   global $user;
   if ($op == 'list') {
      $blocks[0]['info'] = t('Recently updated announcements');	
      $blocks[1]["info"] = t('List nodes in the IBC vocabulary');
      return $blocks;
   }
   else if ($op == 'view')	{
      $block	= array();
      switch ($delta) {
         case 0:
            $announcement_items = array();
            if (user_access('access content')) {
               $q = 'SELECT … '; 
               $now = time();
               $items = variable_get('announcement_block_max_list_count', 3);
               while (db_num_rows($announcements) > 0 and 
                      $announcement = db_fetch_object($announcements)) {	
                  $announcement_items[] = $announcement;			
               }
            }
            $block['subject'] = t('Announcements');
            $block['content'] = theme('announcement_block_list', $announcement_items);
            break;
         case 1:
            if (user_access("access content")) {
               $vocabulary = taxonomy_get_vocabulary_by_name('IBC');
               $block["subject"]= t('IBC');
               $block["content"]= _announcement_vocab($vocabulary->vid);
            }
      }
      return $block;
   }
}
	

In the list operation we register the IBC vocabulary with the delta of 1. This will display in the administer/blocks interface, as shown in Figure 10.

Once enabled, the view operation renders the IBC vocabulary terms in this new sidebar. When the IBC vocabulary block is being displayed, the $delta argument to the block hook function will be 1. The taxonomy_dhtml module uses a different technique by looping over all the vocabularies and displaying each in a separate block indexed by the vocabulary's vid. Here, we simply use the function taxonomy_get_vocabulary_by_name to get the IBC vocabulary and the support function _announcement_vocab(), shown in Listing 3, that does the work of producing the terms to be listed.

function _announcement_vocab($vocabulary_id, $op = NULL) {
  $tree = taxonomy_get_tree($vocabulary_id);
  foreach ($tree as $term) {
  	$url = "taxonomy/term/$term->tid";
    if ($op) {
    	$url .= "/$op";
    }
    $link = l(t($term->name), $url, array("title" => t($term->description)));
    $out .= _taxonomy_depth($term->depth, " ")."- $link";
    $count = taxonomy_term_count_nodes($term->tid);
    if ($count) {
    	$out .= " ($count)";
    	$out .= _announcement_by_terms($term->tid);
    }
    else {
    	$out .= " (0)";
    }
    $out .= "<br />";
  }
  return $out;
}
	

For each term, it creates a link in the sidebar of that term. Clicking on the term will display a page with all nodes that are categorized with that term. It uses the taxonomy function taxonomy_term_count_nodes() to count the number of nodes classified and displays it next to the term. Then for each term, we prepare links for each classified node using the function _announcement_by_terms(), shown in Listing 4.

function _announcement_by_terms($tid) {
	$result = '';
	$tids   = array( $tid );
	$nodes  = taxonomy_select_nodes($tids, 'or', 0, FALSE);
	while ($r = db_fetch_object($nodes)) {
		$url = "announcements/". $r->nid;
		$result .= "<br/>&nbsp; - &nbsp;" . 
		           l($r->title, $url, array("title" => t($r->title)));
	}
	return $result;
}
	

Here we use the function taxonomy_select_nodes() to get all the nodes (which will only be announcements in our case) classified by the term ID, $tid. We create the link that will be presented with the term.

See Resources for more information on using taxonomies for navigation.

Back to top

Taxonomy used for styling

Part 7 explains a method for setting the class attribute value in the body element defined in the page.tpl.php file. You use the method to automatically change the presentation of a page when, for example, content for a new section is displayed. This method used a PHP switch statement that sets the value for the class attribute based on the first argument in the URL. Listing 6 in Part 7 shows this code.

In this section, we present a method by which we can define the class attribute value using a specifically defined vocabulary. This way we can control the styling of particular areas of the Web site using this vocabulary controlled through the Drupal administration interface, rather than changing code in the page.tpl.php template.

Let's start by defining the new vocabulary that is going to describe the relationship of our IBC content types to the major Web site sections -- home, workgroups, conferences, and members. We need a single select, single hierarchy vocabulary and will call it IBC Section Hierarchy. We create this vocabulary as described earlier in this article. Then we add the terms that define Web site sections that we determined from our analysis in Part 2. Under these we add the terms identifying the node type names of content that will appear within these Web site sections. Figure 12 shows a list of what this vocabulary might look like.

You'll notice that announcements appear under the home term. In our information architecture for the IBC Web site, we grouped site-wide content like announcements, about, and contact information into the general home section. From a visual point of view, they are styled the same way as the home page.

Instead of using the code presented in Part 7, we'll use the code in Listing 6 to demonstrate how we can use the vocabulary above to define a class attribute value for use in the BODY element of our Web page.

...
<?php
  $page_type = '';
  if (!$is_front) {
    if (arg(0) == 'node' && arg(2) == NULL) {
      $terms = taxonomy_node_get_terms(arg(1));
    }
    else {
      $terms = taxonomy_get_term_by_name(arg(0));
    }
    foreach ($terms as $term) {
      $tid = $term->tid;
      break;
    }
    $parents = taxonomy_get_parents($tid);
    foreach ($parents as $parent) {
      $section = $parent->name;
      break;
    }
    $page_type = ($section?$section:$term->name);
  }
  else {
    $page_type = 'home';
  }
?>
<body class="<?php print $page_type; ?>" >
...
    

If the front page is being displayed, then the class attribute value is set to home by default. If the front page is not being presented, then we need to determine what the associated taxonomy term is for the given URL. Unlike our previous method, we check generic Drupal URLs such as /node/123. For these, we pass the node ID to the taxonomy_node_get_terms() function to get an array of term objects associated with this URL. If this isn't a generic Drupal URL, such as /announcements/123, we use the taxonomy_get_term_by_name() function to get an array of term objects associated with this URL.

The term ID, $tid, is found using a foreach loop on the array term object array retrieved. Now that we have the term ID associated with this URL, we need to find out if there is a parent to this term. We pass the term ID to the taxonomy_get_parents() function to get an array of parent term objects. Using a similar foreach loop, we can set the $section variable with the name of the parent term. So, imagine the URL is /announcements/123, then the term ID for the announcements term is used to retrieve the parent term name, home.

Now the $page_type variable, which we use to set the class attribute value, is built. If a parent term is found, then its name is used. If no parent is found, then the term name associated with the URL is used. As long as we maintain a vocabulary, like the one above, that matches the first argument of the URL to the associated node terms, we can control the styling of the page.

Summary

This article describes taxonomies and tagging to help create meaningful user experiences on Web sites. We introduced the terminology used in Drupal and provided a few examples of things you can do with the flexible taxonomy system. We've tried to take a pragmatic approach by showing a few techniques that are available to developers. Once you start using it, you will find new ways to take advantage of its flexibility. Check out the many modules that extend the taxonomy system (see Resources).

In the next article, you'll learn how to deploy your Web site to a production environment.

Resources

Learn

• RSS feed for this series. (Find out more about RSS.)
  
  
• The following links point to Drupal documentation that is relevant to this article:
  • Taxonomy modules, by category
  • More about Taxonomy
  • More information on using taxonomies for navigation
  • Taxonomy reference, categories and classification schemes
  • Guidelines for effective design of taxonomies
  • Taxonomy functions
  
  
• Drupal: Creating Blogs, Forums, Portals and Community Websites (David Mercer PACKT Publishing, May 2006).
  
  
• In the Architecture area on developerWorks, get the resources you need to advance your skills in the architecture arena.
  
  
• Browse the technology bookstore for books on these and other technical topics.
  
  

Get products and technologies

• Part 14 provides the complete announcement module download.
  
  
• Download IBM product evaluation versions and get your hands on application development tools and middleware products from DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
  
  

Discuss

• Participate in the discussion forum.
  
  
• Check out developerWorks blogs and get involved in the developerWorks community.
  
  

About the authors

Alister Lewis-Bowen is a senior software engineer in IBM's Internet Technology Group. He has worked on Internet and Web technologies as an IBM UK employee since 1993. Alister was brought to the U.S. to work on the Web sites for the IBM-sponsored sports events, then as senior Webmaster for ibm.com. He is currently helping create semantic Web prototypes.

Stephen Evanchik is a software engineer in IBM's Internet Technology Group. He has been a contributor to many open source software projects, the most notable being his IBM TrackPoint driver in the Linux kernel. Stephen is currently working with emerging semantic Web technologies.

Louis Weitzman is a senior software engineer in IBM's Internet Technology Group. For 30 years he has worked at the intersection of design and computation. He helped develop an XML, fragment-based content management system in use by ibm.com, and currently is involved with bringing the design process to emerging projects.

Comments (Undergoing maintenance)

Back to top

Trademarks  |  My developerWorks terms and conditions

Table of contents

• Introduction
• Taxonomies in Drupal
• Creating a taxonomy
• Taxonomy and content creation
• Taxonomy functions
• Programmatically adding taxonomy terms to a node
• Organizing and navigating content
• Taxonomy used for styling
• Summary
• Resources
• About the authors
• Comments

Local resources

• IBM Innovation Center - Austin, TX
• IBM Innovation Center - Chicago, IL
• IBM Innovation Center - Dallas, TX
• IBM Innovation Center - San Mateo, CA
• IBM Innovation Center - Waltham, MA
• Technical Briefings in North America

My developerWorks community