values[key] = val
- values['depot-paths'] = values.get("depot-paths").split(',')
+ paths = values.get("depot-paths")
+ if not paths:
+ paths = values.get("depot-path")
+ if paths:
+ values['depot-paths'] = paths.split(',')
return values
def gitBranchExists(branch):
def gitConfig(key):
return read_pipe("git config %s" % key, ignore_error=True).strip()
+def findUpstreamBranchPoint():
+ settings = None
+ branchPoint = ""
+ parent = 0
+ while parent < 65535:
+ commit = "HEAD~%s" % parent
+ log = extractLogMessageFromGitCommit(commit)
+ settings = extractSettingsGitLog(log)
+ if not settings.has_key("depot-paths"):
+ parent = parent + 1
+ continue
+
+ names = read_pipe_lines("git name-rev \"--refs=refs/remotes/p4/*\" \"%s\"" % commit)
+ if len(names) <= 0:
+ continue
+
+ # strip away the beginning of 'HEAD~42 refs/remotes/p4/foo'
+ branchPoint = names[0].strip()[len(commit) + 1:]
+ break
+
+ return [branchPoint, settings]
+
class Command:
def __init__(self):
self.usage = "usage: %prog [options]"
def __init__(self):
Command.__init__(self)
self.options = [
- optparse.make_option("--verbose", dest="verbose", action="store_true"),
+ optparse.make_option("--verbose", dest="verbose", action="store_true",
+ default=False),
]
self.description = "A tool to debug the output of p4 -G."
self.needsGit = False
+ self.verbose = False
def run(self, args):
+ j = 0
for output in p4CmdList(" ".join(args)):
+ print 'Element: %d' % j
+ j += 1
print output
return True
self.origin = ""
self.directSubmit = False
self.trustMeLikeAFool = False
+ self.verbose = False
+ self.isWindows = (platform.system() == "Windows")
self.logSubstitutions = {}
self.logSubstitutions["<enter description here>"] = "%log%"
system(applyPatchCmd)
for f in filesToAdd:
- system("p4 add %s" % f)
+ system("p4 add \"%s\"" % f)
for f in filesToDelete:
- system("p4 revert %s" % f)
- system("p4 delete %s" % f)
+ system("p4 revert \"%s\"" % f)
+ system("p4 delete \"%s\"" % f)
logMessage = ""
if not self.directSubmit:
logMessage = extractLogMessageFromGitCommit(id)
logMessage = logMessage.replace("\n", "\n\t")
+ if self.isWindows:
+ logMessage = logMessage.replace("\n", "\r\n")
logMessage = logMessage.strip()
template = read_pipe("p4 change -o")
tmpFile.close()
os.remove(fileName)
submitTemplate = message[:message.index(separatorLine)]
+ if self.isWindows:
+ submitTemplate = submitTemplate.replace("\r\n", "\n")
if response == "y" or response == "yes":
if self.dryRun:
% (fileName, fileName))
def run(self, args):
- # make gitdir absolute so we can cd out into the perforce checkout
- os.environ["GIT_DIR"] = gitdir
-
if len(args) == 0:
self.master = currentGitBranch()
if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
else:
return False
- depotPath = ""
- settings = None
- if gitBranchExists("p4"):
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit("p4"))
- if len(depotPath) == 0 and gitBranchExists("origin"):
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit("origin"))
- depotPaths = settings['depot-paths']
+ [upstream, settings] = findUpstreamBranchPoint()
+ depotPath = settings['depot-paths'][0]
+ if len(self.origin) == 0:
+ self.origin = upstream
+
+ if self.verbose:
+ print "Origin branch is " + self.origin
if len(depotPath) == 0:
print "Internal error: cannot locate perforce depot path from existing branches"
if response == "y" or response == "yes":
system("p4 sync ...")
- if len(self.origin) == 0:
- if gitBranchExists("p4"):
- self.origin = "p4"
- else:
- self.origin = "origin"
-
if self.reset:
self.firstTime = True
self.isWindows = (platform.system() == "Windows")
self.keepRepoPath = False
self.depotPaths = None
+ self.p4BranchesInGit = []
if gitConfig("git-p4.syncFromOrigin") == "false":
self.syncWithOrigin = False
## Should move this out, doesn't use SELF.
def readP4Files(self, files):
- specs = [(f['path'] + "#" + f['rev'], f) for f in files
+ files = [f for f in files
if f['action'] != 'delete']
- if not specs:
+ if not files:
return
- filedata = p4CmdList('print %s' % ' '.join(['"%s"' % path
- for (path, info) in specs]))
+ filedata = p4CmdList('print %s' % ' '.join(['"%s#%s"' % (f['path'],
+ f['rev'])
+ for f in files]))
j = 0;
contents = {}
- while filedata[j:]:
+ while j < len(filedata):
stat = filedata[j]
- text = filedata[j+1]
- j += 2
+ j += 1
+ text = ''
+ while j < len(filedata) and filedata[j]['code'] in ('text',
+ 'binary'):
+ text += filedata[j]['data']
+ j += 1
+
- assert stat['code'] == 'stat' and text['code'] == 'text'
- contents[stat['depotFile']] = text['data']
+ if not stat.has_key('depotFile'):
+ sys.stderr.write("p4 print fails with: %s\n" % repr(stat))
+ continue
+
+ contents[stat['depotFile']] = text
for f in files:
assert not f.has_key('data')
self.gitStream.write("data <<EOT\n")
self.gitStream.write(details["desc"])
- self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s: "
- "options = %s]\n"
- % (','.join (branchPrefixes), details["change"],
- details['options']
- ))
- self.gitStream.write("EOT\n\n")
+ self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
+ % (','.join (branchPrefixes), details["change"]))
+ if len(details['options']) > 0:
+ self.gitStream.write(": options = %s" % details['options'])
+ self.gitStream.write("]\nEOT\n\n")
if len(parent) > 0:
if self.verbose:
if self.isWindows and file["type"].endswith("text"):
data = data.replace("\r\n", "\n")
- self.gitStream.write("M %s inline %s\n" % (mode, relPath))
+ self.gitStream.write("M %d inline %s\n" % (mode, relPath))
self.gitStream.write("data %s\n" % len(data))
self.gitStream.write(data)
self.gitStream.write("\n")
def guessProjectName(self):
for p in self.depotPaths:
- return p [p.strip().rfind("/") + 1:]
+ if p.endswith("/"):
+ p = p[:-1]
+ p = p[p.strip().rfind("/") + 1:]
+ if not p.endswith("/"):
+ p += "/"
+ return p
def getBranchMapping(self):
-
- ## FIXME - what's a P4 projectName ?
- self.projectName = self.guessProjectName()
-
for info in p4CmdList("branches"):
details = p4Cmd("branch -o %s" % info["branch"])
viewIdx = 0
continue
source = paths[0]
destination = paths[1]
- if source.startswith(self.depotPath) and destination.startswith(self.depotPath):
- source = source[len(self.depotPath):-4]
- destination = destination[len(self.depotPath):-4]
+ ## HACK
+ if source.startswith(self.depotPaths[0]) and destination.startswith(self.depotPaths[0]):
+ source = source[len(self.depotPaths[0]):-4]
+ destination = destination[len(self.depotPaths[0]):-4]
if destination not in self.knownBranches:
self.knownBranches[destination] = source
if source not in self.knownBranches:
line = line.strip()
## only import to p4/
- if not line.startswith('p4/'):
+ if not line.startswith('p4/') or line == "p4/HEAD":
continue
branch = line
- if self.importIntoRemotes:
- # strip off p4
- branch = re.sub ("^p4/", "", line)
+
+ # strip off p4
+ branch = re.sub ("^p4/", "", line)
self.p4BranchesInGit.append(branch)
self.initialParents[self.refPrefix + branch] = parseRevision(line)
print ("Creating/updating branch(es) in %s based on origin branch(es)"
% self.refPrefix)
+ originPrefix = "origin/p4/"
+
for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
line = line.strip()
- if (not line.startswith("origin/")) or line.endswith("HEAD\n"):
+ if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
continue
- headName = line[len("origin/"):]
+ headName = line[len(originPrefix):]
remoteHead = self.refPrefix + headName
- originHead = "origin/" + headName
+ originHead = line
original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
if (not original.has_key('depot-paths')
print "creating %s" % remoteHead
update = True
else:
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
+ settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
if settings.has_key('change') > 0:
if settings['depot-paths'] == original['depot-paths']:
originP4Change = int(original['change'])
# map from branch depot path to parent branch
self.knownBranches = {}
self.initialParents = {}
- self.hasOrigin = gitBranchExists("origin")
+ self.hasOrigin = gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
+ if not self.syncWithOrigin:
+ self.hasOrigin = False
if self.importIntoRemotes:
self.refPrefix = "refs/remotes/p4/"
else:
- self.refPrefix = "refs/heads/"
+ self.refPrefix = "refs/heads/p4/"
if self.syncWithOrigin and self.hasOrigin:
if not self.silent:
system("git fetch origin")
if len(self.branch) == 0:
- self.branch = self.refPrefix + "p4/master"
+ self.branch = self.refPrefix + "master"
if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
system("git update-ref %s refs/heads/p4" % self.branch)
system("git branch -D p4");
p4Change = 0
for branch in self.p4BranchesInGit:
- print self.p4BranchesInGit
logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
settings = extractSettingsGitLog(logMsg)
else:
paths = []
for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
- for i in range(0, max(len(cur), len(prev))):
+ for i in range(0, min(len(cur), len(prev))):
if cur[i] <> prev[i]:
+ i = i - 1
break
- paths.append (cur[:i])
+ paths.append (cur[:i + 1])
self.previousDepotPaths = paths
if p4Change > 0:
self.depotPaths = sorted(self.previousDepotPaths)
self.changeRange = "@%s,#head" % p4Change
- self.initialParent = parseRevision(self.branch)
+ if not self.detectBranches:
+ self.initialParent = parseRevision(self.branch)
if not self.silent and not self.detectBranches:
print "Performing incremental import into %s git branch" % self.branch
self.getLabels();
if self.detectBranches:
- self.getBranchMapping();
+ ## FIXME - what's a P4 projectName ?
+ self.projectName = self.guessProjectName()
+
+ if not self.hasOrigin:
+ self.getBranchMapping();
if self.verbose:
print "p4-git branches: %s" % self.p4BranchesInGit
print "initial parents: %s" % self.initialParents
self.gitError = importProcess.stderr
if self.revision:
- print "Doing initial import of %s from revision %s" % (' '.join(self.depotPaths), self.revision)
+ print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), self.revision, self.branch)
details = { "user" : "git perforce import user", "time" : int(time.time()) }
details["desc"] = ("Initial import of %s from the state at revision %s"
print "No changes to import!"
return True
+ if not self.silent and not self.detectBranches:
+ print "Import destination: %s" % self.branch
+
self.updatedBranches = set()
cnt = 1
parent = self.initialParents[branch]
del self.initialParents[branch]
- self.commit(description, filesForCommit, branch, branchPrefix, parent)
+ self.commit(description, filesForCommit, branch, [branchPrefix], parent)
else:
files = self.extractFilesFromCommit(description)
self.commit(description, files, self.branch, self.depotPaths,
self.options = [ ]
self.description = ("Fetches the latest revision from perforce and "
+ "rebases the current work (branch) against it")
+ self.verbose = False
def run(self, args):
sync = P4Sync()
sync.run([])
- print "Rebasing the current branch"
+
+ [upstream, settings] = findUpstreamBranchPoint()
+ if len(upstream) == 0:
+ die("Cannot find upstream branchpoint for rebase")
+
+ # the branchpoint may be p4/foo~3, so strip off the parent
+ upstream = re.sub("~[0-9]+$", "", upstream)
+
+ print "Rebasing the current branch onto %s" % upstream
oldHead = read_pipe("git rev-parse HEAD").strip()
- system("git rebase p4")
+ system("git rebase %s" % upstream)
system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
return True
sys.exit(1)
depotPaths = args
+
+ if not self.cloneDestination and len(depotPaths) > 1:
+ self.cloneDestination = depotPaths[-1]
+ depotPaths = depotPaths[:-1]
+
for p in depotPaths:
if not p.startswith("//"):
return False
if not self.cloneDestination:
- self.cloneDestination = self.defaultDestination()
+ self.cloneDestination = self.defaultDestination(args)
print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
- os.makedirs(self.cloneDestination)
+ if not os.path.exists(self.cloneDestination):
+ os.makedirs(self.cloneDestination)
os.chdir(self.cloneDestination)
system("git init")
self.gitdir = os.getcwd() + "/.git"