yaffs.net Git - yaffs-website/blob - web/core/modules/rdf/rdf.module

   1 <?php
   2
   3 /**
   4  * @file
   5  * Enables semantically enriched output for Drupal sites in the form of RDFa.
   6  */
   7
   8 use Drupal\Core\Routing\RouteMatchInterface;
   9 use Drupal\Core\Template\Attribute;
  10 use Drupal\rdf\Entity\RdfMapping;
  11
  12 /**
  13  * Implements hook_help().
  14  */
  15 function rdf_help($route_name, RouteMatchInterface $route_match) {
  16   switch ($route_name) {
  17     case 'help.page.rdf':
  18       $output = '';
  19       $output .= '<h3>' . t('About') . '</h3>';
  20       $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 your website 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 modules define RDF mappings for their data model, and the core 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>.', [':rdfa' => 'http://www.w3.org/TR/xhtml-rdfa-primer/', ':rdf' => 'https://www.drupal.org/documentation/modules/rdf']) . '</p>';
  21       return $output;
  22   }
  23 }
  24
  25 /**
  26  * @defgroup rdf RDF Mapping API
  27  * @{
  28  * Functions to describe entities and bundles in RDF.
  29  *
  30  * The RDF module introduces RDF and RDFa to Drupal. RDF is a W3C standard to
  31  * describe structured data. RDF can be serialized as RDFa in XHTML attributes
  32  * to augment visual data with machine-readable hints.
  33  * @see http://www.w3.org/RDF/
  34  * @see http://www.w3.org/TR/xhtml-rdfa-primer/
  35  *
  36  * Modules can provide mappings of their bundles' data and metadata to RDF
  37  * classes and properties. This module takes care of injecting these mappings
  38  * into variables available to theme functions and templates. All Drupal core
  39  * themes are coded to be RDFa compatible.
  40  */
  41
  42 /**
  43  * Returns the RDF mapping object associated with a bundle.
  44  *
  45  * The function reads the rdf_mapping object from the current configuration,
  46  * or returns a ready-to-use empty one if no configuration entry exists yet for
  47  * this bundle. This streamlines the manipulation of mapping objects by always
  48  * returning a consistent object that reflects the current state of the
  49  * configuration.
  50  *
  51  * Example usage:
  52  * -Map the 'article' bundle to 'sioc:Post' and the 'title' field to 'dc:title'.
  53  * @code
  54  * rdf_get_mapping('node', 'article')
  55  *   ->setBundleMapping(array(
  56  *     'types' => array('sioc:Post'),
  57  *   ))
  58  *   ->setFieldMapping('title', array(
  59  *     'properties' => array('dc:title')
  60  *   ))
  61  *   ->save();
  62  * @endcode
  63  *
  64  * @param string $entity_type
  65  *   The entity type.
  66  * @param string $bundle
  67  *   The bundle.
  68  *
  69  * @return \Drupal\rdf\Entity\RdfMapping
  70  *   The RdfMapping object.
  71  */
  72 function rdf_get_mapping($entity_type, $bundle) {
  73   // Try loading the mapping from configuration.
  74   $mapping = RdfMapping::load($entity_type . '.' . $bundle);
  75
  76   // If not found, create a fresh mapping object.
  77   if (!$mapping) {
  78     $mapping = RdfMapping::create([
  79       'targetEntityType' => $entity_type,
  80       'bundle' => $bundle,
  81     ]);
  82   }
  83
  84   return $mapping;
  85 }
  86
  87 /**
  88  * Implements hook_rdf_namespaces().
  89  */
  90 function rdf_rdf_namespaces() {
  91   return [
  92     'content'  => 'http://purl.org/rss/1.0/modules/content/',
  93     'dc'       => 'http://purl.org/dc/terms/',
  94     'foaf'     => 'http://xmlns.com/foaf/0.1/',
  95     'og'       => 'http://ogp.me/ns#',
  96     'rdfs'     => 'http://www.w3.org/2000/01/rdf-schema#',
  97     'schema'   => 'http://schema.org/',
  98     'sioc'     => 'http://rdfs.org/sioc/ns#',
  99     'sioct'    => 'http://rdfs.org/sioc/types#',
 100     'skos'     => 'http://www.w3.org/2004/02/skos/core#',
 101     'xsd'      => 'http://www.w3.org/2001/XMLSchema#',
 102   ];
 103 }
 104
 105 /**
 106  * Retrieves RDF namespaces.
 107  *
 108  * Invokes hook_rdf_namespaces() and collects RDF namespaces from modules that
 109  * implement it.
 110  */
 111 function rdf_get_namespaces() {
 112   $namespaces = [];
 113   // In order to resolve duplicate namespaces by using the earliest defined
 114   // namespace, do not use \Drupal::moduleHandler()->invokeAll().
 115   foreach (\Drupal::moduleHandler()->getImplementations('rdf_namespaces') as $module) {
 116     $function = $module . '_rdf_namespaces';
 117     foreach ($function() as $prefix => $namespace) {
 118       if (array_key_exists($prefix, $namespaces) && $namespace !== $namespaces[$prefix]) {
 119         throw new Exception(t('Tried to map @prefix to @namespace, but @prefix is already mapped to @orig_namespace.', ['@prefix' => $prefix, '@namespace' => $namespace, '@orig_namespace' => $namespaces[$prefix]]));
 120       }
 121       else {
 122         $namespaces[$prefix] = $namespace;
 123       }
 124     }
 125   }
 126   return $namespaces;
 127 }
 128
 129 /**
 130  * @} End of "defgroup rdf".
 131  */
 132
 133 /**
 134  * @addtogroup rdf
 135  * @{
 136  */
 137
 138 /**
 139  * Builds an array of RDFa attributes for a given mapping.
 140  *
 141  * This array will typically be passed through Drupal\Core\Template\Attribute
 142  * to create the attributes variables that are available to template files.
 143  * These include $attributes, $title_attributes, $content_attributes and the
 144  * field-specific $item_attributes variables.
 145  *
 146  * @param array $mapping
 147  *   An array containing a mandatory 'properties' key and optional 'datatype',
 148  *   'datatype_callback' and 'type' keys. For example:
 149  *   @code
 150  *     array(
 151  *       'properties' => array('schema:interactionCount'),
 152  *       'datatype' => 'xsd:integer',
 153  *       'datatype_callback' => array(
 154  *         'callable' => 'Drupal\rdf\SchemaOrgDataConverter::interactionCount',
 155  *         'arguments' => array(
 156  *           'interaction_type' => 'UserComments'
 157  *         ),
 158  *       ),
 159  *     );
 160  *   @endcode
 161  * @param mixed $data
 162  *   (optional) A value that needs to be converted by the provided callback
 163  *   function.
 164  *
 165  * @return array
 166  *   RDFa attributes suitable for Drupal\Core\Template\Attribute.
 167  */
 168 function rdf_rdfa_attributes($mapping, $data = NULL) {
 169   $attributes = [];
 170
 171   // The type of mapping defaults to 'property'.
 172   $type = isset($mapping['mapping_type']) ? $mapping['mapping_type'] : 'property';
 173
 174   switch ($type) {
 175     // The mapping expresses the relationship between two resources.
 176     case 'rel':
 177     case 'rev':
 178       $attributes[$type] = $mapping['properties'];
 179       break;
 180
 181     // The mapping expresses the relationship between a resource and some
 182     // literal text.
 183     case 'property':
 184       if (!empty($mapping['properties'])) {
 185         $attributes['property'] = $mapping['properties'];
 186         // Convert $data to a specific format as per the callback function.
 187         if (isset($data) && !empty($mapping['datatype_callback'])) {
 188           $callback = $mapping['datatype_callback']['callable'];
 189           $arguments = isset($mapping['datatype_callback']['arguments']) ? $mapping['datatype_callback']['arguments'] : NULL;
 190           $attributes['content'] = call_user_func($callback, $data, $arguments);
 191         }
 192         if (isset($mapping['datatype'])) {
 193           $attributes['datatype'] = $mapping['datatype'];
 194         }
 195         break;
 196       }
 197   }
 198
 199   return $attributes;
 200 }
 201
 202 /**
 203  * @} End of "addtogroup rdf".
 204  */
 205
 206 /**
 207  * Implements hook_entity_prepare_view().
 208  */
 209 function rdf_entity_prepare_view($entity_type, array $entities, array $displays) {
 210   // Iterate over the RDF mappings for each entity and prepare the RDFa
 211   // attributes to be added inside field formatters.
 212   foreach ($entities as $entity) {
 213     $mapping = rdf_get_mapping($entity_type, $entity->bundle());
 214     // Only prepare the RDFa attributes for the fields which are configured to
 215     // be displayed.
 216     foreach ($displays[$entity->bundle()]->getComponents() as $name => $options) {
 217       $field_mapping = $mapping->getPreparedFieldMapping($name);
 218       if ($field_mapping) {
 219         foreach ($entity->get($name) as $item) {
 220           $item->_attributes += rdf_rdfa_attributes($field_mapping, $item->toArray());
 221         }
 222       }
 223     }
 224   }
 225 }
 226
 227 /**
 228  * Implements hook_ENTITY_TYPE_storage_load() for comment entities.
 229  */
 230 function rdf_comment_storage_load($comments) {
 231   foreach ($comments as $comment) {
 232     // Pages with many comments can show poor performance. This information
 233     // isn't needed until rdf_preprocess_comment() is called, but set it here
 234     // to optimize performance for websites that implement an entity cache.
 235     $created_mapping = rdf_get_mapping('comment', $comment->bundle())
 236       ->getPreparedFieldMapping('created');
 237     /** @var \Drupal\comment\CommentInterface $comment*/
 238     $comment->rdf_data['date'] = rdf_rdfa_attributes($created_mapping, $comment->get('created')->first()->toArray());
 239     $entity = $comment->getCommentedEntity();
 240     // The current function is a storage level hook, so avoid to bubble
 241     // bubbleable metadata, because it can be outside of a render context.
 242     $comment->rdf_data['entity_uri'] = $entity->toUrl()->toString(TRUE)->getGeneratedUrl();
 243     if ($comment->hasParentComment()) {
 244       $comment->rdf_data['pid_uri'] = $comment->getParentComment()->url();
 245     }
 246   }
 247 }
 248
 249 /**
 250  * Implements hook_theme().
 251  */
 252 function rdf_theme() {
 253   return [
 254     'rdf_wrapper' => [
 255       'variables' => ['attributes' => [], 'content' => NULL],
 256     ],
 257     'rdf_metadata' => [
 258       'variables' => ['metadata' => []],
 259     ],
 260   ];
 261 }
 262
 263 /**
 264  * Implements hook_preprocess_HOOK() for HTML document templates.
 265  */
 266 function rdf_preprocess_html(&$variables) {
 267   // Adds RDF namespace prefix bindings in the form of an RDFa 1.1 prefix
 268   // attribute inside the html element.
 269   if (!isset($variables['html_attributes']['prefix'])) {
 270     $variables['html_attributes']['prefix'] = [];
 271   }
 272   foreach (rdf_get_namespaces() as $prefix => $uri) {
 273     $variables['html_attributes']['prefix'][] = $prefix . ': ' . $uri . " ";
 274   }
 275 }
 276
 277 /**
 278  * Implements hook_preprocess_HOOK() for UID field templates.
 279  */
 280 function rdf_preprocess_field__node__uid(&$variables) {
 281   _rdf_set_field_rel_attribute($variables);
 282 }
 283
 284 /**
 285  * Transforms the field property attribute into a rel attribute.
 286  */
 287 function _rdf_set_field_rel_attribute(&$variables) {
 288   // Swap the regular field property attribute and use the rel attribute
 289   // instead so that it plays well with the RDFa markup when only a link is
 290   // present in the field output, for example in the case of the uid field.
 291   if (!empty($variables['attributes']['property'])) {
 292     $variables['attributes']['rel'] = $variables['attributes']['property'];
 293     unset($variables['attributes']['property']);
 294   }
 295 }
 296
 297 /**
 298  * Implements hook_preprocess_HOOK() for node templates.
 299  */
 300 function rdf_preprocess_node(&$variables) {
 301   // Adds RDFa markup to the node container. The about attribute specifies the
 302   // URI of the resource described within the HTML element, while the @typeof
 303   // attribute indicates its RDF type (e.g., foaf:Document, sioc:Person, and so
 304   // on.)
 305   $bundle = $variables['node']->bundle();
 306   $mapping = rdf_get_mapping('node', $bundle);
 307   $bundle_mapping = $mapping->getPreparedBundleMapping('node', $bundle);
 308   $variables['attributes']['about'] = empty($variables['url']) ? NULL : $variables['url'];
 309   $variables['attributes']['typeof'] = empty($bundle_mapping['types']) ? NULL : $bundle_mapping['types'];
 310
 311   // Adds RDFa markup for the node title as metadata because wrapping the title
 312   // with markup is not reliable and the title output is different depending on
 313   // the view mode (e.g. full vs. teaser).
 314   $title_mapping = $mapping->getPreparedFieldMapping('title');
 315   if ($title_mapping) {
 316     $title_attributes['property'] = empty($title_mapping['properties']) ? NULL : $title_mapping['properties'];
 317     $title_attributes['content'] = $variables['node']->label();
 318     $variables['title_suffix']['rdf_meta_title'] = [
 319       '#theme' => 'rdf_metadata',
 320       '#metadata' => [$title_attributes],
 321     ];
 322   }
 323
 324   // Adds RDFa markup for the date.
 325   $created_mapping = $mapping->getPreparedFieldMapping('created');
 326   if (!empty($created_mapping) && $variables['display_submitted']) {
 327     $date_attributes = rdf_rdfa_attributes($created_mapping, $variables['node']->get('created')->first()->toArray());
 328     $rdf_metadata = [
 329       '#theme' => 'rdf_metadata',
 330       '#metadata' => [$date_attributes],
 331     ];
 332     $variables['metadata'] = \Drupal::service('renderer')->render($rdf_metadata);
 333   }
 334
 335   // Adds RDFa markup annotating the number of comments a node has.
 336   if (\Drupal::moduleHandler()->moduleExists('comment') && \Drupal::currentUser()->hasPermission('access comments')) {
 337     $comment_count_mapping = $mapping->getPreparedFieldMapping('comment_count');
 338     if (!empty($comment_count_mapping['properties'])) {
 339       $fields = array_keys(\Drupal::service('comment.manager')->getFields('node'));
 340       $definitions = array_keys($variables['node']->getFieldDefinitions());
 341       $valid_fields = array_intersect($fields, $definitions);
 342       $count = 0;
 343       foreach ($valid_fields as $field_name) {
 344         $count += $variables['node']->get($field_name)->comment_count;
 345         // Adds RDFa markup for the comment count near the node title as
 346         // metadata.
 347         $comment_count_attributes = rdf_rdfa_attributes($comment_count_mapping, $variables['node']->get($field_name)->comment_count);
 348         $variables['title_suffix']['rdf_meta_comment_count'] = [
 349           '#theme' => 'rdf_metadata',
 350           '#metadata' => [$comment_count_attributes],
 351         ];
 352       }
 353     }
 354   }
 355 }
 356
 357 /**
 358  * Implements hook_preprocess_HOOK() for user templates.
 359  */
 360 function rdf_preprocess_user(&$variables) {
 361   /** @var $account \Drupal\user\UserInterface */
 362   $account = $variables['elements']['#user'];
 363   $uri = $account->urlInfo();
 364   $mapping = rdf_get_mapping('user', 'user');
 365   $bundle_mapping = $mapping->getPreparedBundleMapping();
 366
 367   // Adds RDFa markup to the user profile page. Fields displayed in this page
 368   // will automatically describe the user.
 369   if (!empty($bundle_mapping['types'])) {
 370     $variables['attributes']['typeof'] = $bundle_mapping['types'];
 371     $variables['attributes']['about'] = $account->url();
 372   }
 373   // If we are on the user account page, add the relationship between the
 374   // sioc:UserAccount and the foaf:Person who holds the account.
 375   if (\Drupal::routeMatch()->getRouteName() == $uri->getRouteName()) {
 376     // Adds the markup for username as language neutral literal, see
 377     // rdf_preprocess_username().
 378     $name_mapping = $mapping->getPreparedFieldMapping('name');
 379     if (!empty($name_mapping['properties'])) {
 380       $username_meta = [
 381         '#tag' => 'meta',
 382         '#attributes' => [
 383           'about' => $account->url(),
 384           'property' => $name_mapping['properties'],
 385           'content' => $account->getDisplayName(),
 386           'lang' => '',
 387         ],
 388       ];
 389       $variables['#attached']['html_head'][] = [$username_meta, 'rdf_user_username'];
 390     }
 391   }
 392 }
 393
 394 /**
 395  * Implements hook_preprocess_HOOK() for username.html.twig.
 396  */
 397 function rdf_preprocess_username(&$variables) {
 398   // Because lang is set on the HTML element that wraps the page, the
 399   // username inherits this language attribute. However, since the username
 400   // might not be transliterated to the same language that the content is in,
 401   // we do not want it to inherit the language attribute, so we set the
 402   // attribute to an empty string.
 403   if (empty($variables['attributes']['lang'])) {
 404     $variables['attributes']['lang'] = '';
 405   }
 406
 407   // The profile URI is used to identify the user account. The about attribute
 408   // is used to set the URI as the default subject of the properties embedded
 409   // as RDFa in the child elements. Even if the user profile is not accessible
 410   // to the current user, we use its URI in order to identify the user in RDF.
 411   // We do not use this attribute for the anonymous user because we do not have
 412   // a user profile URI for it (only a homepage which cannot be used as user
 413   // profile in RDF.)
 414   if ($variables['uid'] > 0) {
 415     $variables['attributes']['about'] = \Drupal::url('entity.user.canonical', ['user' => $variables['uid']]);
 416   }
 417
 418   // Add RDF type of user.
 419   $mapping = rdf_get_mapping('user', 'user');
 420   $bundle_mapping = $mapping->getPreparedBundleMapping();
 421   if (!empty($bundle_mapping['types'])) {
 422     $variables['attributes']['typeof'] = $bundle_mapping['types'];
 423   }
 424   // Annotate the username in RDFa. A property attribute is used with an empty
 425   // datatype attribute to ensure the username is parsed as a plain literal
 426   // in RDFa 1.0 and 1.1.
 427   $name_mapping = $mapping->getPreparedFieldMapping('name');
 428   if (!empty($name_mapping)) {
 429     $variables['attributes']['property'] = $name_mapping['properties'];
 430     $variables['attributes']['datatype'] = '';
 431   }
 432   // Add the homepage RDFa markup if present.
 433   $homepage_mapping = $mapping->getPreparedFieldMapping('homepage');
 434   if (!empty($variables['homepage']) && !empty($homepage_mapping)) {
 435     $variables['attributes']['rel'] = $homepage_mapping['properties'];
 436   }
 437   // Long usernames are truncated by template_preprocess_username(). Store the
 438   // full name in the content attribute so it can be extracted in RDFa.
 439   if ($variables['truncated']) {
 440     $variables['attributes']['content'] = $variables['name_raw'];
 441   }
 442 }
 443
 444 /**
 445  * Implements hook_preprocess_HOOK() for comment templates.
 446  */
 447 function rdf_preprocess_comment(&$variables) {
 448   $comment = $variables['comment'];
 449   $mapping = rdf_get_mapping('comment', $comment->bundle());
 450   $bundle_mapping = $mapping->getPreparedBundleMapping();
 451
 452   if (!empty($bundle_mapping['types']) && !isset($comment->in_preview)) {
 453     // Adds RDFa markup to the comment container. The about attribute specifies
 454     // the URI of the resource described within the HTML element, while the
 455     // typeof attribute indicates its RDF type (e.g., sioc:Post, foaf:Document,
 456     // and so on.)
 457     $variables['attributes']['about'] = $comment->url();
 458     $variables['attributes']['typeof'] = $bundle_mapping['types'];
 459   }
 460
 461   // Adds RDFa markup for the relation between the comment and its author.
 462   $author_mapping = $mapping->getPreparedFieldMapping('uid');
 463   if (!empty($author_mapping)) {
 464     $author_attributes = ['rel' => $author_mapping['properties']];
 465     // Wraps the 'author' and 'submitted' variables which are both available in
 466     // comment.html.twig.
 467     $variables['author'] = [
 468       '#theme' => 'rdf_wrapper',
 469       '#content' => $variables['author'],
 470       '#attributes' => $author_attributes,
 471     ];
 472     $variables['submitted'] = [
 473       '#theme' => 'rdf_wrapper',
 474       '#content' => $variables['submitted'],
 475       '#attributes' => $author_attributes,
 476     ];
 477   }
 478   // Adds RDFa markup for the date of the comment.
 479   $created_mapping = $mapping->getPreparedFieldMapping('created');
 480   if (!empty($created_mapping)) {
 481     // The comment date is precomputed as part of the rdf_data so that it can be
 482     // cached as part of the entity.
 483     $date_attributes = $comment->rdf_data['date'];
 484
 485     $rdf_metadata = [
 486       '#theme' => 'rdf_metadata',
 487       '#metadata' => [$date_attributes],
 488     ];
 489     // Ensure the original variable is represented as a render array.
 490     $created = !is_array($variables['created']) ? ['#markup' => $variables['created']] : $variables['created'];
 491     $submitted = !is_array($variables['submitted']) ? ['#markup' => $variables['submitted']] : $variables['submitted'];
 492     // Make render array and RDF metadata available in comment.html.twig.
 493     $variables['created'] = [$created, $rdf_metadata];
 494     $variables['submitted'] = [$submitted, $rdf_metadata];
 495   }
 496   $title_mapping = $mapping->getPreparedFieldMapping('subject');
 497   if (!empty($title_mapping)) {
 498     // Adds RDFa markup to the subject of the comment. Because the RDFa markup
 499     // is added to an <h3> tag which might contain HTML code, we specify an
 500     // empty datatype to ensure the value of the title read by the RDFa parsers
 501     // is a literal.
 502     $variables['title_attributes']['property'] = $title_mapping['properties'];
 503     $variables['title_attributes']['datatype'] = '';
 504   }
 505
 506   // Annotates the parent relationship between the current comment and the node
 507   // it belongs to. If available, the parent comment is also annotated.
 508   // @todo When comments are turned into fields, this should be changed.
 509   // Currently there is no mapping relating a comment to its node.
 510   $pid_mapping = $mapping->getPreparedFieldMapping('pid');
 511   if (!empty($pid_mapping)) {
 512     // Adds the relation to the parent entity.
 513     $parent_entity_attributes['rel'] = $pid_mapping['properties'];
 514     // The parent entity URI is precomputed as part of the rdf_data so that it
 515     // can be cached as part of the entity.
 516     $parent_entity_attributes['resource'] = $comment->rdf_data['entity_uri'];
 517     $variables['rdf_metadata_attributes'][] = $parent_entity_attributes;
 518
 519     // Adds the relation to parent comment, if it exists.
 520     if ($comment->hasParentComment()) {
 521       $parent_comment_attributes['rel'] = $pid_mapping['properties'];
 522       // The parent comment URI is precomputed as part of the rdf_data so that
 523       // it can be cached as part of the entity.
 524       $parent_comment_attributes['resource'] = $comment->rdf_data['pid_uri'];
 525       $variables['rdf_metadata_attributes'][] = $parent_comment_attributes;
 526     }
 527   }
 528   // Adds RDF metadata markup above comment body if any.
 529   if (!empty($variables['rdf_metadata_attributes']) && isset($variables['content']['comment_body'])) {
 530     $rdf_metadata = [
 531       '#theme' => 'rdf_metadata',
 532       '#metadata' => $variables['rdf_metadata_attributes'],
 533     ];
 534     if (!empty($variables['content']['comment_body']['#prefix'])) {
 535       $rdf_metadata['#suffix'] = $variables['content']['comment_body']['#prefix'];
 536     }
 537     $variables['content']['comment_body']['#prefix'] = \Drupal::service('renderer')->render($rdf_metadata);
 538   }
 539 }
 540
 541 /**
 542  * Implements hook_preprocess_HOOK() for taxonomy term templates.
 543  */
 544 function rdf_preprocess_taxonomy_term(&$variables) {
 545   // Adds RDFa markup to the taxonomy term container.
 546   // The @about attribute specifies the URI of the resource described within
 547   // the HTML element, while the @typeof attribute indicates its RDF type
 548   // (e.g., schema:Thing, skos:Concept, and so on).
 549   $term = $variables['term'];
 550   $mapping = rdf_get_mapping('taxonomy_term', $term->bundle());
 551   $bundle_mapping = $mapping->getPreparedBundleMapping();
 552   $variables['attributes']['about'] = $term->url();
 553   $variables['attributes']['typeof'] = empty($bundle_mapping['types']) ? NULL : $bundle_mapping['types'];
 554
 555   // Add RDFa markup for the taxonomy term name as metadata, if present.
 556   $name_field_mapping = $mapping->getPreparedFieldMapping('name');
 557   if (!empty($name_field_mapping) && !empty($name_field_mapping['properties'])) {
 558     $name_attributes = [
 559       'property' => $name_field_mapping['properties'],
 560       'content' => $term->getName(),
 561     ];
 562     $variables['title_suffix']['taxonomy_term_rdfa'] = [
 563       '#theme' => 'rdf_metadata',
 564       '#metadata' => [$name_attributes],
 565     ];
 566   }
 567 }
 568
 569 /**
 570  * Implements hook_preprocess_HOOK() for image.html.twig.
 571  */
 572 function rdf_preprocess_image(&$variables) {
 573   // Adds the RDF type for image.  We cannot use the usual entity-based mapping
 574   // to get 'foaf:Image' because image does not have its own entity type or
 575   // bundle.
 576   $variables['attributes']['typeof'] = ['foaf:Image'];
 577 }
 578
 579 /**
 580  * Prepares variables for RDF metadata templates.
 581  *
 582  * Default template: rdf-metadata.html.twig.
 583  *
 584  * Sometimes it is useful to export data which is not semantically present in
 585  * the HTML output. For example, a hierarchy of comments is visible for a human
 586  * but not for machines because this hierarchy is not present in the DOM tree.
 587  * We can express it in RDFa via empty <span> tags. These aren't visible and
 588  * give machines extra information about the content and its structure.
 589  *
 590  * @param array $variables
 591  *   An associative array containing:
 592  *   - metadata: An array of attribute arrays. Each item in the array
 593  *     corresponds to its own set of attributes, and therefore, needs its own
 594  *     element.
 595  */
 596 function template_preprocess_rdf_metadata(&$variables) {
 597   foreach ($variables['metadata'] as $key => $attributes) {
 598     if (!is_null($attributes)) {
 599       $variables['metadata'][$key] = new Attribute($attributes);
 600     }
 601     else {
 602       $variables['metadata'][$key] = new Attribute();
 603     }
 604   }
 605 }