Docserver: Add support for viewing docs with a codereview patch applied

chrome/common/extensions/docs/server2/server_instance.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 fnmatch import fnmatch
 import logging
 import mimetypes
 import traceback
 import os
 
 from api_data_source import APIDataSource
 from api_list_data_source import APIListDataSource
 from appengine_blobstore import AppEngineBlobstore
 from appengine_url_fetcher import AppEngineUrlFetcher
 from appengine_wrappers import GetAppVersion, IsDevServer
 from branch_utility import BranchUtility
 from caching_file_system import CachingFileSystem
 from compiled_file_system import CompiledFileSystem
 from empty_dir_file_system import EmptyDirFileSystem
 from example_zipper import ExampleZipper
 from file_system import FileNotFoundError
 from github_file_system import GithubFileSystem
 from intro_data_source import IntroDataSource
 from local_file_system import LocalFileSystem
 from object_store_creator import ObjectStoreCreator
 from offline_file_system import OfflineFileSystem
+from patched_file_system import PatchedFileSystem
 from path_canonicalizer import PathCanonicalizer
 from reference_resolver import ReferenceResolver
+from rietveld_patcher import RietveldPatcher
 from samples_data_source import SamplesDataSource
 from sidenav_data_source import SidenavDataSource
 from subversion_file_system import SubversionFileSystem
 import svn_constants
 from template_data_source import TemplateDataSource
 from third_party.json_schema_compiler.memoize import memoize
 from third_party.json_schema_compiler.model import UnixName
 import url_constants
 
 def _IsSamplesDisabled():
   return IsDevServer()
 
 class ServerInstance(object):
   # Lazily create so we don't create github file systems unnecessarily in
   # tests.
   branch_utility = None
   github_file_system = None
 
   @staticmethod
   @memoize
-  def GetOrCreateOffline(channel):
+  def GetOrCreateOffline(channel, static_path=None, issue=None):

[not at google - send to devlin, 2013/05/07 05:45:40]

these optional parameters won't work well with the memoization, but I've...
almost... finished simplifying the way this stuff works and that'll let you do
this much more easily.

     '''Gets/creates a local ServerInstance, meaning that only resources local to
     the server - memcache, object store, etc, are queried. This amounts to not
     setting up the subversion nor github file systems.
     '''
     branch_utility = ServerInstance._GetOrCreateBranchUtility()
     branch = branch_utility.GetBranchNumberForChannelName(channel)
     object_store_creator_factory = ObjectStoreCreator.Factory(GetAppVersion(),
                                                               branch)
     # No svn nor github file systems. Rely on the crons to fill the caches, and
     # for the caches to exist.
-    return ServerInstance(
+    return ServerInstance._CreateWithPatch(
         channel,
+        static_path,
         object_store_creator_factory,
         CachingFileSystem(OfflineFileSystem(SubversionFileSystem),
                           object_store_creator_factory,
                           use_existing_values=True),
         # TODO(kalman): convert GithubFileSystem to be wrappable in a
         # CachingFileSystem so that it can be replaced with an
         # OfflineFileSystem. Currently GFS doesn't set the child versions of
         # stat requests so it doesn't.
-        ServerInstance._GetOrCreateGithubFileSystem())
+        ServerInstance._GetOrCreateGithubFileSystem(),
+        issue)
 
   @staticmethod
-  def CreateOnline(channel):
+  def CreateOnline(channel, static_path=None, issue=None):
     '''Creates/creates an online server instance, meaning that both local and
     subversion/github resources are queried.
     '''
     branch_utility = ServerInstance._GetOrCreateBranchUtility()
     branch = branch_utility.GetBranchNumberForChannelName(channel)
 
     if branch == 'trunk':
       svn_url = '/'.join((url_constants.SVN_TRUNK_URL,
                           'src',
                           svn_constants.EXTENSIONS_PATH))
     else:
       svn_url = '/'.join((url_constants.SVN_BRANCH_URL,
                           branch,
                           'src',
                           svn_constants.EXTENSIONS_PATH))
 
     viewvc_url = svn_url.replace(url_constants.SVN_URL,
                                  url_constants.VIEWVC_URL)
 
     object_store_creator_factory = ObjectStoreCreator.Factory(GetAppVersion(),
                                                               branch)
 
     svn_file_system = CachingFileSystem(
         SubversionFileSystem(AppEngineUrlFetcher(svn_url),
                              AppEngineUrlFetcher(viewvc_url)),
         object_store_creator_factory)
 
