'])
return None
class QueryGtags(QueryBase):
def __init__(self, conf):
QueryBase.__init__(self)
self.conf = conf
self.gt_file_list_update()
def query(self, rquery):
if (not self.conf):
#or not self.conf.is_ready()):
print "pm_query not is_ready"
return None
cmd_str = rquery['cmd']
req = rquery['req']
opt = rquery['opt']
if opt == None or opt == '':
opt = []
else:
opt = opt.split()
cmd_opt = GtagsProjectUi.cmd_str2id[cmd_str]
pargs = [ 'global', '-a', '--result=cscope', '-x' ] + opt
if cmd_opt != '':
pargs += [ cmd_opt ]
pargs += [ '--', req ]
qsig = GtProcess(self.conf.gt_dir, [cmd_str, req]).run_query_process(pargs, req, rquery)
return qsig
def rebuild(self):
if (not self.conf.is_ready()):
print "pm_query not is_ready"
return None
if (os.path.exists(os.path.join(self.conf.gt_dir, 'GTAGS'))):
pargs = [ 'global', '-u' ]
else:
pargs = [ 'gtags', '-i' ]
qsig = GtProcess(self.conf.gt_dir, None).run_rebuild_process(pargs)
qsig.connect(self.gt_file_list_update)
return qsig
def gt_file_list_update(self):
wdir = self.conf.gt_dir
if not os.path.exists(os.path.join(wdir, 'GTAGS')):
return
fl = []
try:
import subprocess
pargs = [ 'global', '-P', '-a' ]
proc = subprocess.Popen(pargs, stdin=subprocess.PIPE, stdout=subprocess.PIPE, cwd=wdir)
(out_data, err_data) = proc.communicate()
fl = re.split('\r?\n', out_data.strip())
PluginHelper.file_view_update(fl)
except:
import sys
e = sys.exc_info()[1]
print ' '.join(pargs)
print e
def gt_is_open(self):
return self.conf != None
def gt_is_ready(self):
return self.conf.is_ready()
seascope-0.7/src/backend/plugins/gtags/GtagsProjectUi.py 0000664 0023763 0023763 00000010725 12062273150 022047 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import os
import sys
import re
from PyQt4 import QtGui, QtCore, uic
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from ..PluginBase import ProjectBase, ConfigBase, QueryBase
from ..PluginBase import QueryUiBase
from .. import PluginBase, PluginHelper
cmd_table = [
[ ['REF', '-r'], ['&References', 'Ctrl+0'], ['References to' ] ],
[ ['DEF', ''], ['&Definitions', 'Ctrl+1'], ['Definition of' ] ],
#[ ['<--', '2'], ['&Called Functions', 'Ctrl+2'], ['Functions called by' ] ],
[ ['-->', '-r'], ['C&alling Functions', 'Ctrl+3'], ['Functions calling' ] ],
#[ ['TXT', '4'], ['Find &Text', 'Ctrl+4'], ['Find text' ] ],
[ ['GRP', '-g'], ['Find &Egrep', 'Ctrl+5'], ['Find egrep pattern' ] ],
[ ['FIL', '-P'], ['Find &File', 'Ctrl+7'], ['Find files' ] ],
[ ['INC', '-g'], ['&Include/Import', 'Ctrl+8'], ['Find include/import' ] ],
[ ['---', None], [None ] ],
[ ['QDEF', ''], ['&Quick Definition', 'Ctrl+]'], [None ] ],
[ ['CTREE','12'], ['Call Tr&ee', 'Ctrl+\\'], ['Call tree' ] ],
[ ['---', None], [None ], ],
[ ['UPD', '25'], ['Re&build Database', None ], [None ] ],
]
menu_cmd_list = [ [c[0][0]] + c[1] for c in cmd_table ]
cmd_str2id = {}
cmd_str2qstr = {}
cmd_qstr2str = {}
for c in cmd_table:
if c[0][1] != None:
cmd_str2id[c[0][0]] = c[0][1]
cmd_str2qstr[c[0][0]] = c[2][0]
cmd_qstr2str[c[2][0]] = c[0][0]
# python 2.7
#cmd_str2id = { c[0][0]:c[0][1] for c in cmd_table if c[0][1] != None }
#cmd_str2qstr = { c[0][0]:c[2][0] for c in cmd_table if c[0][1] != None }
#cmd_qstr2str = { c[2][0]:c[0][0] for c in cmd_table if c[0][1] != None }
cmd_qstrlist = [ c[2][0] for c in cmd_table if c[0][1] != None and c[2][0] != None ]
ctree_query_args = [
['-->', '--> F', 'Calling tree' ],
#['<--', 'F -->', 'Called tree' ],
['REF', '==> F', 'Advanced calling tree' ],
]
class QueryDialog(QDialog):
dlg = None
def __init__(self):
QDialog.__init__(self)
self.ui = uic.loadUi('backend/plugins/gtags/ui/gt_query.ui', self)
self.qd_sym_inp.setAutoCompletion(False)
self.qd_sym_inp.setInsertPolicy(QComboBox.InsertAtTop)
self.qd_cmd_inp.addItems(cmd_qstrlist)
def run_dialog(self, cmd_str, req):
s = cmd_str2qstr[cmd_str]
inx = self.qd_cmd_inp.findText(s)
self.qd_cmd_inp.setCurrentIndex(inx)
if (req == None):
req = ''
self.qd_sym_inp.setFocus()
self.qd_sym_inp.setEditText(req)
self.qd_sym_inp.lineEdit().selectAll()
self.qd_substr_chkbox.setChecked(False)
self.qd_icase_chkbox.setChecked(False)
self.show()
if (self.exec_() == QDialog.Accepted):
req = str(self.qd_sym_inp.currentText())
s = str(self.qd_cmd_inp.currentText())
cmd_str = cmd_qstr2str[s]
#self.qd_sym_inp.addItem(req)
if (req != '' and self.qd_substr_chkbox.isChecked()):
req = '.*' + req + '.*'
opt = None
if (self.qd_icase_chkbox.isChecked()):
opt = '-i'
res = (cmd_str, req, opt)
return res
return None
@staticmethod
def show_dlg(cmd_str, req):
if (QueryDialog.dlg == None):
QueryDialog.dlg = QueryDialog()
return QueryDialog.dlg.run_dialog(cmd_str, req)
def show_msg_dialog(msg):
QMessageBox.warning(None, "Seascope", msg, QMessageBox.Ok)
class QueryUiGtags(QueryUiBase):
def __init__(self, qry):
self.menu_cmd_list = menu_cmd_list
QueryUiBase.__init__(self)
self.query = qry
self.ctree_args = ctree_query_args
def query_cb(self, cmd_str):
if (not self.query.gt_is_open()):
return
if (not self.query.gt_is_ready()):
show_msg_dialog('\nProject has no source files')
return
req = PluginHelper.editor_current_word()
if (req != None):
req = str(req).strip()
opt = None
if (cmd_str != 'QDEF'):
val = QueryDialog.show_dlg(cmd_str, req)
if (val == None):
return
(cmd_str, req, opt) = val
if (req == None or req == ''):
return
if cmd_str == 'QDEF':
self.query_qdef(req, opt)
elif cmd_str == 'CTREE':
self.query_ctree(req, opt)
else:
self.do_query(cmd_str, req, opt)
def prepare_menu(self):
QueryUiBase.prepare_menu(self)
menu = PluginHelper.backend_menu
menu.setTitle('G&tags')
@staticmethod
def prj_show_settings_ui(proj_args):
dlg = ProjectSettingsGtagsDialog()
return dlg.run_dialog(proj_args)
class ProjectSettingsGtagsDialog(QDialog):
def __init__(self):
QDialog.__init__(self)
self.ui = uic.loadUi('ui/project_settings.ui', self)
def run_dialog(self, proj_args):
self.pi_path_lbl.setText(proj_args[0])
self.pi_type_lbl.setText('GNU global/gtags')
self.exec_()
return proj_args
seascope-0.7/src/backend/plugins/__init__.py 0000664 0023763 0023763 00000000112 12062273150 017574 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
seascope-0.7/src/backend/plugins/PluginBase.py 0000664 0023763 0023763 00000020026 12062273150 020074 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import os, re
def msg_box(msg):
QMessageBox.warning(None, "Seascope", msg, QMessageBox.Ok)
class ProjectBase(QObject):
prj = None
qry = None
def __init__(self):
QObject.__init__(self)
def prj_close(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_get_dir(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_get_name(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_get_src_files(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_is_open(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_is_ready(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_get_conf(self):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_update_conf(self, proj_args):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_show_settings(self, proj_args):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def prj_settings(self, proj_args):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
class ConfigBase(QObject):
@staticmethod
def prepare_menu(menubar):
pass
class QueryBase(QObject):
@staticmethod
def prepare_menu(menubar):
pass
def query(self, rquery):
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
def rebuild():
msg_box('%s: %s: Not implemeted' % (__name__, __func__))
import PluginHelper
class QueryUiBase(QObject):
def __init__(self):
QObject.__init__(self)
self.prepare_menu()
def menu_cb(self, act):
if act.cmd_str != None:
self.query_cb(act.cmd_str)
def prepare_menu(self):
menu = PluginHelper.backend_menu
menu.triggered.connect(self.menu_cb)
for c in self.menu_cmd_list:
if c[0] == '---':
menu.addSeparator()
continue
if c[2] == None:
if c[0] == 'UPD':
func = self.rebuild_cb
act = menu.addAction(c[1], func)
act.cmd_str = None
else:
act = menu.addAction(c[1])
act.setShortcut(c[2])
act.cmd_str = c[0]
def query_ctree(self, req, opt):
PluginHelper.call_view_page_new(req, self.query.query, self.ctree_args, opt)
def query_class_graph(self, req, opt):
PluginHelper.class_graph_view_page_new(req, self.query.conf.id_dir, self.query.query, self.clgraph_args, opt)
def _prepare_rquery(self, cmd_str, req, opt):
rquery = {}
rquery['cmd'] = cmd_str
rquery['req'] = req
rquery['opt'] = opt
# add current file info
rquery['hint_file'] = PluginHelper.editor_current_file()
return rquery
def query_qdef(self, req, opt):
rquery = {}
rquery = self._prepare_rquery('DEF', req, opt)
sig_res = self.query.query(rquery)
PluginHelper.quick_def_page_new(sig_res)
def do_query(self, cmd_str, req, opt):
## create page
name = cmd_str + ' ' + req
rquery = self._prepare_rquery(cmd_str, req, opt)
sig_res = self.query.query(rquery)
PluginHelper.result_page_new(name, sig_res)
def do_rebuild(self):
sig_rebuild = self.query.rebuild()
if not sig_rebuild:
return
dlg = QProgressDialog()
dlg.setWindowTitle('Seascope rebuild')
dlg.setLabelText('Rebuilding database...')
dlg.setCancelButton(None)
dlg.setMinimum(0)
dlg.setMaximum(0)
sig_rebuild.connect(dlg.accept)
while dlg.exec_() != QDialog.Accepted:
pass
def rebuild_cb(self):
self.do_rebuild()
from PyQt4.QtGui import QMessageBox
class QuerySignal(QObject):
sig_result = pyqtSignal(str, list)
sig_result_dbg = pyqtSignal(str, str, str)
sig_rebuild = pyqtSignal()
def __init__(self):
QObject.__init__(self)
def _relevancy_sort(self, hfile, res):
pt = []
pd = {}
p = hfile
(pre, ext) = os.path.splitext(hfile)
c = None
while p != c:
e = [p, [], []]
pt += [e]
pd[p] = e
c = p
p = os.path.dirname(p)
for line in res:
f = line[1]
d = os.path.dirname(f)
p = f
while p not in pd:
p = os.path.dirname(p)
e = pd[p]
if p in [f, d]:
e[1].append(line)
else:
e[2].append(line)
for e in pt:
e[1] = sorted(e[1], key=lambda li: li[1])
e[2] = sorted(e[2], key=lambda li: li[1])
pre = pre + '.*'
e0 = []
e1 = []
for e in pt[1][1]:
if re.match(pre, e[1]):
e0 += [e]
else:
e1 += [e]
pt[0][1] += e0
pt[1][1] = e1
res1 = []
res2 = []
for e in pt:
res1 += e[1]
res2 += e[2]
res = res1 + res2
return res
def relevancy_sort(self, res):
if os.getenv('RELEVANCY_SORT', 1) == 0:
return res
hint_file = None
try:
hint_file = self.rquery['hint_file']
except:
pass
if not hint_file:
return res
if not os.path.isabs(hint_file):
print 'BUG: relevancy_sort: not abs path:', hint_file
return res
if len(res) > 10000:
return res
return self._relevancy_sort(hint_file, res)
def emit_result(self, res):
res = self.relevancy_sort(res)
self.sig_result.emit(self.sym, res)
class PluginProcess(QObject):
proc_list = []
def __init__(self, wdir):
QObject.__init__(self)
PluginProcess.proc_list.append(self)
self.is_rebuild = False
self.sig = QuerySignal()
self.proc = QProcess()
self.proc.finished.connect(self._finished_cb)
self.proc.error.connect(self._error_cb)
self.proc.setWorkingDirectory(wdir)
self.wdir = wdir
def _cleanup(self):
PluginProcess.proc_list.remove(self)
if self.err_str != '':
s = '' + self.p_cmd + '' + '
'.join(self.err_str.splitlines())
QMessageBox.warning(None, "Seascope", s, QMessageBox.Ok)
if self.res != '':
s = '' + self.p_cmd + '
Summary
' + self.res
QMessageBox.information(None, "Seascope", s, QMessageBox.Ok)
def _error_cb(self, err):
err_dict = {
QProcess.FailedToStart: 'FailedToStart',
QProcess.Crashed: 'Crashed',
QProcess.Timedout: 'The last waitFor...() function timed out',
QProcess.WriteError: 'An error occurred when attempting to write to the process',
QProcess.ReadError: 'An error occurred when attempting to read from the process',
QProcess.UnknownError: 'An unknown error occurred',
}
self.err_str = '' + self.p_cmd + '
' + err_dict[err]
self._cleanup()
def _finished_cb(self, ret):
res = str(self.proc.readAllStandardOutput())
self.err_str = str(self.proc.readAllStandardError())
#print 'output', res
#print 'cmd:', self.p_cmd
if self.is_rebuild:
self.res = res
self.sig.sig_rebuild.emit()
else:
self.res = ''
self.sig.sig_result_dbg.emit(self.p_cmd, res, self.err_str)
try:
res = self.parse_result(res, self.sig)
except:
res = [['', '', '', 'error while parsing output of: ' + self.p_cmd]]
if res != None:
self.sig.emit_result(res)
self._cleanup()
def run_query_process(self, pargs, sym, rquery=None):
self.sig.sym = sym
self.sig.rquery = rquery
self.p_cmd = ' '.join(pargs)
if os.getenv('SEASCOPE_DEBUG'):
print self.p_cmd
self.proc.start(pargs[0], pargs[1:])
if self.proc.waitForStarted() == False:
return None
self.proc.closeWriteChannel()
return [self.sig.sig_result, self.sig.sig_result_dbg]
def run_rebuild_process(self, pargs):
self.is_rebuild = True
self.p_cmd = ' '.join(pargs)
self.proc.start(pargs[0], pargs[1:])
if self.proc.waitForStarted() == False:
return None
#print 'cmd:', pargs
import CtagsCache
self.sig.sig_rebuild.connect(CtagsCache.flush)
return self.sig.sig_rebuild
def parse_result(self, text, sig):
print 'parse_result not implemented'
if text == '':
text = ['Empty output']
else:
text = text.strip().split('\n')
return text
if __name__ == '__main__':
import sys
def slot_result(sym, res):
print 'slot_result: ', [str(sym), res]
sys.exit(0)
def slot_result_dbg(cmd, res, err_str):
print 'slot_result_dbg:', [str(cmd), str(res).strip().split('\n'), str(err_str)]
def slot_rebuild():
print 'slot_rebuild'
app = QCoreApplication(sys.argv)
qsig = PluginProcess('.').run_query_process(['ls'], 'ls')
#qsig = PluginProcess('/home/anil/prj/ss/lin').run_query_process(['cscope', '-q', '-k', '-L', '-d', '-0', 'vdso'], 'ls')
if qsig == None:
sys.exit(-1)
qsig[0].connect(slot_result)
qsig[1].connect(slot_result_dbg)
app.exec_()
seascope-0.7/src/backend/plugins/idutils/ 0000775 0023763 0023763 00000000000 12062273150 017146 5 ustar anil anil seascope-0.7/src/backend/plugins/idutils/ui/ 0000775 0023763 0023763 00000000000 12062273150 017563 5 ustar anil anil seascope-0.7/src/backend/plugins/idutils/ui/id_query.ui 0000664 0023763 0023763 00000007021 12062273150 021743 0 ustar anil anil
QueryDialog
Qt::ApplicationModal
0
0
357
171
Idutils Query
-
-
40
16777215
Type
-
false
-
Symbol
-
true
10
-
-
50
16777215
-
Substring
-
Case Insensitive
-
Qt::Horizontal
QDialogButtonBox::Cancel|QDialogButtonBox::Ok
qd_sym_inp
qd_substr_chkbox
qd_icase_chkbox
buttonBox
qd_cmd_inp
buttonBox
accepted()
QueryDialog
accept()
248
254
157
274
buttonBox
rejected()
QueryDialog
reject()
316
260
286
274
seascope-0.7/src/backend/plugins/idutils/__init__.py 0000664 0023763 0023763 00000001737 12062273150 021267 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import os
def name():
return 'idutils'
def is_your_prj(path):
f = os.path.join(path, 'ID')
return os.path.exists(f)
def project_class():
from IdutilsProject import ProjectIdutils
return ProjectIdutils
def description():
d = 'Preferred backend of seascope.\n'
d += 'Some advanced features of seascope are available only with this backend\n'
d += '\n'
d += 'It\'s really "idutils + ctags" backend.\n'
d += ' - idutils provides the indexing facility\n'
d += ' - ctags provides the language intelligence\n'
d += 'This backend combines both of these intelligently to provide superior source code browsing facility\n'
d += '\n'
d += 'A wide variety of languages are supported (ctags --list-languages)\n'
d += 'For example C, C++, Java, Python etc\n'
d += '\n'
d += 'If your source files are not being indexed by idutils then configure it using /usr/share/id-lang.map\n'
return d
priority = 800
seascope-0.7/src/backend/plugins/idutils/IdutilsProject.py 0000664 0023763 0023763 00000012721 12062273150 022467 0 ustar anil anil #!/usr/bin/python
# Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import sys, os, string, re
from PyQt4.QtCore import *
from ..PluginBase import ProjectBase, ConfigBase, QueryBase
from IdutilsProjectUi import QueryUiIdutils
class ConfigIdutils(ConfigBase):
def __init__(self):
ConfigBase.__init__(self)
self.id_dir = ''
self.id_opt = ''
self.id_list = []
def get_proj_name(self):
return os.path.split(self.id_dir)[1]
def get_proj_src_files(self):
return []
def proj_start(self):
id_args = string.join(self.id_opt)
def proj_open(self, proj_path):
self.id_dir = proj_path
self.proj_start()
def proj_update(self, proj_args):
self.proj_new(proj_args)
def proj_new(self, proj_args):
self.proj_args = proj_args
(self.id_dir, self.id_opt, self.id_list) = proj_args
self.proj_start()
def proj_close(self):
pass
def get_proj_conf(self):
return (self.id_dir, self.id_opt, self.id_list)
def is_ready(self):
return True
class ProjectIdutils(ProjectBase):
def __init__(self):
ProjectBase.__init__(self)
@staticmethod
def _prj_new_or_open(conf):
prj = ProjectIdutils()
prj.conf = conf
prj.qry = QueryIdutils(prj.conf)
prj.qryui = QueryUiIdutils(prj.qry)
return (prj)
@staticmethod
def prj_new():
from PyQt4.QtGui import QFileDialog
fdlg = QFileDialog(None, "Choose source code directory")
fdlg.setFileMode(QFileDialog.Directory);
#fdlg.setDirectory(self.pd_path_inp.text())
if fdlg.exec_():
d = fdlg.selectedFiles()[0];
d = str(d)
if not d:
return None
d = os.path.normpath(d)
if d == '' or not os.path.isabs(d):
return None
prj = ProjectIdutils.prj_open(d)
prj.qryui.do_rebuild()
return prj
return None
@staticmethod
def prj_open(proj_path):
conf = ConfigIdutils()
conf.proj_open(proj_path)
prj = ProjectIdutils._prj_new_or_open(conf)
return (prj)
def prj_close(self):
if (self.conf != None):
self.conf.proj_close()
self.conf = None
def prj_dir(self):
return self.conf.id_dir
def prj_name(self):
return self.conf.get_proj_name()
def prj_src_files(self):
return self.conf.get_proj_src_files()
def prj_is_open(self):
return self.conf != None
def prj_is_ready(self):
return self.conf.is_ready()
def prj_conf(self):
return self.conf.get_proj_conf()
def prj_update_conf(self, proj_args):
self.conf.proj_update(proj_args)
def prj_settings_trigger(self):
proj_args = self.prj_conf()
proj_args = QueryUiIdutils.prj_show_settings_ui(proj_args)
#if (proj_args == None):
#return False
#self.prj_update_conf(proj_args)
#return True
return False
from ..PluginBase import PluginProcess
from .. import PluginHelper
from ..CtagsCache import CtagsThread
class IdCtagsThread(CtagsThread):
def __init__(self, sig):
CtagsThread.__init__(self, sig)
def ctags_bsearch(self, ct, n):
m = CtagsThread.ctags_bsearch(self, ct, n)
return m
def parse_result(self, res, sig):
res = self._filter_res(res, sig)
return res
class IdProcess(PluginProcess):
def __init__(self, wdir, rq):
PluginProcess.__init__(self, wdir)
self.name = 'idutils process'
if rq == None:
rq = ['', '']
self.cmd_str = rq[0]
self.req = rq[1]
def parse_result(self, text, sig):
#from datetime import datetime
#t1 = datetime.now()
text = re.split('\r?\n', text)
#t2 = datetime.now()
#print 'parse-split', t2 - t1
if self.cmd_str == 'FIL':
res = [ ['', os.path.join(self.wdir, line), '', '' ] for line in text if line != '' ]
return res
res = []
for line in text:
if line == '':
continue
line = line.split(':', 2)
line = ['', os.path.join(self.wdir, line[0]), line[1], line[2]]
res.append(line)
#t3 = datetime.now()
#print 'parse-loop', t3 - t2
IdCtagsThread(sig).apply_fix(self.cmd_str, res, [''])
return None
class QueryIdutils(QueryBase):
def __init__(self, conf):
QueryBase.__init__(self)
self.conf = conf
self.id_file_list_update()
def query(self, rquery):
if (not self.conf):
#or not self.conf.is_ready()):
print "pm_query not is_ready"
return None
cmd_str = rquery['cmd']
req = rquery['req']
opt = rquery['opt']
if opt == None:
opt = []
pargs = ['lid', '-R', 'grep']
if cmd_str == 'FIL':
pargs = ['fnid', '-S', 'newline']
elif cmd_str == 'TXT':
pargs += ['-l']
elif 'substring' in opt:
#req = '.*' + req + '.*'
#pargs += ' -s'
pass
elif cmd_str in ['-->', '<--']:
pargs += ['-l']
pargs += [ '--', req ]
qsig = IdProcess(self.conf.id_dir, [cmd_str, req]).run_query_process(pargs, req, rquery)
return qsig
def rebuild(self):
if (not self.conf.is_ready()):
print "pm_query not is_ready"
return None
pargs = [ 'mkid', '-s' ]
qsig = IdProcess(self.conf.id_dir, None).run_rebuild_process(pargs)
qsig.connect(self.id_file_list_update)
return qsig
def id_file_list_update(self):
wdir = self.conf.id_dir
if not os.path.exists(os.path.join(wdir, 'ID')):
return
fl = []
try:
import subprocess
pargs = [ 'fnid', '-S', 'newline', '-f', 'ID' ]
proc = subprocess.Popen(pargs, stdin=subprocess.PIPE, stdout=subprocess.PIPE, cwd=wdir)
(out_data, err_data) = proc.communicate()
fl = []
for f in re.split('\r?\n', out_data.strip()):
if f == '':
continue
fl.append(os.path.join(wdir, f))
PluginHelper.file_view_update(fl)
except:
import sys
e = sys.exc_info()[1]
print ' '.join(pargs)
print e
def id_is_open(self):
return self.conf != None
def id_is_ready(self):
return self.conf.is_ready()
seascope-0.7/src/backend/plugins/idutils/IdutilsProjectUi.py 0000664 0023763 0023763 00000011620 12062273150 022762 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import os
import sys
import re
from PyQt4 import QtGui, QtCore, uic
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from ..PluginBase import ProjectBase, ConfigBase, QueryBase
from ..PluginBase import QueryUiBase
from .. import PluginBase, PluginHelper
cmd_table = [
[ ['REF', ''], ['&References', 'Ctrl+0'], ['References to' ] ],
[ ['DEF', ''], ['&Definitions', 'Ctrl+1'], ['Definition of' ] ],
#[ ['<--', '2'], ['&Called Functions', 'Ctrl+2'], ['Functions called by' ] ],
[ ['-->', '3'], ['C&alling Functions', 'Ctrl+3'], ['Functions calling' ] ],
#[ ['TXT', '4'], ['Find &Text', 'Ctrl+4'], ['Find text' ] ],
#[ ['GRP', ''], ['Find &Egrep', 'Ctrl+5'], ['Find egrep pattern' ] ],
[ ['FIL', ''], ['Find &File', 'Ctrl+7'], ['Find files' ] ],
[ ['INC', '8'], ['&Include/Import', 'Ctrl+8'], ['Find include/import' ] ],
[ ['---', None], [None ] ],
[ ['QDEF', ''], ['&Quick Definition', 'Ctrl+]'], [None ] ],
[ ['CTREE','12'], ['Call Tr&ee', 'Ctrl+\\'], ['Call tree' ] ],
[ ['---', None], [None ], ],
[ ['CLGRAPH', '13'], ['Class &Graph', 'Ctrl+:'], ['Class graph' ] ],
[ ['---', None], [None ], ],
[ ['UPD', '25'], ['Re&build Database', None ], [None ] ],
]
menu_cmd_list = [ [c[0][0]] + c[1] for c in cmd_table ]
cmd_str2id = {}
cmd_str2qstr = {}
cmd_qstr2str = {}
for c in cmd_table:
if c[0][1] != None:
cmd_str2id[c[0][0]] = c[0][1]
cmd_str2qstr[c[0][0]] = c[2][0]
cmd_qstr2str[c[2][0]] = c[0][0]
# python 2.7
#cmd_str2id = { c[0][0]:c[0][1] for c in cmd_table if c[0][1] != None }
#cmd_str2qstr = { c[0][0]:c[2][0] for c in cmd_table if c[0][1] != None }
#cmd_qstr2str = { c[2][0]:c[0][0] for c in cmd_table if c[0][1] != None }
cmd_qstrlist = [ c[2][0] for c in cmd_table if c[0][1] != None and c[2][0] != None ]
ctree_query_args = [
['-->', '--> F', 'Calling tree' ],
#['<--', 'F -->', 'Called tree' ],
['REF', '==> F', 'Advanced calling tree' ],
]
clgraph_query_args = [
['CLGRAPH', 'D', 'Derived classes' ],
['CLGRAPH', 'B', 'Base classes' ],
]
class QueryDialog(QDialog):
dlg = None
def __init__(self):
QDialog.__init__(self)
self.ui = uic.loadUi('backend/plugins/idutils/ui/id_query.ui', self)
self.qd_sym_inp.setAutoCompletion(False)
self.qd_sym_inp.setInsertPolicy(QComboBox.InsertAtTop)
self.qd_cmd_inp.addItems(cmd_qstrlist)
def run_dialog(self, cmd_str, req):
s = cmd_str2qstr[cmd_str]
inx = self.qd_cmd_inp.findText(s)
self.qd_cmd_inp.setCurrentIndex(inx)
if (req == None):
req = ''
self.qd_sym_inp.setFocus()
self.qd_sym_inp.setEditText(req)
self.qd_sym_inp.lineEdit().selectAll()
self.qd_substr_chkbox.setChecked(False)
self.qd_icase_chkbox.setChecked(False)
self.show()
if (self.exec_() == QDialog.Accepted):
req = str(self.qd_sym_inp.currentText())
s = str(self.qd_cmd_inp.currentText())
cmd_str = cmd_qstr2str[s]
#self.qd_sym_inp.addItem(req)
opt = []
if cmd_str != 'TXT' and req != '' and self.qd_substr_chkbox.isChecked():
opt.append('substring')
if cmd_str == 'FIL':
req = '*' + req + '*'
else:
req = '.*' + req + '.*'
if (self.qd_icase_chkbox.isChecked()):
opt.append('ignorecase')
res = (cmd_str, req, opt)
return res
return None
@staticmethod
def show_dlg(cmd_str, req):
if (QueryDialog.dlg == None):
QueryDialog.dlg = QueryDialog()
return QueryDialog.dlg.run_dialog(cmd_str, req)
def show_msg_dialog(msg):
QMessageBox.warning(None, "Seascope", msg, QMessageBox.Ok)
class QueryUiIdutils(QueryUiBase):
def __init__(self, qry):
self.menu_cmd_list = menu_cmd_list
QueryUiBase.__init__(self)
self.query = qry
self.ctree_args = ctree_query_args
self.clgraph_args = clgraph_query_args
def query_cb(self, cmd_str):
if (not self.query.id_is_open()):
return
if (not self.query.id_is_ready()):
show_msg_dialog('\nProject has no source files')
return
req = PluginHelper.editor_current_word()
if (req != None):
req = str(req).strip()
opt = None
if cmd_str not in [ 'QDEF' ]:
val = QueryDialog.show_dlg(cmd_str, req)
if (val == None):
return
(cmd_str, req, opt) = val
if (req == None or req == ''):
return
if cmd_str == 'QDEF':
self.query_qdef(req, opt)
elif cmd_str == 'CTREE':
self.query_ctree(req, opt)
elif cmd_str == 'CLGRAPH':
self.query_class_graph(req, opt)
else:
self.do_query(cmd_str, req, opt)
def prepare_menu(self):
QueryUiBase.prepare_menu(self)
menu = PluginHelper.backend_menu
menu.setTitle('&Idutils')
@staticmethod
def prj_show_settings_ui(proj_args):
dlg = ProjectSettingsIdutilsDialog()
return dlg.run_dialog(proj_args)
class ProjectSettingsIdutilsDialog(QDialog):
def __init__(self):
QDialog.__init__(self)
self.ui = uic.loadUi('ui/project_settings.ui', self)
def run_dialog(self, proj_args):
self.pi_path_lbl.setText(proj_args[0])
self.pi_type_lbl.setText('idutils')
self.exec_()
return proj_args
seascope-0.7/src/backend/__init__.py 0000664 0023763 0023763 00000006474 12062273150 016134 0 ustar anil anil # Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import os
import sys
import re
from PyQt4 import QtGui, QtCore, uic
from PyQt4.QtGui import *
from PyQt4.QtCore import *
import DialogManager
from plugins import PluginHelper
backend_plugins = []
backend_dict = {}
def _load_plugins(module, directory):
pluginImports = __import__(module, globals(), locals())
print 'Scanning for backend plugins...'
plist = []
pdict = {}
for i in sorted(os.listdir(directory)):
path = os.path.join( directory, i, '__init__.py' )
if os.path.isfile( path ):
p = __import__( '%s.%s' % (module, i), globals(), locals(), ['*'] )
plist.append(p)
pdict[p.name()] = p
if not hasattr(p, 'priority'):
p.priority = 0
plist = sorted(plist, key=lambda p: p.priority, reverse=True)
for p in plist:
print '\t', p.name()
return (plist, pdict)
def load_plugins():
global backend_plugins, backend_dict
(backend_plugins, backend_dict) = _load_plugins('backend.plugins', 'backend/plugins')
from plugins.PluginBase import ProjectBase, ConfigBase, QueryBase, QueryUiBase
prj_actions = []
prj = None
def _proj_new_open():
for act in prj_actions:
act.setEnabled(True)
class ProjectNewDialog(QDialog):
def __init__(self):
QDialog.__init__(self)
self.ui = uic.loadUi('ui/proj_new.ui', self)
self.backend_lw.currentRowChanged.connect(self.currentRowChanged_cb)
def currentRowChanged_cb(self, row):
if row == -1:
return
bname = str(self.backend_lw.currentItem().text())
b = backend_dict[bname]
try:
self.descr_te.setText(b.description())
except:
self.descr_te.setText('')
def run_dialog(self):
bi = [ b.name() for b in backend_plugins]
self.backend_lw.addItems(bi)
self.backend_lw.setCurrentRow(0)
if self.exec_() == QDialog.Accepted:
bname = str(self.backend_lw.currentItem().text())
return (backend_dict[bname])
return None
def msg_box(msg):
QMessageBox.warning(None, "Seascope", msg, QMessageBox.Ok)
def proj_new():
if len(backend_plugins) == 0:
msg_box('No backends are available/usable')
dlg = ProjectNewDialog()
b = dlg.run_dialog()
if b == None:
return
global prj
assert not prj
prj = b.project_class().prj_new()
if prj:
_proj_new_open()
return prj != None
def proj_open(proj_path):
be = []
for p in backend_plugins:
if p.is_your_prj(proj_path):
be.append(p)
if len(be) == 0:
msg = "Project '%s': No backend is interested" % proj_path
msg_box(msg)
return
if len(be) > 1:
msg = "Project '%s': Many backends interested" % proj_path
for b in be:
msg += '\n\t' + b.name()
msg += '\n\nGoing ahead with: ' + be[0].name()
msg_box(msg)
b = be[0]
print "Project '%s': using '%s' backend" % (proj_path, b.name())
global prj
prj = b.project_class().prj_open(proj_path)
if prj:
_proj_new_open()
return prj != None
def proj_close():
global prj
prj.prj_close()
prj = None
PluginHelper.backend_menu.clear()
PluginHelper.backend_menu.setTitle('')
for act in prj_actions:
act.setEnabled(False)
from plugins import CtagsCache
CtagsCache.flush()
def proj_is_open():
return prj != None
def proj_name():
return prj.prj_name() if prj else None
def proj_dir():
return prj.prj_dir() if prj else None
def proj_src_files():
return prj.prj_src_files()
def proj_conf():
return prj.prj_conf()
def proj_settings_trigger():
return prj.prj_settings_trigger() seascope-0.7/src/DialogManager.py 0000664 0023763 0023763 00000016461 12062273150 015475 0 ustar anil anil #!/usr/bin/env python
# Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import sys
import os
import string
from PyQt4 import QtGui, QtCore, uic
from PyQt4.QtGui import *
from PyQt4.QtCore import *
def show_msg_dialog(msg):
QMessageBox.information(None, "Seascope", msg, QMessageBox.Ok)
def show_yes_no(msg):
ret = QMessageBox.question(None, "Seascope", msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
return ret == QMessageBox.Yes
def show_yes_no_dontask(msg):
return QMessageBox.question(None, "Seascope", msg, "Yes", "No", "Yes, Don't ask again")
def show_proj_close():
return show_yes_no("\nClose current project?")
class ProjectOpenDialog(QObject):
def __init__(self):
QObject.__init__(self)
self.dlg = uic.loadUi('ui/proj_open.ui')
self.dlg.pod_open_btn.setIcon(QFileIconProvider().icon(QFileIconProvider.Folder))
QObject.connect(self.dlg.pod_open_btn, SIGNAL("clicked()"), self.open_btn_cb)
QObject.connect(self.dlg, SIGNAL("accepted()"), self.ok_btn_cb)
QObject.connect(self.dlg.pod_proj_list, SIGNAL("itemSelectionChanged()"), self.proj_list_change_cb)
def proj_list_change_cb(self):
item = self.dlg.pod_proj_list.selectedItems()[0]
proj_dir = str(item.text())
self.dlg.pod_proj_name.setText(str(proj_dir))
self.path = proj_dir
def open_btn_cb(self):
fdlg = QFileDialog(None, "Choose project directory")
fdlg.setFileMode(QFileDialog.Directory);
fdlg.setDirectory(self.dlg.pod_proj_name.text())
if (fdlg.exec_()):
proj_dir = fdlg.selectedFiles()[0];
self.dlg.pod_proj_name.setText(str(proj_dir))
def ok_btn_cb(self):
p = str(self.dlg.pod_proj_name.text()).strip()
if (p == ''):
self.dlg.setResult(2)
return
p = os.path.normpath(p)
if (not os.path.isabs(p)):
show_msg_dialog("\nProject path is not absolute")
self.dlg.setResult(2)
return
if (not os.path.isdir(p)):
show_msg_dialog("\nProject path is not a directory")
self.dlg.setResult(2)
return
self.path = p
def run_dialog(self, path_list):
self.path = None
self.dlg.pod_proj_name.setText('')
self.dlg.pod_proj_list.addItems(path_list)
while True:
ret = self.dlg.exec_()
if (ret == QDialog.Accepted or ret == QDialog.Rejected):
break
return self.path
def show_project_open_dialog(path_list):
d = ProjectOpenDialog()
return d.run_dialog(path_list)
class FilePreferencesDialog(QObject):
def __init__(self, app_style, edit_ext_cmd, ev_font, dontask, innered, ln_nr):
QObject.__init__(self)
self.dlg = uic.loadUi('ui/preferences.ui')
self.dlg.prd_style_lw.addItems(QStyleFactory.keys())
self.dlg.prd_style_lw.itemSelectionChanged.connect(self.style_changed_cb)
self.dlg.prd_font_app_btn.clicked.connect(self.font_app_btn_cb)
self.dlg.prd_font_ev_btn.clicked.connect(self.font_ev_btn_cb)
self.set_btn_text_and_font(self.dlg.prd_font_app_btn, QApplication.font())
self.set_btn_text_and_font(self.dlg.prd_font_ev_btn, ev_font)
self.app_style = app_style
self.ev_font = ev_font
self.edit_ext_cmd = edit_ext_cmd
self.exit_dontask = dontask
self.inner_editing = innered
self.show_ln_nr = ln_nr
if self.exit_dontask:
self.dlg.prd_opt_ask_chkb.setCheckState(Qt.Unchecked)
else:
self.dlg.prd_opt_ask_chkb.setCheckState(Qt.Checked)
if self.inner_editing:
self.dlg.prd_opt_inner_ed.setCheckState(Qt.Checked)
else:
self.dlg.prd_opt_inner_ed.setCheckState(Qt.Unchecked)
if self.show_ln_nr:
self.dlg.prd_opt_show_ln_nr.setCheckState(Qt.Checked)
else:
self.dlg.prd_opt_show_ln_nr.setCheckState(Qt.Unchecked)
if (self.edit_ext_cmd):
self.dlg.prd_edit_ext_inp.setText(self.edit_ext_cmd)
def set_btn_text_and_font(self, btn, font):
ftext = font.family() + ' ' + str(font.pointSize())
btn.setFont(font)
btn.setText(ftext)
def style_changed_cb(self):
item = self.dlg.prd_style_lw.currentItem()
self.app_style = item.text()
QApplication.setStyle(self.app_style)
def font_app_btn_cb(self):
(font, ok) = QFontDialog().getFont(QApplication.font())
if (ok):
self.set_btn_text_and_font(self.dlg.prd_font_app_btn, font)
def font_ev_btn_cb(self):
(font, ok) = QFontDialog().getFont(self.ev_font)
if (ok):
self.set_btn_text_and_font(self.dlg.prd_font_ev_btn, font)
def run_dialog(self):
ret = self.dlg.exec_()
if (ret == QDialog.Accepted):
QApplication.setFont(self.dlg.prd_font_app_btn.font())
self.ev_font = self.dlg.prd_font_ev_btn.font()
self.edit_ext_cmd = self.dlg.prd_edit_ext_inp.text()
self.exit_dontask = self.dlg.prd_opt_ask_chkb.checkState() == Qt.Unchecked
self.inner_editing = self.dlg.prd_opt_inner_ed.checkState() == Qt.Checked
self.show_ln_nr = self.dlg.prd_opt_show_ln_nr.checkState() == Qt.Checked
return (self.app_style, self.dlg.prd_font_app_btn.font().toString(), self.edit_ext_cmd,
self.ev_font, self.exit_dontask, self.inner_editing, self.show_ln_nr)
def show_preferences_dialog(app_style, edit_ext_cmd, ev_font, dontask, innered, ln_nr):
d = FilePreferencesDialog(app_style, edit_ext_cmd, ev_font, dontask, innered, ln_nr)
return d.run_dialog()
def show_about_dialog():
d = uic.loadUi('ui/about.ui')
p = QApplication.windowIcon().pixmap(128)
d.ad_logo_lbl.setPixmap(p)
d.exec_()
def show_goto_line_dialog(line, max_line):
d = uic.loadUi('ui/goto_line.ui')
d.gl_spinbox.setMaximum(max_line)
d.gl_hslider.setMaximum(max_line)
d.gl_spinbox.setValue(line)
d.gl_spinbox.lineEdit().selectAll()
if (d.exec_() == QDialog.Accepted):
return d.gl_spinbox.value()
return None
class FindDialog:
dlg = None
def __init__(self):
self.dlg = uic.loadUi('ui/find.ui')
self.dlg.ft_text_inp.setAutoCompletion(False)
self.dlg.ft_text_inp.setInsertPolicy(QComboBox.InsertAtTop)
def run_dlg(self, text):
if (text == None):
text = ''
d = self.dlg
d.ft_text_inp.lineEdit().setText(text)
d.ft_text_inp.lineEdit().selectAll()
d.ft_text_inp.lineEdit().setFocus()
d.ft_from_cursor.setChecked(True)
while True:
ret = d.exec_()
if (ret != QDialog.Accepted):
return None
text = d.ft_text_inp.currentText()
text = str(text).strip()
if (text != ''):
break
opt = {
'cs' : d.ft_cs.isChecked(),
're' : d.ft_re.isChecked(),
'wo' : d.ft_wo.isChecked(),
'fw' : not d.ft_bw.isChecked(),
'cursor' : d.ft_from_cursor.isChecked(),
}
return (text, opt)
def show_find_dialog(text):
if (FindDialog.dlg == None):
FindDialog.dlg = FindDialog()
return FindDialog.dlg.run_dlg(text)
class FilterDialog:
def __init__(self, cmd_items, cmd_sel):
self.dlg = uic.loadUi('ui/filter.ui')
self.dlg.fd_cmd_inp.addItems(cmd_items)
self.dlg.fd_cmd_inp.setCurrentIndex(cmd_items.index(cmd_sel))
self.dlg.fd_regex_err_lbl.setVisible(False)
def run_dialog(self):
while True:
ret = self.dlg.exec_()
if ret != QDialog.Accepted:
return None
is_regex = self.dlg.fd_regex_chkbox.isChecked()
text = str(self.dlg.fd_filter_inp.text())
if is_regex == True:
try:
import re
re.compile(text)
except:
e = str(sys.exc_info()[1])
lbl = self.dlg.fd_regex_err_lbl
lbl.setVisible(True)
lbl.setText("regex: " + e + '')
continue
res = [
text,
is_regex,
self.dlg.fd_negate_chkbox.isChecked(),
self.dlg.fd_icase_chkbox.isChecked(),
str(self.dlg.fd_cmd_inp.currentText())
]
return res
def show_filter_dialog(cmd_items, cmd_sel):
dlg = FilterDialog(cmd_items,cmd_sel)
return dlg.run_dialog()
seascope-0.7/src/tools/ 0000775 0023763 0023763 00000000000 12062273150 013561 5 ustar anil anil seascope-0.7/src/tools/ClassGraph.py 0000664 0023763 0023763 00000011515 12062273150 016165 0 ustar anil anil #!/usr/bin/env python
# Copyright (c) 2010 Anil Kumar
# All rights reserved.
#
# License: BSD
import sys
import subprocess
import os
import re
class ClassGraphGenerator:
def __init__(self, d, wlimit=5000, is_base=False):
self.wdir = d;
self.width_limit = wlimit;
self.graphRules = []
self.visitedRules = {}
self.visitedSym = {}
if is_base:
self.visitedSym = {'object' : 1}
self.is_base = is_base
def addGraphRule(self, sym, d):
if (sym, d) in self.visitedRules:
return
self.visitedRules[(sym, d)] = 1
self.graphRules.append([sym, d])
def refFiles(self, sym):
args = ['lid', '-R', 'grep', sym]
try:
# In python >= 2.7 can use subprocess.check_output
# output = subprocess.check_output(args, cwd=self.wdir)
proc = subprocess.Popen(args, cwd=self.wdir, stdout=subprocess.PIPE)
(output, err_data) = proc.communicate()
output = re.split('\r?\n', output)
except Exception as e:
print >> sys.stderr, e, '\n'
print >> sys.stderr, 'Run this script from a directory where lid can find ID file\n'
sys.exit(-1)
res = set()
for line in output:
if line == '':
continue
f = line.split(':', 1)[0]
f = os.path.normpath(os.path.join(self.wdir, f))
res.add(f)
return res
def runCtags(self, fl):
cmd = 'ctags -n -u --fields=+i -L - -f -'
args = cmd.split()
proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
(out_data, err_data) = proc.communicate('\n'.join(fl))
out_data = re.split('\r?\n', out_data)
return out_data
def classHierarchy(self, sym):
fl = self.refFiles(sym)
data = self.runCtags(fl)
res = []
for line in data:
if line == '':
continue
line = line.split('\t', 4)
if len(line) == 4:
continue
sd = dict([ x.split(':', 1) for x in line[4].split('\t')])
if 'inherits' not in sd:
continue
sd = sd['inherits']
if sd == '':
continue
sd = sd.split(',')
dd = [ re.split('::|\.', x.strip())[-1] for x in sd ]
if self.is_base:
if sym == line[0]:
res += dd
else:
if sym in dd:
res.append(line[0])
return res
def classHierarchyRecursive(self, symList):
for sym in symList:
if sym in self.visitedSym:
return
self.visitedSym[sym] = 1
dclasses = self.classHierarchy(sym)
if len(dclasses):
if len(dclasses) > self.width_limit:
if is_base:
s = 'base'
else:
s= 'derived'
print >> sys.stderr, 'num %s classes(%s) = %d, truncating to %d.\n' % (s, sym, len(dclasses), self.width_limit)
dclasses = dclasses[0:self.width_limit]
self.addGraphRule(sym, '...(%s)' % sym)
for d in dclasses:
self.addGraphRule(sym, d)
self.classHierarchyRecursive(dclasses)
def prepareDotInput(self, sym):
if len(self.graphRules) == 0:
if is_base:
s = 'base'
else:
s= 'derived'
print >> sys.stderr, 'No %s classes for %s\n' % (s, sym)
sys.exit(0)
dotInput = 'digraph "%s" {\n' % sym
dotInput += '\t"%s" [style=bold];\n' % sym
for r in self.graphRules:
if not self.is_base:
dotInput += '\t"%s" -> "%s";\n' % (r[0], r[1])
else:
dotInput += '\t"%s" -> "%s";\n' % (r[1], r[0])
dotInput += '}\n'
return dotInput
def saveDotFile(self, sym, dotInput):
f = open(sym + '.dot', 'w')
f.write(dotInput)
f.close()
def saveSvgFile(sym, svg_data):
dot_svg = sym + '.svg'
f = open(dot_svg, 'w')
f.write(svg_data)
f.close()
print >> sys.stderr, 'saved', dot_svg, '\n'
def generateGraph(self, sym):
self.classHierarchyRecursive([sym])
dotInput = self.prepareDotInput(sym)
#self.saveDotFile(sym, dotInput)
args = ['dot', '-Tsvg']
try:
p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
(svg_data, err_data) = p.communicate(dotInput)
if err_data and err_data != '':
print >> sys.stderr, err_data, '\n'
#self.saveSvgFile(sym, svg_data)
return svg_data
except Exception as e:
print >> sys.stderr, 'Failed to run:', ' '.join(args), '\n'
print >> sys.stderr, e, '\n'
if __name__ == '__main__':
import optparse
usage = "usage: %prog [options] symbol"
op = optparse.OptionParser(usage=usage)
op.add_option("-p", "--project", dest="id_path", help="Idutils project dir", metavar="PROJECT")
op.add_option("-b", action="store_true", dest="is_base", help="Show base classes")
(options, args) = op.parse_args()
# id utils project dir
if not options.id_path:
print >> sys.stderr, 'idutils project path required'
sys.exit(-1)
id_path = os.path.normpath(options.id_path)
if not os.path.exists(os.path.join(id_path, 'ID')):
print >> sys.stderr, 'idutils project path does not exist'
sys.exit(-2)
is_base = False
if options.is_base:
is_base = True
# symbol
if len(args) != 1:
print >> sys.stderr, 'Please specify a symbol'
sys.exit(-3)
sym = args[0]
#print options.id_path, args
cgg = ClassGraphGenerator(id_path, is_base=is_base)
svg_data = cgg.generateGraph(sym)
print svg_data