src/third_party/trace-viewer/third_party/tvcm/tvcm/project.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4 import os
   5
   6 from tvcm import resource as resource_module
   7 from tvcm import resource_loader
   8
   9 def _FindAllFilesRecursive(source_paths):
  10   all_filenames = set()
  11   for source_path in source_paths:
  12     for dirpath, dirnames, filenames in os.walk(source_path):
  13       for f in filenames:
  14         if f.startswith('.'):
  15           continue
  16         x = os.path.abspath(os.path.join(dirpath, f))
  17         all_filenames.add(x)
  18   return all_filenames
  19
  20 def _IsFilenameAModule(loader, x):
  21   if x.endswith('.html'):
  22     return True
  23   else:
  24     return False
  25
  26
  27 def _IsFilenameATest(loader, x):
  28   if x.endswith('_test.js'):
  29     return True
  30
  31   if x.endswith('_test.html'):
  32     return True
  33
  34   if x.endswith('_unittest.js'):
  35     return True
  36
  37   if x.endswith('_unittest.html'):
  38     return True
  39
  40   # TODO(nduca): Add content test?
  41   return False
  42
  43 class AbsFilenameList(object):
  44   def __init__(self, willDirtyCallback):
  45     self._willDirtyCallback = willDirtyCallback
  46     self._filenames = []
  47     self._filenames_set = set()
  48
  49   def _WillBecomeDirty(self):
  50     if self._willDirtyCallback:
  51       self._willDirtyCallback()
  52
  53   def append(self, filename):
  54     assert os.path.isabs(filename)
  55     self._WillBecomeDirty()
  56     self._filenames.append(filename)
  57     self._filenames_set.add(filename)
  58
  59   def extend(self, iter):
  60     self._WillBecomeDirty()
  61     for filename in iter:
  62       assert os.path.isabs(filename)
  63       self._filenames.append(filename)
  64       self._filenames_set.add(filename)
  65
  66   def appendRel(self, basedir, filename):
  67     assert os.path.isabs(basedir)
  68     self._WillBecomeDirty()
  69     n = os.path.abspath(os.path.join(basedir, filename))
  70     self._filenames.append(n)
  71     self._filenames_set.add(n)
  72
  73   def extendRel(self, basedir, iter):
  74     self._WillBecomeDirty()
  75     assert os.path.isabs(basedir)
  76     for filename in iter:
  77       n = os.path.abspath(os.path.join(basedir, filename))
  78       self._filenames.append(n)
  79       self._filenames_set.add(n)
  80
  81   def __contains__(self, x):
  82     return x in self._filenames_set
  83
  84   def __len__(self):
  85     return self._filenames.__len__()
  86
  87   def __iter__(self):
  88     return iter(self._filenames)
  89
  90   def __repr__(self):
  91     return repr(self._filenames)
  92
  93   def __str__(self):
  94     return str(self._filenames)
  95
  96
  97 class Project(object):
  98   tvcm_path = os.path.abspath(os.path.join(
  99       os.path.dirname(__file__), '..'))
 100
 101   tvcm_src_path = os.path.abspath(os.path.join(
 102       tvcm_path, 'src'))
 103
 104   def __init__(self, source_paths=None, include_tvcm_paths=True, non_module_html_files=None):
 105     """
 106     source_paths: A list of top-level directories in which modules and raw scripts can be found.
 107         Module paths are relative to these directories.
 108     """
 109     self._loader = None
 110     self._frozen = False
 111     self.source_paths = AbsFilenameList(self._WillPartOfPathChange)
 112     self.non_module_html_files = AbsFilenameList(self._WillPartOfPathChange)
 113
 114     if include_tvcm_paths:
 115       self.source_paths.append(self.tvcm_src_path)
 116
 117     if source_paths != None:
 118       self.source_paths.extend(source_paths)
 119
 120     if non_module_html_files != None:
 121       self.non_module_html_files.extend(non_module_html_files)
 122
 123   def Freeze(self):
 124     self._frozen = True
 125
 126   def _WillPartOfPathChange(self):
 127     if self._frozen:
 128       raise Exception('The project is frozen. You cannot edit it now')
 129     self._loader = None
 130
 131   @staticmethod
 132   def FromDict(d):
 133     return Project(d['source_paths'],
 134                    include_tvcm_paths=False,
 135                    non_module_html_files=d.get('non_module_html_files', None))
 136
 137   def AsDict(self):
 138     return {
 139       'source_paths': list(self.source_paths),
 140       'non_module_html_files': list(self.non_module_html_files)
 141     }
 142
 143   def __repr__(self):
 144     return "Project(%s)" % repr(self.source_paths)
 145
 146   def AddSourcePath(self, path):
 147     self.source_paths.append(path)
 148
 149   @property
 150   def loader(self):
 151     if self._loader == None:
 152       self._loader = resource_loader.ResourceLoader(self)
 153     return self._loader
 154
 155   def ResetLoader(self):
 156     self._loader = None
 157
 158   def _FindAllModuleFilenames(self, source_paths):
 159     all_filenames = _FindAllFilesRecursive(source_paths)
 160     return [x for x in all_filenames if
 161             x not in self.non_module_html_files and
 162             _IsFilenameAModule(self.loader, x)]
 163
 164   def _FindTestModuleFilenames(self, source_paths):
 165     all_filenames = _FindAllFilesRecursive(source_paths)
 166     return [x for x in all_filenames if
 167             x not in self.non_module_html_files and
 168             _IsFilenameATest(self.loader, x)]
 169
 170   def FindAllTestModuleResources(self, start_path=None):
 171     if start_path == None:
 172       test_module_filenames = self._FindTestModuleFilenames(self.source_paths)
 173     else:
 174       test_module_filenames = self._FindTestModuleFilenames([start_path])
 175     test_module_filenames.sort()
 176
 177     # Find the equivalent resources.
 178     return [self.loader.FindResourceGivenAbsolutePath(x)
 179             for x in test_module_filenames]
 180
 181   def FindAllModuleFilenames(self):
 182     return self._FindAllModuleFilenames(self.source_paths)
 183
 184   def CalcLoadSequenceForAllModules(self):
 185     filenames = self.FindAllModuleFilenames()
 186     return self.CalcLoadSequenceForModuleFilenames(filenames)
 187
 188   def _Load(self, filenames):
 189     return [self.loader.LoadModule(module_filename=filename) for
 190             filename in filenames]
 191
 192   def CalcLoadSequenceForModuleFilenames(self, filenames):
 193     modules = self._Load(filenames)
 194     return self.CalcLoadSequenceForModules(modules)
 195
 196   def CalcLoadSequenceForModuleNames(self, module_names):
 197     modules = [self.loader.LoadModule(module_name=name) for
 198                name in module_names]
 199     return self.CalcLoadSequenceForModules(modules)
 200
 201   def CalcLoadSequenceForModules(self, modules):
 202     already_loaded_set = set()
 203     load_sequence = []
 204     for m in modules:
 205       m.ComputeLoadSequenceRecursive(load_sequence, already_loaded_set)
 206     return load_sequence