rdf.module 23.2 KB
Newer Older
1 2 3 4
<?php

/**
 * @file
5
 * Enables semantically enriched output for Drupal sites in the form of RDFa.
6 7
 */

8
use Drupal\Core\Template\Attribute;
9
use Symfony\Cmf\Component\Routing\RouteObjectInterface;
10

11
/**
12
 * Implements hook_help().
13 14 15 16 17 18
 */
function rdf_help($path, $arg) {
  switch ($path) {
    case 'admin/help#rdf':
      $output = '';
      $output .= '<h3>' . t('About') . '</h3>';
19
      $output .= '<p>' . t('The RDF module enriches your content with metadata to let other applications (e.g., search engines, aggregators, and so on) better understand its relationships and attributes. This semantically enriched, machine-readable output for Drupal sites uses the <a href="!rdfa">RDFa specification</a>, which allows RDF data to be embedded in HTML markup. Other modules can define mappings of their data to RDF terms, and the RDF module makes this RDF data available to the theme. The core Drupal modules define RDF mappings for their data model, and the core Drupal themes output this RDF metadata information along with the human-readable visual information. For more information, see the <a href="!rdf">online documentation for the RDF module</a>.', array('!rdfa' => 'http://www.w3.org/TR/xhtml-rdfa-primer/', '!rdf' => 'https://drupal.org/documentation/modules/rdf')) . '</p>';
20 21 22 23
      return $output;
  }
}

24
/**
25
 * @defgroup rdf RDF Mapping API
26
 * @{
27
 * Functions to describe entities and bundles in RDF.
28
 *
29 30 31 32
 * The RDF module introduces RDF and RDFa to Drupal. RDF is a W3C standard to
 * describe structured data. RDF can be serialized as RDFa in XHTML attributes
 * to augment visual data with machine-readable hints.
 * @see http://www.w3.org/RDF/
33 34
 * @see http://www.w3.org/TR/xhtml-rdfa-primer/
 *
35 36 37 38
 * Modules can provide mappings of their bundles' data and metadata to RDF
 * classes and properties. This module takes care of injecting these mappings
 * into variables available to theme functions and templates. All Drupal core
 * themes are coded to be RDFa compatible.
39 40 41
 */
/**
 * Returns the RDF mapping object associated to a bundle.
42
 *
43 44 45 46 47 48 49 50
 * The function reads the rdf_mapping object from the current configuration,
 * or returns a ready-to-use empty one if no configuration entry exists yet for
 * this bundle. This streamlines the manipulation of mapping objects by always
 * returning a consistent object that reflects the current state of the
 * configuration.
 *
 * Example usage:
 * -Map the 'article' bundle to 'sioc:Post' and the 'title' field to 'dc:title'.
51
 * @code
52 53 54 55 56 57 58 59
 * rdf_get_mapping('node', 'article')
 *   ->setBundleMapping(array(
 *     'types' => array('sioc:Post'),
 *   ))
 *   ->setFieldMapping('title', array(
 *     'properties' => array('dc:title')
 *   ))
 *   ->save();
60 61
 * @endcode
 *
62 63 64 65 66
 * @param string $entity_type
 *   The entity type.
 * @param string $bundle
 *   The bundle.
 *
67
 * @return \Drupal\rdf\Entity\RdfMapping
68
 *   The RdfMapping object.
69
 */
70 71 72 73 74 75 76 77 78 79 80 81 82 83
function rdf_get_mapping($entity_type, $bundle) {
  // Try loading the mapping from configuration.
  $mapping = entity_load('rdf_mapping', $entity_type . '.' . $bundle);

  // If not found, create a fresh mapping object.
  if (!$mapping) {
    $mapping = entity_create('rdf_mapping', array(
      'targetEntityType' => $entity_type,
      'bundle' => $bundle,
    ));
  }

  return $mapping;
}
84

85 86 87 88 89 90 91 92
/**
 * Implements hook_rdf_namespaces().
 */
function rdf_rdf_namespaces() {
  return array(
    'content'  => 'http://purl.org/rss/1.0/modules/content/',
    'dc'       => 'http://purl.org/dc/terms/',
    'foaf'     => 'http://xmlns.com/foaf/0.1/',
93
    'og'       => 'http://ogp.me/ns#',
94
    'rdfs'     => 'http://www.w3.org/2000/01/rdf-schema#',
95
    'schema'   => 'http://schema.org/',
96 97 98 99 100 101 102
    'sioc'     => 'http://rdfs.org/sioc/ns#',
    'sioct'    => 'http://rdfs.org/sioc/types#',
    'skos'     => 'http://www.w3.org/2004/02/skos/core#',
    'xsd'      => 'http://www.w3.org/2001/XMLSchema#',
  );
}

