[recipe_modules/file] add real file module to engine.

recipe_modules/path/api.py

 # Copyright 2013 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 functools
 import itertools
 import os
 import re
 import tempfile
 
@@ skipping 17 matching lines @@
 def string_filter(func):
   @functools.wraps(func)
   def inner(*args, **kwargs):
     return func(*map(str, args), **kwargs)
   return inner
 
 
 class path_set(object):
   """ implements a set which contains all the parents folders of added folders.
   """
+  # TODO(iannucci): Expand this to be a full fakey filesystem, including file
+  # contents and file types. Coordinate with the `file` module.
   def __init__(self, path_mod, initial_paths):
     self._path_mod = path_mod
     self._initial_paths = set(initial_paths)
     self._paths = set()
 
   def _initialize(self):
     self._initialize = lambda: None
     for path in self._initial_paths:
       self.add(path)
     self._initial_paths = None
     self.contains = lambda path: path in self._paths
 
   def add(self, path):
     path = str(path)
     self._initialize()
     while path:
       self._paths.add(path)
       path = self._path_mod.dirname(path)
 
+  def copy(self, source, dest):
+    source, dest = str(source), str(dest)
+    self._initialize()
+    to_add = set()
+    for p in self._paths:
+      if p.startswith(source):
+        to_add.add(p.replace(source, dest))
+    self._paths |= to_add
+
+  def remove(self, path, filt):
+    path = str(path)
+    self._initialize()
+    kill_set = set(p for p in self._paths if p.startswith(path) and filt(p))
+    self._paths -= kill_set
+
   def contains(self, path):
     self._initialize()
     return self.contains(path)
 
 
 class fake_path(object):
   """Standin for os.path when we're in test mode.
 
   This class simulates the os.path interface exposed by PathApi, respecting the
   current platform according to the `platform` module. This allows us to
@@ skipping 17 matching lines @@
   def __getattr__(self, name):
     self._init_pth()
     return getattr(self._pth, name)
 
   def mock_add_paths(self, path):
     """
     Adds a path and all of its parents to the set of existing paths.
     """
     self._mock_path_exists.add(path)
 
+  def mock_copy_paths(self, source, dest):
+    """
+    Duplicates a path and all of its children to another path.
+    """
+    self._mock_path_exists.copy(source, dest)
+
+  def mock_remove_paths(self, path, filt):
+    """
+    Removes a path and all of its children from the set of existing paths.
+    """
+    self._mock_path_exists.remove(path, filt)
+
   def exists(self, path):  # pylint: disable=E0202
     """Return True if path refers to an existing path."""
     return self._mock_path_exists.contains(path)
 
   # This matches:
   #   [START_DIR]
   #   RECIPE[some_pkg::some_module:recipe_name]
   #
   # and friends at the beginning of a string.
   ROOT_MATCHER = re.compile('^[A-Z_]*\[[^]]*\]')
@@ skipping 129 matching lines @@
       self._temp_dir = ['/']
       self._cache_dir = ['/', 'b', 'c']
 
     self.set_config('BASE')
 
   def mock_add_paths(self, path):
     """For testing purposes, assert that |path| exists."""
     if self._test_data.enabled:
       self._path_mod.mock_add_paths(path)
 
+  def mock_copy_paths(self, source, dest):
+    """For testing purposes, copy |source| to |dest|."""
+    if self._test_data.enabled:
+      self._path_mod.mock_copy_paths(source, dest)
+
+  def mock_remove_paths(self, path, filt=lambda p: True):
+    """For testing purposes, assert that |path| doesn't exist.
+
+    Args:
+      path (str|Path) - The path to remove.
+      filt (func[str] bool) - Called for every candidate path. Return
+        True to remove this path.
+    """
+    if self._test_data.enabled:
+      self._path_mod.mock_remove_paths(path, filt)
+
   def assert_absolute(self, path):
     assert self.abspath(path) == str(path), '%s is not absolute' % path
 
   def mkdtemp(self, prefix):
     """Makes a new temp directory, returns path to it."""
     if not self._test_data.enabled:  # pragma: no cover
       # New path as str.
       new_path = tempfile.mkdtemp(prefix=prefix, dir=str(self['tmp_base']))
       # Ensure it's under self._temp_dir, convert to Path.
       new_path = _split_path(new_path)
@@ skipping 79 matching lines @@
     if name in self.OK_ATTRS:
       return getattr(self._path_mod, name)
     if name in self.FILTER_METHODS:
       return string_filter(getattr(self._path_mod, name))
     raise AttributeError("'%s' object has no attribute '%s'" %
                          (self._path_mod, name))  # pragma: no cover
 
   def __dir__(self):  # pragma: no cover
     # Used for helping out show_me_the_modules.py
     return self.__dict__.keys() + list(self.OK_ATTRS + self.FILTER_METHODS)