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

chrome/common/extensions/docs/server2/api_data_source.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.
 
 import copy
 import json
 import logging
 import os
 from collections import defaultdict, Mapping
 
 from environment import IsPreviewServer
-import svn_constants
+from extensions_paths import (
+    API, API_FEATURES, JSON_TEMPLATES, PRIVATE_TEMPLATES)
 import third_party.json_schema_compiler.json_parse as json_parse
 import third_party.json_schema_compiler.model as model
 import third_party.json_schema_compiler.idl_schema as idl_schema
 import third_party.json_schema_compiler.idl_parser as idl_parser
 from schema_util import RemoveNoDocs, DetectInlineableTypes, InlineDocs
 from third_party.handlebar import Handlebar
 
 
 def _CreateId(node, prefix):
   if node.parent is not None and not isinstance(node.parent, model.Namespace):
@@ skipping 54 matching lines @@
                branch_utility,
                parse_cache,
                template_cache,
                event_byname_function,
                idl=False):
     self._ref_resolver = ref_resolver
     self._disable_refs = disable_refs
     self._availability_finder = availability_finder
     self._branch_utility = branch_utility
     self._api_availabilities = parse_cache.GetFromFile(
-        '%s/api_availabilities.json' % svn_constants.JSON_PATH)
+        '%s/api_availabilities.json' % JSON_TEMPLATES)
     self._intro_tables = parse_cache.GetFromFile(
-        '%s/intro_tables.json' % svn_constants.JSON_PATH)
-    self._api_features = parse_cache.GetFromFile(
-        '%s/_api_features.json' % svn_constants.API_PATH)
+        '%s/intro_tables.json' % JSON_TEMPLATES)
+    self._api_features = parse_cache.GetFromFile(API_FEATURES)
     self._template_cache = template_cache
     self._event_byname_function = event_byname_function
     clean_json = copy.deepcopy(json)
     if RemoveNoDocs(clean_json):
       self._namespace = None
     else:
       if idl:
         DetectInlineableTypes(clean_json)
       InlineDocs(clean_json)
       self._namespace = model.Namespace(clean_json, clean_json['namespace'])
@@ skipping 292 matching lines @@
       version = None
     else:
       availability = self._GetApiAvailability()
       status = availability.channel
       version = availability.version
     return {
       'title': 'Availability',
       'content': [{
         'partial': self._template_cache.GetFromFile(
                        '%s/intro_tables/%s_message.html' %
-                           (svn_constants.PRIVATE_TEMPLATE_PATH, status)).Get(),
+                           (PRIVATE_TEMPLATES, status)).Get(),
         'version': version
       }]
     }
 
   def _GetIntroDependencyRows(self):
     # Devtools aren't in _api_features. If we're dealing with devtools, bail.
     if 'devtools' in self._namespace.name:
       return []
     feature = self._api_features.Get().get(self._namespace.name)
     assert feature, ('"%s" not found in _api_features.json.'
@@ skipping 52 matching lines @@
     if table_info is None:
       return misc_rows
 
     for category in table_info.keys():
       content = copy.deepcopy(table_info[category])
       for node in content:
         # If there is a 'partial' argument and it hasn't already been
         # converted to a Handlebar object, transform it to a template.
         if 'partial' in node:
           node['partial'] = self._template_cache.GetFromFile('%s/%s' %
-              (svn_constants.PRIVATE_TEMPLATE_PATH, node['partial'])).Get()
+              (PRIVATE_TEMPLATES, node['partial'])).Get()
       misc_rows.append({ 'title': category, 'content': content })
     return misc_rows
 
 
 class _LazySamplesGetter(object):
   '''This class is needed so that an extensions API page does not have to fetch
   the apps samples page and vice versa.
   '''
 
   def __init__(self, api_name, samples):
     self._api_name = api_name
     self._samples = samples
 
   def get(self, key):
     return self._samples.FilterSamples(key, self._api_name)
 
 
 class APIDataSource(object):
   '''This class fetches and loads JSON APIs from the FileSystem passed in with
   |compiled_fs_factory|, so the APIs can be plugged into templates.
   '''
 
   class Factory(object):
     def __init__(self,
                  compiled_fs_factory,
                  file_system,
-                 base_path,
                  availability_finder,
                  branch_utility):
       def create_compiled_fs(fn, category):
         return compiled_fs_factory.Create(
             file_system, fn, APIDataSource, category=category)
 
       self._json_cache = create_compiled_fs(
           lambda api_name, api: self._LoadJsonAPI(api, False),
           'json')
       self._idl_cache = create_compiled_fs(
           lambda api_name, api: self._LoadIdlAPI(api, False),
           'idl')
 
       # These caches are used if an APIDataSource does not want to resolve the
       # $refs in an API. This is needed to prevent infinite recursion in
       # ReferenceResolver.
       self._json_cache_no_refs = create_compiled_fs(
           lambda api_name, api: self._LoadJsonAPI(api, True),
           'json-no-refs')
       self._idl_cache_no_refs = create_compiled_fs(
           lambda api_name, api: self._LoadIdlAPI(api, True),
           'idl-no-refs')
 
       self._idl_names_cache = create_compiled_fs(self._GetIDLNames, 'idl-names')
       self._names_cache = create_compiled_fs(self._GetAllNames, 'names')
 