103
/**
104 105 106 107
 * Retrieves RDF namespaces.
 *
 * Invokes hook_rdf_namespaces() and collects RDF namespaces from modules that
 * implement it.
108 109
 */
function rdf_get_namespaces() {
110 111
  $namespaces = array();
  // In order to resolve duplicate namespaces by using the earliest defined
112
  // namespace, do not use \Drupal::moduleHandler()->invokeAll().
113
  foreach (\Drupal::moduleHandler()->getImplementations('rdf_namespaces') as $module) {
114
    $function = $module . '_rdf_namespaces';
115 116 117 118 119 120 121
    foreach($function() as $prefix => $namespace) {
      if (array_key_exists($prefix, $namespaces) && $namespace !== $namespaces[$prefix]) {
        throw new Exception(t('Tried to map @prefix to @namespace, but @prefix is already mapped to @orig_namespace.', array('@prefix' => $prefix, '@namespace' => $namespace, '@orig_namespace' => $namespaces[$prefix])));
      }
      else {
        $namespaces[$prefix] = $namespace;
      }
122 123
    }
  }
124
  return $namespaces;
125 126
}

127 128 129 130 131 132 133 134 135
/**
 * @} End of "defgroup rdf".
 */

/**
 * @addtogroup rdf
 * @{
 */

136
/**
137 138
 * Builds an array of RDFa attributes for a given mapping.
 *
139 140 141 142
 * This array will typically be passed through Drupal\Core\Template\Attribute
 * to create the attributes variables that are available to template files.
 * These include $attributes, $title_attributes, $content_attributes and the
 * field-specific $item_attributes variables.
143
 *
144 145 146
 * @param array $mapping
 *   An array containing a mandatory 'properties' key and optional 'datatype',
 *   'datatype_callback' and 'type' keys. For example:
147 148
 *   @code
 *     array(
149 150 151 152 153 154 155
 *       'properties' => array('schema:interactionCount'),
 *       'datatype' => 'xsd:integer',
 *       'datatype_callback' => array(
 *         'callable' => 'Drupal\rdf\SchemaOrgDataConverter::interactionCount',
 *         'arguments' => array(
 *           'interaction_type' => 'UserComments'
 *         ),
156 157 158
 *       ),
 *     );
 *   @endcode
159
 * @param mixed $data
160 161
 *   (optional) A value that needs to be converted by the provided callback
 *   function.
162
 *
163
 * @return array
164
 *   RDFa attributes suitable for Drupal\Core\Template\Attribute.
165 166
 */
function rdf_rdfa_attributes($mapping, $data = NULL) {
167 168
  $attributes = array();

169
  // The type of mapping defaults to 'property'.
170
  $type = isset($mapping['mapping_type']) ? $mapping['mapping_type'] : 'property';
171 172 173 174 175

  switch ($type) {
    // The mapping expresses the relationship between two resources.
    case 'rel':
    case 'rev':
176
      $attributes[$type] = $mapping['properties'];
177 178 179 180 181
      break;

    // The mapping expresses the relationship between a resource and some
    // literal text.
    case 'property':
182 183 184 185
      if (!empty($mapping['properties'])) {
        $attributes['property'] = $mapping['properties'];
        // Convert $data to a specific format as per the callback function.
        if (isset($data) && !empty($mapping['datatype_callback'])) {
186 187 188
          $callback = $mapping['datatype_callback']['callable'];
          $arguments = isset($mapping['datatype_callback']['arguments']) ? $mapping['datatype_callback']['arguments'] : NULL;
          $attributes['content'] = call_user_func($callback, $data, $arguments);
189 190 191 192 193
        }
        if (isset($mapping['datatype'])) {
          $attributes['datatype'] = $mapping['datatype'];
        }
        break;
194 195 196 197 198 199 200
      }
  }

  return $attributes;
}

/**
201
 * @} End of "addtogroup rdf".
202 203
 */

204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
/**
 * Implements hook_entity_prepare_view().
 */
