def handlePackageScope(package, fqn):
#print "handlePackageScope",package,fqn
child = package.getChild(fqn)
if child:
return child
if isinstance(package,Root):
return getModuleOrPackageUsingFQN(fqn)
# try searching the fs
node = getModuleOrPackageUsingFQN(fqn,package.path)
if node:
return node
# try the package init module
initmod = package.getChild("__init__")
if initmod is not None:
type = getImportedType(initmod, fqn)
if type:
return type
# maybe fqn is absolute
return getTypeOf(getRoot(), fqn)
def resolveImportedModuleOrPackage(scope, fqn):
# try searching from directory containing scope module
path = os.path.dirname(scope.module.filename)
node = getModuleOrPackageUsingFQN(fqn, path)
if node is not None:
return node
# try searching from the root
node = getModuleOrPackageUsingFQN(fqn)
if node is not None:
return node
def resolveImportedModuleOrPackage(scope,fqn):
# try searching from directory containing scope module
path = os.path.dirname(scope.module.filename)
node = getModuleOrPackageUsingFQN(fqn,path)
if node is not None:
return node
# try searching from the root
node = getModuleOrPackageUsingFQN(fqn)
if node is not None:
return node
def getTypeOf(scope, fqn):
if isinstance(scope, Root):
return getModuleOrPackageUsingFQN(fqn)
assert False, "Can't use getTypeOf to resolve from Root. Use getModuleOrPackageUsingFQN instead"
#print_ "getTypeOf:"+fqn+" -- "+str(scope)
#print_
#print_ str(getTypeOfStack)
#print_
if (fqn, scope) in getTypeOfStack: # loop protection
return None
# this is crap!
hashcode = str(scope) + fqn
try:
getTypeOfStack.append((fqn, scope))
try:
type = Cache.instance.typecache[hashcode]
except KeyError:
type = getTypeOf_impl(scope, fqn)
Cache.instance.typecache[hashcode] = type
return type
finally:
del getTypeOfStack[-1]
def getTypeOf(scope, fqn):
if isinstance(scope, Root):
return getModuleOrPackageUsingFQN(fqn)
assert False, "Can't use getTypeOf to resolve from Root. Use getModuleOrPackageUsingFQN instead"
#print_ "getTypeOf:"+fqn+" -- "+str(scope)
#print_
#print_ str(getTypeOfStack)
#print_
if (fqn,scope) in getTypeOfStack: # loop protection
return None
# this is crap!
hashcode = str(scope)+fqn
try:
getTypeOfStack.append((fqn,scope))
try:
type = Cache.instance.typecache[hashcode]
except KeyError:
type = getTypeOf_impl(scope, fqn)
Cache.instance.typecache[hashcode] = type
return type
finally:
del getTypeOfStack[-1]
def test_worksForPackage(self):
try:
createPackageStructure("pass","pass")
self.assertEqual(getModuleOrPackageUsingFQN("a.b").path,
pkgstructureChilddir)
finally:
removePackageStructure()
def test_worksForFullPath(self):
try:
createPackageStructure("pass","pass")
self.assertEqual(getModuleOrPackageUsingFQN("a.b.bah").filename,
pkgstructureFile2)
finally:
removePackageStructure()
def test_worksForPackage(self):
try:
createPackageStructure("pass", "pass")
self.assertEqual(
getModuleOrPackageUsingFQN("a.b").path, pkgstructureChilddir)
finally:
removePackageStructure()
def test_worksForFullPath(self):
try:
createPackageStructure("pass", "pass")
self.assertEqual(
getModuleOrPackageUsingFQN("a.b.bah").filename,
pkgstructureFile2)
finally:
removePackageStructure()
def test_handlesRecursionProblem(self):
src = trimLines("""
def fn(root):
node = root
node = node.getPackage('something')
""")
root = createSourceNodeAt(src,"a.foo")
m = getModuleOrPackageUsingFQN("a.foo")
fn = getTypeOf(m,"fn")
getTypeOf(fn,"node") # stack overflow!
def test_doesntGotIntoRecursiveLoopWhenEvaluatingARecursiveFunction(self):
src = trimLines("""
def fn(v):
if v < 45:
return fn(root+1)
val = fn(3)
""")
root = createSourceNodeAt(src,"a.foo")
mod = getModuleOrPackageUsingFQN("a.foo")
getTypeOf(mod,"val") # stack overflow!
def test_getsTypeOfClassReferencedViaAlias(self):
src = trimLines("""
from b.bah import TheClass as FooBah
FooBah()
""")
root = createSourceNodeAt(src,"a.foo")
root = createSourceNodeAt(testdata.TheClass, "a.b.bah")
themodule = getModuleOrPackageUsingFQN("a.foo")
self.assertEqual(getTypeOf(themodule,"FooBah").name,"TheClass")
self.assertEqual(getTypeOf(themodule,"FooBah").filename,
os.path.abspath(os.path.join("a","b","bah.py")))
def resolveImportedModuleOrPackage(scope,fqn):
# try searching from directory containing scope module
path = os.path.dirname(scope.module.filename)
node = getModuleOrPackageUsingFQN(fqn,path)
if node is not None:
return node
# try searching in same package hierarchy
basedir = getPackageBaseDirectory(scope.module.filename)
if fqn.split('.')[0] == os.path.split(basedir)[-1]:
# base package in fqn matches base directory
restOfFqn = ".".join(fqn.split('.')[1:])
node = getModuleOrPackageUsingFQN(restOfFqn,basedir)
if node is not None:
return node
# try searching the python path
node = getModuleOrPackageUsingFQN(fqn)
if node is not None:
return node
def resolveImportedModuleOrPackage(scope, fqn):
# try searching from directory containing scope module
path = os.path.dirname(scope.module.filename)
node = getModuleOrPackageUsingFQN(fqn, path)
if node is not None:
return node
# try searching in same package hierarchy
basedir = getPackageBaseDirectory(scope.module.filename)
if fqn.split('.')[0] == os.path.split(basedir)[-1]:
# base package in fqn matches base directory
restOfFqn = ".".join(fqn.split('.')[1:])
node = getModuleOrPackageUsingFQN(restOfFqn, basedir)
if node is not None:
return node
# try searching the python path
node = getModuleOrPackageUsingFQN(fqn)
if node is not None:
return node
def test_getsTypeOfClassReferenceFromImportedPackage(self):
src = trimLines("""
import b
a = b.bah.TheClass()
""")
root = createSourceNodeAt(src,"a.foo")
root = createSourceNodeAt(testdata.TheClass, "a.b.bah")
module = getModuleOrPackageUsingFQN("a.foo")
res = getTypeOf(module,"a")
assert isinstance(res,Instance)
assert isinstance(res.getType(),Class)
assert res.getType().name == "TheClass"
def handlePackageScope(package, fqn):
#print "handlePackageScope",package,fqn
child = package.getChild(fqn)
if child:
return child
if isinstance(package, Root):
return getModuleOrPackageUsingFQN(fqn)
# try searching the fs
node = getModuleOrPackageUsingFQN(fqn, package.path)
if node:
return node
# try the package init module
initmod = package.getChild("__init__")
if initmod is not None:
type = getImportedType(initmod, fqn)
if type:
return type
# maybe fqn is absolute
return getTypeOf(getRoot(), fqn)
def test_getsTypeOfSimpleClassInstanceReference(self):
src = trimLines("""
from b.bah import TheClass
a = TheClass()
a.theMethod()
""")
root = createSourceNodeAt(src,"a.foo")
root = createSourceNodeAt(testdata.TheClass, "a.b.bah")
module = getModuleOrPackageUsingFQN("a.foo")
res = getTypeOf(module,"a")
assert isinstance(res,Instance)
assert isinstance(res.getType(),Class)
assert res.getType().name == "TheClass"
def test_doesntGetTypeDefinedInChildFunction(self):
src = trimLines("""
from b.bah import TheClass
a = AnotherClass()
def foo():
a = TheClass()
a.theMethod()
""")
root = createSourceNodeAt(src,"a.foo")
root = createSourceNodeAt(testdata.TheClass, "a.b.bah")
themodule = getModuleOrPackageUsingFQN("a.foo")
assert isinstance(getTypeOf(themodule,"a"),UnfoundType)
def test_getsTypeOfClassImportedFromPackageScope(self):
initfile = trimLines("""
from bah import TheClass
""")
src = trimLines("""
from a import b
b.TheClass()
""")
createSourceNodeAt(src,"a.foo")
createSourceNodeAt(testdata.TheClass, "a.b.bah")
createSourceNodeAt(initfile,"a.b.__init__")
themodule = getModuleOrPackageUsingFQN("a.foo")
self.assertEqual(getTypeOf(themodule,"b.TheClass").name,"TheClass")
self.assertEqual(getTypeOf(themodule,"b.TheClass").filename,
os.path.abspath(os.path.join("a","b","bah.py")))
def test_findsClassRefUsingFromImportStatement(self):
src=trimLines("""
from a.b.bah import TheClass
""")
classsrc=trimLines("""
class TheClass:
pass
""")
root = createSourceNodeAt(src,"a.foo")
root = createSourceNodeAt(classsrc, "a.b.bah")
module = getModuleOrPackageUsingFQN("a.foo")
filename = os.path.abspath(os.path.join("a","foo.py"))
defn = [x for x in findAllPossibleDefinitionsByCoords(filename,1,21)]
assert defn[0].filename == os.path.abspath(os.path.join("a","b","bah.py"))
assert defn[0].lineno == 1
assert defn[0].colno == 6
assert defn[0].confidence == 100
def test_getsTypeOfInstanceThatIsAnAttributeOfSelf(self):
src = trimLines("""
class TheClass:
def theMethod(self):
pass
class AnotherClass:
def __init__(self):
self.a = TheClass()
def anotherFn(self):
self.a.theMethod()
""")
root = createSourceNodeAt(src,"a.foo")
module = getModuleOrPackageUsingFQN('a.foo')
theclass = getTypeOf(module,"TheClass")
fn = getTypeOf(module,"AnotherClass.anotherFn")
self.assertEqual(getTypeOf(fn,"self.a").getType().name, "TheClass")
def test_findsClassRefUsingFromImportStatement(self):
src = trimLines("""
from a.b.bah import TheClass
""")
classsrc = trimLines("""
class TheClass:
pass
""")
root = createSourceNodeAt(src, "a.foo")
root = createSourceNodeAt(classsrc, "a.b.bah")
module = getModuleOrPackageUsingFQN("a.foo")
filename = os.path.abspath(os.path.join("a", "foo.py"))
defn = [x for x in findAllPossibleDefinitionsByCoords(filename, 1, 21)]
assert defn[0].filename == os.path.abspath(
os.path.join("a", "b", "bah.py"))
assert defn[0].lineno == 1
assert defn[0].colno == 6
assert defn[0].confidence == 100
def visitFrom(self, node):
if node.names[0][0] == '*': # e.g. from foo import *
if not "."in self.targetfqn:
module = resolveImportedModuleOrPackage(self.scope,
node.modname)
if module:
self.match = getTypeOf(module, self.targetfqn)
else:
for name, alias in node.names:
if alias == self.targetfqn or \
(alias is None and name == self.targetfqn):
scope = resolveImportedModuleOrPackage(self.scope,
node.modname)
if scope is not None:
if isinstance(scope,Package):
self.match = getModuleOrPackageUsingFQN(name,scope.path)
else:
assert isinstance(scope,Module)
self.match = getTypeOf(scope, name)
def visitFrom(self, node):
if node.names[0][0] == '*': # e.g. from foo import *
if not "." in self.targetfqn:
module = resolveImportedModuleOrPackage(
self.scope, node.modname)
if module:
self.match = getTypeOf(module, self.targetfqn)
else:
for name, alias in node.names:
if alias == self.targetfqn or \
(alias is None and name == self.targetfqn):
scope = resolveImportedModuleOrPackage(
self.scope, node.modname)
if scope is not None:
if isinstance(scope, Package):
self.match = getModuleOrPackageUsingFQN(
name, scope.path)
else:
assert isinstance(scope, Module)
self.match = getTypeOf(scope, name)
