def test_series_v(self):
with tmp_series() as [dir, series]:
applied = Db(dir)
applied.add_patch(Patch("applied.patch"))
applied.add_patch(Patch("topmost.patch"))
applied.save()
series.add_patches(applied.applied_patches())
series.add_patch(Patch("unapplied.patch"))
series.save()
output = run_cli(SeriesCommand, dict(v=True),
series.dirname, applied.dirname)
self.assertMultiLineEqual(output,
"+ applied.patch\n"
"= topmost.patch\n"
" unapplied.patch\n")
class Pop(Command):
unapplying = Signal()
unapplied = Signal()
unapplied_patch = Signal()
empty_patch = Signal()
def __init__(self, cwd, quilt_pc):
super(Pop, self).__init__(cwd)
self.quilt_pc = Directory(quilt_pc)
self.db = Db(quilt_pc)
def _check(self, force=False):
if not self.db.exists() or not self.db.patches():
raise NoAppliedPatch(self.db)
if not force:
patch = self.db.top_patch()
pc_dir = self.quilt_pc + patch.get_name()
refresh = File(pc_dir.get_name() + "~refresh")
if refresh.exists():
raise QuiltError("Patch %s needs to be refreshed first." %
patch.get_name())
def _unapply_patch(self, patch):
self.unapplying(patch)
patch_name = patch.get_name()
pc_dir = self.quilt_pc + patch_name
timestamp = pc_dir + File(".timestamp")
timestamp.delete_if_exists()
if pc_dir.is_empty():
pc_dir.delete()
self.empty_patch(patch)
else:
unpatch = RollbackPatch(self.cwd, pc_dir)
unpatch.rollback()
unpatch.delete_backup()
self.db.remove_patch(patch)
refresh = File(pc_dir.get_name() + "~refresh")
refresh.delete_if_exists()
self.unapplied_patch(patch)
def unapply_patch(self, patch_name, force=False):
""" Unapply patches up to patch_name. patch_name will end up as top
patch """
self._check(force)
patches = self.db.patches_after(Patch(patch_name))
for patch in reversed(patches):
self._unapply_patch(patch)
self.db.save()
self.unapplied(self.db.top_patch())
def unapply_top_patch(self, force=False):
""" Unapply top patch """
self._check(force)
patch = self.db.top_patch()
self._unapply_patch(patch)
self.db.save()
self.unapplied(self.db.top_patch())
def unapply_all(self, force=False):
""" Unapply all patches """
self._check(force)
for patch in reversed(self.db.applied_patches()):
self._unapply_patch(patch)
self.db.save()
self.unapplied(self.db.top_patch())
class Push(Command):
applying = Signal()
applying_patch = Signal()
applied = Signal()
applied_patch = Signal()
applied_empty_patch = Signal()
def __init__(self, cwd, quilt_pc, quilt_patches):
super(Push, self).__init__(cwd)
self.quilt_pc = Directory(quilt_pc)
self.quilt_patches = Directory(quilt_patches)
self.db = Db(quilt_pc)
self.series = Series(quilt_patches)
def _apply_patch(self, patch, force=False, quiet=False):
patch_name = patch.get_name()
pc_dir = self.quilt_pc + patch_name
patch_file = self.quilt_patches + File(patch_name)
refresh = File(pc_dir.get_name() + "~refresh")
forced = False
self.applying_patch(patch)
if patch_file.exists():
try:
patch.run(self.cwd, patch_dir=self.quilt_patches, backup=True,
prefix=pc_dir.get_name(), quiet=quiet)
except SubprocessError as e:
if not force:
patch = RollbackPatch(self.cwd, pc_dir)
patch.rollback()
patch.delete_backup()
raise QuiltError("Patch %s does not apply" % patch_name)
else:
refresh.touch()
forced = True
self.db.add_patch(patch)
if pc_dir.exists():
timestamp = pc_dir + File(".timestamp")
timestamp.touch()
else:
pc_dir.create()
if not patch_file.exists():
self.applied_empty_patch(patch, False)
elif pc_dir.is_empty():
self.applied_empty_patch(patch, True)
elif forced:
raise QuiltError("Applied patch %s (forced; needs refresh)" %
patch.get_name())
else:
self.applied_patch(patch)
def _check(self):
if not self.series.exists() or not self.series.patches():
raise NoPatchesInSeries(self.series)
top = self.db.top_patch()
if top is not None:
refresh = top.get_name() + "~refresh"
refresh = os.path.join(self.quilt_pc.get_name(), refresh)
if os.path.exists(refresh):
raise QuiltError("Patch %s needs to be refreshed" % \
top.get_name())
def apply_patch(self, patch_name, force=False, quiet=False):
""" Apply all patches up to patch_name """
self._check()
patch = Patch(patch_name)
patches = self.series.patches_until(patch)[:]
applied = self.db.applied_patches()
for patch in applied:
if patch in patches:
patches.remove(patch)
if not patches:
raise AllPatchesApplied(self.series, self.db.top_patch())
self.applying(patch)
try:
for cur_patch in patches:
self._apply_patch(cur_patch, force, quiet)
finally:
self.db.save()
self.applied(self.db.top_patch())
def apply_next_patch(self, force=False, quiet=False):
""" Apply next patch in series file """
self._check()
top = self.db.top_patch()
if not top:
patch = self.series.first_patch()
else:
patch = self.series.patch_after(top)
if not patch:
raise AllPatchesApplied(self.series, top)
self.applying(patch)
self._apply_patch(patch, force, quiet)
self.db.save()
self.applied(self.db.top_patch())
def apply_all(self, force=False, quiet=False):
""" Apply all patches in series file """
self._check()
top = self.db.top_patch()
if top:
patches = self.series.patches_after(top)
else:
patches = self.series.patches()
if not patches:
raise AllPatchesApplied(self.series, top)
try:
for patch in patches:
self.applying(patch)
self._apply_patch(patch, force, quiet)
finally:
self.db.save()
self.applied(self.db.top_patch())