function rdf_entity_prepare_view($entity_type, array $entities, array $displays) {
  // Iterate over the RDF mappings for each entity and prepare the RDFa
  // attributes to be added inside field formatters.
  foreach ($entities as $entity) {
    $mapping = rdf_get_mapping($entity_type, $entity->bundle());
    // Only prepare the RDFa attributes for the fields which are configured to
    // be displayed.
    foreach ($displays[$entity->bundle()]->getComponents() as $name => $options) {
      $field_mapping = $mapping->getPreparedFieldMapping($name);
      if ($field_mapping['properties']) {
        foreach ($entity->get($name) as $item) {
          $item->_attributes += rdf_rdfa_attributes($field_mapping, $item->getValue());
        }
      }
    }
  }
}

225 226 227 228 229
/**
 * Implements hook_comment_load().
 */
function rdf_comment_load($comments) {
  foreach ($comments as $comment) {
230 231 232
    // Pages with many comments can show poor performance. This information
    // isn't needed until rdf_preprocess_comment() is called, but set it here
    // to optimize performance for websites that implement an entity cache.
233 234
    $created_mapping = rdf_get_mapping('comment', $comment->bundle())
      ->getPreparedFieldMapping('created');
235 236
    $comment->rdf_data['date'] = rdf_rdfa_attributes($created_mapping, $comment->getCreatedTime());
    $entity = $comment->getCommentedEntity();
237
    $comment->rdf_data['entity_uri'] = $entity->url();
238 239
    if ($comment->hasParentComment()) {
      $comment->rdf_data['pid_uri'] = $comment->getParentComment()->url();
240 241 242 243
    }
  }
}

244 245 246 247 248 249
/**
 * Implements hook_theme().
 */
function rdf_theme() {
  return array(
    'rdf_metadata' => array(
250
      'variables' => array('metadata' => array()),
251
      'template' => 'rdf-metadata',
252 253 254 255
    ),
  );
}

256
/**
257
 * Implements hook_preprocess_HOOK() for HTML document templates.
258 259 260 261
 */
function rdf_preprocess_html(&$variables) {
  // Adds RDF namespace prefix bindings in the form of an RDFa 1.1 prefix
  // attribute inside the html element.
262 263 264
  if (!isset($variables['html_attributes']['prefix'])) {
    $variables['html_attributes']['prefix'] = array();
  }
265
  foreach(rdf_get_namespaces() as $prefix => $uri) {
266
    $variables['html_attributes']['prefix'][] = $prefix . ': ' . $uri . " ";
267 268 269
  }
}

270
/**
271
 * Implements hook_preprocess_HOOK() for node templates.
272 273
 */
function rdf_preprocess_node(&$variables) {
274
  // Adds RDFa markup to the node container. The about attribute specifies the
275 276 277
  // URI of the resource described within the HTML element, while the @typeof
  // attribute indicates its RDF type (e.g., foaf:Document, sioc:Person, and so
  // on.)
278 279 280
  $bundle = $variables['node']->bundle();
  $mapping = rdf_get_mapping('node', $bundle);
  $bundle_mapping = $mapping->getPreparedBundleMapping('node', $bundle);
281
  $variables['attributes']['about'] = empty($variables['node_url']) ? NULL: $variables['node_url'];
282
  $variables['attributes']['typeof'] = empty($bundle_mapping['types']) ? NULL : $bundle_mapping['types'];
283

284 285 286
  // Adds RDFa markup for the node title as metadata because wrapping the title
  // with markup is not reliable and the title output is different depdending on
  // the view mode (e.g. full vs. teaser).
287
  $title_mapping = $mapping->getPreparedFieldMapping('title');
288 289
  if ($title_mapping) {
    $title_attributes['property'] = empty($title_mapping['properties']) ? NULL : $title_mapping['properties'];
290
    $title_attributes['content'] = $variables['node']->label();
291 292 293
    $variables['title_suffix']['rdf_meta_title'] = array(
      '#theme' => 'rdf_metadata',
      '#metadata' => array($title_attributes),
294
    );
295 296
  }

297 298 299 300 301 302 303
  // Adds RDFa markup for the relation between the node and its author.
  $author_mapping = $mapping->getPreparedFieldMapping('uid');
  if (!empty($author_mapping['properties']) && $variables['submitted']) {
    $author_attributes = array('rel' => $author_mapping['properties']);
    $variables['submitted'] = '<span ' . new Attribute($author_attributes) . '>' . $variables['submitted'] . '</span>';
  }

304
  // Adds RDFa markup for the date.
305
  $created_mapping = $mapping->getPreparedFieldMapping('created');
306
  if (!empty($created_mapping) && $variables['submitted']) {
307
    $date_attributes = rdf_rdfa_attributes($created_mapping, $variables['node']->getCreatedTime());
308 309 310 311 312
    $rdf_metadata = array(
      '#theme' => 'rdf_metadata',
      '#metadata' => array($date_attributes),
    );
    $variables['submitted'] .= drupal_render($rdf_metadata);
313
  }
314 315

  // Adds RDFa markup annotating the number of comments a node has.
316 317
  if (\Drupal::moduleHandler()->moduleExists('comment') && \Drupal::currentUser()->hasPermission('access comments')) {
    $comment_count_mapping = $mapping->getPreparedFieldMapping('comment_count');
318 319
    if (!empty($comment_count_mapping['properties'])) {
      $fields = array_keys(\Drupal::service('comment.manager')->getFields('node'));
320
      $definitions = array_keys($variables['node']->getFieldDefinitions());
321 322 323 324
      $valid_fields = array_intersect($fields, $definitions);
      $count = 0;
      foreach ($valid_fields as $field_name) {
        $count += $variables['node']->get($field_name)->comment_count;
325 326 327 328 329
        // Adds RDFa markup for the comment count near the node title as metadata
        $comment_count_attributes = rdf_rdfa_attributes($comment_count_mapping, $variables['node']->get($field_name)->comment_count);
        $variables['title_suffix']['rdf_meta_comment_count'] = array(
          '#theme' => 'rdf_metadata',
          '#metadata' => array($comment_count_attributes),
330 331
        );
      }
332 333
    }
  }
334 335 336
}

