bee_python 0.0.1

data/tools/logilab/logilab/astng/manager.py

@@ -0,0 +1,421 @@
+# This program 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 of the License, or (at your option) any later
+# version.
+#
+# This program 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
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+# copyright 2003-2010 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/>.
+"""astng manager: avoid multiple astng build of a same module when
+possible by providing a class responsible to get astng representation
+from various source and using a cache of built modules)
+
+"""
+
+__docformat__ = "restructuredtext en"
+
+import sys
+import os
+from os.path import dirname, basename, abspath, join, isdir, exists
+
+from logilab.common.modutils import NoSourceFile, is_python_source, \
+     file_from_modpath, load_module_from_name, modpath_from_file, \
+     get_module_files, get_source_file, zipimport
+from logilab.common.configuration import OptionsProviderMixIn
+
+from logilab.astng._exceptions import ASTNGBuildingException
+
+def astng_wrapper(func, modname):
+    """wrapper to give to ASTNGManager.project_from_files"""
+    print 'parsing %s...' % modname
+    try:
+        return func(modname)
+    except ASTNGBuildingException, exc:
+        print exc
+    except KeyboardInterrupt:
+        raise
+    except Exception, exc:
+        import traceback
+        traceback.print_exc()
+
+def safe_repr(obj):
+    try:
+        return repr(obj)
+    except:
+        return '???'
+
+def zip_import_data(filepath):
+    if zipimport is None:
+        return None, None
+    for ext in ('.zip', '.egg'):
+        try:
+            eggpath, resource = filepath.split(ext + '/', 1)
+        except ValueError:
+            continue
+        try:
+            importer = zipimport.zipimporter(eggpath + ext)
+            return importer.get_source(resource), resource.replace('/', '.')
+        except:
+            continue
+    return None, None
+
+
+class ASTNGManager(OptionsProviderMixIn):
+    """the astng manager, responsible to build astng from files
+     or modules.
+
+    Use the Borg pattern.
+    """
+
+    name = 'astng loader'
+    options = (("ignore",
+                {'type' : "csv", 'metavar' : "<file>",
+                 'dest' : "black_list", "default" : ('CVS',),
+                 'help' : "add <file> (may be a directory) to the black list\
+. It should be a base name, not a path. You may set this option multiple times\
+."}),
+               ("project",
+                {'default': "No Name", 'type' : 'string', 'short': 'p',
+                 'metavar' : '<project name>',
+                 'help' : 'set the project name.'}),
+               )
+    brain = {}
+    def __init__(self, borg=True):
+        if borg:
+            self.__dict__ = ASTNGManager.brain
+        if not self.__dict__:
+            OptionsProviderMixIn.__init__(self)
+            self.load_defaults()
+            # NOTE: cache entries are added by the [re]builder
+            self._cache = {} #Cache(cache_size)
+            self._mod_file_cache = {}
+
+    def reset_cache(self):
+        self._cache = {} #Cache(cache_size)
+        self._mod_file_cache = {}
+
+    def from_directory(self, directory, modname=None):
+        """given a module name, return the astng object"""
+        modname = modname or basename(directory)
+        directory = abspath(directory)
+        return Package(directory, modname, self)
+
+    def astng_from_file(self, filepath, modname=None, fallback=True):
+        """given a module name, return the astng object"""
+        try:
+            filepath = get_source_file(filepath, include_no_ext=True)
+            source = True
+        except NoSourceFile:
+            source = False
+        if modname is None:
+            modname = '.'.join(modpath_from_file(filepath))
+        if modname in self._cache:
+            return self._cache[modname]
+        if source:
+            try:
+                from logilab.astng.builder import ASTNGBuilder
+                return ASTNGBuilder(self).file_build(filepath, modname)
+            except (SyntaxError, KeyboardInterrupt, SystemExit):
+                raise
+            except Exception, ex:
+                raise
+                if __debug__:
+                    print 'error while building astng for', filepath
+                    import traceback
+                    traceback.print_exc()
+                msg = 'Unable to load module %s (%s)' % (modname, ex)
+                raise ASTNGBuildingException(msg), None, sys.exc_info()[-1]
+        elif fallback and modname:
+            return self.astng_from_module_name(modname)
+        raise ASTNGBuildingException('unable to get astng for file %s' %
+                                     filepath)
+
+    def astng_from_module_name(self, modname, context_file=None):
+        """given a module name, return the astng object"""
+        if modname in self._cache:
+            return self._cache[modname]
+        old_cwd = os.getcwd()
+        if context_file:
+            os.chdir(dirname(context_file))
+        try:
+            filepath = self.file_from_module_name(modname, context_file)
+            if filepath is not None and not is_python_source(filepath):
+                data, zmodname = zip_import_data(filepath)
+                if data is not None:
+                    from logilab.astng.builder import ASTNGBuilder
+                    try:
+                        return ASTNGBuilder(self).string_build(data, zmodname,
+                                                               filepath)
+                    except (SyntaxError, KeyboardInterrupt, SystemExit):
+                        raise
+            if filepath is None or not is_python_source(filepath):
+                try:
+                    module = load_module_from_name(modname)
+                # catch SystemError as well, we may get that on badly
+                # initialized C-module
+                except (SystemError, ImportError), ex:
+                    msg = 'Unable to load module %s (%s)' % (modname, ex)
+                    raise ASTNGBuildingException(msg)
+                return self.astng_from_module(module, modname)
+            return self.astng_from_file(filepath, modname, fallback=False)
+        finally:
+            os.chdir(old_cwd)
+
+    def file_from_module_name(self, modname, contextfile):
+        try:
+            value = self._mod_file_cache[(modname, contextfile)]
+        except KeyError:
+            try:
+                value = file_from_modpath(modname.split('.'),
+                                          context_file=contextfile)
+            except ImportError, ex:
+                msg = 'Unable to load module %s (%s)' % (modname, ex)
+                value = ASTNGBuildingException(msg)
+            self._mod_file_cache[(modname, contextfile)] = value
+        if isinstance(value, ASTNGBuildingException):
+            raise value
+        return value
+
+    def astng_from_module(self, module, modname=None):
+        """given an imported module, return the astng object"""
+        modname = modname or module.__name__
+        if modname in self._cache:
+            return self._cache[modname]
+        try:
+            # some builtin modules don't have __file__ attribute
+            filepath = module.__file__
+            if is_python_source(filepath):
+                return self.astng_from_file(filepath, modname)
+        except AttributeError:
+            pass
+        from logilab.astng.builder import ASTNGBuilder
+        return ASTNGBuilder(self).module_build(module, modname)
+
+    def astng_from_class(self, klass, modname=None):
+        """get astng for the given class"""
+        if modname is None:
+            try:
+                modname = klass.__module__
+            except AttributeError:
+                raise ASTNGBuildingException(
+                    'Unable to get module for class %s' % safe_repr(klass))
+        modastng = self.astng_from_module_name(modname)
+        return modastng.getattr(klass.__name__)[0] # XXX
+
+
+    def infer_astng_from_something(self, obj, modname=None, context=None):
+        """infer astng for the given class"""
+        if hasattr(obj, '__class__') and not isinstance(obj, type):
+            klass = obj.__class__
+        else:
+            klass = obj
+        if modname is None:
+            try:
+                modname = klass.__module__
+            except AttributeError:
+                raise ASTNGBuildingException(
+                    'Unable to get module for %s' % safe_repr(klass))
+            except Exception, ex:
+                raise ASTNGBuildingException(
+                    'Unexpected error while retrieving module for %s: %s'
+                    % (safe_repr(klass), ex))
+        try:
+            name = klass.__name__
+        except AttributeError:
+            raise ASTNGBuildingException(
+                'Unable to get name for %s' % safe_repr(klass))
+        except Exception, ex:
+            raise ASTNGBuildingException(
+                'Unexpected error while retrieving name for %s: %s'
+                % (safe_repr(klass), ex))
+        # take care, on living object __module__ is regularly wrong :(
+        modastng = self.astng_from_module_name(modname)
+        if klass is obj:
+            for  infered in modastng.igetattr(name, context):
+                yield infered
+        else:
+            for infered in modastng.igetattr(name, context):
+                yield infered.instanciate_class()
+
+    def project_from_files(self, files, func_wrapper=astng_wrapper,
+                           project_name=None, black_list=None):
+        """return a Project from a list of files or modules"""
+        # insert current working directory to the python path to have a correct
+        # behaviour
+        sys.path.insert(0, os.getcwd())
+        try:
+            # build the project representation
+            project_name = project_name or self.config.project
+            black_list = black_list or self.config.black_list
+            project = Project(project_name)
+            for something in files:
+                if not exists(something):
+                    fpath = file_from_modpath(something.split('.'))
+                elif isdir(something):
+                    fpath = join(something, '__init__.py')
+                else:
+                    fpath = something
+                astng = func_wrapper(self.astng_from_file, fpath)
+                if astng is None:
+                    continue
+                project.path = project.path or astng.file
+                project.add_module(astng)
+                base_name = astng.name
+                # recurse in package except if __init__ was explicitly given
+                if astng.package and something.find('__init__') == -1:
+                    # recurse on others packages / modules if this is a package
+                    for fpath in get_module_files(dirname(astng.file),
+                                                  black_list):
+                        astng = func_wrapper(self.astng_from_file, fpath)
+                        if astng is None or astng.name == base_name:
+                            continue
+                        project.add_module(astng)
+            return project
+        finally:
+            sys.path.pop(0)
+
+
+
+class Package:
+    """a package using a dictionary like interface
+
+    load submodules lazily, as they are needed
+    """
+
+    def __init__(self, path, name, manager):
+        self.name = name
+        self.path = abspath(path)
+        self.manager = manager
+        self.parent = None
+        self.lineno = 0
+        self.__keys = None
+        self.__subobjects = None
+
+    def fullname(self):
+        """return the full name of the package (i.e. prefix by the full name
+        of the parent package if any
+        """
+        if self.parent is None:
+            return self.name
+        return '%s.%s' % (self.parent.fullname(), self.name)
+
+    def get_subobject(self, name):
+        """method used to get sub-objects lazily : sub package or module are
+        only build once they are requested
+        """
+        if self.__subobjects is None:
+            try:
+                self.__subobjects = dict.fromkeys(self.keys())
+            except AttributeError:
+                # python <= 2.3
+                self.__subobjects = dict([(k, None) for k in self.keys()])
+        obj = self.__subobjects[name]
+        if obj is None:
+            objpath = join(self.path, name)
+            if isdir(objpath):
+                obj = Package(objpath, name, self.manager)
+                obj.parent = self
+            else:
+                modname = '%s.%s' % (self.fullname(), name)
+                obj = self.manager.astng_from_file(objpath + '.py', modname)
+            self.__subobjects[name] = obj
+        return obj
+
+    def get_module(self, modname):
+        """return the Module or Package object with the given name if any
+        """
+        path = modname.split('.')
+        if path[0] != self.name:
+            raise KeyError(modname)
+        obj = self
+        for part in path[1:]:
+            obj = obj.get_subobject(part)
+        return obj
+
+    def keys(self):
+        if self.__keys is None:
+            self.__keys = []
+            for fname in os.listdir(self.path):
+                if fname.endswith('.py'):
+                    self.__keys.append(fname[:-3])
+                    continue
+                fpath = join(self.path, fname)
+                if isdir(fpath) and exists(join(fpath, '__init__.py')):
+                    self.__keys.append(fname)
+            self.__keys.sort()
+        return self.__keys[:]
+
+    def values(self):
+        return [self.get_subobject(name) for name in self.keys()]
+
+    def items(self):
+        return zip(self.keys(), self.values())
+
+    def has_key(self, name):
+        return bool(self.get(name))
+
+    def get(self, name, default=None):
+        try:
+            return self.get_subobject(name)
+        except KeyError:
+            return default
+
+    def __getitem__(self, name):
+        return self.get_subobject(name)
+    def __contains__(self, name):
+        return self.has_key(name)
+    def __iter__(self):
+        return iter(self.keys())
+
+
+class Project:
+    """a project handle a set of modules / packages"""
+    def __init__(self, name=''):
+        self.name = name
+        self.path = None
+        self.modules = []
+        self.locals = {}
+        self.__getitem__ = self.locals.__getitem__
+        self.__iter__ = self.locals.__iter__
+        self.values = self.locals.values
+        self.keys = self.locals.keys
+        self.items = self.locals.items
+        self.has_key = self.locals.has_key
+
+    def add_module(self, node):
+        self.locals[node.name] = node
+        self.modules.append(node)
+
+    def get_module(self, name):
+        return self.locals[name]
+
+    def get_children(self):
+        return self.modules
+
+    def __repr__(self):
+        return '<Project %r at %s (%s modules)>' % (self.name, id(self),
+                                                    len(self.modules))
+

