Added the ActiveGrid IDE as a sample application
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@33440 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
896
wxPython/samples/ide/activegrid/tool/checker.py
Normal file
896
wxPython/samples/ide/activegrid/tool/checker.py
Normal file
@@ -0,0 +1,896 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
# Copyright (c) 2001-2004, MetaSlash Inc. All rights reserved.
|
||||
|
||||
"""
|
||||
Copyright notice from pychecker:
|
||||
|
||||
Copyright (c) 2000-2001, MetaSlash Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
- Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
- 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.
|
||||
|
||||
- Neither name of MetaSlash Inc. nor the names of contributors
|
||||
may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
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 THE REGENTS OR
|
||||
CONTRIBUTORS 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.
|
||||
"""
|
||||
|
||||
|
||||
"""
|
||||
Check python source code files for possible errors and print warnings
|
||||
|
||||
Contact Info:
|
||||
http://pychecker.sourceforge.net/
|
||||
pychecker-list@lists.sourceforge.net
|
||||
"""
|
||||
|
||||
import string
|
||||
import types
|
||||
import sys
|
||||
import imp
|
||||
import os
|
||||
import glob
|
||||
import traceback
|
||||
import re
|
||||
import wx
|
||||
_ = wx.GetTranslation
|
||||
|
||||
# see __init__.py for meaning, this must match the version there
|
||||
LOCAL_MAIN_VERSION = 1
|
||||
|
||||
|
||||
def setupNamespace(path) :
|
||||
# remove pychecker if it's the first component, it needs to be last
|
||||
if sys.path[0][-9:] == 'pychecker' :
|
||||
del sys.path[0]
|
||||
|
||||
# make sure pychecker is last in path, so we can import
|
||||
checker_path = os.path.dirname(os.path.dirname(path))
|
||||
if checker_path not in sys.path :
|
||||
sys.path.append(checker_path)
|
||||
|
||||
if __name__ == '__main__' :
|
||||
setupNamespace(sys.argv[0])
|
||||
|
||||
from pychecker import utils
|
||||
from pychecker import printer
|
||||
from pychecker import warn
|
||||
from pychecker import OP
|
||||
from pychecker import Config
|
||||
from pychecker import function
|
||||
from pychecker.Warning import Warning
|
||||
|
||||
# Globals for storing a dictionary of info about modules and classes
|
||||
_allModules = {}
|
||||
_cfg = None
|
||||
|
||||
# Constants
|
||||
_DEFAULT_MODULE_TOKENS = ('__builtins__', '__doc__', '__file__', '__name__',
|
||||
'__path__')
|
||||
_DEFAULT_CLASS_TOKENS = ('__doc__', '__name__', '__module__')
|
||||
|
||||
_VERSION_MISMATCH_ERROR = '''
|
||||
There seem to be two versions of PyChecker being used.
|
||||
One is probably in python/site-packages, the other in a local directory.
|
||||
If you want to run the local version, you must remove the version
|
||||
from site-packages. Or you can install the current version
|
||||
by doing python setup.py install.
|
||||
'''
|
||||
|
||||
def cfg() :
|
||||
return utils.cfg()
|
||||
|
||||
def _flattenList(list) :
|
||||
"Returns a list which contains no lists"
|
||||
|
||||
new_list = []
|
||||
for element in list :
|
||||
if type(element) == types.ListType :
|
||||
new_list.extend(_flattenList(element))
|
||||
else :
|
||||
new_list.append(element)
|
||||
|
||||
return new_list
|
||||
|
||||
def getModules(arg_list) :
|
||||
"Returns a list of module names that can be imported"
|
||||
|
||||
global _output
|
||||
|
||||
new_arguments = []
|
||||
for arg in arg_list :
|
||||
# is this a wildcard filespec? (necessary for windows)
|
||||
if '*' in arg or '?' in arg or '[' in arg :
|
||||
arg = glob.glob(arg)
|
||||
new_arguments.append(arg)
|
||||
|
||||
PY_SUFFIXES = ['.py']
|
||||
PY_SUFFIX_LENS = [3]
|
||||
if _cfg.quixote:
|
||||
PY_SUFFIXES.append('.ptl')
|
||||
PY_SUFFIX_LENS.append(4)
|
||||
|
||||
modules = []
|
||||
for arg in _flattenList(new_arguments) :
|
||||
fullpath = arg
|
||||
# is it a .py file?
|
||||
for suf, suflen in zip(PY_SUFFIXES, PY_SUFFIX_LENS):
|
||||
if len(arg) > suflen and arg[-suflen:] == suf:
|
||||
arg_dir = os.path.dirname(arg)
|
||||
if arg_dir and not os.path.exists(arg) :
|
||||
txt = _('File or pathname element does not exist: "%s"') % arg
|
||||
_output.AddLines(txt)
|
||||
continue
|
||||
|
||||
module_name = os.path.basename(arg)[:-suflen]
|
||||
if arg_dir not in sys.path :
|
||||
sys.path.insert(0, arg_dir)
|
||||
arg = module_name
|
||||
modules.append((arg, fullpath))
|
||||
|
||||
return modules
|
||||
|
||||
def _q_file(f):
|
||||
# crude hack!!!
|
||||
# imp.load_module requires a real file object, so we can't just
|
||||
# fiddle def lines and yield them
|
||||
import tempfile
|
||||
fd, newfname = tempfile.mkstemp(suffix=".py", text=True)
|
||||
newf = os.fdopen(fd, 'r+')
|
||||
os.unlink(newfname)
|
||||
for line in f:
|
||||
mat = re.match(r'(\s*def\s+\w+\s*)\[(html|plain)\](.*)', line)
|
||||
if mat is None:
|
||||
newf.write(line)
|
||||
else:
|
||||
newf.write(mat.group(1)+mat.group(3)+'\n')
|
||||
newf.seek(0)
|
||||
return newf
|
||||
|
||||
def _q_find_module(p, path):
|
||||
if not _cfg.quixote:
|
||||
return imp.find_module(p, path)
|
||||
else:
|
||||
for direc in path:
|
||||
try:
|
||||
return imp.find_module(p, [direc])
|
||||
except ImportError:
|
||||
f = os.path.join(direc, p+".ptl")
|
||||
if os.path.exists(f):
|
||||
return _q_file(file(f)), f, ('.ptl', 'U', 1)
|
||||
|
||||
def _findModule(name) :
|
||||
"""Returns the result of an imp.find_module(), ie, (file, filename, smt)
|
||||
name can be a module or a package name. It is *not* a filename."""
|
||||
|
||||
path = sys.path[:]
|
||||
packages = string.split(name, '.')
|
||||
for p in packages :
|
||||
# smt = (suffix, mode, type)
|
||||
file, filename, smt = _q_find_module(p, path)
|
||||
if smt[-1] == imp.PKG_DIRECTORY :
|
||||
try :
|
||||
# package found - read path info from init file
|
||||
m = imp.load_module(p, file, filename, smt)
|
||||
finally :
|
||||
if file is not None :
|
||||
file.close()
|
||||
|
||||
# importing xml plays a trick, which replaces itself with _xmlplus
|
||||
# both have subdirs w/same name, but different modules in them
|
||||
# we need to choose the real (replaced) version
|
||||
if m.__name__ != p :
|
||||
try :
|
||||
file, filename, smt = _q_find_module(m.__name__, path)
|
||||
m = imp.load_module(p, file, filename, smt)
|
||||
finally :
|
||||
if file is not None :
|
||||
file.close()
|
||||
|
||||
new_path = m.__path__
|
||||
if type(new_path) == types.ListType :
|
||||
new_path = filename
|
||||
if new_path not in path :
|
||||
path.insert(1, new_path)
|
||||
elif smt[-1] != imp.PY_COMPILED:
|
||||
if p is not packages[-1] :
|
||||
if file is not None :
|
||||
file.close()
|
||||
raise ImportError, "No module named %s" % packages[-1]
|
||||
return file, filename, smt
|
||||
|
||||
# in case we have been given a package to check
|
||||
return file, filename, smt
|
||||
|
||||
|
||||
class Variable :
|
||||
"Class to hold all information about a variable"
|
||||
|
||||
def __init__(self, name, type):
|
||||
self.name = name
|
||||
self.type = type
|
||||
self.value = None
|
||||
|
||||
def __str__(self) :
|
||||
return self.name
|
||||
|
||||
__repr__ = utils.std_repr
|
||||
|
||||
|
||||
def _filterDir(object, ignoreList) :
|
||||
"Return a list of tokens (attributes) in a class, except for ignoreList"
|
||||
|
||||
tokens = dir(object)
|
||||
for token in ignoreList :
|
||||
if token in tokens :
|
||||
tokens.remove(token)
|
||||
return tokens
|
||||
|
||||
def _getClassTokens(c) :
|
||||
return _filterDir(c, _DEFAULT_CLASS_TOKENS)
|
||||
|
||||
|
||||
class Class :
|
||||
"Class to hold all information about a class"
|
||||
|
||||
def __init__(self, name, module) :
|
||||
self.name = name
|
||||
self.classObject = getattr(module, name)
|
||||
|
||||
modname = getattr(self.classObject, '__module__', None)
|
||||
if modname is None:
|
||||
# hm, some ExtensionClasses don't have a __module__ attribute
|
||||
# so try parsing the type output
|
||||
typerepr = repr(type(self.classObject))
|
||||
mo = re.match("^<type ['\"](.+)['\"]>$", typerepr)
|
||||
if mo:
|
||||
modname = ".".join(mo.group(1).split(".")[:-1])
|
||||
|
||||
self.module = sys.modules.get(modname)
|
||||
if not self.module:
|
||||
self.module = module
|
||||
|
||||
global _output
|
||||
txt = _("warning: couldn't find real module for class %s (module name: %s)\n") % (self.classObject, modname)
|
||||
_output.AddLines(txt)
|
||||
|
||||
self.ignoreAttrs = 0
|
||||
self.methods = {}
|
||||
self.members = { '__class__': types.ClassType,
|
||||
'__doc__': types.StringType,
|
||||
'__dict__': types.DictType, }
|
||||
self.memberRefs = {}
|
||||
self.statics = {}
|
||||
self.lineNums = {}
|
||||
|
||||
def __str__(self) :
|
||||
return self.name
|
||||
|
||||
__repr__ = utils.std_repr
|
||||
|
||||
def getFirstLine(self) :
|
||||
"Return first line we can find in THIS class, not any base classes"
|
||||
|
||||
lineNums = []
|
||||
classDir = dir(self.classObject)
|
||||
for m in self.methods.values() :
|
||||
if m != None and m.function.func_code.co_name in classDir:
|
||||
lineNums.append(m.function.func_code.co_firstlineno)
|
||||
if lineNums :
|
||||
return min(lineNums)
|
||||
return 0
|
||||
|
||||
|
||||
def allBaseClasses(self, c = None) :
|
||||
"Return a list of all base classes for this class and it's subclasses"
|
||||
|
||||
baseClasses = []
|
||||
if c == None :
|
||||
c = self.classObject
|
||||
for base in c.__bases__ :
|
||||
baseClasses = baseClasses + [ base ] + self.allBaseClasses(base)
|
||||
return baseClasses
|
||||
|
||||
def __getMethodName(self, func_name, className = None) :
|
||||
if func_name[0:2] == '__' and func_name[-2:] != '__' :
|
||||
if className == None :
|
||||
className = self.name
|
||||
if className[0] != '_' :
|
||||
className = '_' + className
|
||||
func_name = className + func_name
|
||||
return func_name
|
||||
|
||||
def addMethod(self, method, methodName = None) :
|
||||
if type(method) == types.StringType :
|
||||
self.methods[method] = None
|
||||
else :
|
||||
assert methodName is not None, "must supply methodName"
|
||||
self.methods[methodName] = function.Function(method, 1)
|
||||
|
||||
def addMethods(self, classObject) :
|
||||
for classToken in _getClassTokens(classObject) :
|
||||
token = getattr(classObject, classToken, None)
|
||||
if token is None:
|
||||
continue
|
||||
|
||||
# Looks like a method. Need to code it this way to
|
||||
# accommodate ExtensionClass and Python 2.2. Yecchh.
|
||||
if (hasattr(token, "func_code") and
|
||||
hasattr(token.func_code, "co_argcount")):
|
||||
self.addMethod(token, token.__name__)
|
||||
|
||||
elif hasattr(token, '__get__') and \
|
||||
not hasattr(token, '__set__') and \
|
||||
type(token) is not types.ClassType :
|
||||
self.addMethod(getattr(token, '__name__', classToken))
|
||||
else :
|
||||
self.members[classToken] = type(token)
|
||||
self.memberRefs[classToken] = None
|
||||
|
||||
self.cleanupMemberRefs()
|
||||
# add standard methods
|
||||
for methodName in ('__class__',) :
|
||||
self.addMethod(methodName, classObject.__name__)
|
||||
|
||||
def addMembers(self, classObject) :
|
||||
if not cfg().onlyCheckInitForMembers :
|
||||
for classToken in _getClassTokens(classObject) :
|
||||
method = getattr(classObject, classToken, None)
|
||||
if type(method) == types.MethodType :
|
||||
self.addMembersFromMethod(method.im_func)
|
||||
else:
|
||||
try:
|
||||
self.addMembersFromMethod(classObject.__init__.im_func)
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
def addMembersFromMethod(self, method) :
|
||||
if not hasattr(method, 'func_code') :
|
||||
return
|
||||
|
||||
func_code, code, i, maxCode, extended_arg = OP.initFuncCode(method)
|
||||
stack = []
|
||||
while i < maxCode :
|
||||
op, oparg, i, extended_arg = OP.getInfo(code, i, extended_arg)
|
||||
if op >= OP.HAVE_ARGUMENT :
|
||||
operand = OP.getOperand(op, func_code, oparg)
|
||||
if OP.LOAD_CONST(op) or OP.LOAD_FAST(op) :
|
||||
stack.append(operand)
|
||||
elif OP.STORE_ATTR(op) :
|
||||
if len(stack) > 0 :
|
||||
if stack[-1] == cfg().methodArgName:
|
||||
value = None
|
||||
if len(stack) > 1 :
|
||||
value = type(stack[-2])
|
||||
self.members[operand] = value
|
||||
self.memberRefs[operand] = None
|
||||
stack = []
|
||||
|
||||
self.cleanupMemberRefs()
|
||||
|
||||
def cleanupMemberRefs(self) :
|
||||
try :
|
||||
del self.memberRefs[Config.CHECKER_VAR]
|
||||
except KeyError :
|
||||
pass
|
||||
|
||||
def abstractMethod(self, m):
|
||||
"""Return 1 if method is abstract, None if not
|
||||
An abstract method always raises an exception.
|
||||
"""
|
||||
if not self.methods.get(m, None):
|
||||
return None
|
||||
func_code, bytes, i, maxCode, extended_arg = \
|
||||
OP.initFuncCode(self.methods[m].function)
|
||||
# abstract if the first conditional is RAISE_VARARGS
|
||||
while i < maxCode:
|
||||
op, oparg, i, extended_arg = OP.getInfo(bytes, i, extended_arg)
|
||||
if OP.RAISE_VARARGS(op):
|
||||
return 1
|
||||
if OP.conditional(op):
|
||||
break
|
||||
return None
|
||||
|
||||
def isAbstract(self):
|
||||
"""Return the method names that make a class abstract.
|
||||
An abstract class has at least one abstract method."""
|
||||
result = []
|
||||
for m in self.methods.keys():
|
||||
if self.abstractMethod(m):
|
||||
result.append(m)
|
||||
return result
|
||||
|
||||
def _getLineInFile(moduleName, linenum):
|
||||
line = ''
|
||||
file, filename, smt = _findModule(moduleName)
|
||||
try:
|
||||
lines = file.readlines()
|
||||
line = string.rstrip(lines[linenum - 1])
|
||||
except (IOError, IndexError):
|
||||
pass
|
||||
file.close()
|
||||
return line
|
||||
|
||||
def importError(moduleName):
|
||||
exc_type, exc_value, tb = sys.exc_info()
|
||||
|
||||
# First, try to get a nice-looking name for this exception type.
|
||||
exc_name = getattr(exc_type, '__name__', None)
|
||||
if not exc_name:
|
||||
# either it's a string exception or a user-defined exception class
|
||||
# show string or fully-qualified class name
|
||||
exc_name = str(exc_type)
|
||||
|
||||
# Print a traceback, unless this is an ImportError. ImportError is
|
||||
# presumably the most common import-time exception, so this saves
|
||||
# the clutter of a traceback most of the time. Also, the locus of
|
||||
# the error is usually irrelevant for ImportError, so the lack of
|
||||
# traceback shouldn't be a problem.
|
||||
if exc_type is SyntaxError:
|
||||
# SyntaxErrors are special, we want to control how we format
|
||||
# the output and make it consistent for all versions of Python
|
||||
e = exc_value
|
||||
msg = '%s (%s, line %d)' % (e.msg, e.filename, e.lineno)
|
||||
line = _getLineInFile(moduleName, e.lineno)
|
||||
offset = e.offset
|
||||
if type(offset) is not types.IntType:
|
||||
offset = 0
|
||||
exc_value = '%s\n %s\n %s^' % (msg, line, ' ' * offset)
|
||||
elif exc_type is not ImportError:
|
||||
global _output
|
||||
txt = _(" Caught exception importing module %s:\n") % moduleName
|
||||
_output.AddLines(txt)
|
||||
|
||||
try:
|
||||
tbinfo = traceback.extract_tb(tb)
|
||||
except:
|
||||
tbinfo = []
|
||||
txt = _(" Unable to format traceback\n")
|
||||
_output.AddLines(txt)
|
||||
for filename, line, func, text in tbinfo[1:]:
|
||||
txt = _(" File \"%s\", line %d") % (filename, line)
|
||||
_output.AddLines(txt)
|
||||
if func != "?":
|
||||
txt = _(", in %s()") % func
|
||||
_output.AddLines(txt)
|
||||
_output.AddLines("\n")
|
||||
if text:
|
||||
txt = _(" %s\n") % text
|
||||
_output.AddLines(txt)
|
||||
|
||||
# And finally print the exception type and value.
|
||||
# Careful formatting exc_value -- can fail for some user exceptions
|
||||
txt = " %s: " % exc_name
|
||||
_output.AddLines(txt)
|
||||
try:
|
||||
txt = str(exc_value) + '\n'
|
||||
_output.AddLines(txt)
|
||||
except:
|
||||
txt = _('**error formatting exception value**\n')
|
||||
_output.AddLines(txt)
|
||||
|
||||
|
||||
def _getPyFile(filename):
|
||||
"""Return the file and '.py' filename from a filename which could
|
||||
end with .py, .pyc, or .pyo"""
|
||||
|
||||
if filename[-1] in 'oc' and filename[-4:-1] == '.py':
|
||||
return filename[:-1]
|
||||
return filename
|
||||
|
||||
class Module :
|
||||
"Class to hold all information for a module"
|
||||
|
||||
def __init__(self, moduleName, check = 1, fullpath = None) :
|
||||
self.moduleName = moduleName
|
||||
self.variables = {}
|
||||
self.functions = {}
|
||||
self.classes = {}
|
||||
self.modules = {}
|
||||
self.moduleLineNums = {}
|
||||
self.attributes = [ '__dict__' ]
|
||||
self.main_code = None
|
||||
self.module = None
|
||||
self.check = check
|
||||
self.fullpath = fullpath
|
||||
_allModules[moduleName] = self
|
||||
|
||||
def __str__(self) :
|
||||
return self.moduleName
|
||||
|
||||
__repr__ = utils.std_repr
|
||||
|
||||
def addVariable(self, var, varType) :
|
||||
self.variables[var] = Variable(var, varType)
|
||||
|
||||
def addFunction(self, func) :
|
||||
self.functions[func.__name__] = function.Function(func)
|
||||
|
||||
def __addAttributes(self, c, classObject) :
|
||||
for base in classObject.__bases__ :
|
||||
self.__addAttributes(c, base)
|
||||
c.addMethods(classObject)
|
||||
c.addMembers(classObject)
|
||||
|
||||
def addClass(self, name) :
|
||||
self.classes[name] = c = Class(name, self.module)
|
||||
try:
|
||||
objName = str(c.classObject)
|
||||
except TypeError:
|
||||
# this can happen if there is a goofy __getattr__
|
||||
c.ignoreAttrs = 1
|
||||
else:
|
||||
packages = string.split(objName, '.')
|
||||
c.ignoreAttrs = packages[0] in cfg().blacklist
|
||||
if not c.ignoreAttrs :
|
||||
self.__addAttributes(c, c.classObject)
|
||||
|
||||
def addModule(self, name) :
|
||||
module = _allModules.get(name, None)
|
||||
if module is None :
|
||||
self.modules[name] = module = Module(name, 0)
|
||||
if imp.is_builtin(name) == 0 :
|
||||
module.load()
|
||||
else :
|
||||
globalModule = globals().get(name)
|
||||
if globalModule :
|
||||
module.attributes.extend(dir(globalModule))
|
||||
else :
|
||||
self.modules[name] = module
|
||||
|
||||
def filename(self) :
|
||||
try :
|
||||
filename = self.module.__file__
|
||||
except AttributeError :
|
||||
filename = self.moduleName
|
||||
return _getPyFile(filename)
|
||||
|
||||
def load(self, warnings = None):
|
||||
try :
|
||||
# there's no need to reload modules we already have
|
||||
global _output, _statusDlg, _count
|
||||
txt = _("Loading Module %s\n") % self.moduleName
|
||||
_output.AddLines(txt)
|
||||
_count += 1
|
||||
if _count == 100:
|
||||
_count = 95
|
||||
_statusDlg.Update(_count, txt)
|
||||
|
||||
module = sys.modules.get(self.moduleName)
|
||||
if module :
|
||||
if not _allModules[self.moduleName].module :
|
||||
return self._initModule(module)
|
||||
return 1
|
||||
|
||||
return self._initModule(self.setupMainCode())
|
||||
except (SystemExit, KeyboardInterrupt) :
|
||||
exc_type, exc_value, exc_tb = sys.exc_info()
|
||||
raise exc_type, exc_value
|
||||
except SyntaxError, (message, (fileName, line, col, text)):
|
||||
# ActiveGrid: added this for better feedback when module couldn't be loaded.
|
||||
w = Warning(self.fullpath, line, _("Syntax Error: %s\n%s\n%s^error near here") % (message, text, ' '*(col-1)))
|
||||
warnings.append(w)
|
||||
return 0
|
||||
except:
|
||||
w = Warning(self.moduleName, 1, sys.exc_info()[0] + " NOT PROCESSED UNABLE TO IMPORT")
|
||||
warnings.append(w)
|
||||
importError(self.moduleName)
|
||||
return 0
|
||||
|
||||
def initModule(self, module) :
|
||||
if not self.module:
|
||||
filename = _getPyFile(module.__file__)
|
||||
if string.lower(filename[-3:]) == '.py':
|
||||
try:
|
||||
file = open(filename)
|
||||
except IOError:
|
||||
pass
|
||||
else:
|
||||
self._setupMainCode(file, filename, module)
|
||||
return self._initModule(module)
|
||||
return 1
|
||||
|
||||
def _initModule(self, module):
|
||||
self.module = module
|
||||
self.attributes = dir(self.module)
|
||||
|
||||
pychecker_attr = getattr(module, Config.CHECKER_VAR, None)
|
||||
if pychecker_attr is not None :
|
||||
utils.pushConfig()
|
||||
utils.updateCheckerArgs(pychecker_attr, 'suppressions', 0, [])
|
||||
|
||||
for tokenName in _filterDir(self.module, _DEFAULT_MODULE_TOKENS) :
|
||||
token = getattr(self.module, tokenName)
|
||||
if isinstance(token, types.ModuleType) :
|
||||
# get the real module name, tokenName could be an alias
|
||||
self.addModule(token.__name__)
|
||||
elif isinstance(token, types.FunctionType) :
|
||||
self.addFunction(token)
|
||||
elif isinstance(token, types.ClassType) or \
|
||||
hasattr(token, '__bases__') :
|
||||
self.addClass(tokenName)
|
||||
else :
|
||||
self.addVariable(tokenName, type(token))
|
||||
|
||||
if pychecker_attr is not None :
|
||||
utils.popConfig()
|
||||
return 1
|
||||
|
||||
def setupMainCode(self) :
|
||||
file, filename, smt = _findModule(self.moduleName)
|
||||
# FIXME: if the smt[-1] == imp.PKG_DIRECTORY : load __all__
|
||||
module = imp.load_module(self.moduleName, file, filename, smt)
|
||||
self._setupMainCode(file, filename, module)
|
||||
return module
|
||||
|
||||
def _setupMainCode(self, file, filename, module):
|
||||
try :
|
||||
self.main_code = function.create_from_file(file, filename, module)
|
||||
finally :
|
||||
if file != None :
|
||||
file.close()
|
||||
|
||||
|
||||
def getAllModules() :
|
||||
"Returns a list of all modules that should be checked."
|
||||
modules = []
|
||||
for module in _allModules.values() :
|
||||
if module.check :
|
||||
modules.append(module)
|
||||
return modules
|
||||
|
||||
_BUILTIN_MODULE_ATTRS = { 'sys': [ 'ps1', 'ps2', 'tracebacklimit',
|
||||
'exc_type', 'exc_value', 'exc_traceback',
|
||||
'last_type', 'last_value', 'last_traceback',
|
||||
],
|
||||
}
|
||||
|
||||
def fixupBuiltinModules(needs_init=0):
|
||||
for moduleName in sys.builtin_module_names :
|
||||
if needs_init:
|
||||
_ = Module(moduleName, 0)
|
||||
module = _allModules.get(moduleName, None)
|
||||
if module is not None :
|
||||
try :
|
||||
m = imp.init_builtin(moduleName)
|
||||
except ImportError :
|
||||
pass
|
||||
else :
|
||||
extra_attrs = _BUILTIN_MODULE_ATTRS.get(moduleName, [])
|
||||
module.attributes = [ '__dict__' ] + dir(m) + extra_attrs
|
||||
|
||||
|
||||
def _printWarnings(warnings, stream=None):
|
||||
if stream is None:
|
||||
stream = sys.stdout
|
||||
|
||||
warnings.sort()
|
||||
lastWarning = None
|
||||
for warning in warnings :
|
||||
if lastWarning != None :
|
||||
# ignore duplicate warnings
|
||||
if cmp(lastWarning, warning) == 0 :
|
||||
continue
|
||||
# print blank line between files
|
||||
if lastWarning.file != warning.file :
|
||||
global _output
|
||||
_output.AddLines("\n")
|
||||
|
||||
lastWarning = warning
|
||||
_output.AddLines(warning.format() + "\n")
|
||||
|
||||
|
||||
def processFiles(files, cfg = None, pre_process_cb = None) :
|
||||
# insert this here, so we find files in the local dir before std library
|
||||
if sys.path[0] != '' :
|
||||
sys.path.insert(0, '')
|
||||
|
||||
# ensure we have a config object, it's necessary
|
||||
global _cfg
|
||||
if cfg is not None :
|
||||
_cfg = cfg
|
||||
elif _cfg is None :
|
||||
_cfg = Config.Config()
|
||||
|
||||
warnings = []
|
||||
utils.initConfig(_cfg)
|
||||
for moduleName, filename in getModules(files) :
|
||||
if callable(pre_process_cb) :
|
||||
pre_process_cb(moduleName)
|
||||
module = Module(moduleName, fullpath = filename)
|
||||
|
||||
module.load(warnings)
|
||||
utils.popConfig()
|
||||
return warnings
|
||||
|
||||
|
||||
def getWarnings(files, cfg = None, suppressions = None):
|
||||
warnings = processFiles(files, cfg)
|
||||
fixupBuiltinModules()
|
||||
return warnings + warn.find(getAllModules(), _cfg, suppressions)
|
||||
|
||||
|
||||
def _print_processing(name) :
|
||||
if not _cfg.quiet :
|
||||
global _output, _statusDlg, _count
|
||||
txt = _("Processing %s...\n") % name
|
||||
_output.AddLines(txt)
|
||||
_count += 1
|
||||
_statusDlg.Update(_count, txt)
|
||||
|
||||
|
||||
|
||||
def checkSyntax(filename, messageView):
|
||||
""" Massively hacked version of main for ActiveGrid IDE integration """
|
||||
global _cfg
|
||||
_cfg, files, suppressions = Config.setupFromArgs([filename])
|
||||
if not files :
|
||||
return 0
|
||||
|
||||
global _output, _statusDlg, _count
|
||||
_output = messageView
|
||||
# wxBug: Need to show progress dialog box, or message window never gets updated until the method returns
|
||||
_statusDlg = wx.ProgressDialog(_("Check Code"), _("Checking %s") % filename, maximum = 100, style = wx.PD_AUTO_HIDE | wx.PD_APP_MODAL | wx.PD_ELAPSED_TIME)
|
||||
_count = 0
|
||||
|
||||
# insert this here, so we find files in the local dir before std library
|
||||
sys.path.insert(0, '')
|
||||
|
||||
importWarnings = processFiles(files, _cfg, _print_processing)
|
||||
fixupBuiltinModules()
|
||||
if _cfg.printParse :
|
||||
for module in getAllModules() :
|
||||
printer.module(module)
|
||||
|
||||
warnings = warn.find(getAllModules(), _cfg, suppressions)
|
||||
|
||||
_statusDlg.Update(100, _("Done"))
|
||||
_statusDlg.Destroy()
|
||||
|
||||
if not _cfg.quiet :
|
||||
_output.AddLines(_("\nWarnings and Errors...\n"))
|
||||
if warnings or importWarnings :
|
||||
_printWarnings(importWarnings + warnings)
|
||||
return 1
|
||||
|
||||
if not _cfg.quiet :
|
||||
_output.AddLines(_("No Syntax Errors"))
|
||||
return 0
|
||||
|
||||
##
|
||||
##
|
||||
##def main(argv) :
|
||||
## __pychecker__ = 'no-miximport'
|
||||
## import pychecker
|
||||
## if LOCAL_MAIN_VERSION != pychecker.MAIN_MODULE_VERSION :
|
||||
## sys.stderr.write(_VERSION_MISMATCH_ERROR)
|
||||
## sys.exit(100)
|
||||
##
|
||||
## # remove empty arguments
|
||||
## argv = filter(None, argv)
|
||||
##
|
||||
## # if the first arg starts with an @, read options from the file
|
||||
## # after the @ (this is mostly for windows)
|
||||
## if len(argv) >= 2 and argv[1][0] == '@':
|
||||
## # read data from the file
|
||||
## command_file = argv[1][1:]
|
||||
## try:
|
||||
## f = open(command_file, 'r')
|
||||
## command_line = f.read()
|
||||
## f.close()
|
||||
## except IOError, err:
|
||||
## sys.stderr.write("Unable to read commands from file: %s\n %s\n" % \
|
||||
## (command_file, err))
|
||||
## sys.exit(101)
|
||||
##
|
||||
## # convert to an argv list, keeping argv[0] and the files to process
|
||||
## argv = argv[:1] + string.split(command_line) + argv[2:]
|
||||
##
|
||||
## global _cfg
|
||||
## _cfg, files, suppressions = Config.setupFromArgs(argv[1:])
|
||||
## if not files :
|
||||
## return 0
|
||||
##
|
||||
## # insert this here, so we find files in the local dir before std library
|
||||
## sys.path.insert(0, '')
|
||||
##
|
||||
## importWarnings = processFiles(files, _cfg, _print_processing)
|
||||
## fixupBuiltinModules()
|
||||
## if _cfg.printParse :
|
||||
## for module in getAllModules() :
|
||||
## printer.module(module)
|
||||
##
|
||||
## warnings = warn.find(getAllModules(), _cfg, suppressions)
|
||||
## if not _cfg.quiet :
|
||||
## print "\nWarnings...\n"
|
||||
## if warnings or importWarnings :
|
||||
## _printWarnings(importWarnings + warnings)
|
||||
## return 1
|
||||
##
|
||||
## if not _cfg.quiet :
|
||||
## print "None"
|
||||
## return 0
|
||||
##
|
||||
##
|
||||
##if __name__ == '__main__' :
|
||||
## try :
|
||||
## sys.exit(main(sys.argv))
|
||||
## except Config.UsageError :
|
||||
## sys.exit(127)
|
||||
##
|
||||
##else :
|
||||
## _orig__import__ = None
|
||||
## _suppressions = None
|
||||
## _warnings_cache = {}
|
||||
##
|
||||
## def _get_unique_warnings(warnings):
|
||||
## for i in range(len(warnings)-1, -1, -1):
|
||||
## w = warnings[i].format()
|
||||
## if _warnings_cache.has_key(w):
|
||||
## del warnings[i]
|
||||
## else:
|
||||
## _warnings_cache[w] = 1
|
||||
## return warnings
|
||||
##
|
||||
## def __import__(name, globals=None, locals=None, fromlist=None):
|
||||
## if globals is None:
|
||||
## globals = {}
|
||||
## if locals is None:
|
||||
## locals = {}
|
||||
## if fromlist is None:
|
||||
## fromlist = []
|
||||
##
|
||||
## check = not sys.modules.has_key(name) and name[:10] != 'pychecker.'
|
||||
## pymodule = _orig__import__(name, globals, locals, fromlist)
|
||||
## if check :
|
||||
## try :
|
||||
## module = Module(pymodule.__name__)
|
||||
## if module.initModule(pymodule):
|
||||
## warnings = warn.find([module], _cfg, _suppressions)
|
||||
## _printWarnings(_get_unique_warnings(warnings))
|
||||
## else :
|
||||
## print 'Unable to load module', pymodule.__name__
|
||||
## except Exception:
|
||||
## name = getattr(pymodule, '__name__', str(pymodule))
|
||||
## importError(name)
|
||||
##
|
||||
## return pymodule
|
||||
##
|
||||
## def _init() :
|
||||
## global _cfg, _suppressions, _orig__import__
|
||||
##
|
||||
## args = string.split(os.environ.get('PYCHECKER', ''))
|
||||
## _cfg, files, _suppressions = Config.setupFromArgs(args)
|
||||
## utils.initConfig(_cfg)
|
||||
## fixupBuiltinModules(1)
|
||||
##
|
||||
## # keep the orig __import__ around so we can call it
|
||||
## import __builtin__
|
||||
## _orig__import__ = __builtin__.__import__
|
||||
## __builtin__.__import__ = __import__
|
||||
##
|
||||
## if not os.environ.get('PYCHECKER_DISABLED') :
|
||||
## _init()
|
||||
##
|
||||
Reference in New Issue
Block a user