/**
337
 * Implements hook_preprocess_HOOK() for user templates.
338
 */
339
function rdf_preprocess_user(&$variables) {
340
  /** @var $account \Drupal\user\UserInterface */
341
  $account = $variables['elements']['#user'];
342
  $uri = $account->urlInfo();
343 344
  $mapping = rdf_get_mapping('user', 'user');
  $bundle_mapping = $mapping->getPreparedBundleMapping();
345 346

  // Adds RDFa markup to the user profile page. Fields displayed in this page
347
  // will automatically describe the user.
348 349
  if (!empty($bundle_mapping['types'])) {
    $variables['attributes']['typeof'] = $bundle_mapping['types'];
350
    $variables['attributes']['about'] = $account->url();
351
  }
352 353
  // If we are on the user account page, add the relationship between the
  // sioc:UserAccount and the foaf:Person who holds the account.
354
  if (\Drupal::request()->attributes->get(RouteObjectInterface::ROUTE_NAME) == $uri['route_name']) {
355 356
    // Adds the markup for username as language neutral literal, see
    // rdf_preprocess_username().
357 358 359 360 361
    $name_mapping = $mapping->getPreparedFieldMapping('name');
    if (!empty($name_mapping['properties'])) {
      $username_meta = array(
        '#tag' => 'meta',
        '#attributes' => array(
362
          'about' => $account->url(),
363
          'property' => $name_mapping['properties'],
364
          'content' => $account->getUsername(),
365 366 367 368 369
          'lang' => '',
        ),
      );
      drupal_add_html_head($username_meta, 'rdf_user_username');
    }
370
  }
371 372 373
}

/**
374
 * Implements hook_preprocess_HOOK() for theme_username().
375 376
 */
