Prevent conflicting namespaces and move hook_rdf_namespaces() invocation into rdf.module

As scor said, this is definitely a bug.

This solution does a good job of handling the namespace collision as long as neither namespace is redefined. However, once hook_rdf_namespaces is fixed, the bug would resurface, I believe.

For instance:

• User installs module X (which has redefined foaf)
• Drupal saves x_rdf_mapping to the database, including foaf:CrazyNewClass

Currently, all is fine because foaf is defined twice and the prefix has been dropped.

• Someone (either user or module creator) fixes hook_rdf_namespaces and foaf is no longer defined twice
• Because foaf:CrazyNewClass is defined in the mapping for the bundle, we have triples that assert typeof http://xmlns.com/foaf/0.1/CrazyNewClass.

All of the sudden, we have inaccurate statements.

We can fix this by running all of the curies through a function at the time of module installation to ensure that their prefix has only been defined once. If it has been defined more than once, or not defined at all, don't save the term in the mapping.

I have a first crack at this solution mostly finished, will post a patch shortly.

The way I implemented this, it does change the way hook_rdf_namespaces is invoked slightly. I have created a function in the RDF module that actually invokes the hook and merges the duplicates. drupal_get_rdf_namespaces then calls this function instead of invoking the hooks directly.

I did this because I need a list of the RDF namespaces as an array, so as to not repeat the functionality, I moved it to a separate function.

I am posting the patch here for discussion, we can move to a separate issue if need be.

We would need to change hook_rdf_mapping implementations slightly. First, the function needs to invoke any hook_rdf_namespaces that defines the namespace prefixes it wants to use. Then it needs to call rdf_get_curie for the terms, instead of setting the curie as a string value.

I included the revised hook_rdf_mapping for node as an example.

I have created #736210: RDF Mapping API mints fake terms when namespaces collide. I feel that this secondary bug is potentially harmful to the use of RDF and that it is deserving of an API change, but as scor points out, it is unlikely to happen very often.

Even though we probably can't change the handling of curies at this point, I still think it might be good to do the invocation of the hook from a new function in rdf. We can then call that from drupal_get_rdf_namespaces. This approach allows us to reuse the functionality. We might want to come up with a better name for the function than the one I used, though.

145 critical left. Go review some!

+++ includes/common.inc	8 Mar 2010 16:48:17 -0000
@@ -256,8 +256,12 @@ function drupal_get_breadcrumb() {
+  foreach (rdf_get_rdf_namespaces_array() as $prefix => $uri) {
+    // Do not include prefixes that are defined for more than one URI.
+    // Otherwise we may make inaccurate statements in RDF.
+    if (!is_array($uri)) {
+      $xml_rdf_namespaces[] = 'xmlns:' . $prefix . '="' . $uri . '"';
+    }

The change in drupal_get_rdf_namespaces

+++ modules/rdf/rdf.module	8 Mar 2010 16:48:17 -0000
@@ -799,3 +799,57 @@ function theme_rdf_metadata($variables) 
+function rdf_get_rdf_namespaces_array() {
+  $ns = array();
+
+  foreach (module_invoke_all('rdf_namespaces') as $prefix => $uri) {
+    if (is_array($uri)) {
+      if (count(array_unique($uri)) == 1) {
+        // All namespaces declared for this prefix are the same, merge all
+        // duplicates.
+       $uri = $uri[0];
+      }
+    }
+    $ns[$prefix] = $uri;
+  }
+  return $ns;
+}

The new function.

Powered by Dreditor.

It makes sense to move all the logic to RDF.

I think we need two different options for the array result. One needs to simply merge duplicate namespace definitions, but leave arrays for prefixes that have two or more unique namespaces assigned—like I used in rdf_get_curie. The other needs to totally flatten the array (and possibly provide warnings that namespaces need to be redefined).

We could do this either by passing the namespaces through two functions like I did in the patch, or by passing in a flag to one function.

As scor says in #5:

No API changes from drupal_get_rdf_namespaces()'s point of view since it still returns the exact same xmlns serialization, just that instead of doing all the logic, it calls the new rdf_get_rdf_namespaces() from rdf.module.

There is just a bit of logic added to rdf_get_rdf_namespaces to make sure that we don't get xmlns:prefix="Array" in the namespace declarations.

Tests check for all of the different cases of namespace/prefix overlap.

RTBC.

Since the dependency was fixed, I think this can go back to RTBC.