-      self._base_path = base_path
       self._availability_finder = availability_finder
       self._branch_utility = branch_utility
 
       self._parse_cache = compiled_fs_factory.ForJson(file_system)
       self._template_cache = compiled_fs_factory.ForTemplates(file_system)
 
       # These must be set later via the SetFooDataSourceFactory methods.
       self._ref_resolver_factory = None
       self._samples_data_source_factory = None
 
@@ skipping 17 matching lines @@
                         'APIDataSource.Factory.')
         samples = None
       else:
         samples = self._samples_data_source_factory.Create(request)
       return APIDataSource(self._json_cache,
                            self._idl_cache,
                            self._json_cache_no_refs,
                            self._idl_cache_no_refs,
                            self._names_cache,
                            self._idl_names_cache,
-                           self._base_path,
                            samples)
 
     def _LoadEventByName(self):
       """ All events have some members in common. We source their description
       from Event in events.json.
       """
       if self._event_byname is None:
-        events_json = self._json_cache.GetFromFile(
-            '%s/events.json' % self._base_path).Get()
+        events_json = self._json_cache.GetFromFile('%s/events.json' % API).Get()
         self._event_byname = _GetEventByNameFromEvents(events_json)
       return self._event_byname
 
     def _LoadJsonAPI(self, api, disable_refs):
       return _JSCModel(
           json_parse.Parse(api)[0],
           self._ref_resolver_factory.Create() if not disable_refs else None,
           disable_refs,
           self._availability_finder,
           self._branch_utility,
@@ skipping 24 matching lines @@
       return [model.UnixName(os.path.splitext(api)[0]) for api in apis
               if os.path.splitext(api)[1][1:] in exts]
 
   def __init__(self,
                json_cache,
                idl_cache,
                json_cache_no_refs,
                idl_cache_no_refs,
                names_cache,
                idl_names_cache,
-               base_path,
                samples):
-    self._base_path = base_path
     self._json_cache = json_cache
     self._idl_cache = idl_cache
     self._json_cache_no_refs = json_cache_no_refs
     self._idl_cache_no_refs = idl_cache_no_refs
     self._names_cache = names_cache
     self._idl_names_cache = idl_names_cache
     self._samples = samples
 
   def _GenerateHandlebarContext(self, handlebar_dict):
     # Parsing samples on the preview server takes seconds and doesn't add
@@ skipping 12 matching lines @@
         return '/'.join(parts)
       return '%s/%s' % (parts[0], name)
     return name.replace('_', '/', 1)
 
   def get(self, key, disable_refs=False):
     if key.endswith('.html') or key.endswith('.json') or key.endswith('.idl'):
       path, ext = os.path.splitext(key)
     else:
       path = key
     unix_name = model.UnixName(path)
-    idl_names = self._idl_names_cache.GetFromFileListing(self._base_path).Get()
-    names = self._names_cache.GetFromFileListing(self._base_path).Get()
+    idl_names = self._idl_names_cache.GetFromFileListing(API).Get()
+    names = self._names_cache.GetFromFileListing(API).Get()
     if unix_name not in names and self._GetAsSubdirectory(unix_name) in names:
       unix_name = self._GetAsSubdirectory(unix_name)
 
     if disable_refs:
       cache, ext = (
           (self._idl_cache_no_refs, '.idl') if (unix_name in idl_names) else
           (self._json_cache_no_refs, '.json'))
     else:
       cache, ext = ((self._idl_cache, '.idl') if (unix_name in idl_names) else
                     (self._json_cache, '.json'))
     return self._GenerateHandlebarContext(
-        cache.GetFromFile('%s/%s%s' % (self._base_path, unix_name, ext)).Get())
+        cache.GetFromFile('%s/%s%s' % (API, unix_name, ext)).Get())