function rdf_preprocess_username(&$variables) {
377
  $attributes = array();
378
  // Because lang is set on the HTML element that wraps the page, the
379 380 381 382
  // username inherits this language attribute. However, since the username
  // might not be transliterated to the same language that the content is in,
  // we do not want it to inherit the language attribute, so we set the
  // attribute to an empty string.
383
  if (empty($variables['attributes']['lang'])) {
384
    $attributes['lang'] = '';
385 386
  }

387
  // The profile URI is used to identify the user account. The about attribute
388
  // is used to set the URI as the default subject of the properties embedded
389 390 391 392
  // as RDFa in the child elements. Even if the user profile is not accessible
  // to the current user, we use its URI in order to identify the user in RDF.
  // We do not use this attribute for the anonymous user because we do not have
  // a user profile URI for it (only a homepage which cannot be used as user
393
  // profile in RDF.)
394
  if ($variables['uid'] > 0) {
395
    $attributes['about'] = url('user/' . $variables['uid']);
396
  }
397

398 399 400 401 402
  // Add RDF type of user.
  $mapping = rdf_get_mapping('user', 'user');
  $bundle_mapping = $mapping->getPreparedBundleMapping();
  if (!empty($bundle_mapping['types'])) {
    $attributes['typeof'] = $bundle_mapping['types'];
403
  }
404 405 406
  // Annotate the username in RDFa. A property attribute is used with an empty
  // datatype attribute to ensure the username is parsed as a plain literal
  // in RDFa 1.0 and 1.1.
407 408 409
  $name_mapping = $mapping->getPreparedFieldMapping('name');
  if (!empty($name_mapping)) {
    $attributes['property'] = $name_mapping['properties'];
410
    $attributes['datatype'] = '';
411 412
  }
  // Add the homepage RDFa markup if present.
413 414 415
  $homepage_mapping = $mapping->getPreparedFieldMapping('homepage');
  if (!empty($variables['homepage']) && !empty($homepage_mapping)) {
    $attributes['rel'] = $homepage_mapping['properties'];
416
  }
417
  // The remaining attributes can have multiple values listed, with whitespace
418 419
  // separating the values in the RDFa attributes
  // (see http://www.w3.org/TR/rdfa-syntax/#rdfa-attributes).
420
  // Therefore, merge rather than override so as not to clobber values set by
421 422 423 424 425 426 427 428
  // earlier preprocess functions. These attributes will be placed in the a
  // element if a link is rendered, or on a span element otherwise.
  if (isset($variables['link_path'])) {
    $variables['link_options']['attributes'] = array_merge_recursive($variables['link_options']['attributes'], $attributes);
  }
  else {
    $variables['attributes'] = array_merge_recursive($variables['attributes'], $attributes);
  }
429 430 431
}

/**
432
 * Implements hook_preprocess_HOOK() for comment templates.
433 434 435
 */
function rdf_preprocess_comment(&$variables) {
  $comment = $variables['comment'];
436 437 438
  $mapping = rdf_get_mapping('comment', $comment->bundle());
  $bundle_mapping = $mapping->getPreparedBundleMapping();

439
  if (!empty($bundle_mapping['types']) && !isset($comment->in_preview)) {
440
    // Adds RDFa markup to the comment container. The about attribute specifies
441
    // the URI of the resource described within the HTML element, while the
442 443
    // typeof attribute indicates its RDF type (e.g., sioc:Post, foaf:Document,
    // and so on.)
444
    $variables['attributes']['about'] = $comment->url();
445
    $variables['attributes']['typeof'] = $bundle_mapping['types'];
446 447
  }

448 449 450 451
  // Adds RDFa markup for the relation between the comment and its author.
  $author_mapping = $mapping->getPreparedFieldMapping('uid');
  if (!empty($author_mapping)) {
    $author_attributes = array('rel' => $author_mapping['properties']);
452 453 454
    // Wraps the author variable and the submitted variable which are both
    // available in comment.html.twig.
    $variables['author'] = '<span ' . new Attribute($author_attributes) . '>' . $variables['author'] . '</span>';
455 456
    $variables['submitted'] = '<span ' . new Attribute($author_attributes) . '>' . $variables['submitted'] . '</span>';
  }
457
  // Adds RDFa markup for the date of the comment.
458 459
  $created_mapping = $mapping->getPreparedFieldMapping('created');
  if (!empty($created_mapping)) {
460 461
    // The comment date is precomputed as part of the rdf_data so that it can be
    // cached as part of the entity.
462
    $date_attributes = $comment->rdf_data['date'];
463 464 465 466 467 468 469 470 471 472

    $rdf_metadata = array(
      '#theme' => 'rdf_metadata',
      '#metadata' => array($date_attributes),
    );
    $created_metadata_markup = drupal_render($rdf_metadata);
    // Appends the markup to the created variable and the submitted variable
    // which are both available in comment.html.twig.
    $variables['created'] .= $created_metadata_markup;
    $variables['submitted'] .= $created_metadata_markup;
473
  }
474
  $title_mapping = $mapping->getPreparedFieldMapping('subject');
475
  if (!empty($title_mapping)) {
476 477 478 479
    // Adds RDFa markup to the subject of the comment. Because the RDFa markup
    // is added to an <h3> tag which might contain HTML code, we specify an
    // empty datatype to ensure the value of the title read by the RDFa parsers
    // is a literal.
480
    $variables['title_attributes']['property'] = $title_mapping['properties'];
481
    $variables['title_attributes']['datatype'] = '';
482 483 484 485
  }

  // Annotates the parent relationship between the current comment and the node
  // it belongs to. If available, the parent comment is also annotated.
486 487
  // @todo When comments are turned into fields, this should be changed.
  // Currently there is no mapping relating a comment to its node.
488 489
  $pid_mapping = $mapping->getPreparedFieldMapping('pid');
  if (!empty($pid_mapping)) {
490 491 492 493 494 495
    // Adds the relation to the parent entity.
    $parent_entity_attributes['rel'] = $pid_mapping['properties'];
    // The parent entity URI is precomputed as part of the rdf_data so that it
    // can be cached as part of the entity.
    $parent_entity_attributes['resource'] = $comment->rdf_data['entity_uri'];
    $variables['rdf_metadata_attributes'][] = $parent_entity_attributes;
496

497
    // Adds the relation to parent comment, if it exists.
498
    if ($comment->hasParentComment()) {
499
      $parent_comment_attributes['rel'] = $pid_mapping['properties'];
500 501
      // The parent comment URI is precomputed as part of the rdf_data so that
      // it can be cached as part of the entity.
502
      $parent_comment_attributes['resource'] = $comment->rdf_data['pid_uri'];
503
      $variables['rdf_metadata_attributes'][] = $parent_comment_attributes;
504 505
    }
  }
506 507 508 509 510
  // Adds RDF metadata markup above comment body.
  if (!empty($variables['rdf_metadata_attributes'])) {
    if (!isset($variables['content']['comment_body']['#prefix'])) {
      $variables['content']['comment_body']['#prefix'] = '';
    }
511 512 513 514 515
    $rdf_metadata = array(
      '#theme' => 'rdf_metadata',
      '#metadata' => $variables['rdf_metadata_attributes'],
    );
    $variables['content']['comment_body']['#prefix'] = drupal_render($rdf_metadata) . $variables['content']['comment_body']['#prefix'];
516
  }
517 518
}

