Date: Sunday, December 29, 2019 @ 19:43:24 Author: eworm Revision: 372336
upgpkg: git 2.24.1-4 fix 'git p4' with python 3.x (FS#64977) Added: git/trunk/0001-git-p4-python.patch Modified: git/trunk/PKGBUILD --------------------------+ 0001-git-p4-python.patch | 762 +++++++++++++++++++++++++++++++++++++++++++++ PKGBUILD | 10 2 files changed, 771 insertions(+), 1 deletion(-) Added: 0001-git-p4-python.patch =================================================================== --- 0001-git-p4-python.patch (rev 0) +++ 0001-git-p4-python.patch 2019-12-29 19:43:24 UTC (rev 372336) @@ -0,0 +1,762 @@ +diff --git a/git-p4.py b/git-p4.py +index 60c73b6a37..d9df7747cb 100755 +--- a/git-p4.py ++++ b/git-p4.py +@@ -8,12 +8,12 @@ + # License: MIT <http://www.opensource.org/licenses/mit-license.php> + # + import sys +-if sys.hexversion < 0x02040000: +- # The limiter is the subprocess module +- sys.stderr.write("git-p4: requires Python 2.4 or later.\n") ++if sys.version_info.major < 3 and sys.version_info.minor < 7: ++ sys.stderr.write("git-p4: requires Python 2.7 or later.\n") + sys.exit(1) + import os + import optparse ++import functools + import marshal + import subprocess + import tempfile +@@ -27,36 +27,15 @@ + import ctypes + import errno + ++# On python2.7 where raw_input() and input() are both availble, ++# we want raw_input's semantics, but aliased to input for python3 ++# compatibility + # support basestring in python3 + try: +- unicode = unicode +-except NameError: +- # 'unicode' is undefined, must be Python 3 +- str = str +- unicode = str +- bytes = bytes +- basestring = (str,bytes) +-else: +- # 'unicode' exists, must be Python 2 +- str = str +- unicode = unicode +- bytes = str +- basestring = basestring +- +-try: +- from subprocess import CalledProcessError +-except ImportError: +- # from python2.7:subprocess.py +- # Exception classes used by this module. +- class CalledProcessError(Exception): +- """This exception is raised when a process run by check_call() returns +- a non-zero exit status. The exit status will be stored in the +- returncode attribute.""" +- def __init__(self, returncode, cmd): +- self.returncode = returncode +- self.cmd = cmd +- def __str__(self): +- return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode) ++ if raw_input and input: ++ input = raw_input ++except: ++ pass + + verbose = False + +@@ -105,7 +84,7 @@ def p4_build_cmd(cmd): + # Provide a way to not pass this option by setting git-p4.retries to 0 + real_cmd += ["-r", str(retries)] + +- if isinstance(cmd,basestring): ++ if not isinstance(cmd, list): + real_cmd = ' '.join(real_cmd) + ' ' + cmd + else: + real_cmd += cmd +@@ -167,11 +146,56 @@ def die(msg): + sys.stderr.write(msg + "\n") + sys.exit(1) + ++def prompt(prompt_text): ++ """ Prompt the user to choose one of the choices ++ ++ Choices are identified in the prompt_text by square brackets around ++ a single letter option. ++ """ ++ choices = set(m.group(1) for m in re.finditer(r"\[(.)\]", prompt_text)) ++ while True: ++ response = input(prompt_text).strip().lower() ++ if not response: ++ continue ++ response = response[0] ++ if response in choices: ++ return response ++ ++# We need different encoding/decoding strategies for text data being passed ++# around in pipes depending on python version ++if bytes is not str: ++ # For python3, always encode and decode as appropriate ++ def decode_text_stream(s): ++ return s.decode() if isinstance(s, bytes) else s ++ def encode_text_stream(s): ++ return s.encode() if isinstance(s, str) else s ++else: ++ # For python2.7, pass read strings as-is, but also allow writing unicode ++ def decode_text_stream(s): ++ return s ++ def encode_text_stream(s): ++ return s.encode('utf_8') if isinstance(s, unicode) else s ++ ++def decode_path(path): ++ """Decode a given string (bytes or otherwise) using configured path encoding options ++ """ ++ encoding = gitConfig('git-p4.pathEncoding') or 'utf_8' ++ if bytes is not str: ++ return path.decode(encoding, errors='replace') if isinstance(path, bytes) else path ++ else: ++ try: ++ path.decode('ascii') ++ except: ++ path = path.decode(encoding, errors='replace') ++ if verbose: ++ print('Path with non-ASCII characters detected. Used {} to decode: {}'.format(encoding, path)) ++ return path ++ + def write_pipe(c, stdin): + if verbose: + sys.stderr.write('Writing pipe: %s\n' % str(c)) + +- expand = isinstance(c,basestring) ++ expand = not isinstance(c, list) + p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand) + pipe = p.stdin + val = pipe.write(stdin) +@@ -183,6 +207,8 @@ def write_pipe(c, stdin): + + def p4_write_pipe(c, stdin): + real_cmd = p4_build_cmd(c) ++ if bytes is not str and isinstance(stdin, str): ++ stdin = encode_text_stream(stdin) + return write_pipe(real_cmd, stdin) + + def read_pipe_full(c): +@@ -193,15 +219,17 @@ def read_pipe_full(c): + if verbose: + sys.stderr.write('Reading pipe: %s\n' % str(c)) + +- expand = isinstance(c,basestring) ++ expand = not isinstance(c, list) + p = subprocess.Popen(c, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=expand) + (out, err) = p.communicate() +- return (p.returncode, out, err) ++ return (p.returncode, out, decode_text_stream(err)) + +-def read_pipe(c, ignore_error=False): ++def read_pipe(c, ignore_error=False, raw=False): + """ Read output from command. Returns the output text on + success. On failure, terminates execution, unless + ignore_error is True, when it returns an empty string. ++ ++ If raw is True, do not attempt to decode output text. + """ + (retcode, out, err) = read_pipe_full(c) + if retcode != 0: +@@ -209,6 +237,8 @@ def read_pipe(c, ignore_error=False): + out = "" + else: + die('Command failed: %s\nError: %s' % (str(c), err)) ++ if not raw: ++ out = decode_text_stream(out) + return out + + def read_pipe_text(c): +@@ -219,23 +249,22 @@ def read_pipe_text(c): + if retcode != 0: + return None + else: +- return out.rstrip() ++ return decode_text_stream(out).rstrip() + +-def p4_read_pipe(c, ignore_error=False): ++def p4_read_pipe(c, ignore_error=False, raw=False): + real_cmd = p4_build_cmd(c) +- return read_pipe(real_cmd, ignore_error) ++ return read_pipe(real_cmd, ignore_error, raw=raw) + + def read_pipe_lines(c): + if verbose: + sys.stderr.write('Reading pipe: %s\n' % str(c)) + +- expand = isinstance(c, basestring) ++ expand = not isinstance(c, list) + p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) + pipe = p.stdout +- val = pipe.readlines() ++ val = [decode_text_stream(line) for line in pipe.readlines()] + if pipe.close() or p.wait(): + die('Command failed: %s' % str(c)) +- + return val + + def p4_read_pipe_lines(c): +@@ -263,6 +292,7 @@ def p4_has_move_command(): + cmd = p4_build_cmd(["move", "-k", "@from", "@to"]) + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + (out, err) = p.communicate() ++ err = decode_text_stream(err) + # return code will be 1 in either case + if err.find("Invalid option") >= 0: + return False +@@ -272,7 +302,7 @@ def p4_has_move_command(): + return True + + def system(cmd, ignore_error=False): +- expand = isinstance(cmd,basestring) ++ expand = not isinstance(cmd, list) + if verbose: + sys.stderr.write("executing %s\n" % str(cmd)) + retcode = subprocess.call(cmd, shell=expand) +@@ -284,7 +314,7 @@ def system(cmd, ignore_error=False): + def p4_system(cmd): + """Specifically invoke p4 as the system command. """ + real_cmd = p4_build_cmd(cmd) +- expand = isinstance(real_cmd, basestring) ++ expand = not isinstance(real_cmd, list) + retcode = subprocess.call(real_cmd, shell=expand) + if retcode: + raise CalledProcessError(retcode, real_cmd) +@@ -522,7 +552,7 @@ def getP4OpenedType(file): + # Return the set of all p4 labels + def getP4Labels(depotPaths): + labels = set() +- if isinstance(depotPaths,basestring): ++ if not isinstance(depotPaths, list): + depotPaths = [depotPaths] + + for l in p4CmdList(["labels"] + ["%s..." % p for p in depotPaths]): +@@ -539,12 +569,7 @@ def getGitTags(): + gitTags.add(tag) + return gitTags + +-def diffTreePattern(): +- # This is a simple generator for the diff tree regex pattern. This could be +- # a class variable if this and parseDiffTreeEntry were a part of a class. +- pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)') +- while True: +- yield pattern ++_diff_tree_pattern = None + + def parseDiffTreeEntry(entry): + """Parses a single diff tree entry into its component elements. +@@ -565,7 +590,11 @@ def parseDiffTreeEntry(entry): + + If the pattern is not matched, None is returned.""" + +- match = diffTreePattern().next().match(entry) ++ global _diff_tree_pattern ++ if not _diff_tree_pattern: ++ _diff_tree_pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)') ++ ++ match = _diff_tree_pattern.match(entry) + if match: + return { + 'src_mode': match.group(1), +@@ -609,7 +638,7 @@ def isModeExecChanged(src_mode, dst_mode): + def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None, skip_info=False, + errors_as_exceptions=False): + +- if isinstance(cmd,basestring): ++ if not isinstance(cmd, list): + cmd = "-G " + cmd + expand = True + else: +@@ -626,11 +655,12 @@ def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None, skip_info=False, + stdin_file = None + if stdin is not None: + stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode) +- if isinstance(stdin,basestring): ++ if not isinstance(stdin, list): + stdin_file.write(stdin) + else: + for i in stdin: +- stdin_file.write(i + '\n') ++ stdin_file.write(encode_text_stream(i)) ++ stdin_file.write(b'\n') + stdin_file.flush() + stdin_file.seek(0) + +@@ -643,6 +673,20 @@ def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None, skip_info=False, + try: + while True: + entry = marshal.load(p4.stdout) ++ if bytes is not str: ++ # Decode unmarshalled dict to use str keys and values, except for: ++ # - `data` which may contain arbitrary binary data ++ # - `depotFile[0-9]*`, `path`, or `clientFile` which may contain non-UTF8 encoded text ++ decoded_entry = {} ++ for key, value in entry.items(): ++ key = key.decode() ++ if isinstance(value, bytes) and not (key in ('data', 'path', 'clientFile') or key.startswith('depotFile')): ++ value = value.decode() ++ decoded_entry[key] = value ++ # Parse out data if it's an error response ++ if decoded_entry.get('code') == 'error' and 'data' in decoded_entry: ++ decoded_entry['data'] = decoded_entry['data'].decode() ++ entry = decoded_entry + if skip_info: + if 'code' in entry and entry['code'] == 'info': + continue +@@ -693,7 +737,8 @@ def p4Where(depotPath): + if "depotFile" in entry: + # Search for the base client side depot path, as long as it starts with the branch's P4 path. + # The base path always ends with "/...". +- if entry["depotFile"].find(depotPath) == 0 and entry["depotFile"][-4:] == "/...": ++ entry_path = decode_path(entry['depotFile']) ++ if entry_path.find(depotPath) == 0 and entry_path[-4:] == "/...": + output = entry + break + elif "data" in entry: +@@ -708,11 +753,11 @@ def p4Where(depotPath): + return "" + clientPath = "" + if "path" in output: +- clientPath = output.get("path") ++ clientPath = decode_path(output['path']) + elif "data" in output: + data = output.get("data") +- lastSpace = data.rfind(" ") +- clientPath = data[lastSpace + 1:] ++ lastSpace = data.rfind(b" ") ++ clientPath = decode_path(data[lastSpace + 1:]) + + if clientPath.endswith("..."): + clientPath = clientPath[:-3] +@@ -860,6 +905,7 @@ def branch_exists(branch): + cmd = [ "git", "rev-parse", "--symbolic", "--verify", branch ] + p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, _ = p.communicate() ++ out = decode_text_stream(out) + if p.returncode: + return False + # expect exactly one line of output: the branch name +@@ -1137,7 +1183,7 @@ def pushFile(self, localLargeFile): + assert False, "Method 'pushFile' required in " + self.__class__.__name__ + + def hasLargeFileExtension(self, relPath): +- return reduce( ++ return functools.reduce( + lambda a, b: a or b, + [relPath.endswith('.' + e) for e in gitConfigList('git-p4.largeFileExtensions')], + False +@@ -1244,7 +1290,7 @@ def generatePointer(self, contentFile): + ['git', 'lfs', 'pointer', '--file=' + contentFile], + stdout=subprocess.PIPE + ) +- pointerFile = pointerProcess.stdout.read() ++ pointerFile = decode_text_stream(pointerProcess.stdout.read()) + if pointerProcess.wait(): + os.remove(contentFile) + die('git-lfs pointer command failed. Did you install the extension?') +@@ -1257,9 +1303,15 @@ def generatePointer(self, contentFile): + pointerFile = re.sub(r'Git LFS pointer for.*\n\n', '', pointerFile) + + oid = re.search(r'^oid \w+:(\w+)', pointerFile, re.MULTILINE).group(1) ++ # if someone use external lfs.storage ( not in local repo git ) ++ lfs_path = gitConfig('lfs.storage') ++ if not lfs_path: ++ lfs_path = 'lfs' ++ if not os.path.isabs(lfs_path): ++ lfs_path = os.path.join(os.getcwd(), '.git', lfs_path) + localLargeFile = os.path.join( +- os.getcwd(), +- '.git', 'lfs', 'objects', oid[:2], oid[2:4], ++ lfs_path, ++ 'objects', oid[:2], oid[2:4], + oid, + ) + # LFS Spec states that pointer files should not have the executable bit set. +@@ -1374,14 +1426,14 @@ def getUserMapFromPerforceServer(self): + for (key, val) in self.users.items(): + s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1)) + +- open(self.getUserCacheFilename(), "wb").write(s) ++ open(self.getUserCacheFilename(), 'w').write(s) + self.userMapFromPerforceServer = True + + def loadUserMapFromCache(self): + self.users = {} + self.userMapFromPerforceServer = False + try: +- cache = open(self.getUserCacheFilename(), "rb") ++ cache = open(self.getUserCacheFilename(), 'r') + lines = cache.readlines() + cache.close() + for line in lines: +@@ -1658,7 +1710,8 @@ def modifyChangelistUser(self, changelist, newUser): + c = changes[0] + if c['User'] == newUser: return # nothing to do + c['User'] = newUser +- input = marshal.dumps(c) ++ # p4 does not understand format version 3 and above ++ input = marshal.dumps(c, 2) + + result = p4CmdList("change -f -i", stdin=input) + for r in result: +@@ -1722,7 +1775,7 @@ def prepareSubmitTemplate(self, changelist=None): + break + if not change_entry: + die('Failed to decode output of p4 change -o') +- for key, value in change_entry.iteritems(): ++ for key, value in change_entry.items(): + if key.startswith('File'): + if 'depot-paths' in settings: + if not [p for p in settings['depot-paths'] +@@ -1778,12 +1831,11 @@ def edit_template(self, template_file): + if os.stat(template_file).st_mtime > mtime: + return True + +- while True: +- response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ") +- if response == 'y': +- return True +- if response == 'n': +- return False ++ response = prompt("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ") ++ if response == 'y': ++ return True ++ if response == 'n': ++ return False + + def get_diff_description(self, editedFiles, filesToAdd, symlinks): + # diff +@@ -1939,8 +1991,23 @@ def applyCommit(self, id): + # disable the read-only bit on windows. + if self.isWindows and file not in editedFiles: + os.chmod(file, stat.S_IWRITE) +- self.patchRCSKeywords(file, kwfiles[file]) +- fixed_rcs_keywords = True ++ ++ try: ++ self.patchRCSKeywords(file, kwfiles[file]) ++ fixed_rcs_keywords = True ++ except: ++ # We are throwing an exception, undo all open edits ++ for f in editedFiles: ++ p4_revert(f) ++ raise ++ else: ++ # They do not have attemptRCSCleanup set, this might be the fail point ++ # Check to see if the file has RCS keywords and suggest setting the property. ++ for file in editedFiles | filesToDelete: ++ if p4_keywords_regexp_for_file(file) is not None: ++ print("At least one file in this commit has RCS Keywords that may be causing problems. ") ++ print("Consider:\ngit config git-p4.attemptRCSCleanup true") ++ break + + if fixed_rcs_keywords: + print("Retrying the patch with RCS keywords cleaned up") +@@ -2003,7 +2070,7 @@ def applyCommit(self, id): + tmpFile = os.fdopen(handle, "w+b") + if self.isWindows: + submitTemplate = submitTemplate.replace("\n", "\r\n") +- tmpFile.write(submitTemplate) ++ tmpFile.write(encode_text_stream(submitTemplate)) + tmpFile.close() + + if self.prepare_p4_only: +@@ -2050,7 +2117,7 @@ def applyCommit(self, id): + if self.edit_template(fileName): + # read the edited message and submit + tmpFile = open(fileName, "rb") +- message = tmpFile.read() ++ message = decode_text_stream(tmpFile.read()) + tmpFile.close() + if self.isWindows: + message = message.replace("\r\n", "\n") +@@ -2345,31 +2412,22 @@ def run(self, args): + " --prepare-p4-only") + break + if i < last: +- quit = False +- while True: +- # prompt for what to do, or use the option/variable +- if self.conflict_behavior == "ask": +- print("What do you want to do?") +- response = raw_input("[s]kip this commit but apply" +- " the rest, or [q]uit? ") +- if not response: +- continue +- elif self.conflict_behavior == "skip": +- response = "s" +- elif self.conflict_behavior == "quit": +- response = "q" +- else: +- die("Unknown conflict_behavior '%s'" % +- self.conflict_behavior) +- +- if response[0] == "s": +- print("Skipping this commit, but applying the rest") +- break +- if response[0] == "q": +- print("Quitting") +- quit = True +- break +- if quit: ++ # prompt for what to do, or use the option/variable ++ if self.conflict_behavior == "ask": ++ print("What do you want to do?") ++ response = prompt("[s]kip this commit but apply the rest, or [q]uit? ") ++ elif self.conflict_behavior == "skip": ++ response = "s" ++ elif self.conflict_behavior == "quit": ++ response = "q" ++ else: ++ die("Unknown conflict_behavior '%s'" % ++ self.conflict_behavior) ++ ++ if response == "s": ++ print("Skipping this commit, but applying the rest") ++ if response == "q": ++ print("Quitting") + break + + chdir(self.oldWorkingDirectory) +@@ -2479,7 +2537,7 @@ def append(self, view_line): + + def convert_client_path(self, clientFile): + # chop off //client/ part to make it relative +- if not clientFile.startswith(self.client_prefix): ++ if not decode_path(clientFile).startswith(self.client_prefix): + die("No prefix '%s' on clientFile '%s'" % + (self.client_prefix, clientFile)) + return clientFile[len(self.client_prefix):] +@@ -2488,7 +2546,7 @@ def update_client_spec_path_cache(self, files): + """ Caching file paths by "p4 where" batch query """ + + # List depot file paths exclude that already cached +- fileArgs = [f['path'] for f in files if f['path'] not in self.client_spec_path_cache] ++ fileArgs = [f['path'] for f in files if decode_path(f['path']) not in self.client_spec_path_cache] + + if len(fileArgs) == 0: + return # All files in cache +@@ -2503,16 +2561,18 @@ def update_client_spec_path_cache(self, files): + if "unmap" in res: + # it will list all of them, but only one not unmap-ped + continue ++ depot_path = decode_path(res['depotFile']) + if gitConfigBool("core.ignorecase"): +- res['depotFile'] = res['depotFile'].lower() +- self.client_spec_path_cache[res['depotFile']] = self.convert_client_path(res["clientFile"]) ++ depot_path = depot_path.lower() ++ self.client_spec_path_cache[depot_path] = self.convert_client_path(res["clientFile"]) + + # not found files or unmap files set to "" + for depotFile in fileArgs: ++ depotFile = decode_path(depotFile) + if gitConfigBool("core.ignorecase"): + depotFile = depotFile.lower() + if depotFile not in self.client_spec_path_cache: +- self.client_spec_path_cache[depotFile] = "" ++ self.client_spec_path_cache[depotFile] = b'' + + def map_in_client(self, depot_path): + """Return the relative location in the client where this +@@ -2617,6 +2677,7 @@ def __init__(self): + def checkpoint(self): + self.gitStream.write("checkpoint\n\n") + self.gitStream.write("progress checkpoint\n\n") ++ self.gitStream.flush() + out = self.gitOutput.readline() + if self.verbose: + print("checkpoint finished: " + out) +@@ -2630,7 +2691,7 @@ def isPathWanted(self, path): + elif path.lower() == p.lower(): + return False + for p in self.depotPaths: +- if p4PathStartsWith(path, p): ++ if p4PathStartsWith(path, decode_path(p)): + return True + return False + +@@ -2639,7 +2700,7 @@ def extractFilesFromCommit(self, commit, shelved=False, shelved_cl = 0): + fnum = 0 + while "depotFile%s" % fnum in commit: + path = commit["depotFile%s" % fnum] +- found = self.isPathWanted(path) ++ found = self.isPathWanted(decode_path(path)) + if not found: + fnum = fnum + 1 + continue +@@ -2673,7 +2734,7 @@ def stripRepoPath(self, path, prefixes): + if self.useClientSpec: + # branch detection moves files up a level (the branch name) + # from what client spec interpretation gives +- path = self.clientSpecDirs.map_in_client(path) ++ path = decode_path(self.clientSpecDirs.map_in_client(path)) + if self.detectBranches: + for b in self.knownBranches: + if p4PathStartsWith(path, b + "/"): +@@ -2707,14 +2768,15 @@ def splitFilesIntoBranches(self, commit): + branches = {} + fnum = 0 + while "depotFile%s" % fnum in commit: +- path = commit["depotFile%s" % fnum] ++ raw_path = commit["depotFile%s" % fnum] ++ path = decode_path(raw_path) + found = self.isPathWanted(path) + if not found: + fnum = fnum + 1 + continue + + file = {} +- file["path"] = path ++ file["path"] = raw_path + file["rev"] = commit["rev%s" % fnum] + file["action"] = commit["action%s" % fnum] + file["type"] = commit["type%s" % fnum] +@@ -2723,7 +2785,7 @@ def splitFilesIntoBranches(self, commit): + # start with the full relative path where this file would + # go in a p4 client + if self.useClientSpec: +- relPath = self.clientSpecDirs.map_in_client(path) ++ relPath = decode_path(self.clientSpecDirs.map_in_client(path)) + else: + relPath = self.stripRepoPath(path, self.depotPaths) + +@@ -2739,7 +2801,7 @@ def splitFilesIntoBranches(self, commit): + return branches + + def writeToGitStream(self, gitMode, relPath, contents): +- self.gitStream.write('M %s inline %s\n' % (gitMode, relPath)) ++ self.gitStream.write(encode_text_stream(u'M {} inline {}\n'.format(gitMode, relPath))) + self.gitStream.write('data %d\n' % sum(len(d) for d in contents)) + for d in contents: + self.gitStream.write(d) +@@ -2761,14 +2823,15 @@ def encodeWithUTF8(self, path): + # - helper for streamP4Files + + def streamOneP4File(self, file, contents): +- relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes) +- relPath = self.encodeWithUTF8(relPath) ++ file_path = file['depotFile'] ++ relPath = self.stripRepoPath(decode_path(file_path), self.branchPrefixes) ++ + if verbose: + if 'fileSize' in self.stream_file: + size = int(self.stream_file['fileSize']) + else: + size = 0 # deleted files don't get a fileSize apparently +- sys.stdout.write('\r%s --> %s (%i MB)\n' % (file['depotFile'], relPath, size/1024/1024)) ++ sys.stdout.write('\r%s --> %s (%i MB)\n' % (file_path, relPath, size/1024/1024)) + sys.stdout.flush() + + (type_base, type_mods) = split_p4_type(file["type"]) +@@ -2780,13 +2843,13 @@ def streamOneP4File(self, file, contents): + git_mode = "120000" + # p4 print on a symlink sometimes contains "target\n"; + # if it does, remove the newline +- data = ''.join(contents) ++ data = ''.join(decode_text_stream(c) for c in contents) + if not data: + # Some version of p4 allowed creating a symlink that pointed + # to nothing. This causes p4 errors when checking out such + # a change, and errors here too. Work around it by ignoring + # the bad symlink; hopefully a future change fixes it. +- print("\nIgnoring empty symlink in %s" % file['depotFile']) ++ print("\nIgnoring empty symlink in %s" % file_path) + return + elif data[-1] == '\n': + contents = [data[:-1]] +@@ -2805,7 +2868,7 @@ def streamOneP4File(self, file, contents): + # just the native "NT" type. + # + try: +- text = p4_read_pipe(['print', '-q', '-o', '-', '%s@%s' % (file['depotFile'], file['change'])]) ++ text = p4_read_pipe(['print', '-q', '-o', '-', '%s@%s' % (decode_path(file['depotFile']), file['change'])], raw=True) + except Exception as e: + if 'Translation of file content failed' in str(e): + type_base = 'binary' +@@ -2813,7 +2876,7 @@ def streamOneP4File(self, file, contents): + raise e + else: + if p4_version_string().find('/NT') >= 0: +- text = text.replace('\r\n', '\n') ++ text = text.replace(b'\r\n', b'\n') + contents = [ text ] + + if type_base == "apple": +@@ -2834,7 +2897,7 @@ def streamOneP4File(self, file, contents): + pattern = p4_keywords_regexp_for_type(type_base, type_mods) + if pattern: + regexp = re.compile(pattern, re.VERBOSE) +- text = ''.join(contents) ++ text = ''.join(decode_text_stream(c) for c in contents) + text = regexp.sub(r'$\1$', text) + contents = [ text ] + +@@ -2844,12 +2907,11 @@ def streamOneP4File(self, file, contents): + self.writeToGitStream(git_mode, relPath, contents) + + def streamOneP4Deletion(self, file): +- relPath = self.stripRepoPath(file['path'], self.branchPrefixes) +- relPath = self.encodeWithUTF8(relPath) ++ relPath = self.stripRepoPath(decode_path(file['path']), self.branchPrefixes) + if verbose: + sys.stdout.write("delete %s\n" % relPath) + sys.stdout.flush() +- self.gitStream.write("D %s\n" % relPath) ++ self.gitStream.write(encode_text_stream(u'D {}\n'.format(relPath))) + + if self.largeFileSystem and self.largeFileSystem.isLargeFile(relPath): + self.largeFileSystem.removeLargeFile(relPath) +@@ -2949,9 +3011,9 @@ def streamP4FilesCbSelf(entry): + if 'shelved_cl' in f: + # Handle shelved CLs using the "p4 print file@=N" syntax to print + # the contents +- fileArg = '%s@=%d' % (f['path'], f['shelved_cl']) ++ fileArg = f['path'] + encode_text_stream('@={}'.format(f['shelved_cl'])) + else: +- fileArg = '%s#%s' % (f['path'], f['rev']) ++ fileArg = f['path'] + encode_text_stream('#{}'.format(f['rev'])) + + fileArgs.append(fileArg) + +@@ -3032,8 +3094,8 @@ def commit(self, details, files, branch, parent = "", allow_empty=False): + if self.clientSpecDirs: + self.clientSpecDirs.update_client_spec_path_cache(files) + +- files = [f for f in files +- if self.inClientSpec(f['path']) and self.hasBranchPrefix(f['path'])] ++ files = [f for (f, path) in ((f, decode_path(f['path'])) for f in files) ++ if self.inClientSpec(path) and self.hasBranchPrefix(path)] + + if gitConfigBool('git-p4.keepEmptyCommits'): + allow_empty = True +@@ -3537,6 +3599,15 @@ def openStreams(self): + self.gitStream = self.importProcess.stdin + self.gitError = self.importProcess.stderr + ++ if bytes is not str: ++ # Wrap gitStream.write() so that it can be called using `str` arguments ++ def make_encoded_write(write): ++ def encoded_write(s): ++ return write(s.encode() if isinstance(s, str) else s) ++ return encoded_write ++ ++ self.gitStream.write = make_encoded_write(self.gitStream.write) ++ + def closeStreams(self): + self.gitStream.close() + if self.importProcess.wait() != 0: +@@ -4140,7 +4211,12 @@ def main(): + description = cmd.description, + formatter = HelpFormatter()) + +- (cmd, args) = parser.parse_args(sys.argv[2:], cmd); ++ try: ++ (cmd, args) = parser.parse_args(sys.argv[2:], cmd); ++ except: ++ parser.print_help() ++ raise ++ + global verbose + verbose = cmd.verbose + if cmd.needsGit: Modified: PKGBUILD =================================================================== --- PKGBUILD 2019-12-29 19:09:25 UTC (rev 372335) +++ PKGBUILD 2019-12-29 19:43:24 UTC (rev 372336) @@ -3,7 +3,7 @@ pkgname=git pkgver=2.24.1 -pkgrel=3 +pkgrel=4 pkgdesc='the fast distributed version control system' arch=(x86_64) url='https://git-scm.com/' @@ -28,11 +28,13 @@ install=git.install validpgpkeys=('96E07AF25771955980DAD10020D04E5A713660A7') # Junio C Hamano source=("https://www.kernel.org/pub/software/scm/git/git-$pkgver.tar."{xz,sign} + '0001-git-p4-python.patch' '[email protected]' 'git-daemon.socket' 'git-sysusers.conf') sha256sums=('723f24dce8fdd621a308b6187553fce7d5244205c065fe0a3aebd0b7c3f88562' 'SKIP' + '256f9c674e3617ae4373cb89b6ab972bb0279331c39425b94becadccb3b1a63a' '14c0b67cfe116b430645c19d8c4759419657e6809dfa28f438c33a005245ad91' 'ac4c90d62c44926e6d30d18d97767efc901076d4e0283ed812a349aece72f203' '7630e8245526ad80f703fac9900a1328588c503ce32b37b9f8811674fcda4a45') @@ -52,6 +54,12 @@ USE_LIBPCRE2=1 ) +prepare() { + cd "$srcdir/$pkgname-$pkgver" + + patch -Np1 < ../0001-git-p4-python.patch +} + build() { cd "$srcdir/$pkgname-$pkgver"