+    return ServerInstance._CreateWithPatch(
+        channel,
+        static_path,
+        object_store_creator_factory,
+        svn_file_system,
+        ServerInstance._GetOrCreateGithubFileSystem(),
+        issue)
+
+  @staticmethod
+  def _CreateWithPatch(channel,
+                       static_path,
+                       object_store_creator_factory,
+                       svn_file_system,
+                       github_file_system,
+                       issue=None):
+    if static_path is None:
+      static_path = ('/static' if channel == 'stable' else
+                     '/%s/static' % channel)
+    if issue is not None:
+      original_object_store_creator_factory = object_store_creator_factory
+      original_svn_file_system = svn_file_system
+      object_store_creator_factory = ObjectStoreCreator.Factory(
+          GetAppVersion(),
+          'trunk@%s' % issue)
+      rietveld_patcher = RietveldPatcher(
+          svn_constants.EXTENSIONS_PATH,
+          issue,
+          AppEngineUrlFetcher(url_constants.CODEREVIEW_SERVER),
+          object_store_creator_factory)
+      svn_file_system = PatchedFileSystem(svn_file_system,
+                                          rietveld_patcher)
+      compiled_fs_factory = CompiledFileSystem.Factory(
+          original_svn_file_system,
+          original_object_store_creator_factory,
+          svn_file_system,
+          object_store_creator_factory)
+    else:
+      compiled_fs_factory = None
+
     return ServerInstance(channel,
+                          static_path,
                           object_store_creator_factory,
                           svn_file_system,
-                          ServerInstance._GetOrCreateGithubFileSystem())
+                          github_file_system,
+                          compiled_fs_factory)
 
   @staticmethod
   def CreateForTest(file_system):
     return ServerInstance('test',
+                          '/static',
                           ObjectStoreCreator.TestFactory(),
                           file_system,
                           None)
 
   @staticmethod
   def _GetOrCreateBranchUtility():
     if ServerInstance.branch_utility is None:
       ServerInstance.branch_utility = BranchUtility(
           url_constants.OMAHA_PROXY_URL,
           AppEngineUrlFetcher())
     return ServerInstance.branch_utility
 
   @staticmethod
   def _GetOrCreateGithubFileSystem():
     # Initialising github is pointless if samples are disabled, since it's only
     # used for apps samples.
     if ServerInstance.github_file_system is None:
       if _IsSamplesDisabled():
         ServerInstance.github_file_system = EmptyDirFileSystem()
       else:
         ServerInstance.github_file_system = GithubFileSystem(
             AppEngineUrlFetcher(url_constants.GITHUB_URL),
             AppEngineBlobstore())
     return ServerInstance.github_file_system
 
   def __init__(self,
                channel,
+               static_path,
                object_store_creator_factory,
                svn_file_system,
-               github_file_system):
+               github_file_system,
+               compiled_fs_factory=None):
     self.svn_file_system = svn_file_system
 
     self.github_file_system = github_file_system
 
-    self.compiled_fs_factory = CompiledFileSystem.Factory(
-        svn_file_system,
-        object_store_creator_factory)
+    if compiled_fs_factory is None:
+      self.compiled_fs_factory = CompiledFileSystem.Factory(
+          svn_file_system,
+          object_store_creator_factory)
+    else:
+      self.compiled_fs_factory = compiled_fs_factory
 
     self.api_list_data_source_factory = APIListDataSource.Factory(
         self.compiled_fs_factory,
         svn_constants.API_PATH,
         svn_constants.PUBLIC_TEMPLATE_PATH)
 
     self.api_data_source_factory = APIDataSource.Factory(
         self.compiled_fs_factory,
         svn_constants.API_PATH)
 
@@ skipping 35 matching lines @@
     self.template_data_source_factory = TemplateDataSource.Factory(
         channel,
         self.api_data_source_factory,
         self.api_list_data_source_factory,
         self.intro_data_source_factory,
         self.samples_data_source_factory,
         self.sidenav_data_source_factory,
         self.compiled_fs_factory,
         self.ref_resolver_factory,
         svn_constants.PUBLIC_TEMPLATE_PATH,
-        svn_constants.PRIVATE_TEMPLATE_PATH)
+        svn_constants.PRIVATE_TEMPLATE_PATH,
+        static_path)
 
     self.example_zipper = ExampleZipper(
         self.compiled_fs_factory,
         svn_constants.DOCS_PATH)
 
     self.path_canonicalizer = PathCanonicalizer(
         channel,
         self.compiled_fs_factory)
 
     self.content_cache = self.compiled_fs_factory.CreateIdentity(ServerInstance)