Presubmit checks for the Pipa repository

pipa/py/gitdeps.py

 # Copyright 2014 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 36 matching lines @@
 import glob
 import hashlib
 import logging
 import optparse
 import os
 import random
 import re
 import subprocess
 import threading
 
+import deps_utils
 
 _LOGGER = logging.getLogger(os.path.basename(__file__))
 
 
 # Matches a SHA1 hash used as a git revision.
 _GIT_SHA1_RE = re.compile('^[A-Fa-f0-9]{40}$')
 
 
 def _ParseCommandLine():
   """Parses the command-line and returns an options structure."""
@@ skipping 556 matching lines @@
       'safesync_url': '',
     }
   ]
   solutions = 'solutions=%s' % solutions.__repr__()
   _WriteIfChanged(gclient_file, solutions, options.dry_run)
 
   # Invoke 'gclient' on the sub-repository.
   _Shell('gclient', 'sync', cwd=repo.checkout_dir, dry_run=options.dry_run)
 
 
-def _FindGlobalVariableInAstTree(tree, name, functions=None):
-  """Finds and evaluates to global assignment of the variables |name| in the
-  AST |tree|. Will allow the evaluations of some functions as defined in
-  |functions|.
-  """
-  if functions is None:
-    functions = {}
-
-  class FunctionEvaluator(ast.NodeTransformer):
-    """A tree transformer that evaluates permitted functions."""
-
-    def visit_BinOp(self, binop_node):
-      """Is called for BinOp nodes. We only support string additions."""
-      if type(binop_node.op) != ast.Add:
-        return binop_node
-      left = ast.literal_eval(self.visit(binop_node.left))
-      right = ast.literal_eval(self.visit(binop_node.right))
-      value = left + right
-      new_node = ast.Str(s=value)
-      new_node = ast.copy_location(new_node, binop_node)
-      return new_node
-
-    def visit_Call(self, call_node):
-      """Evaluates function calls that return a single string as output."""
-      func_name = call_node.func.id
-      if func_name not in functions:
-        return call_node
-      func = functions[func_name]
-
-      # Evaluate the arguments. We don't care about starargs, keywords or
-      # kwargs.
-      args = [ast.literal_eval(self.visit(arg)) for arg in
-                  call_node.args]
-
-      # Now evaluate the function.
-      value = func(*args)
-      new_node = ast.Str(s=value)
-      new_node = ast.copy_location(new_node, call_node)
-      return new_node
-
-  # Look for assignment nodes.
-  for node in tree.body:
-    if type(node) != ast.Assign:
-      continue
-    # Look for assignment in the 'store' context, to a variable with
-    # the given name.
-    for target in node.targets:
-      if type(target) != ast.Name:
-        continue
-      if type(target.ctx) != ast.Store:
-        continue
-      if target.id == name:
-        value = FunctionEvaluator().visit(node.value)
-        value = ast.fix_missing_locations(value)
-        value = ast.literal_eval(value)
-        return value
-
-
-def _ParseDepsFile(path):
-  """Parsed a DEPS-like file at the given |path|."""
-  # Utility function for performing variable expansions.
-  vars_dict = {}
-  def _Var(s):
-    return vars_dict[s]
-
-  contents = open(path, 'rb').read()
-  tree = ast.parse(contents, path)
-  vars_dict = _FindGlobalVariableInAstTree(tree, 'vars')
-  deps_dict = _FindGlobalVariableInAstTree(
-      tree, 'deps', functions={'Var': _Var})
-  return deps_dict
 
 
 def _RemoveFile(options, path):
   """Removes the provided file. If it doesn't exist, raises an Exception."""
   _LOGGER.debug('Removing file: %s', path)
   if not os.path.isfile(path):
     raise Exception('Path does not exist: %s' % path)
 
   if not options.dry_run:
     os.remove(path)
@@ skipping 153 matching lines @@
 
   # Read junctions that have been written in previous runs.
   state_path = _GetJunctionStatePath(options)
   old_junctions = _ReadJunctions(options)
 
   # Parse each deps file in order, and extract the dependencies, looking for
   # conflicts in the output directories.
   output_dirs = {}
   all_deps = []
   for deps_file in args:
-    deps = _ParseDepsFile(deps_file)
+    deps = deps_utils.ParseDepsFile(deps_file)
     for key, value in deps.iteritems():
       repo_options = _ParseRepoOptions(
           options.cache_dir, options.output_dir, deps_file, key, value)
       if repo_options.output_dir in output_dirs:
         other_repo_options = output_dirs[repo_options.output_dir]
         _LOGGER.error('Conflicting output directory: %s',
                       repo_options.output_dir)
         _LOGGER.error('First specified in file: %s',
                       other_repo_options.deps_file)
         _LOGGER.error('And then specified in file: %s', repo_options.deps_file)
@@ skipping 56 matching lines @@
       continue
     if not checkout_dirs[repo.checkout_dir] and not options.force:
       continue
     _RecurseRepository(options, repo)
 
   return
 
 
 if __name__ == '__main__':
   main()