Docserver: Serve docs out of src/ not src/chrome/common/extensions. This allows

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

 # Copyright 2013 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 collections import defaultdict, deque, namedtuple
 from HTMLParser import HTMLParser, HTMLParseError
 from itertools import groupby
 from operator import itemgetter
 import posixpath
 from urlparse import urlsplit
 
 from file_system_util import CreateURLsFromPaths
-import svn_constants
+
 
 Page = namedtuple('Page', 'status, links, anchors, anchor_refs')
 
+
 def _SplitAnchor(url):
   components = urlsplit(url)
   return components.path, components.fragment
 
+
 def _Process(path, renderer):
   '''Render the page at |path| using a |renderer| and process the contents of
   that page. Returns a |Page| namedtuple with fields for the http status code
   of the page render, the href of all the links that occurred on the page, all
   of the anchors on the page (ids and names), and all links that contain an
   anchor component.
 
   If a non-html page is properly rendered, a |Page| with status code 200 and
   all other fields empty is returned.
   '''
@@ skipping 40 matching lines @@
       else:
         link = posixpath.normpath('%s/%s' % (base, link))
 
       if '#' in link:
         anchor_refs.append(link)
       else:
         edges.append(link)
 
   return Page(200, edges, anchors, anchor_refs)
 
+
 class _ContentParser(HTMLParser):
   '''Parse an html file pulling out all links and anchor_refs, where an
   anchor_ref is a link that contains an anchor.
   '''
 
   def __init__(self):
     HTMLParser.__init__(self)
     self.links = []
     self.anchors = set()
 
   def handle_starttag(self, tag, raw_attrs):
     attrs = dict(raw_attrs)
 
     if tag == 'a':
       # Handle special cases for href's that: start with a space, contain
       # just a '.' (period), contain python templating code, are an absolute
       # url, are a zip file, or execute javascript on the page.
       href = attrs.get('href', '').strip()
       if href and not href == '.' and not '{{' in href:
         if not urlsplit(href).scheme in ('http', 'https'):
           if not href.endswith('.zip') and not 'javascript:' in href:
             self.links.append(href)
 
     if attrs.get('id'):
       self.anchors.add(attrs['id'])
     if attrs.get('name'):
       self.anchors.add(attrs['name'])
 
+
 class LinkErrorDetector(object):
   '''Finds link errors on the doc server. This includes broken links, those with
   a target page that 404s or contain an anchor that doesn't exist, or pages that
   have no links to them.
   '''
 
   def __init__(self, file_system, renderer, public_path, root_pages):
     '''Creates a new broken link detector. |renderer| is a callable that takes
     a path and returns a full html page. |public_path| is the path to public
     template files. All URLs in |root_pages| are used as the starting nodes for
@@ skipping 11 matching lines @@
         'extensions/private_apis.html'))
     self._redirection_whitelist = frozenset(('extensions/', 'apps/'))
 
     self._RenderAllPages()
 
   def _RenderAllPages(self):
     '''Traverses the public templates directory rendering each URL and
     processing the resultant html to pull out all links and anchors.
     '''
     top_level_directories = (
-      (svn_constants.PUBLIC_TEMPLATE_PATH, ''),
-      (svn_constants.STATIC_PATH, 'static/'),
-      (svn_constants.EXAMPLES_PATH, 'extensions/examples/'),
+      ('docs/templates/public', ''),
+      ('docs/static', 'static/'),
+      ('docs/examples', 'extensions/examples/'),
     )
 
     for dirpath, urlprefix in top_level_directories:
       files = CreateURLsFromPaths(self._file_system, dirpath, urlprefix)
       for url, path in files:
         self._pages[url] = _Process(url, self._renderer)
 
         if self._pages[url].status != 200:
           print(url, ', a url derived from the path', dirpath +
               ', resulted in a', self._pages[url].status)
@@ skipping 109 matching lines @@
       for link in target_page.links:
         if link not in found:
           found.add(link)
           pages_to_check.append(link)
 
     all_urls = set(
         [url for url, page in self._pages.iteritems() if page.status == 200])
 
     return [url for url in all_urls - found if url.endswith('.html')]
 
+
 def StringifyBrokenLinks(broken_links):
   '''Prints out broken links in a more readable format.
   '''
   def fixed_width(string, width):
     return "%s%s" % (string, (width - len(string)) * ' ')
 
   first_col_width = max(len(link[1]) for link in broken_links)
   second_col_width = max(len(link[2]) for link in broken_links)
   target = itemgetter(2)
   output = []
 
   def pretty_print(link, col_offset=0):
     return "%s -> %s %s" % (
         fixed_width(link[1], first_col_width - col_offset),
         fixed_width(link[2], second_col_width),
         link[3])
 
   for target, links in groupby(sorted(broken_links, key=target), target):
     links = list(links)
     # Compress messages
     if len(links) > 50 and not links[0][2].startswith('#'):
       message = "Found %d broken links (" % len(links)
       output.append("%s%s)" % (message, pretty_print(links[0], len(message))))
     else:
       for link in links:
         output.append(pretty_print(link))
 
   return '\n'.join(output)