Extensions Docs Server: Preserve JSON declaration order in extensions documentation

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 os
 
 from docs_server_utils import GetLinkToRefType
 import compiled_file_system as compiled_fs
 from file_system import FileNotFoundError
-import third_party.json_schema_compiler.json_comment_eater as json_comment_eater
+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
 
 # Increment this version when there are changes to the data stored in any of
 # the caches used by APIDataSource. This allows the cache to be invalidated
 # without having to flush memcache on the production server.
-_VERSION = 0
+_VERSION = 1
 
 def _RemoveNoDocs(item):
-  if type(item) == dict:
+  if isinstance(item, (dict, json_parse.OrderedDict)):
     if item.get('nodoc', False):
       return True
     for key, value in item.items():
       if _RemoveNoDocs(value):
         del item[key]
   elif type(item) == list:
     for i in item:
       if _RemoveNoDocs(i):
         item.remove(i)
   return False
@@ skipping 221 matching lines @@
 
     def Create(self, request):
       return APIDataSource(self._permissions_cache,
                            self._json_cache,
                            self._idl_cache,
                            self._idl_names_cache,
                            self._base_path,
                            self._samples_factory.Create(request))
 
     def _LoadPermissions(self, json_str):
-      return json.loads(json_comment_eater.Nom(json_str))
+      return json_parse.Parse(json_str)
 
     def _LoadJsonAPI(self, api):
-      return _JscModel(json.loads(json_comment_eater.Nom(api))[0])
+      return _JscModel(json_parse.Parse(api)[0])
 
     def _LoadIdlAPI(self, api):
       idl = idl_parser.IDLParser().ParseData(api)
       return _JscModel(idl_schema.IDLSchema(idl).process()[0])
 
     def _GetIDLNames(self, apis):
       return [model.UnixName(os.path.splitext(api.split('/')[-1])[0])
               for api in apis if api.endswith('.idl')]
 
   def __init__(self,
@@ skipping 24 matching lines @@
     path = model.UnixName(path.replace('experimental_', ''))
     for filename in ['_permission_features.json', '_manifest_features.json']:
       api_perms = self._GetPermsFromFile(filename).get(path, None)
       if api_perms is not None:
         break
     if api_perms and api_perms['channel'] in ('trunk', 'dev', 'beta'):
       api_perms[api_perms['channel']] = True
     return api_perms
 
   def _GenerateHandlebarContext(self, handlebar, path):
-    return_dict = {
-      'permissions': self._GetFeature(path),
-      'samples': _LazySamplesGetter(path, self._samples)
-    }
-    return_dict.update(handlebar.ToDict())
+    return_dict = handlebar.ToDict()
+    return_dict['permissions'] = self._GetFeature(path)
+    return_dict['samples'] = _LazySamplesGetter(path, self._samples)
     return return_dict
 
   def __getitem__(self, key):
     return self.get(key)
 
   def get(self, key):
     path, ext = os.path.splitext(key)
     unix_name = model.UnixName(path)
     idl_names = self._idl_names_cache.GetFromFileListing(self._base_path)
     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)),
         path)