data/tools/logilab/logilab/astng/mixins.py

@@ -0,0 +1,165 @@
+# This program 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 of the License, or (at your option) any later
+# version.
+#
+# This program 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
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+# copyright 2003-2010 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/>.
+"""This module contains some mixins for the different nodes.
+
+"""
+
+from logilab.astng import (ASTNGBuildingException, InferenceError,
+                           NotFoundError)
+from logilab.astng.bases import BaseClass
+
+# /!\ We cannot build a StmtNode(NodeNG) class since modifying "__bases__"
+# in "nodes.py" has to work *both* for old-style and new-style classes,
+# but we need the StmtMixIn for scoped nodes
+
+class StmtMixIn(BaseClass):
+    """StmtMixIn used only for a adding a few attributes"""
+    is_statement = True
+
+    def replace(self, child, newchild):
+        sequence = self.child_sequence(child)
+        newchild.parent = self
+        child.parent = None
+        sequence[sequence.index(child)] = newchild
+
+    def next_sibling(self):
+        """return the next sibling statement"""
+        stmts = self.parent.child_sequence(self)
+        index = stmts.index(self)
+        try:
+            return stmts[index +1]
+        except IndexError:
+            pass
+
+    def previous_sibling(self):
+        """return the previous sibling statement"""
+        stmts = self.parent.child_sequence(self)
+        index = stmts.index(self)
+        if index >= 1:
+            return stmts[index -1]
+
+
+class BlockRangeMixIn(BaseClass):
+    """override block range """
+    def set_line_info(self, lastchild):
+        self.fromlineno = self.lineno
+        self.tolineno = lastchild.tolineno
+        self.blockstart_tolineno = self._blockstart_toline()
+
+    def _elsed_block_range(self, lineno, orelse, last=None):
+        """handle block line numbers range for try/finally, for, if and while
+        statements
+        """
+        if lineno == self.fromlineno:
+            return lineno, lineno
+        if orelse:
+            if lineno >= orelse[0].fromlineno:
+                return lineno, orelse[-1].tolineno
+            return lineno, orelse[0].fromlineno - 1
+        return lineno, last or self.tolineno
+
+class FilterStmtsMixin(object):
+    """Mixin for statement filtering and assignment type"""
+
+    def _get_filtered_stmts(self, _, node, _stmts, mystmt):
+        """method used in _filter_stmts to get statemtents and trigger break"""
+        if self.statement() is mystmt:
+            # original node's statement is the assignment, only keep
+            # current node (gen exp, list comp)
+            return [node], True
+        return _stmts, False
+
+    def ass_type(self):
+        return self
+
+
+class AssignTypeMixin(object):
+
+    def ass_type(self):
+        return self
+
+    def _get_filtered_stmts(self, lookup_node, node, _stmts, mystmt):
+        """method used in filter_stmts"""
+        if self is mystmt:
+            return _stmts, True
+        if self.statement() is mystmt:
+            # original node's statement is the assignment, only keep
+            # current node (gen exp, list comp)
+            return [node], True
+        return _stmts, False
+
+
+class ParentAssignTypeMixin(AssignTypeMixin):
+
+    def ass_type(self):
+        return self.parent.ass_type()
+
+
+
+class FromImportMixIn(BaseClass, FilterStmtsMixin):
+    """MixIn for From and Import Nodes"""
+
+    def _infer_name(self, frame, name):
+        return name
+
+    def do_import_module(self, modname):
+        """return the ast for a module whose name is <modname> imported by <self>
+        """
+        # handle special case where we are on a package node importing a module
+        # using the same name as the package, which may end in an infinite loop
+        # on relative imports
+        # XXX: no more needed ?
+        mymodule = self.root()
+        level = getattr(self, 'level', None) # Import as no level
+        if mymodule.absolute_modname(modname, level) == mymodule.name:
+            # FIXME: I don't know what to do here...
+            raise InferenceError('module importing itself: %s' % modname)
+        try:
+            return mymodule.import_module(modname, level=level)
+        except (ASTNGBuildingException, SyntaxError):
+            raise InferenceError(modname)
+
+    def real_name(self, asname):
+        """get name from 'as' name"""
+        for index in range(len(self.names)):
+            name, _asname = self.names[index]
+            if name == '*':
+                return asname
+            if not _asname:
+                name = name.split('.', 1)[0]
+                _asname = name
+            if asname == _asname:
+                return name
+        raise NotFoundError(asname)
+
+
+