def test_old_revision(self): c = hglib.open(self.tmpdir) with open(self.tmppath('foo'), 'wb') as fh: fh.write('foo initial') c.add(self.tmppath('foo')) c.commit('initial') with open(self.tmppath('foo'), 'wb') as fh: fh.write('foo second') with open(self.tmppath('bar'), 'wb') as fh: fh.write('bar second') c.add(self.tmppath('bar')) c.commit('second') # This wipes out the working directory, ensuring the finder isn't # finding anything from the filesystem. c.rawcommand(['update', 'null']) finder = self._get_finder(self.tmpdir, 0) f = finder.get('foo') self.assertEqual(f.read(), 'foo initial') self.assertEqual(f.read(), 'foo initial', 'read again for good measure') self.assertIsNone(finder.get('bar')) finder = MercurialRevisionFinder(self.tmpdir, rev=1) f = finder.get('foo') self.assertEqual(f.read(), 'foo second') f = finder.get('bar') self.assertEqual(f.read(), 'bar second')
def _get_files_info(self, paths, rev=None): from mozbuild.frontend.reader import default_finder from mozpack.files import FileFinder, MercurialRevisionFinder # Normalize to relative from topsrcdir. relpaths = [] for p in paths: a = mozpath.abspath(p) if not mozpath.basedir(a, [self.topsrcdir]): raise InvalidPathException('path is outside topsrcdir: %s' % p) relpaths.append(mozpath.relpath(a, self.topsrcdir)) repo = None if rev: hg_path = os.path.join(self.topsrcdir, '.hg') if not os.path.exists(hg_path): raise InvalidPathException('a Mercurial repo is required ' 'when specifying a revision') repo = self.topsrcdir # We need two finders because the reader's finder operates on # absolute paths. finder = FileFinder(self.topsrcdir) if repo: reader_finder = MercurialRevisionFinder(repo, rev=rev, recognize_repo_paths=True) else: reader_finder = default_finder # Expand wildcards. # One variable is for ordering. The other for membership tests. # (Membership testing on a list can be slow.) allpaths = [] all_paths_set = set() for p in relpaths: if '*' not in p: if p not in all_paths_set: all_paths_set.add(p) allpaths.append(p) continue if repo: raise InvalidPathException( 'cannot use wildcard in version control mode') for path, f in finder.find(p): if path not in all_paths_set: all_paths_set.add(path) allpaths.append(path) reader = self._get_reader(finder=reader_finder) return reader.files_info(allpaths)
def _get_finder(self, *args, **kwargs): f = MercurialRevisionFinder(*args, **kwargs) self._clients.append(f._client) return f
def mozbuild_reader(self, config_mode='build', vcs_revision=None, vcs_check_clean=True): """Obtain a ``BuildReader`` for evaluating moz.build files. Given arguments, returns a ``mozbuild.frontend.reader.BuildReader`` that can be used to evaluate moz.build files for this repo. ``config_mode`` is either ``build`` or ``empty``. If ``build``, ``self.config_environment`` is used. This requires a configured build system to work. If ``empty``, an empty config is used. ``empty`` is appropriate for file-based traversal mode where ``Files`` metadata is read. If ``vcs_revision`` is defined, it specifies a version control revision to use to obtain files content. The default is to use the filesystem. This mode is only supported with Mercurial repositories. If ``vcs_revision`` is not defined and the version control checkout is sparse, this implies ``vcs_revision='.'``. If ``vcs_revision`` is ``.`` (denotes the parent of the working directory), we will verify that the working directory is clean unless ``vcs_check_clean`` is False. This prevents confusion due to uncommitted file changes not being reflected in the reader. """ from mozbuild.frontend.reader import ( default_finder, BuildReader, EmptyConfig, ) from mozpack.files import ( MercurialRevisionFinder, ) if config_mode == 'build': config = self.config_environment elif config_mode == 'empty': config = EmptyConfig(self.topsrcdir) else: raise ValueError('unknown config_mode value: %s' % config_mode) try: repo = self.repository except InvalidRepoPath: repo = None if repo and not vcs_revision and repo.sparse_checkout_present(): vcs_revision = '.' if vcs_revision is None: finder = default_finder else: # If we failed to detect the repo prior, check again to raise its # exception. if not repo: self.repository assert False if repo.name != 'hg': raise Exception('do not support VCS reading mode for %s' % repo.name) if vcs_revision == '.' and vcs_check_clean: with repo: if not repo.working_directory_clean(): raise Exception('working directory is not clean; ' 'refusing to use a VCS-based finder') finder = MercurialRevisionFinder(self.topsrcdir, rev=vcs_revision, recognize_repo_paths=True) return BuildReader(config, finder=finder)
def _get_finder(self, *args, **kwargs): return MercurialRevisionFinder(*args, **kwargs)