" VIM integration via P4Python
" Depends on P4Python API
" P4RevGraph requires perl and Graph::Easy module
" Uses the connection environment from the current working directory.
" Oriented towards commands that can be run on a single file.
" Get help by typing :help vimp4python.
"
" Copyright (c) Perforce Software, Inc., 1997-2010. All rights reserved
"
" Redistribution and use in source and binary forms, with or without
" modification, are permitted provided that the following conditions are met:
"
" 1. Redistributions of source code must retain the above copyright
" notice, this list of conditions and the following disclaimer.
"
" 2. Redistributions in binary form must reproduce the above copyright
" notice, this list of conditions and the following disclaimer in the
" documentation and/or other materials provided with the distribution.
"
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
" 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
" FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE
" SOFTWARE, INC. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
" ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
" TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
" THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
" DAMAGE.
"
" User contributed content on the Perforce Public Depot is not supported by Perforce,
" although it may be supported by its author. This applies to all contributions
" even those submitted by Perforce employees.
"
"
" Standard code to avoid loading twice and to allow not loading
" Also detects if python is available
"
if exists("loaded_vimp4python")
finish
endif
let loaded_vimp4python=1
if (has('python') || has('python/dyn'))
let loaded_vimp4python=1
else
finish
endif
"
" check for P4Python API
"
python << EOF
try:
import vim, P4
p4 = P4.P4()
vim.command("let b:hasp4 = \"1\"")
except:
vim.command("let b:hasp4 = \"0\"")
EOF
if b:hasp4 == "0"
finish
endif
" set this to 0 to disable ruler calls
let P4SetRuler = 1
"
" define the mappings that provide the user interface to this plug-in
"
augroup vimp4python
" events
autocmd BufRead * call <SID>P4InitialBufferVariables()
autocmd BufRead * call <SID>P4FstatVars()
" Keyboard shortcuts - default <Leader> is \
" (listed in order of shortcuts)
map <silent> <Leader>a :echo <SID>P4Add()<CR>
map <silent> <Leader>b :echo <SID>P4Branches()<CR>
map <silent> <Leader>c :echo <SID>P4Clients()<CR>
map <silent> <Leader>d :echo <SID>P4Delete()<CR>
map <silent> <Leader>e :echo <SID>P4Edit()<CR>
map <silent> <Leader>f :echo <SID>P4Fstat()<CR>
map <silent> <Leader>g :echo <SID>P4Sync()<CR>
map <silent> <Leader>h :echo <SID>P4Filelog()<CR>
map <silent> <Leader>i :echo <SID>P4Info()<CR>
map <silent> <Leader>k :echo <SID>P4Diff()<CR>
map <silent> <Leader>l :echo <SID>P4Lock()<CR>
map <silent> <Leader>n :echo <SID>P4Annotate()<CR>
map <silent> <Leader>o :echo <SID>P4Opened()<CR>
map <silent> <Leader>p :echo <SID>PluginHelp()<CR>
map <silent> <Leader>r :echo <SID>P4Revert()<CR>
map <silent> <Leader>s :echo <SID>P4Submit()<CR>
map <silent> <Leader>t :echo <SID>P4Tag()<CR>
map <silent> <Leader>u :echo <SID>P4Unlock()<CR>
map <silent> <Leader>w :echo <SID>P4Where()<CR>
map <silent> <Leader>x :echo <SID>P4Fix()<CR>
map <silent> <Leader>z :echo <SID>P4Run()<CR>
" menus
" (listed in order of shortcuts)
menu <silent> &Perforce.Plugin\ Help :echo <SID>PluginHelp()<CR>
menu <silent> &Perforce.&Add :echo <SID>P4Add()<CR>
menu <silent> &Perforce.&Branches\ for\ current\ user :echo <SID>P4Branches()<CR>
menu <silent> &Perforce.&Clients\ for\ current\ user :echo <SID>P4Clients()<CR>
menu <silent> &Perforce.&Delete :echo <SID>P4Delete()<CR>
menu <silent> &Perforce.&Edit :echo <SID>P4Edit()<CR>
menu <silent> &Perforce.&Fstat :echo <SID>P4Fstat()<CR>
menu <silent> &Perforce.Connection\ &Info :echo <SID>P4Info()<CR>
menu <silent> &Perforce.File&log :echo <SID>P4Filelog()<CR>
menu <silent> &Perforce.A&nnotate :echo <SID>P4Annotate()<CR>
menu <silent> &Perforce.&Opened\ files :echo <SID>P4Opened()<CR>
menu <silent> &Perforce.&Revert :echo <SID>P4Revert()<CR>
menu <silent> &Perforce.&Submit :echo <SID>P4Submit()<CR>
menu <silent> &Perforce.&Tag :echo <SID>P4Tag()<CR>
menu <silent> &Perforce.&Where :echo <SID>P4Where()<CR>
menu <silent> &Perforce.S&ync :echo <SID>P4Sync()<CR>
menu <silent> &Perforce.Run\ Command :echo <SID>P4Run()<CR>
menu <silent> &Perforce.File.Attribute\ set :echo <SID>P4Attribute()<CR>
menu <silent> &Perforce.File.Attribute\ list :echo <SID>P4Attributes()<CR>
menu <silent> &Perforce.File.Lock :echo <SID>P4Lock()<CR>
menu <silent> &Perforce.File.Unlock :echo <SID>P4Unlock()<CR>
menu <silent> &Perforce.Branching.Branch\ Info :echo <SID>P4Branch()<CR>
menu <silent> &Perforce.File.Changelist\ Info :echo <SID>P4Change()<CR>
menu <silent> &Perforce.File.Changelists\ For\ File :echo <SID>P4Changes()<CR>
menu <silent> &Perforce.Workspace.Workspace\ Info :echo <SID>P4Client()<CR>
menu <silent> &Perforce.File.Diff :echo <SID>P4Diff()<CR>
menu <silent> &Perforce.File.Diff2 :echo <SID>P4Diff2()<CR>
menu <silent> &Perforce.Jobs.Fix\ Job :echo <SID>P4Fix()<CR>
menu <silent> &Perforce.Jobs.Fixes\ for\ Job :echo <SID>P4Fixes()<CR>
menu <silent> &Perforce.Other.Grep :echo <SID>P4Grep()<CR>
menu <silent> &Perforce.User.Group\ Info :echo <SID>P4Group()<CR>
menu <silent> &Perforce.User.Group\ List :echo <SID>P4Groups()<CR>
menu <silent> &Perforce.Other.Help :echo <SID>P4Help()<CR>
menu <silent> &Perforce.Branching.Integrated :echo <SID>P4Integrated()<CR>
menu <silent> &Perforce.Branching.Rev\ Graph :echo <SID>P4RevGraph()<CR>
menu <silent> &Perforce.Jobs.Job\ Info :echo <SID>P4Job()<CR>
menu <silent> &Perforce.Jobs.Job\ List :echo <SID>P4Jobs()<CR>
menu <silent> &Perforce.Labels.Label\ Info :echo <SID>P4Label()<CR>
menu <silent> &Perforce.Labels.Label\ List :echo <SID>P4Labels()<CR>
menu <silent> &Perforce.File.Print :echo <SID>P4Print()<CR>
menu <silent> &Perforce.User.Protections\ Info :echo <SID>P4Protects()<CR>
menu <silent> &Perforce.File.Reopen\ to\ changelist :echo <SID>P4ReopenChange()<CR>
menu <silent> &Perforce.File.Reopen\ type :echo <SID>P4ReopenType()<CR>
menu <silent> &Perforce.File.Resolve\ automatically :echo <SID>P4Resolve()<CR>
menu <silent> &Perforce.File.Resolve\ status :echo <SID>P4Resolved()<CR>
menu <silent> &Perforce.Other.Set :echo <SID>P4Set()<CR>
menu <silent> &Perforce.File.Shelve :echo <SID>P4Shelve()<CR>
menu <silent> &Perforce.File.Remove\ from\ shelf :echo <SID>P4ShelveRemove()<CR>
menu <silent> &Perforce.File.Sizes :echo <SID>P4Sizes()<CR>
menu <silent> &Perforce.User.Tickets :echo <SID>P4Tickets()<CR>
menu <silent> &Perforce.File.Unshelve :echo <SID>P4Unshelve()<CR>
menu <silent> &Perforce.User.User\ Info :echo <SID>P4User()<CR>
menu <silent> &Perforce.User.User\ list :echo <SID>P4Users()<CR>
menu <silent> &Perforce.File.Verify :echo <SID>P4Verify()<CR>
menu <silent> &Perforce.Admin.Counters :echo <SID>P4Counters()<CR>
menu <silent> &Perforce.Admin.Database\ Schema :echo <SID>P4Dbschema()<CR>
menu <silent> &Perforce.Admin.Database\ Statistics :echo <SID>P4Dbstat()<CR>
menu <silent> &Perforce.Admin.Depots :echo <SID>P4Depots()<CR>
menu <silent> &Perforce.Admin.Jobspec :echo <SID>P4Jobspec()<CR>
menu <silent> &Perforce.Admin.License\ Info :echo <SID>P4License()<CR>
menu <silent> &Perforce.Admin.Database\ Lock\ Info :echo <SID>P4Lockstat()<CR>
menu <silent> &Perforce.Admin.Log\ Info :echo <SID>P4Logstat()<CR>
menu <silent> &Perforce.Admin.Log\ Tail :echo <SID>P4Logtail()<CR>
menu <silent> &Perforce.Admin.Monitor :echo <SID>P4Monitor()<CR>
menu <silent> &Perforce.Admin.Obliterate\ Preview :echo <SID>P4Obliterate()<CR>
menu <silent> &Perforce.Admin.Protections\ Table :echo <SID>P4Protect()<CR>
menu <silent> &Perforce.Admin.Trigger\ Table :echo <SID>P4Triggers()<CR>
menu <silent> &Perforce.Admin.Tunables :echo <SID>P4Tunables()<CR>
menu <silent> &Perforce.Admin.Typemap\ Table :echo <SID>P4Typemap()<CR>
augroup END
"
" initialize status variables
"
function s:P4InitialBufferVariables()
let b:headrev=""
let b:headtype=""
let b:depotfile=""
let b:haverev=""
let b:action=""
let b:changelist=""
endfunction
"
" init ruler for status messages
"
if( strlen( &rulerformat ) == 0 ) && ( P4SetRuler == 1 )
set rulerformat=%60(%=%{P4RulerStatus()}\ %4l,%-3c\ %3p%%%)
endif
"
" filelog
"
function s:P4Filelog()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("filelog", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
print m['depotFile']
print "{0:<5}{1:<10}{2:<15}{3:<20}{4:<12}description".format('rev','change','action','user','date')
for i in range(len(m['rev'])):
timeobj = datetime.fromtimestamp(float(m['time'][i]))
timestr = timeobj.strftime('%Y/%m/%d')
print "{0:<5}{1:<10}{2:<15}{3:<20}{4:<12}{5}".format(m['rev'][i],m['change'][i],m['action'][i],m['user'][i],timestr,m['desc'][i])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" Produce string for ruler output
"
function P4RulerStatus()
if !exists( "b:headrev" )
call s:P4InitialBufferVariables()
endif
if b:action == ""
if b:headrev == ""
return "[Not in P4]"
else
return "[P4: " . b:haverev . "/" . b:headrev . " (" . b:headtype . ")]"
endif
else
return "[P4: " . b:action . " (". b:changelist . ")]"
endif
endfunction
"
" fstat for ruler
"
function s:P4FstatVars()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("fstat", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
change = ""
if 'change' in m:
change = m['change']
action = ""
if 'action' in m:
action = m['action']
headRev = ""
if 'headRev' in m:
headRev = m['headRev']
headType = ""
if 'headType' in m:
headType = m['headType']
haveRev = ""
if 'haveRev' in m:
haveRev = m['haveRev']
depotFile = ""
if 'depotFile' in m:
depotFile = m['depotFile']
vim.command("let b:headrev = \"%s\"" % headRev)
vim.command("let b:headtype = \"%s\"" % headType)
vim.command("let b:changelist = \"%s\"" % change)
vim.command("let b:depotfile = \"%s\"" % depotFile)
vim.command("let b:haverev = \"%s\"" % haveRev)
vim.command("let b:action = \"%s\"" % action)
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" fstat
"
function s:P4Fstat()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("fstat", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
change = ""
if 'change' in m:
change = m['change']
action = ""
if 'action' in m:
action = m['action']
headRev = ""
if 'headRev' in m:
headRev = m['headRev']
headType = ""
if 'headType' in m:
headType = m['headType']
haveRev = ""
if 'haveRev' in m:
haveRev = m['haveRev']
depotFile = ""
if 'depotFile' in m:
depotFile = m['depotFile']
print "{0}: {1}/{2} ({3})".format(depotFile,haveRev,headRev,headType)
if change != "":
print "Opened in {0} ({1})".format(change,action)
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" open for edit
"
function s:P4Edit()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("edit", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" revert
"
function s:P4Revert()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("revert", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" open for add
"
function s:P4Add()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("add", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" open for delete
"
function s:P4Delete()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("delete", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
print "File opened for delete and removed from workspace - Vim buffer no longer valid"
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" submit a single file
"
function s:P4Submit()
let desc = inputdialog( "Enter changelist description", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("submit", "-d", vim.eval("desc"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" sync to head
"
function s:P4Sync()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("sync", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" annotate
"
function s:P4Annotate()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("annotate", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" list branches owned by current user
"
function s:P4Branches()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
info = p4.run("info")
username = info[0]['userName']
out = p4.run("branches", "-u", username)
if not (isinstance(out, types.NoneType)):
print "{0:<25}description".format('branch')
for m in out:
print "{0:<25}{1}".format(m['branch'],m['Description'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" connection info
"
function s:P4Info()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("info")
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display branch mapping
"
function s:P4Branch()
let branch = inputdialog( "Enter branch name", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("branch", "-o", vim.eval("branch"))
if not (isinstance(out, types.NoneType)):
m = out[0]
print m['Branch']
print m['Description']
for s in m['View']:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display changelist info
"
function s:P4Change()
let change = inputdialog( "Enter changelist number", "")
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("describe", "-s", vim.eval("change"))
if not (isinstance(out, types.NoneType)):
m = out[0]
timeobj = datetime.fromtimestamp(float(m['time']))
timestr = timeobj.strftime('%Y/%m/%d')
print "Change {0} on {1} by {2} ({3})".format(m['change'],timestr,m['user'],m['status'])
print m['desc']
for i in range(len(m['depotFile'])):
print "{0:<15}{1}#{2}".format(m['action'][i],m['depotFile'][i],m['rev'][i])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display changelists for current file
"
function s:P4Changes()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("changes", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
print "{0:<10}{1:<15}{2:<15}{3}".format('change','date','user','description')
for m in out:
timeobj = datetime.fromtimestamp(float(m['time']))
timestr = timeobj.strftime('%Y/%m/%d')
print "{0:<10}{1:<15}{2:<15}{3}".format(m['change'],timestr,m['user'],m['desc'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display workspace data
"
function s:P4Client()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("client", "-o")
if not (isinstance(out, types.NoneType)):
m = out[0]
print "Client : %s" % m['Client']
print "Root : %s" % m['Root']
print "Options : {0}, {1}".format(m['Options'],m['SubmitOptions'])
print "Line endings: %s" % m['LineEnd']
print m['Description']
for s in m['View']:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" list workspaces owned by current user
"
function s:P4Clients()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
info = p4.run("info")
username = info[0]['userName']
out = p4.run("clients", "-u", username)
if not (isinstance(out, types.NoneType)):
print "{0:<25}description".format('client')
for m in out:
print "{0:<25}{1}".format(m['client'],m['Description'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" counters
"
function s:P4Counters()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("counters")
if not (isinstance(out, types.NoneType)):
print "{0:<20}{1:<20}".format("counter","value")
for m in out:
print "{0:<20}{1:<20}".format(m['counter'],m['value'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" database schema
"
function s:P4Dbschema()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("dbschema")
if not (isinstance(out, types.NoneType)):
print "{0:<20}{1:<20}".format("table","version")
for m in out:
print "{0:<20}{1:<20}".format(m['table'],m['version'])
print "{0:<5}{1:<20}{2:<15}{3:<15}{4:<15}".format('','name','type','dmtype','fmtkind')
for i in range(len(m['name'])):
print "{0:<5}{1:<20}{2:<15}{3:<15}{4:<15}".format('',m['name'][i],m['type'][i],m['dmtype'][i],m['fmtkind'][i])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" database stats
"
function s:P4Depots()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("depots")
if not (isinstance(out, types.NoneType)):
print "{0:<20}{1:<10}{2:<20}{3}".format("depot","type","map","description")
for m in out:
print "{0:<20}{1:<10}{2:<20}{3}".format(m['name'],m['type'],m['map'],m['desc'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" depot list
"
function s:P4Dbstat()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("dbstat","-a")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
out = p4.run("dbstat","-s")
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" diff
"
function s:P4Diff()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("diff", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" diff2
"
function s:P4Diff2()
let rev = inputdialog( "Enter revision to diff against head", "")
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("diff2", vim.current.buffer.name + "#" + vim.eval("rev"), vim.current.buffer.name + "#head")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" fix job
"
function s:P4Fix()
let change = inputdialog( "Enter changelist number", "")
let job = inputdialog( "Enter job ID", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("fix", "-c", vim.eval("change"), vim.eval("job"))
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" fixes for job
"
function s:P4Fixes()
let job = inputdialog( "Enter job ID", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("fixes", "-j", vim.eval("job"))
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" where
"
function s:P4Where()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("where", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
print "{0:<15}{1}".format("Depot path",m['depotFile'])
print "{0:<15}{1}".format("Client path",m['clientFile'])
print "{0:<15}{1}".format("Local path",m['path'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" command help
"
function s:P4Help()
let topic = inputdialog( "Help on?", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("help", vim.eval("topic"))
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" verify
"
function s:P4Verify()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("verify", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
print "{0:<5}{1:<15}{2:<10}{3:<12}{4:<15}{5}".format('rev','action','change','type','status','depot path')
for m in out:
status = 'OK'
if 'status' in m:
status = m['status']
print "{0:<5}{1:<15}{2:<10}{3:<12}{4:<15}{5}".format(m['rev'],m['action'],m['change'],m['type'],status,m['depotFile'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display user data
"
function s:P4User()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("user", "-o")
if not (isinstance(out, types.NoneType)):
m = out[0]
print "user : %s" % m['User']
print "Email : %s" % m['Email']
print "FullName : {0}".format(m['FullName'])
if 'JobView' in m:
print "JobView : {0}".format(m['JobView'])
if 'Reviews' in m:
print "Reviews :"
for s in m['Reviews']:
print " %s" % s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display user list
"
function s:P4Users()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("users")
if not (isinstance(out, types.NoneType)):
print "{0:<20}{1:<30}{2}".format('User','Email','Name')
for m in out:
print "{0:<20}{1:<30}{2}".format(m['User'],m['Email'],m['FullName'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" lock
"
function s:P4Lock()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("lock", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" unlock
"
function s:P4Unlock()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("unlock", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" print
"
function s:P4Print()
let rev = inputdialog( "Enter revision to print", "")
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("print", "-q", vim.current.buffer.name + "#" + vim.eval("rev"))
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" opened files
"
function s:P4Opened()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("opened")
if not (isinstance(out, types.NoneType)):
print "{0:<40}{1:<10}{2:<12}{3:<10}".format('depotFile','rev','action','change')
for m in out:
print "{0:<40}{1:<10}{2:<12}{3:<10}".format(m['depotFile'],m['rev'],m['action'],m['change'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display group info
"
function s:P4Group()
let group = inputdialog( "Enter group name", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("group", "-o", vim.eval("group"))
if not (isinstance(out, types.NoneType)):
m = out[0]
print m['Group']
print "{0:<15}{1}".format("MaxResults",m['MaxResults'])
print "{0:<15}{1}".format("MaxScanRows",m['MaxScanRows'])
print "{0:<15}{1}".format("MaxLockTime",m['MaxLockTime'])
print "{0:<15}{1}".format("Timeout",m['Timeout'])
if 'Subgroups' in m:
print "{0:<15}".format("Subgroups")
for s in m['Subgroups']:
print "{0:<5}{1}".format("",s)
if 'Users' in m:
print "{0:<15}".format("Users")
for s in m['Users']:
print "{0:<5}{1}".format("",s)
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" list groups for current user
"
function s:P4Groups()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
info = p4.run("info")
username = info[0]['userName']
out = p4.run("groups", username)
if not (isinstance(out, types.NoneType)):
print "{0:<25}{1:<15}{2:<15}{3:<15}{4:<15}".format('group','maxResults','maxScanRows','maxLockTime','timeout')
for m in out:
print "{0:<25}{1:<15}{2:<15}{3:<15}{4:<15}".format(m['group'],m['maxResults'],m['maxScanRows'],m['maxLockTime'],m['timeout'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" grep
"
function s:P4Grep()
let pattern = inputdialog( "Grep for", "")
let path = inputdialog( "Grep where", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("grep", "-e", vim.eval("pattern"), vim.eval("path"))
if not (isinstance(out, types.NoneType)):
print "{0:<40}{1:<10}{2}".format('depotFile','rev','matchedLine')
for m in out:
print "{0:<40}{1:<10}{2}".format(m['depotFile'],m['rev'],m['matchedLine'].replace("\t"," "))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" integrated
"
function s:P4Integrated()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("integrated", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display job info
"
function s:P4Job()
let job = inputdialog( "Enter job ID", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("job", "-o", vim.eval("job"))
if not (isinstance(out, types.NoneType)):
m = out[0]
print m['Job'] + " (" + m['Status'] + ")"
print " " + m['Description']
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display job list
"
function s:P4Jobs()
let jobview = inputdialog( "Enter job query", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("jobs", "-e", vim.eval("jobview"))
if not (isinstance(out, types.NoneType)):
for m in out:
print m['Job'] + " (" + m['Status'] + ") " + m['Description']
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" job spec
"
function s:P4Jobspec()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("jobspec", "-o")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display label info
"
function s:P4Label()
let label = inputdialog( "Enter label name", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("label", "-o", vim.eval("label"))
if not (isinstance(out, types.NoneType)):
m = out[0]
print m['Label'] + " (" + m['Options'] + ")"
if 'Revision' in m:
print "Revision: %s" % m['Revision']
print " " + m['Description']
for s in m['View']:
print " " + s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display label list
"
function s:P4Labels()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("labels", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
print "{0:<25}{1:<15}description".format('label','options')
for m in out:
print "{0:<25}{1:<15}{2}".format(m['label'],m['Options'],m['Description'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" plugin help
"
function s:PluginHelp()
python << EOF
print("P4Python.vim: Vim plugin for Perforce, based on P4Python API")
print("Uses Perforce environment from current working directory")
print("Perforce and P4Python are copyright Perforce Software, Inc.")
print("Available commands:")
print("{0:<4}{1:<15}{2}".format("","PluginHelp","See this message"))
print("{0:<4}{1:<15}{2}".format("","P4Add","Add current file to Perforce"))
print("{0:<4}{1:<15}{2}".format("","P4Annotate","Revision annotations for current file"))
print("{0:<4}{1:<15}{2}".format("","P4Attribute","Set a file attribute"))
print("{0:<4}{1:<15}{2}".format("","P4Attributes","List file attributes"))
print("{0:<4}{1:<15}{2}".format("","P4Branch","See information about one branch spec"))
print("{0:<4}{1:<15}{2}".format("","P4Branches","List branches owned by current user"))
print("{0:<4}{1:<15}{2}".format("","P4Change","See information about one changelist"))
print("{0:<4}{1:<15}{2}".format("","P4Changes","See information about all changelists affecting current file"))
print("{0:<4}{1:<15}{2}".format("","P4Client","Current workspace information"))
print("{0:<4}{1:<15}{2}".format("","P4Clients","List workspaces owned by current user"))
print("{0:<4}{1:<15}{2}".format("","P4Counters","List system counters"))
print("{0:<4}{1:<15}{2}".format("","P4Dbschema","Database schema information"))
print("{0:<4}{1:<15}{2}".format("","P4Dbstat","Database statistics"))
print("{0:<4}{1:<15}{2}".format("","P4Delete","Delete current file"))
print("{0:<4}{1:<15}{2}".format("","P4Depots","List all depots"))
print("{0:<4}{1:<15}{2}".format("","P4Diff","Diff current file against have revision"))
print("{0:<4}{1:<15}{2}".format("","P4Diff2","Diff two revisions of current file"))
print("{0:<4}{1:<15}{2}".format("","P4Edit","Open current file for edit"))
print("{0:<4}{1:<15}{2}".format("","P4Filelog","See history of current file"))
print("{0:<4}{1:<15}{2}".format("","P4Fix","Fix a job"))
print("{0:<4}{1:<15}{2}".format("","P4Fixes","List fix records for a job"))
print("{0:<4}{1:<15}{2}".format("","P4Fstat","Get current file information"))
print("{0:<4}{1:<15}{2}".format("","P4Grep","Search in Perforce files"))
print("{0:<4}{1:<15}{2}".format("","P4Group","Information on one group"))
print("{0:<4}{1:<15}{2}".format("","P4Groups","List groups for current user"))
print("{0:<4}{1:<15}{2}".format("","P4Help","Perforce help for a command"))
print("{0:<4}{1:<15}{2}".format("","P4Info","Perforce connection information"))
print("{0:<4}{1:<15}{2}".format("","P4Integrated","Integration records for current file"))
print("{0:<4}{1:<15}{2}".format("","P4Job","Information on one job"))
print("{0:<4}{1:<15}{2}".format("","P4Jobs","List jobs that match a job query"))
print("{0:<4}{1:<15}{2}".format("","P4Jobspec","Perforce jobspec information"))
print("{0:<4}{1:<15}{2}".format("","P4Label","Information on one label"))
print("{0:<4}{1:<15}{2}".format("","P4Labels","List labels for current file"))
print("{0:<4}{1:<15}{2}".format("","P4License","Perforce license information"))
print("{0:<4}{1:<15}{2}".format("","P4Lock","Lock current file"))
print("{0:<4}{1:<15}{2}".format("","P4Lockstat","Database lock information"))
print("{0:<4}{1:<15}{2}".format("","P4Logstat","Log information"))
print("{0:<4}{1:<15}{2}".format("","P4Logtail","Log tail"))
print("{0:<4}{1:<15}{2}".format("","P4Monitor","Process monitor"))
print("{0:<4}{1:<15}{2}".format("","P4Obliterate","Obliterate preview"))
print("{0:<4}{1:<15}{2}".format("","P4Opened","See files open in current workspace"))
print("{0:<4}{1:<15}{2}".format("","P4Print","Print a revision of the current file"))
print("{0:<4}{1:<15}{2}".format("","P4Protect","Protections table"))
print("{0:<4}{1:<15}{2}".format("","P4Protects","User protections"))
print("{0:<4}{1:<15}{2}".format("","P4ReopenChange","Reopen to different changelist"))
print("{0:<4}{1:<15}{2}".format("","P4ReopenType","Reopen to different file type"))
print("{0:<4}{1:<15}{2}".format("","P4Resolve","Resolve automatically"))
print("{0:<4}{1:<15}{2}".format("","P4Resolved","Resolve status"))
print("{0:<4}{1:<15}{2}".format("","P4Revert","Revert current file"))
print("{0:<4}{1:<15}{2}".format("","P4RevGraph","Show revision graph with integration points"))
print("{0:<4}{1:<15}{2}".format("","P4Run","Run any command"))
print("{0:<4}{1:<15}{2}".format("","P4Set","Environment information"))
print("{0:<4}{1:<15}{2}".format("","P4Shelve","Shelve current file in changelist"))
print("{0:<4}{1:<15}{2}".format("","P4ShelveRemove","Remove current file from shelved changelist"))
print("{0:<4}{1:<15}{2}".format("","P4Sizes","File size for each revision of current file"))
print("{0:<4}{1:<15}{2}".format("","P4Submit","Submit current file"))
print("{0:<4}{1:<15}{2}".format("","P4Sync","Get head revision of current file"))
print("{0:<4}{1:<15}{2}".format("","P4Tag","Label current file"))
print("{0:<4}{1:<15}{2}".format("","P4Tickets","Tickets for current user"))
print("{0:<4}{1:<15}{2}".format("","P4Triggers","Trigger table"))
print("{0:<4}{1:<15}{2}".format("","P4Tunables","Tunables"))
print("{0:<4}{1:<15}{2}".format("","P4Typemap","Typemap table"))
print("{0:<4}{1:<15}{2}".format("","P4Unlock","Unlock current file"))
print("{0:<4}{1:<15}{2}".format("","P4Unshelve","Unshelve current file from changelist"))
print("{0:<4}{1:<15}{2}".format("","P4User","User profile"))
print("{0:<4}{1:<15}{2}".format("","P4Users","List all users"))
print("{0:<4}{1:<15}{2}".format("","P4Verify","Verify current file"))
print("{0:<4}{1:<15}{2}".format("","P4Where","See depot and local path for current file"))
EOF
endfunction
"
" environment info
"
function s:P4Set()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
print p4.identify()
env_vars = ["P4AUDIT","P4CHARSET","P4COMMANDCHARSET","P4CLIENT","P4CONFIG","P4DEBUG","P4DESCRIPTION","P4DIFF","P4DIFFUNICODE","P4EDITOR","P4HOST","P4JOURNAL","P4LANGUAGE","P4LOG","P4MERGE","P4MERGEUNICODE","P4NAME","P4PAGER","P4PASSWD","P4PORT","P4TARGET","P4TICKETS","P4USER","P4ZEROCONF","PWD","TMP","TEMP"]
for e in env_vars:
print("{0:<4}{1:<20}{2}".format("",e,p4.env(e)))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" sizes
"
function s:P4Sizes()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("sizes", "-a", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
print "{0:<5}{1}".format('rev','fileSize (KB)')
for m in out:
fsize = "%.1f" % (float(m['fileSize']) / 1024.0)
print "{0:<5}{1}".format(m['rev'],fsize)
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" tag a single file
"
function s:P4Tag()
let label = inputdialog( "Enter label name", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("tag", "-l", vim.eval("label"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" license info
"
function s:P4License()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("license", "-o")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" db lock info
"
function s:P4Lockstat()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("lockstat")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" log info
"
function s:P4Logstat()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("logstat")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" log tail
"
function s:P4Logtail()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("logtail")
if not (isinstance(out, types.NoneType)):
print out[0]['file']
print out[0]['data'].replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" monitor
"
function s:P4Monitor()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("monitor", "show")
if not (isinstance(out, types.NoneType)):
print("{0:<10}{1:<10}{2:<20}{3:<15}{4}".format('id','status','user','time','command'))
for m in out:
print("{0:<10}{1:<10}{2:<20}{3:<15}{4}".format(m['id'],m['status'],m['user'],m['time'],m['command']))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" obliterate
"
function s:P4Obliterate()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("obliterate", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
print("PREVIEW MODE")
for m in out:
if 'clientRecDeleted' in m:
print("{0:<5}{1}".format(m['clientRecDeleted'], "client records deleted"))
if 'labelRecDeleted' in m:
print("{0:<5}{1}".format(m['labelRecDeleted'], "label records deleted"))
if 'integrationRecDeleted' in m:
print("{0:<5}{1}".format(m['integrationRecDeleted'], "integration records deleted"))
if 'workingRecDeleted' in m:
print("{0:<5}{1}".format(m['workingRecDeleted'], "working records deleted"))
if 'revisionRecDeleted' in m:
print("{0:<5}{1}".format(m['revisionRecDeleted'], "revision records deleted"))
if 'purgeFile' in m:
print('Purged ' + m['purgeFile'] + '#' + m['purgeRev'])
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" display protetions data
"
function s:P4Protects()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("protects")
if not (isinstance(out, types.NoneType)):
print("{0:<15}{1:<20}{2:<20}{3}".format('Permission','User or group','Host','Path'))
for m in out:
who = ''
if 'user' in m:
who = m['user']
if 'group' in m:
who = m['group']
print("{0:<15}{1:<20}{2:<20}{3}".format(m['perm'],who,m['host'],m['depotFile']))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" protections table
"
function s:P4Protect()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("protect", "-o")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" reopen to changelist
"
function s:P4ReopenChange()
let change = inputdialog( "Enter changelist number", "")
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("reopen", "-c", vim.eval("change"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" reopen file type
"
function s:P4ReopenType()
let type = inputdialog( "Enter file type", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("reopen", "-t", vim.eval("type"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" resolve
"
function s:P4Resolve()
let accept = inputdialog( "Enter accept resolve option", "")
python << EOF
import vim, P4, types
accept = vim.eval("accept")
if accept == '-am' or accept == '-af' or accept == '-as' or accept == '-at' or accept == '-ay':
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("resolve", accept, vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
else:
print("Error: you must select one of -am/-af/-as/-at/-ay")
EOF
endfunction
"
" resolve status
"
function s:P4Resolved()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("resolved", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
print("{0:<40}{1:<15}{2}{3},{4}".format(m['toFile'],m['how'],m['fromFile'],m['startFromRev'],m['endFromRev']))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" trigger table
"
function s:P4Triggers()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("triggers", "-o")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" typemap table
"
function s:P4Typemap()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("typemap", "-o")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" tickets
"
function s:P4Tickets()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("tickets")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" tunables
"
function s:P4Tunables()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("tunables", "-a")
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" set attribute
"
function s:P4Attribute()
let attrib = inputdialog( "Attribute name", "")
let value = inputdialog( "Enter value", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("attribute", "-n", vim.eval("attrib"), "-v", vim.eval("value"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s.replace("\t"," ")
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" attribute list
"
function s:P4Attributes()
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("fstat", "-Oa", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
m = out[0]
print("{0:<30}{1}".format("Name","Value"))
for key in iter(m):
if key.find("attr-") == 0:
print("{0:<30}{1}".format(key[5:],m[key]))
if key.find("openattr-") == 0:
print("{0:<30}{1}".format(key[9:],m[key]))
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" run any command
"
function s:P4Run()
let cmd = inputdialog( "Enter complete command to run, without the leading 'p4'", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run(vim.eval("cmd").split())
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" shelve
"
function s:P4Shelve()
let change = inputdialog( "Enter changelist number", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("reopen", "-c", vim.eval("change"), vim.current.buffer.name)
out = p4.run("shelve", "-c", vim.eval("change"), "-f", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" remove from shelf
"
function s:P4ShelveRemove()
let change = inputdialog( "Enter changelist number", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("shelve", "-d", "-c", vim.eval("change"), "-f", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" unshelve
"
function s:P4Unshelve()
let change = inputdialog( "Enter changelist number", "")
python << EOF
import vim, P4, types
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = False
out = p4.run("unshelve", "-s", vim.eval("change"), vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
for s in out:
print s
p4.disconnect()
vim.command("edit")
except P4Exception:
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
endfunction
"
" ASCII rev graph
"
function s:P4RevGraph()
python << EOF
import vim, P4, types
from datetime import datetime
p4 = P4.P4()
p4.prog = "VIM Integration"
P4Exception = P4.P4Exception
try:
p4.connect()
p4.tagged = True
out = p4.run("integrated", vim.current.buffer.name)
if not (isinstance(out, types.NoneType)):
graph = ''
for m in out:
# current file always listed as 'to file'
how = m['how']
if how.find("into") != -1 or how.find("ignored by") != -1:
toFile = m['fromFile']
fromFile = m['toFile']
startToRev = m['startFromRev']
endToRev = m['endFromRev']
startFromRev = m['startToRev']
endFromRev = m['endToRev']
else:
toFile = m['toFile']
fromFile = m['fromFile']
startToRev = m['startToRev']
endToRev = m['endToRev']
startFromRev = m['startFromRev']
endFromRev = m['endFromRev']
change = m['change']
graph = graph + fromFile + endFromRev + '@' + toFile + endToRev + '@change ' + change + ' ' + how + "|"
if graph == '':
graph = 'NONE'
vim.command("let b:graph = \"%s\"" % graph)
else:
print("No integration records")
vim.command("let b:graph = \"NONE\"")
p4.disconnect()
except P4Exception:
vim.command("let b:graph = \"NONE\"")
for e in p4.errors:
print e
for w in p4.warnings:
print w
EOF
perl << EOF
use Graph::Easy;
my @gstr = VIM::Eval('b:graph');
if($gstr[1] ne '' and $gstr[1] ne 'NONE') {
my @parts = split(/\|/, $gstr[1]);
my $graph = Graph::Easy->new();
foreach my $pair (@parts) {
my @p = split(/@/,$pair);
$graph->add_node($p[0]);
$graph->add_node($p[1]);
$graph->add_edge($p[0],$p[1],$p[2]);
}
VIM::Msg($graph->as_ascii());
}
EOF
endfunction