You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
227 lines
8.6 KiB
Python
227 lines
8.6 KiB
Python
# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
|
|
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
|
|
# copyright 2003-2010 Sylvain Thenault, all rights reserved.
|
|
# contact mailto:thenault@gmail.com
|
|
#
|
|
# This file is part of logilab-astng.
|
|
#
|
|
# logilab-astng is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU Lesser General Public License as published by the
|
|
# Free Software Foundation, either version 2.1 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# logilab-astng is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
|
|
# for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License along
|
|
# with logilab-astng. If not, see <http://www.gnu.org/licenses/>.
|
|
"""The ASTNGBuilder makes astng from living object and / or from _ast
|
|
|
|
The builder is not thread safe and can't be used to parse different sources
|
|
at the same time.
|
|
"""
|
|
|
|
__docformat__ = "restructuredtext en"
|
|
|
|
import sys, re
|
|
from os.path import splitext, basename, dirname, exists, abspath
|
|
|
|
from logilab.common.modutils import modpath_from_file
|
|
|
|
from logilab.astng.exceptions import ASTNGBuildingException, InferenceError
|
|
from logilab.astng.raw_building import InspectBuilder
|
|
from logilab.astng.rebuilder import TreeRebuilder
|
|
from logilab.astng.manager import ASTNGManager
|
|
from logilab.astng.bases import YES, Instance
|
|
|
|
from _ast import PyCF_ONLY_AST
|
|
def parse(string):
|
|
return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
|
|
|
|
if sys.version_info >= (3, 0):
|
|
from tokenize import detect_encoding
|
|
|
|
def open_source_file(filename):
|
|
byte_stream = open(filename, 'bU')
|
|
encoding = detect_encoding(byte_stream.readline)[0]
|
|
stream = open(filename, 'U', encoding=encoding)
|
|
try:
|
|
data = stream.read()
|
|
except UnicodeError, uex: # wrong encodingg
|
|
# detect_encoding returns utf-8 if no encoding specified
|
|
msg = 'Wrong (%s) or no encoding specified' % encoding
|
|
raise ASTNGBuildingException(msg)
|
|
return stream, encoding, data
|
|
|
|
else:
|
|
import re
|
|
|
|
_ENCODING_RGX = re.compile("\s*#+.*coding[:=]\s*([-\w.]+)")
|
|
|
|
def _guess_encoding(string):
|
|
"""get encoding from a python file as string or return None if not found
|
|
"""
|
|
# check for UTF-8 byte-order mark
|
|
if string.startswith('\xef\xbb\xbf'):
|
|
return 'UTF-8'
|
|
for line in string.split('\n', 2)[:2]:
|
|
# check for encoding declaration
|
|
match = _ENCODING_RGX.match(line)
|
|
if match is not None:
|
|
return match.group(1)
|
|
|
|
def open_source_file(filename):
|
|
"""get data for parsing a file"""
|
|
stream = open(filename, 'U')
|
|
data = stream.read()
|
|
encoding = _guess_encoding(data)
|
|
return stream, encoding, data
|
|
|
|
# ast NG builder ##############################################################
|
|
|
|
MANAGER = ASTNGManager()
|
|
|
|
class ASTNGBuilder(InspectBuilder):
|
|
"""provide astng building methods"""
|
|
rebuilder = TreeRebuilder()
|
|
|
|
def __init__(self, manager=None):
|
|
self._manager = manager or MANAGER
|
|
|
|
def module_build(self, module, modname=None):
|
|
"""build an astng from a living module instance
|
|
"""
|
|
node = None
|
|
path = getattr(module, '__file__', None)
|
|
if path is not None:
|
|
path_, ext = splitext(module.__file__)
|
|
if ext in ('.py', '.pyc', '.pyo') and exists(path_ + '.py'):
|
|
node = self.file_build(path_ + '.py', modname)
|
|
if node is None:
|
|
# this is a built-in module
|
|
# get a partial representation by introspection
|
|
node = self.inspect_build(module, modname=modname, path=path)
|
|
return node
|
|
|
|
def file_build(self, path, modname=None):
|
|
"""build astng from a source code file (i.e. from an ast)
|
|
|
|
path is expected to be a python source file
|
|
"""
|
|
try:
|
|
stream, encoding, data = open_source_file(path)
|
|
except IOError, exc:
|
|
msg = 'Unable to load file %r (%s)' % (path, exc)
|
|
raise ASTNGBuildingException(msg)
|
|
except SyntaxError, exc: # py3k encoding specification error
|
|
raise ASTNGBuildingException(exc)
|
|
except LookupError, exc: # unknown encoding
|
|
raise ASTNGBuildingException(exc)
|
|
# get module name if necessary
|
|
if modname is None:
|
|
try:
|
|
modname = '.'.join(modpath_from_file(path))
|
|
except ImportError:
|
|
modname = splitext(basename(path))[0]
|
|
# build astng representation
|
|
node = self.string_build(data, modname, path)
|
|
node.file_encoding = encoding
|
|
return node
|
|
|
|
def string_build(self, data, modname='', path=None):
|
|
"""build astng from source code string and return rebuilded astng"""
|
|
module = self._data_build(data, modname, path)
|
|
self._manager.astng_cache[module.name] = module
|
|
# post tree building steps after we stored the module in the cache:
|
|
for from_node in module._from_nodes:
|
|
self.add_from_names_to_locals(from_node)
|
|
# handle delayed assattr nodes
|
|
for delayed in module._delayed_assattr:
|
|
self.delayed_assattr(delayed)
|
|
if modname:
|
|
for transformer in self._manager.transformers:
|
|
transformer(module)
|
|
return module
|
|
|
|
def _data_build(self, data, modname, path):
|
|
"""build tree node from data and add some informations"""
|
|
# this method could be wrapped with a pickle/cache function
|
|
node = parse(data + '\n')
|
|
if path is not None:
|
|
node_file = abspath(path)
|
|
else:
|
|
node_file = '<?>'
|
|
if modname.endswith('.__init__'):
|
|
modname = modname[:-9]
|
|
package = True
|
|
else:
|
|
package = path and path.find('__init__.py') > -1 or False
|
|
self.rebuilder.init()
|
|
module = self.rebuilder.visit_module(node, modname, package)
|
|
module.file = module.path = node_file
|
|
module._from_nodes = self.rebuilder._from_nodes
|
|
module._delayed_assattr = self.rebuilder._delayed_assattr
|
|
return module
|
|
|
|
def add_from_names_to_locals(self, node):
|
|
"""store imported names to the locals;
|
|
resort the locals if coming from a delayed node
|
|
"""
|
|
|
|
_key_func = lambda node: node.fromlineno
|
|
def sort_locals(my_list):
|
|
my_list.sort(key=_key_func)
|
|
for (name, asname) in node.names:
|
|
if name == '*':
|
|
try:
|
|
imported = node.root().import_module(node.modname)
|
|
except ASTNGBuildingException:
|
|
continue
|
|
for name in imported.wildcard_import_names():
|
|
node.parent.set_local(name, node)
|
|
sort_locals(node.parent.scope().locals[name])
|
|
else:
|
|
node.parent.set_local(asname or name, node)
|
|
sort_locals(node.parent.scope().locals[asname or name])
|
|
|
|
def delayed_assattr(self, node):
|
|
"""visit a AssAttr node -> add name to locals, handle members
|
|
definition
|
|
"""
|
|
try:
|
|
frame = node.frame()
|
|
for infered in node.expr.infer():
|
|
if infered is YES:
|
|
continue
|
|
try:
|
|
if infered.__class__ is Instance:
|
|
infered = infered._proxied
|
|
iattrs = infered.instance_attrs
|
|
elif isinstance(infered, Instance):
|
|
# Const, Tuple, ... we may be wrong, may be not, but
|
|
# anyway we don't want to pollute builtin's namespace
|
|
continue
|
|
elif infered.is_function:
|
|
iattrs = infered.instance_attrs
|
|
else:
|
|
iattrs = infered.locals
|
|
except AttributeError:
|
|
# XXX log error
|
|
#import traceback
|
|
#traceback.print_exc()
|
|
continue
|
|
values = iattrs.setdefault(node.attrname, [])
|
|
if node in values:
|
|
continue
|
|
# get assign in __init__ first XXX useful ?
|
|
if frame.name == '__init__' and values and not \
|
|
values[0].frame().name == '__init__':
|
|
values.insert(0, node)
|
|
else:
|
|
values.append(node)
|
|
except InferenceError:
|
|
pass
|
|
|