519
/**
520
 * Implements hook_preprocess_HOOK() for taxonomy term templates.
521 522 523
 */
function rdf_preprocess_taxonomy_term(&$variables) {
  $term = $variables['term'];
524 525 526 527
  $mapping = rdf_get_mapping('taxonomy_term', $term->bundle());
  $bundle_mapping = $mapping->getPreparedBundleMapping();
  $name_field_mapping = $mapping->getPreparedFieldMapping('name');
  // Adds the RDF type of the term and the term name in a <meta> tag.
528
  $term_label_meta = array(
529 530 531 532 533 534 535 536
    '#tag' => 'meta',
    '#attributes' => array(
      'about' => url('taxonomy/term/' . $term->id()),
      'typeof' => $bundle_mapping['types'],
      'property' => $name_field_mapping['properties'],
      'content' => $term->label(),
    ),
  );
537 538 539
  drupal_add_html_head($term_label_meta, 'rdf_term_label');
}

540
/**
541
 * Implements hook_preprocess_HOOK() for theme_image().
542 543
 */
function rdf_preprocess_image(&$variables) {
544 545 546
  // Adds the RDF type for image.  We cannot use the usual entity-based mapping
  // to get 'foaf:Image' because image does not have its own entity type or
  // bundle.
547 548 549
  $variables['attributes']['typeof'] = array('foaf:Image');
}

550
/**
551 552 553
 * Prepares variables for RDF metadata templates.
 *
 * Default template: rdf-metadata.html.twig.
554
 *
555 556
 * Sometimes it is useful to export data which is not semantically present in
 * the HTML output. For example, a hierarchy of comments is visible for a human
557
 * but not for machines because this hierarchy is not present in the DOM tree.
558 559
 * We can express it in RDFa via empty <span> tags. These aren't visible and
 * give machines extra information about the content and its structure.
560
 *
561
 * @param array $variables
562 563 564 565
 *   An associative array containing:
 *   - metadata: An array of attribute arrays. Each item in the array
 *     corresponds to its own set of attributes, and therefore, needs its own
 *     element.
566
 */
567 568
function template_preprocess_rdf_metadata(&$variables) {
  foreach ($variables['metadata'] as $key => $attributes) {
569 570 571
    // Add a class so that developers viewing the HTML source can see why there
    // are empty <span> tags in the document. The class can also be used to set
    // a CSS display:none rule in a theme where empty spans affect display.
572
    $attributes['class'][] = 'rdf-meta';
573 574 575 576
    // The XHTML+RDFa doctype allows either <span></span> or <span /> syntax to
    // be used, but for maximum browser compatibility, W3C recommends the
    // former when serving pages using the text/html media type, see
    // http://www.w3.org/TR/xhtml1/#C_3.
577
    $variables['metadata'][$key] = new Attribute($attributes);
578
  }
579
}