def run_pop(args):
number = stop_at_patch = None
patchfns.chdir_to_base_dir()
if args.patchnamornum:
if args.patchnamornum.isdigit():
number = int(args.patchnamornum)
else:
stop_at_patch = patchfns.find_applied_patch(args.patchnamornum)
if not stop_at_patch:
return cmd_result.ERROR
elif not args.opt_all:
number = 1
silent = args.opt_quiet
if patchfns.top_patch_needs_refresh() and not args.opt_force:
output.error('The topmost patch %s needs to be refreshed first.\n' % patchfns.print_top_patch())
return cmd_result.ERROR | cmd_result.SUGGEST_FORCE_OR_REFRESH
patches = list_patches(number=number, stop_at_patch=stop_at_patch)
if not patches:
output.error('No patch removed\n')
return cmd_result.ERROR
is_ok = True
for patch in patches:
result = remove_patch(patch, force=args.opt_force, check=args.opt_remove, silent=silent)
if result is not True:
return cmd_result.ERROR if result is False else result
if not args.opt_quiet:
output.write('\n')
if not patchfns.top_patch():
output.write('No patches applied\n')
else:
output.write('Now at patch %s\n' % patchfns.print_top_patch())
return cmd_result.OK if is_ok is True else cmd_result.ERROR
def set_file_contents(filename, text):
'''
Set the contents of filename to text after applying compression
as indicated by filename's suffix.
'''
_root, ext = os.path.splitext(filename)
res = 0
if ext == '.gz':
try:
gzip.open(filename, 'wb').write(text)
return True
except (IOError, zlib.error):
return False
elif ext == '.bz2':
try:
bz2f = bz2.BZ2File(filename, 'w')
text = bz2f.write(text)
bz2f.close()
return True
except IOError:
return False
elif ext == '.xz':
res, text, serr = shell.run_cmd('xz -c', text)
elif ext == '.lzma':
res, text, serr = shell.run_cmd('lzma -c', text)
if res != 0:
output.error(serr)
return False
try:
open(filename, 'w').write(text)
except IOError:
return False
return True
def run_fork(args):
patchfns.chdir_to_base_dir()
top_patch = patchfns.find_top_patch()
if not top_patch:
return cmd_result.ERROR
new_patch = args.arg_new_name if args.arg_new_name else patchfns.next_filename(top_patch)
new_patch_file = patchfns.patch_file_name(new_patch)
new_patch_dir = os.path.join(patchfns.QUILT_PC, new_patch)
if patchfns.patch_in_series(new_patch) or os.path.isdir(new_patch_dir) or os.path.exists(new_patch_file):
output.error('Patch %s exists already, please choose a new name\n' % patchfns.print_patch(new_patch))
return cmd_result.ERROR | cmd_result.SUGGEST_RENAME
is_ok = patchfns.rename_in_db(top_patch, new_patch)
is_ok = is_ok if not is_ok else patchfns.rename_in_series(top_patch, new_patch)
if is_ok:
top_patch_dir = os.path.join(patchfns.QUILT_PC, top_patch)
try:
os.rename(top_patch_dir, new_patch_dir)
except OSError:
is_ok = False
if is_ok:
top_patch_file = patchfns.patch_file_name(top_patch)
if os.path.exists(top_patch_file):
try:
shutil.copy2(top_patch_file, new_patch_file)
except Exception:
is_ok = False
if not is_ok:
output.write('Fork of patch %s to patch %s failed\n' % (patchfns.print_patch(top_patch), patchfns.print_patch(new_patch)))
else:
output.error('Fork of patch %s created as %s\n' % (patchfns.print_patch(top_patch), patchfns.print_patch(new_patch)))
return cmd_result.OK if is_ok else cmd_result.ERROR
def run_rename(args):
patchfns.chdir_to_base_dir()
patch = patchfns.find_patch_in_series(args.opt_patch)
if not patch:
return cmd_result.ERROR
new_patch = patchfns.patch_name_base(args.new_name)
new_patch_exists = patchfns.patch_in_series(new_patch)
new_patch_exists = True if new_patch_exists else os.path.isdir(os.path.join(patchfns.QUILT_PC, new_patch))
new_patch_exists = True if new_patch_exists else os.path.exists(patchfns.patch_file_name(new_patch))
if new_patch_exists:
output.error('Patch %s exists already, please choose a different name\n' % patchfns.print_patch(new_patch))
return cmd_result.ERROR
is_ok = True
if patchfns.is_applied(patch):
is_ok = patchfns.rename_in_db(patch, new_patch)
if is_ok:
is_ok = move_file(os.path.join(patchfns.QUILT_PC, patch), os.path.join(patchfns.QUILT_PC, new_patch))
if is_ok:
is_ok = patchfns.rename_in_series(patch, new_patch)
if is_ok and os.path.exists(patchfns.patch_file_name(patch)):
is_ok = move_file(patchfns.patch_file_name(patch), patchfns.patch_file_name(new_patch))
if is_ok:
output.write('Patch %s renamed to %s\n' % (patchfns.print_patch(patch), patchfns.print_patch(new_patch)))
return cmd_result.OK
else:
output.error('Renaming of patch %s to %s failed\n' % (patchfns.print_patch(patch), patchfns.print_patch(new_patch)))
return cmd_result.ERROR
def remove_patch(patch, force, check, silent):
try:
status = True
if not force and (check or files_may_have_changed(patch)):
status = check_for_pending_changes(patch)
if status is True:
patchdir = os.path.join(patchfns.QUILT_PC, patch)
try:
os.remove(os.path.join(patchdir, '.timestamp'))
except OSError:
pass
if not os.path.exists(patchdir) or not os.listdir(patchdir):
output.write('Patch %s appears to be empty, removing\n' % patchfns.print_patch(patch))
try:
os.rmdir(patchdir)
except OSError as edata:
if edata.errno != errno.ENOENT:
output.error('%s: %s\n' % (patchdir, edata.errstring))
status = False
else:
output.write('Removing patch %s\n' % patchfns.print_patch(patch))
if not backup.restore(patchdir, touch=True, verbose=not silent):
status = False
patchfns.remove_from_db(patch)
try:
os.remove(os.path.join(patchdir + '~refresh'))
except OSError as edata:
if edata.errno != errno.ENOENT:
output.error('%s: %s\n' % (patchdir, edata.errstring))
status = False
return status
except KeyboardInterrupt:
return False
def find_first_patch():
patches = _get_series()
if len(patches) > 0:
return patches[0]
if os.path.isfile(SERIES):
output.error('No patches in series\n')
else:
output.error('No series file found\n')
return False
def get_diffstat(text, strip_level, quiet=True):
if not PARSER:
make_parser()
diffstat_options = customization.get_default_opts('diffstat')
args, leftovers = PARSER.parse_known_args(diffstat_options.split())
if leftovers and not quiet:
output.error('diffstat default options: %; ignored\n' % ' '.join(leftovers))
obj = patchlib.Patch.parse_text(text)
stats_list = obj.get_diffstat_stats(int(strip_level))
return stats_list.list_format_string(quiet=args.opt_quiet, comment=args.opt_comment, max_width=int(args.opt_max_width))
def in_valid_dir(filename):
'''Is (relative) filename in a valid directory?'''
dirpath = os.path.dirname(filename)
while dirpath:
for invalid_dir in [QUILT_PATCHES, QUILT_PC]:
if os.path.samefile(dirpath, invalid_dir):
output.error('File %s is located below %s\n' % (filename, invalid_dir + os.sep))
return False
dirpath = os.path.dirname(dirpath)
return True
def run_header(args):
def read_input():
text = sys.stdin.read()
if args.opt_strip_trailing_whitespace:
return _trim_trailing_ws(text)
return text
def get_text(pfile):
text = putils.get_patch_hdr(pfile, omit_diffstat=args.opt_strip_diffstat)
if args.opt_strip_trailing_whitespace:
return _trim_trailing_ws(text)
return text
def set_text(pfile, text):
if args.opt_backup:
try:
shutil.copy2(pfile, pfile + '~')
except Exception as edata:
output.perror(edata)
if args.opt_strip_trailing_whitespace:
text = _trim_trailing_ws(text)
putils.set_patch_hdr(pfile, text, omit_diffstat=args.opt_strip_diffstat)
patchfns.chdir_to_base_dir()
if not args.opt_backup:
args.opt_backup = customization.get_config('QUILT_BACKUP')
patch = patchfns.find_patch_in_series(args.arg_patch)
if not patch:
return cmd_result.ERROR
patch_file = patchfns.patch_file_name(patch)
if args.opt_replace:
set_text(patch_file, read_input())
output.write('Replaced header of patch %s\n' % patchfns.print_patch(patch))
elif args.opt_append:
set_text(patch_file, get_text(patch_file) + read_input())
output.write('Appended text to header of patch %s\n' % patchfns.print_patch(patch))
elif args.opt_edit:
savelang = os.getenv('LANG', None)
os.environ['LANG'] = patchfns.ORIGINAL_LANG
tempfile = patchfns.gen_tempfile()
result = shell.run_cmd('%s %s' % (os.getenv('EDITOR'), tempfile))
if savelang:
os.environ['LANG'] = savelang
output.error(result.stderr)
output.write(result.stdout)
text = open(tempfile).read()
os.remove(tempfile)
if result.eflags != 0:
return cmd_result.ERROR
set_text(patch_file, text)
output.write('Replaced header of patch %s\n' % patchfns.print_patch(patch))
else:
if not os.path.exists(patch_file):
return cmd_result.OK
output.start_pager()
output.write(get_text(patch_file))
output.wait_for_pager()
return cmd_result.OK
def version_check():
if not os.path.isdir(QUILT_PC):
return True
ver_file = os.path.join(QUILT_PC, '.version')
if os.path.isfile(ver_file):
version = int(open(ver_file).read().strip())
if version > DB_VERSION:
output.error('The quilt meta-data in this tree has version %s, but this version of quilt can only handle meta-data formats up to and including version %s. Please pop all the patches using the version of quilt used to push them before downgrading.\n' % (version, DB_VERSION))
sys.exit(cmd_result.ERROR)
return version == DB_VERSION
return False
def find_applied_patch(patchname=None):
if patchname:
patch = find_patch(patchname)
if patch:
if not is_applied(patch):
output.error('Patch %s is not applied\n' % print_patch(patch))
return False
return patch
else:
return False
else:
return find_top_patch()
def find_patch_file(name):
"""Find the patch file with the given name"""
rname = filename_rel_base(name)
if os.path.exists(rname) and os.access(rname, os.R_OK):
return rname
output.set_swallow_errors(True)
patch = find_patch_in_series(name)
output.set_swallow_errors(False)
if not patch:
output.error('Patch %s does not exist\n' % name)
return False
return patch_file_name(patch)
def run_fold(args):
patchfns.chdir_to_base_dir()
if not args.opt_strip_level:
args.opt_strip_level = '1'
opt_patch_args = '' if not args.opt_quiet else ' -s'
if not args.opt_force or args.opt_quiet:
opt_patch_args += ' -f'
if args.opt_reverse:
opt_patch_args += ' -R'
top = patchfns.find_top_patch()
if not top:
return cmd_result.ERROR
failed = suggest_force = False
try:
workdir = patchfns.gen_tempfile(template=os.getcwd(), asdir=True)
if patchfns.SUBDIR:
subdir = patchfns.SUBDIR
prefix = os.path.join(workdir, patchfns.SUBDIR) + os.sep
else:
subdir = '.'
prefix = workdir + os.sep
patch_args = '-p%s --backup --prefix="%s" -E %s' % (args.opt_strip_level, prefix, opt_patch_args)
patch_text = sys.stdin.read()
result = putils.apply_patch_text(patch_text, indir=subdir, patch_args=patch_args)
output.write(result.stdout)
output.error(result.stderr)
if result.eflags != 0 and not args.opt_force:
suggest_force = True
failed = True
if not failed:
for filename in fsutils.files_in_dir(workdir):
backup_file = patchfns.backup_file_name(top, filename)
if not os.path.exists(backup_file):
try:
backup_file_dir = os.path.dirname(backup_file)
if backup_file_dir and not os.path.exists(backup_file_dir):
os.makedirs(backup_file_dir)
os.link(os.path.join(workdir, filename), backup_file)
except OSError as edata:
failed = True
break
except KeyboardInterrupt:
failed = True
if failed:
for filename in fsutils.files_in_dir(workdir):
try:
shutil.move(os.path.join(workdir, filename), filename)
except OSError:
output.error('File %s may be corrupted\n' % filename)
if os.path.exists(workdir):
shutil.rmtree(workdir)
return cmd_result.OK if not failed else cmd_result.ERROR_SUGGEST_FORCE if suggest_force else cmd_result.ERROR
def run_new(args):
patchfns.chdir_to_base_dir()
patch = patchfns.patch_name_base(args.patchname)
if patchfns.patch_in_series(patch):
output.error('Patch "%s" exists already\n' % patchfns.print_patch(patch))
return cmd_result.ERROR | cmd_result.SUGGEST_RENAME
patchfns.create_db()
if not patchfns.insert_in_series(patch) or not patchfns.add_to_db(patch):
output.error('Failed to create patch %s\n' % patchfns.print_patch(patch))
return cmd_result.ERROR
else:
output.write('Patch %s is now on top\n' % patchfns.print_patch(patch))
return cmd_result.OK
def find_patch(patchname):
if os.path.exists(SERIES):
if not os.path.isfile(SERIES):
output.error('%s is not a regular file\n' % SERIES)
return False
can_pacthname = _canonical_patchname(patchname)
matcher = _re_for_finding_patch_in_series(can_pacthname)
candidates = []
for line in open(SERIES).readlines():
reres = matcher.match(line)
if reres:
candidates.append(reres.group(1))
if len(candidates) == 1:
return candidates[0]
elif len(candidates) > 1:
for candidate in candidates:
# We may have an exact match, which overrides
# extension expansion. Otherwise we're confused
if candidate == can_pacthname:
return candidate
output.error('%s has too many matches in series:\n' % patchname)
for candidate in candidates:
output.error('\t%s\n' % candidate)
return False
if find_first_patch():
output.error('Patch %s is not in series\n' % patchname)
return False
def run_add(args):
patchfns.chdir_to_base_dir()
patch = patchfns.find_applied_patch(args.opt_patch)
if not patch:
return 1
patch_dir = os.path.join(patchfns.QUILT_PC, patch)
status = 0
for filename in args.filelist:
filename = patchfns.filename_rel_base(filename)
if not patchfns.in_valid_dir(filename):
status = 1
continue
if patchfns.file_in_patch(patch, filename):
output.error('File %s is already in patch %s\n' % (filename, patchfns.print_patch(patch)))
status = 2 if status != 1 else 1
next_patch = patchfns.next_patch_for_file(patch, filename)
if next_patch is not None:
output.error('File %s modified by patch %s\n' % (filename, patchfns.print_patch(next_patch)))
status = 1
continue
if os.path.islink(filename):
output.error('Cannot add symbolic link %s\n' % filename)
status = 1
continue
if not backup.backup(patch_dir, [filename]):
output.error('Failed to back up file %s\n' % filename)
status = 1
continue
if os.path.exists(filename):
# The original tree may be read-only.
os.chmod(filename, os.stat(filename).st_mode|stat.S_IWUSR)
output.write('File %s added to patch %s\n' % (filename, patchfns.print_patch(patch)))
return status
def _create_parents(filename):
last_sep = filename.rfind(os.sep)
if last_sep == -1 or os.path.exists(filename[:last_sep]):
return
next_sep = filename.find(os.sep)
while next_sep != -1:
dirname = filename[:next_sep]
if not os.path.isdir(dirname):
try:
os.mkdir(dirname, 0777)
except OSError:
output.error('Could not create directory %s.\n' % dirname)
sys.exit(1)
next_sep = filename.find(os.sep, next_sep + 1)
def run_edit(args):
patchfns.chdir_to_base_dir()
if patchfns.pyquilt_command('add %s' % ' '.join(args.filelist)) not in [0, 2]:
return cmd_result.ERROR
efilelist = args.filelist if not patchfns.SUBDIR else [os.path.join(patchfns.SUBDIR, fnm) for fnm in args.filelist]
os.environ['LANG'] = patchfns.ORIGINAL_LANG
result = shell.run_cmd('%s %s' % (os.getenv('EDITOR'), ' '.join(efilelist)))
output.error(result.stderr)
output.write(result.stdout)
status = cmd_result.OK if result.eflags == 0 else cmd_result.ERROR
for filename in args.filelist:
efname = filename if not patchfns.SUBDIR else os.path.join(patchfns.SUBDIR, filename)
if not os.path.exists(efname):
patchfns.pyquilt_command('revert %s' % filename)
status = cmd_result.ERROR
return status
def run_files(args):
patchfns.chdir_to_base_dir()
first_patch = None
if args.opt_combine:
args.opt_all = True
if args.opt_combine != '-':
first_patch = patchfns.find_patch_in_series(args.opt_combine)
if not first_patch:
return cmd_result.ERROR
last_patch = patchfns.find_applied_patch(args.patch)
if not last_patch:
return cmd_result.ERROR
if args.opt_all:
if not first_patch:
first_patch = patchfns.applied_patches()[0]
patches = patchfns.patches_before(last_patch) + [last_patch]
if first_patch not in patches:
output.error('Patch %s not applied before patch %s\n' % (patchfns.print_patch(first_patch), patchfns.print_patch(last_patch)))
return cmd_result.ERROR
patches = patches[patches.index(first_patch):]
else:
patches = [last_patch]
use_status = args.opt_verbose and not args.opt_labels
# Note: If opt_labels is set, then use_status is not set.
output.start_pager()
for patch in patches:
if args.opt_all and args.opt_verbose and not args.opt_labels:
output.write('%s\n' % patch)
for filename in sorted(patchfns.files_in_patch(patch)):
if args.opt_labels:
if args.opt_verbose:
output.write('[%s] ' % patch)
else:
output.write('%s ' % patch)
if not use_status:
output.write('%s\n' % filename)
else:
status = ' '
buname = patchfns.backup_file_name(patch, filename)
if os.path.exists(buname) and os.path.getsize(buname) > 0:
if not os.path.exists(filename) or os.path.getsize(filename) == 0:
status = '-'
elif os.path.exists(filename) or os.path.getsize(filename) > 0:
status = '+'
output.write('%s %s\n' % (status, filename))
output.wait_for_pager()
return cmd_result.OK
def check_for_existing_directories(args, script):
status=False
dircty_set = set()
for action in script:
if action[0] == 'patch':
if args.prefix:
dircty_set.add(os.path.join(args.prefix, action[1]))
else:
dircty_set.add(action[1])
last_dir = None
for dircty in dircty_set:
if dircty == ".":
continue
if os.path.exists(dircty):
output.error('Directory %s exists\n' % dircty)
status = True
return status
def apply_patch_temporarily(workdir, patch, files=None):
patch_file = patch_file_name(patch)
args = patch_args(patch)
srcdir = os.path.join(QUILT_PC, patch)
if not backup.restore(srcdir, to_dir=workdir, filelist=files, keep=True):
output.error('Failed to copy files to temporary directory\n')
return False
if os.path.isfile(patch_file) and os.path.getsize(patch_file) > 0:
text = fsutils.get_file_contents(patch_file)
result = putils.apply_patch(indir=workdir, patch_args=' '.join(args) + ' --no-backup-if-mismatch -Ef', patch_file=patch_file)
if result.eflags != 0:
# Generating a relative diff for a subset of files in
# the patch will fail. Also, if a patch was force
# applied, we know that it won't apply cleanly. In
# all other cases, print a warning.
if not os.path.isfile(os.path.join(QUILT_PC, patch + '~refresh')) and len(files) == 0:
output.error('Failed to patch temporary files\n')
return False
return True
def check_for_existing_files(args, script):
status=False
dircty_set = set()
for action in script:
if action[0] == 'patch':
if args.prefix:
dircty_set.add(os.path.join(args.prefix, action[1]))
else:
dircty_set.add(action[1])
for dircty in dircty_set:
patch_dir = os.path.join(dircty, patchfns.QUILT_PATCHES)
if os.path.exists(patch_dir):
output.error('Directory %s exists\n' % patch_dir)
status = True
series_file = os.path.join(dircty, patchfns.QUILT_SERIES)
if os.path.exists(series_file):
output.error('File %s exists\n' % series_file)
status = True
return status
def process_mail(message, args):
if args.opt_send:
sendmail_cmd = '%s %s --f %s ' % (os.getenv('QUILT_SENDMAIL', 'sendmail'), os.getenv('QUILT_SENDMAIL_ARGS', ''), args.opt_sender)
sendmail_cmd += extract_recipients(message)
output.write(sendmail_cmd)
del message['Bcc']
result = shell.run_cmd(sendmail_cmd, message.as_string(False))
output.write(result.stdout)
output.error(result.stderr)
else:
from_date = time.strftime('+%a %b %e %H:%M:%S %Y')
fobj = open(args.opt_mbox, 'a')
fobj.write('From %s %s\n' % (args.opt_sender_address, from_date))
for field, value in message.items():
fobj.write('%s: %s\n' % (field, value))
fobj.write('\n')
for line in message.get_payload().splitlines(True):
fobj.write(re.sub('^From ', '>From ', line))
fobj.close()
def run_delete(args):
patchfns.chdir_to_base_dir()
if args.patch:
patch = patchfns.find_patch(args.patch)
if not patch:
return cmd_result.ERROR
else:
patch = patchfns.top_patch()
if args.opt_next:
patch =patchfns.patch_after(patch)
if not patch:
output.error('No next patch\n')
return cmd_result.ERROR
if not patch:
patchfns.find_top_patch()
return cmd_result.ERROR
if patchfns.is_applied(patch):
if patch != patchfns.top_patch():
output.error('Patch %s is currently applied\n' % patchfns.print_patch(patch))
return cmd_result.ERROR
if patchfns.pyquilt_command('pop -qf') != cmd_result.OK:
return cmd_result.ERROR
if patchfns.remove_from_series(patch):
output.write('Removed patch %s\n' % patchfns.print_patch(patch))
else:
output.error('Failed to remove patch %s\n' % patchfns.print_patch(patch))
return cmd_result.ERROR
patch_file = patchfns.patch_file_name(patch)
if args.opt_remove and os.path.exists(patch_file):
if args.opt_backup:
try:
os.rename(patch_file, patch_file + '~')
except IOError:
output.error('Failed to backup patch file %s\n' % patch_file)
return cmd_result.ERROR
else:
try:
os.remove(patch_file)
except IOError:
output.error('Failed to remove patch file %s\n' % patch_file)
return cmd_result.ERROR
return cmd_result.OK
def create_db(dirpath=None):
if dirpath is not None:
saved_dir = os.getcwd()
os.chdir(dirpath)
if not os.path.isdir(QUILT_PC):
if os.path.exists(QUILT_PC):
output.error('%s is not a directory.\n' % QUILT_PC)
sys.exit(cmd_result.ERROR)
try:
os.mkdir(QUILT_PC)
except OSError:
output.error('Could not create directory %s.\n' % QUILT_PC)
sys.exit(cmd_result.ERROR)
open(os.path.join(QUILT_PC, '.version'), 'w').write('%s\n' % DB_VERSION)
if not os.path.isfile(os.path.join(QUILT_PC, '.quilt_patches')):
open(os.path.join(QUILT_PC, '.quilt_patches'), 'w').write(QUILT_PATCHES + '\n')
if not os.path.isfile(os.path.join(QUILT_PC, '.quilt_series')):
open(os.path.join(QUILT_PC, '.quilt_series'), 'w').write(QUILT_SERIES + '\n')
if dirpath is not None:
os.chdir(saved_dir)
def annotation_for(old_file, new_file, annotation):
"""Return diff for annotation for changes from osd_file to new_file"""
if not os.path.exists(old_file) or os.path.getsize(old_file) == 0:
old_file = '/dev/null'
if not os.path.exists(new_file) or os.path.getsize(new_file) == 0:
new_file = '/dev/null'
result = shell.run_cmd('diff -e "%s" "%s"' % (old_file, new_file))
if result.eflags > 1:
output.error(result.stderr)
sys.exit(result.eflags)
difftxt = ''
start_cre = re.compile('^(\d+)(,\d+)?([acd])$')
end_cre = re.compile('^\.$')
lines = result.stdout.splitlines(True)
index = 0
aline = '%s\n' % annotation
while index < len(lines):
match = start_cre.match(lines[index])
if match:
difftxt += lines[index]
start = int(match.group(1))
if match.group(3) == 'a':
index += 1
while end_cre.match(lines[index]) is None:
difftxt += aline
index += 1
difftxt += lines[index]
elif match.group(3) == 'c':
end = int(match.group(2)[1:]) if match.group(2) is not None else start
cnt = end - start + 1
index += cnt + 1
difftxt += aline * cnt
assert end_cre.match(lines[index])
difftxt += lines[index]
else:
assert match.group(3) == 'd'
index += 1
else:
assert False
index += 1
return difftxt
def run_remove(args):
patchfns.chdir_to_base_dir()
patch = patchfns.find_applied_patch(args.opt_patch)
if not patch:
return cmd_result.ERROR
prpatch = patchfns.print_patch(patch)
patchfn = patchfns.patch_file_name(patch)
patchrefrfile = os.path.join(patchfns.QUILT_PC, patch + '~refresh')
patchrefrdir = os.path.dirname(patchrefrfile)
budir = patchfns.backup_dir_name(patch)
is_ok = True
for filename in args.file_list:
if patchfns.SUBDIR:
filename = os.path.join(patchfns.SUBDIR, filename)
if not patchfns.file_in_patch(filename, patch):
output.error('File %s is not in patch %s\n' % (filename, prpatch))
is_ok = False
continue
next_patch = patchfns.next_patch_for_file(patch, filename)
if next_patch:
output.error('File %s modified by patch %s\n' % (filename, patchfns.print_patch(next_patch)))
is_ok = False
continue
# Restore file from backup
if not backup.restore(budir, filelist=[filename], touch=True):
output.error('Failed to remove file %s from patch %s\n' % (filename, prpatch))
is_ok = False
continue
if os.path.exists(patchrefrdir) and os.path.exists(patchfn):
fsutils.touch(patchrefrfile)
output.write('File %s removed from patch %s\n' % (filename, prpatch))
return cmd_result.OK if is_ok else cmd_result.ERROR
def merge_patches(old, new, opt_desc):
"""Return the merge of the old and new patches"""
old_desc = patchfns.gen_tempfile()
open(old_desc, 'w').write(putils.get_patch_descr(old))
new_desc = patchfns.gen_tempfile()
open(new_desc, 'w').write(putils.get_patch_descr(new))
if opt_desc is None:
if os.path.getsize(old_desc) == 0:
opt_desc = 'n'
elif os.path.getsize(new_desc) == 0:
opt_desc = 'o'
if opt_desc is None:
result = shell.run_cmd('diff -u %s %s' % (old_desc, new_desc))
diff_lines = result.stdout.splitlines(True)
if len(diff_lines) > 2:
output.error('Patch headers differ:\n')
output.error(''.join(diff_lines[2:]))
output.error('Please use -d {o|a|n} to specify which patch header(s) to keep.\n')
os.remove(old_desc)
os.remove(new_desc)
return False
patchtext = open(old_desc).read() if opt_desc != 'n' else ''
if opt_desc == 'a':
patchtext += '---\n'
if opt_desc == 'o':
patchtext += putils.get_patch_diff(new)
else:
patchtext += fsutils.get_file_contents(new)
os.remove(old_desc)
os.remove(new_desc)
return patchtext
def do_diff(filename, old_file, new_file, args):
"""Output the diff for the nominated files"""
if args.opt_reverse:
old_file, new_file = new_file, old_file
if args.opt_diff:
if not os.path.exists(old_file):
old_file = '/dev/null'
if not os.path.exists(new_file):
new_file = '/dev/null'
if not diff.same_contents(old_file, new_file):
os.environ['LANG'] = patchfns.ORIGINAL_LANG
shell.run_cmd('%s %s %s' % (args.opt_diff, old_file, new_file))
os.environ['LANG'] = 'POSIX'
return True
else:
result = diff.diff_file(filename, old_file, new_file, args)
output.error(result.stderr)
if args.opt_color:
output.write(colorize(result.stdout))
else:
output.write(result.stdout)
return result.eflags < 2
def run_grep(args):
patchfns.chdir_to_base_dir()
problem_args = [] # i.e. those wit optional arguments
for arg in ['--color', '--colour']:
while arg in args.remainder_of_args:
problem_args.append(arg)
args.remainder_of_args.remove(arg)
grep_opts, grep_args = getopt.getopt(args.remainder_of_args, grep_options, grep_long_options)
opt_list = make_opt_list(grep_opts) + problem_args
if expect_pattern(grep_opts):
files = grep_args[1:]
opt_list += grep_args[0:1]
else:
files = grep_args
if not files:
files = get_files()
if len(files) == 1 and '-h' not in opt_list and '--no-filename' not in opt_list:
opt_list.append('-H')
result = shell.run_cmd(['grep'] + opt_list + files)
output.write(result.stdout)
output.error(result.stderr)
return result.eflags
