Correct $ref links in extensions documentation server relative location.

chrome/common/extensions/docs/server2/reference_resolver.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from copy import deepcopy
 import logging
 import re
 import string
 
 from file_system import FileNotFoundError
@@ skipping 26 matching lines @@
   key = '%s/%s' % (namespace, ref)
   # AppEngine doesn't like keys > 500, but there will be some other stuff
   # that goes into this key, so truncate it earlier.  This shoudn't be
   # happening anyway unless there's a bug, such as http://crbug.com/314102.
   max_size = 256
   if len(key) > max_size:
     logging.error('Key was >%s characters: %s' % (max_size, key))
     key = key[:max_size]
   return key
 
+def _DetermineLinkPrefix(request):
+  # request.Path should be of the form (apps|extensions)/...../page.html. This
+  # function works out the relative path prefix required so that the target
+  # will point to (apps|extensions)/target.html. This is as many '../' as there
+  # are components between (apps|extensiosn) and page.html, in the example
+  # above
+  prefix = ''
+  components = request.path.split('/')[2:]
+  for piece in components:
+    prefix = prefix + '../'
+  return prefix

[not at google - send to devlin, 2013/11/21 05:26:50]

could be written as

'../' * (path.count('/') - 1)

and for that matter perhaps that's better just inlined with a comment, since a
comment in context of where this method is called from would be easier to
explain, I think.

[benwells, 2013/11/22 05:44:01]

holy cow, I can multiple strings with numbers !?!?!

Done

 
 class ReferenceResolver(object):
   """Resolves references to $ref's by searching through the APIs to find the
   correct node.
 
   $ref's have two forms:
 
     $ref:api.node - Replaces the $ref with a link to node on the API page. The
                     title is set to the name of the node.
 
@@ skipping 106 matching lines @@
       return ref_data
     logging.error('$ref %s could not be resolved in namespace %s.' %
         (ref, namespace))
     type_name = ref.rsplit('.', 1)[-1]
     return {
       'href': '#type-%s' % type_name,
       'text': title or ref,
       'name': ref
     }
 
-  def ResolveAllLinks(self, text, namespace=None):
+  def ResolveAllLinks(self, text, request, namespace=None):

[not at google - send to devlin, 2013/11/21 05:26:50]

Rather than introduce a whole Request as a (conceptual) dependency, just pass in
the path, and make it explicitly named/optional.

[benwells, 2013/11/22 05:44:01]

Done.

     """This method will resolve all $ref links in |text| using namespace
     |namespace| if not None. Any links that cannot be resolved will be replaced
     using the default link format that |SafeGetLink| uses.
+    The links are relative, with the prefix for the path determined by
+    inspecting request.path.
     """
     if text is None or '$ref:' not in text:
       return text
+    link_prefix = ''
+    if request is not None:
+      link_prefix = _DetermineLinkPrefix(request)
     split_text = text.split('$ref:')
     # |split_text| is an array of text chunks that all start with the
     # argument to '$ref:'.
     formatted_text = [split_text[0]]
     for ref_and_rest in split_text[1:]:
       title = None
       if ref_and_rest.startswith('[') and ']' in ref_and_rest:
         # Text was '$ref:[foo.bar maybe title] other stuff'.
         ref_with_title, rest = ref_and_rest[1:].split(']', 1)
         ref_with_title = ref_with_title.split(None, 1)
         if len(ref_with_title) == 1:
           # Text was '$ref:[foo.bar] other stuff'.
           ref = ref_with_title[0]
         else:
           # Text was '$ref:[foo.bar title] other stuff'.
           ref, title = ref_with_title
       else:
         # Text was '$ref:foo.bar other stuff'.
         match = self._bare_ref.match(ref_and_rest)
         if match is None:
           ref = ''
           rest = ref_and_rest
         else:
           ref = match.group()
           rest = ref_and_rest[match.end():]
 
       ref_dict = self.SafeGetLink(ref, namespace=namespace, title=title)
-      formatted_text.append('<a href="%(href)s">%(text)s</a>%(rest)s' %
-          { 'href': ref_dict['href'], 'text': ref_dict['text'], 'rest': rest })
+      formatted_text.append('<a href="%(prefix)s%(href)s">%(text)s</a>%(rest)s' %
+          { 'prefix': link_prefix,
+            'href': ref_dict['href'],
+            'text': ref_dict['text'],
+            'rest': rest })

[not at google - send to devlin, 2013/11/21 05:26:50]

we should kill this confusing %(prefix)s stuff and just use %s with an array.

[benwells, 2013/11/22 05:44:01]

Done.

     return ''.join(formatted_text)