[recipe_engine] Fix a couple path-related bugs.

recipe_engine/package.py

 # Copyright 2015 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 import ast
 import collections
 import contextlib
 import copy
 import difflib
 import functools
@@ skipping 12 matching lines @@
 from . import fetch
 
 
 class InconsistentDependencyGraphError(Exception):
   def __init__(self, project_id, specs):
     self.project_id = project_id
     self.specs = specs
 
   def __str__(self):
     return 'Package specs for %s do not match: %s vs %s' % (
-        project_id, self.specs[0], self.specs[1])
+        self.project_id, self.specs[0], self.specs[1])
 
 
 class CyclicDependencyError(Exception):
   pass
 
 
 def cleanup_pyc(path):
   """Removes any .pyc files from |path|'s directory tree.
 
   This ensures we always use the fresh code.
@@ skipping 115 matching lines @@
     """Returns the root of this repository."""
     raise NotImplementedError()
 
   def __eq__(self, other):
     raise NotImplementedError()
 
   def __ne__(self, other):
     return not (self == other)
 
   def proto_file(self, context):
-    """Returns the ProtoFile of the recipes config file in this repository. 
+    """Returns the ProtoFile of the recipes config file in this repository.
     Requires a good checkout."""
     return ProtoFile(InfraRepoConfig().to_recipes_cfg(self.repo_root(context)))
 
 
 class GitRepoSpec(RepoSpec):
   def __init__(self, project_id, repo, branch, revision, path, backend):
     self.project_id = project_id
     self.repo = repo
     self.branch = branch
     self.revision = revision
@@ skipping 116 matching lines @@
 
   def __eq__(self, other):
     if not isinstance(other, type(self)):
       return False
     return self._components() == other._components()
 
 
 class PathRepoSpec(RepoSpec):
   """A RepoSpec implementation that uses a local filesystem path."""
 
-  def __init__(self, path):
+  def __init__(self, project_id, path):
+    self.project_id = project_id
     self.path = path
 
   def __str__(self):
-    return 'PathRepoSpec{path="%(path)s"}' % self.__dict__
+    return (
+      'PathRepoSpec{project_id="%(project_id)s", path="%(path)s"}'
+      % self.__dict__
+    )
 
   def checkout(self, context):
     pass
 
   def repo_root(self, _context):
     return self.path
 
   def proto_file(self, context):
-    """Returns the ProtoFile of the recipes config file in this repository. 
+    """Returns the ProtoFile of the recipes config file in this repository.
     Requires a good checkout."""
     return ProtoFile(InfraRepoConfig().to_recipes_cfg(self.path))
 
+  def updates(self, _context, _other_revision=None):
+    """Returns (empty) list of potential updates for this spec."""
+    return []
+
+  def dump(self):
+    """Returns the package.proto DepSpec form of this RepoSpec."""
+    return package_pb2.DepSpec(
+        project_id=self.project_id,
+        url="file://"+self.path)

[iannucci, 2017/02/03 00:00:05]

These are used by the autoroller tests.

+
   def __eq__(self, other):
     if not isinstance(other, type(self)):
       return False
     return self.path == other.path
 
 
 class RootRepoSpec(RepoSpec):
   def __init__(self, proto_file):
     self._proto_file = proto_file
 
@@ skipping 169 matching lines @@
     buf = proto_file.read()
     assert buf.api_version == cls.API_VERSION
 
     deps = { str(dep.project_id): cls.spec_for_dep(dep)
              for dep in buf.deps }
     return cls(str(buf.project_id), str(buf.recipes_path), deps)
 
   @classmethod
   def spec_for_dep(cls, dep):
     """Returns a RepoSpec for the given dependency protobuf."""
+    url = str(dep.url)
+    if url.startswith("file://"):
+      return PathRepoSpec(str(dep.project_id), url[len("file://"):])
 
     if dep.repo_type in (package_pb2.DepSpec.GIT, package_pb2.DepSpec.GITILES):
       if dep.repo_type == package_pb2.DepSpec.GIT:
         backend = fetch.GitBackend()
       elif dep.repo_type == package_pb2.DepSpec.GITILES:
         backend = fetch.GitilesBackend()
       return GitRepoSpec(str(dep.project_id),
-                         str(dep.url),
+                         url,
                          str(dep.branch),
                          str(dep.revision),
                          str(dep.path_override),
                          backend)
 
     assert False, 'Unexpected repo type: %s' % dep
 
   @property
   def project_id(self):
     return self._project_id
@@ skipping 75 matching lines @@
       allow_fetch: whether to fetch dependencies rather than just checking for
                    them.
       overrides: if not None, a dictionary of project overrides. Dictionary keys
                  are the `project_id` field to override, and dictionary values
                  are the override path.
     """
     context = PackageContext.from_proto_file(repo_root, proto_file, allow_fetch,
                                              deps_path=deps_path)
 
     if overrides:
-      overrides = {project_id: PathRepoSpec(path)
+      overrides = {project_id: PathRepoSpec(project_id, path)
                    for project_id, path in overrides.iteritems()}
     package_deps = cls(context, overrides=overrides)
 
     package_deps._root_package = package_deps._create_package(RootRepoSpec(proto_file))
 
     return package_deps
 
   def _create_package(self, repo_spec):
     repo_spec.checkout(self._context)
     package_spec = PackageSpec.load_proto(repo_spec.proto_file(self._context))
@@ skipping 49 matching lines @@
   >>> d = { 'x': 1, 'y': 2 }
   >>> sorted(_updated(d, { 'y': 3, 'z': 4 }).items())
   [('x', 1), ('y', 3), ('z', 4)]
   >>> sorted(d.items())
   [('x', 1), ('y', 2)]
   """
 
   d = copy.copy(d)
   d.update(updates)
   return d