bee_python 0.0.1

data/tools/pylint2/pylint/pyreverse/__init__.py

@@ -0,0 +1,5 @@
+"""
+pyreverse.extensions
+"""
+
+__revision__ = "$Id $"

data/tools/pylint2/pylint/pyreverse/diadefslib.py

@@ -0,0 +1,229 @@
+# Copyright (c) 2000-2010 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU 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.
+"""handle diagram generation options for class diagram or default diagrams
+"""
+
+from logilab import astng
+from logilab.astng.utils import LocalsVisitor
+
+from pylint.pyreverse.diagrams import PackageDiagram, ClassDiagram
+
+# diagram generators ##########################################################
+
+class DiaDefGenerator:
+    """handle diagram generation options
+    """
+    def __init__(self, linker, handler):
+        """common Diagram Handler initialization"""
+        self.config = handler.config
+        self._set_default_options()
+        self.linker = linker
+        self.classdiagram = None # defined by subclasses
+
+    def get_title(self, node):
+        """get title for objects"""
+        title = node.name
+        if self.module_names:
+            title =  '%s.%s' % (node.root().name, title)
+        return title
+
+    def _set_option(self, option):
+        """activate some options if not explicitly deactivated"""
+        # if we have a class diagram, we want more information by default;
+        # so if the option is None, we return True
+        if option is None:
+            if self.config.classes:
+                return True
+            else:
+                return False
+        return option
+
+    def _set_default_options(self):
+        """set different default options with _default dictionary"""
+        self.module_names = self._set_option(self.config.module_names)
+        all_ancestors = self._set_option(self.config.all_ancestors)
+        all_associated = self._set_option(self.config.all_associated)
+        anc_level, ass_level = (0, 0)
+        if  all_ancestors:
+            anc_level = -1
+        if all_associated:
+            ass_level = -1
+        if self.config.show_ancestors is not None:
+            anc_level = self.config.show_ancestors
+        if self.config.show_associated is not None:
+            ass_level = self.config.show_associated
+        self.anc_level, self.ass_level = anc_level, ass_level
+
+    def _get_levels(self):
+        """help function for search levels"""
+        return self.anc_level, self.ass_level
+
+    def show_node(self, node):
+        """true if builtins and not show_builtins"""
+        if self.config.show_builtin:
+            return True
+        return node.root().name != '__builtin__'
+
+    def add_class(self, node):
+        """visit one class and add it to diagram"""
+        self.linker.visit(node)
+        self.classdiagram.add_object(self.get_title(node), node)
+
+    def get_ancestors(self, node, level):
+        """return ancestor nodes of a class node"""
+        if level == 0:
+            return
+        for ancestor in node.ancestors(recurs=False):
+            if not self.show_node(ancestor):
+                continue
+            yield ancestor
+
+    def get_associated(self, klass_node, level):
+        """return associated nodes of a class node"""
+        if level == 0:
+            return
+        for ass_nodes in klass_node.instance_attrs_type.values() + \
+                         klass_node.locals_type.values():
+            for ass_node in ass_nodes:
+                if isinstance(ass_node, astng.Instance):
+                    ass_node = ass_node._proxied
+                if not (isinstance(ass_node, astng.Class) 
+                        and self.show_node(ass_node)):
+                    continue
+                yield ass_node
+
+    def extract_classes(self, klass_node, anc_level, ass_level):
+        """extract recursively classes related to klass_node"""
+        if self.classdiagram.has_node(klass_node) or not self.show_node(klass_node):
+            return
+        self.add_class(klass_node)
+
+        for ancestor in self.get_ancestors(klass_node, anc_level):
+            self.extract_classes(ancestor, anc_level-1, ass_level)
+
+        for ass_node in self.get_associated(klass_node, ass_level):
+            self.extract_classes(ass_node, anc_level, ass_level-1)
+
+
+class DefaultDiadefGenerator(LocalsVisitor, DiaDefGenerator):
+    """generate minimum diagram definition for the project :
+
+    * a package diagram including project's modules
+    * a class diagram including project's classes
+    """
+
+    def __init__(self, linker, handler):
+        DiaDefGenerator.__init__(self, linker, handler)
+        LocalsVisitor.__init__(self)
+
+    def visit_project(self, node):
+        """visit an astng.Project node
+
+        create a diagram definition for packages
+        """
+        mode = self.config.mode
+        if len(node.modules) > 1:
+            self.pkgdiagram = PackageDiagram('packages %s' % node.name, mode)
+        else:
+            self.pkgdiagram = None
+        self.classdiagram = ClassDiagram('classes %s' % node.name, mode)
+
+    def leave_project(self, node):
+        """leave the astng.Project node
+
+        return the generated diagram definition
+        """
+        if self.pkgdiagram:
+            return self.pkgdiagram, self.classdiagram
+        return self.classdiagram,
+
+    def visit_module(self, node):
+        """visit an astng.Module node
+
+        add this class to the package diagram definition
+        """
+        if self.pkgdiagram:
+            self.linker.visit(node)
+            self.pkgdiagram.add_object(node.name, node)
+
+    def visit_class(self, node):
+        """visit an astng.Class node
+
+        add this class to the class diagram definition
+        """
+        anc_level, ass_level = self._get_levels()
+        self.extract_classes(node, anc_level, ass_level)
+
+    def visit_from(self, node):
+        """visit astng.From  and catch modules for package diagram
+        """
+        if self.pkgdiagram:
+            self.pkgdiagram.add_from_depend(node, node.modname)
+
+
+class ClassDiadefGenerator(DiaDefGenerator):
+    """generate a class diagram definition including all classes related to a
+    given class
+    """
+
+    def __init__(self, linker, handler):
+        DiaDefGenerator.__init__(self, linker, handler)
+
+    def class_diagram(self, project, klass):
+        """return a class diagram definition for the given klass and its
+        related klasses
+        """
+
+        self.classdiagram = ClassDiagram(klass, self.config.mode)
+        if len(project.modules) > 1:
+            module, klass = klass.rsplit('.', 1)
+            module = project.get_module(module)
+        else:
+            module = project.modules[0]
+            klass = klass.split('.')[-1]
+        klass = module.ilookup(klass).next()
+
+        anc_level, ass_level = self._get_levels()
+        self.extract_classes(klass, anc_level, ass_level)
+        return self.classdiagram
+
+# diagram handler #############################################################
+
+class DiadefsHandler:
+    """handle diagram definitions :
+
+    get it from user (i.e. xml files) or generate them
+    """
+
+    def __init__(self, config):
+        self.config = config
+
+    def get_diadefs(self, project, linker):
+        """get the diagrams configuration data
+        :param linker: astng.inspector.Linker(IdGeneratorMixIn, LocalsVisitor)
+        :param project: astng.manager.Project        
+        """
+
+        #  read and interpret diagram definitions (Diadefs)
+        diagrams = []
+        generator = ClassDiadefGenerator(linker, self)
+        for klass in self.config.classes:
+            diagrams.append(generator.class_diagram(project, klass))
+        if not diagrams:
+            diagrams = DefaultDiadefGenerator(linker, self).visit(project)
+        for diagram in diagrams:
+            diagram.extract_relationships()
+        return  diagrams

data/tools/pylint2/pylint/pyreverse/diagrams.py

@@ -0,0 +1,247 @@
+# Copyright (c) 2004-2010 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU 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.
+"""diagram objects
+"""
+
+from logilab import astng
+from pylint.pyreverse.utils import is_interface, FilterMixIn
+
+def set_counter(value):
+    """Figure counter (re)set"""
+    Figure._UID_COUNT = value
+    
+class Figure:
+    """base class for counter handling"""
+    _UID_COUNT = 0
+    def __init__(self):
+        Figure._UID_COUNT += 1
+        self.fig_id = Figure._UID_COUNT
+        
+class Relationship(Figure):
+    """a relation ship from an object in the diagram to another
+    """
+    def __init__(self, from_object, to_object, relation_type, name=None):
+        Figure.__init__(self)
+        self.from_object = from_object
+        self.to_object = to_object
+        self.type = relation_type
+        self.name = name
+        
+    
+class DiagramEntity(Figure):
+    """a diagram object, i.e. a label associated to an astng node
+    """
+    def __init__(self, title='No name', node=None):
+        Figure.__init__(self)
+        self.title = title
+        self.node = node
+
+class ClassDiagram(Figure, FilterMixIn):
+    """main class diagram handling
+    """
+    TYPE = 'class'
+    def __init__(self, title, mode):
+        FilterMixIn.__init__(self, mode)
+        Figure.__init__(self)
+        self.title = title
+        self.objects = []
+        self.relationships = {}
+        self._nodes = {}
+        self.depends = []
+
+    def add_relationship(self, from_object, to_object, 
+                         relation_type, name=None):
+        """create a relation ship
+        """
+        rel = Relationship(from_object, to_object, relation_type, name)
+        self.relationships.setdefault(relation_type, []).append(rel)
+
+    def get_relationship(self, from_object, relation_type):
+        """return a relation ship or None
+        """
+        for rel in self.relationships.get(relation_type, ()):
+            if rel.from_object is from_object:
+                return rel
+        raise KeyError(relation_type)
+
+    def get_attrs(self, node):
+        """return visible attributes, possibly with class name"""
+        attrs = []
+        for node_name, ass_nodes in node.instance_attrs_type.items() + \
+                                node.locals_type.items():
+            if not self.show_attr(node_name):
+                continue
+            names = self.class_names(ass_nodes)
+            if names:
+                node_name = "%s : %s" % (node_name, ", ".join(names))
+            attrs.append(node_name)
+        return attrs
+
+    def get_methods(self, node):
+        """return visible methods"""
+        return [m for m in node.values()
+                if isinstance(m, astng.Function) and self.show_attr(m.name)]
+
+    def add_object(self, title, node):
+        """create a diagram object
+        """
+        assert not self._nodes.has_key(node)
+        ent = DiagramEntity(title, node)
+        self._nodes[node] = ent
+        self.objects.append(ent)
+
+    def class_names(self, nodes):
+        """return class names if needed in diagram"""
+        names = []
+        for ass_node in nodes:
+            if isinstance(ass_node, astng.Instance):
+                ass_node = ass_node._proxied
+            if isinstance(ass_node, astng.Class) \
+                and hasattr(ass_node, "name") and not self.has_node(ass_node):
+                if ass_node.name not in names:
+                    ass_name = ass_node.name
+                    names.append(ass_name)
+        return names
+
+    def nodes(self):
+        """return the list of underlying nodes
+        """
+        return self._nodes.keys()
+
+    def has_node(self, node):
+        """return true if the given node is included in the diagram
+        """
+        return self._nodes.has_key(node)
+        
+    def object_from_node(self, node):
+        """return the diagram object mapped to node
+        """
+        return self._nodes[node]
+            
+    def classes(self):
+        """return all class nodes in the diagram"""
+        return [o for o in self.objects if isinstance(o.node, astng.Class)]
+
+    def classe(self, name):
+        """return a class by its name, raise KeyError if not found
+        """
+        for klass in self.classes():
+            if klass.node.name == name:
+                return klass
+        raise KeyError(name)
+    
+    def extract_relationships(self):
+        """extract relation ships between nodes in the diagram
+        """
+        for obj in self.classes():
+            node = obj.node
+            obj.attrs = self.get_attrs(node)
+            obj.methods = self.get_methods(node)
+            # shape
+            if is_interface(node):
+                obj.shape = 'interface'
+            else:
+                obj.shape = 'class'
+            # inheritance link
+            for par_node in node.ancestors(recurs=False):
+                try:
+                    par_obj = self.object_from_node(par_node)
+                    self.add_relationship(obj, par_obj, 'specialization')
+                except KeyError:
+                    continue
+            # implements link
+            for impl_node in node.implements:
+                try:
+                    impl_obj = self.object_from_node(impl_node)
+                    self.add_relationship(obj, impl_obj, 'implements')
+                except KeyError:
+                    continue
+            # associations link
+            for name, values in node.instance_attrs_type.items() + \
+                                node.locals_type.items():
+                for value in values:
+                    if value is astng.YES:
+                        continue
+                    if isinstance( value, astng.Instance):
+                        value = value._proxied
+                    try:
+                        ass_obj = self.object_from_node(value)
+                        self.add_relationship(ass_obj, obj, 'association', name)
+                    except KeyError:
+                        continue
+
+
+class PackageDiagram(ClassDiagram):
+    """package diagram handling
+    """
+    TYPE = 'package'
+    
+    def modules(self):
+        """return all module nodes in the diagram"""
+        return [o for o in self.objects if isinstance(o.node, astng.Module)]
+
+    def module(self, name):
+        """return a module by its name, raise KeyError if not found
+        """
+        for mod in self.modules():
+            if mod.node.name == name:
+                return mod
+        raise KeyError(name)
+
+    def get_module(self, name, node):
+        """return a module by its name, looking also for relative imports;
+        raise KeyError if not found
+        """
+        for mod in self.modules():
+            mod_name = mod.node.name
+            if mod_name == name:
+                return mod
+            #search for fullname of relative import modules
+            package = node.root().name
+            if mod_name == "%s.%s" % (package, name):
+                return mod
+            if mod_name == "%s.%s" % (package.rsplit('.', 1)[0], name):
+                return mod
+        raise KeyError(name)
+        
+    def add_from_depend(self, node, from_module):
+        """add dependencies created by from-imports
+        """
+        mod_name = node.root().name
+        obj = self.module( mod_name )
+        if from_module not in obj.node.depends:
+            obj.node.depends.append(from_module)
+
+    def extract_relationships(self):
+        """extract relation ships between nodes in the diagram
+        """
+        ClassDiagram.extract_relationships(self)
+        for obj in self.classes():
+            # ownership
+            try:
+                mod = self.object_from_node(obj.node.root())
+                self.add_relationship(obj, mod, 'ownership')
+            except KeyError:
+                continue
+        for obj in self.modules():
+            obj.shape = 'package'
+            # dependencies
+            for dep_name in obj.node.depends:
+                try:
+                    dep = self.get_module(dep_name, obj.node)
+                except KeyError:
+                    continue
+                self.add_relationship(obj, dep, 'depends')

data/tools/pylint2/pylint/pyreverse/main.py

@@ -0,0 +1,123 @@
+# # Copyright (c) 2000-2010 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU 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 General Public License for more details.
+#
+# You should have received a copy of the GNU 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.
+"""
+  %prog [options] <packages>
+
+  create UML diagrams for classes and modules in <packages> 
+"""
+
+import sys
+from logilab.common.configuration import ConfigurationMixIn
+from logilab.astng.manager import astng_wrapper, ASTNGManager
+from logilab.astng.inspector import Linker
+
+from pylint.pyreverse.diadefslib import DiadefsHandler
+from pylint.pyreverse import writer
+from pylint.pyreverse.utils import insert_default_options
+
+OPTIONS = (
+("filter-mode",
+    dict(short='f', default='PUB_ONLY', dest='mode', type='string',
+    action='store', metavar='<mode>', 
+    help="""filter attributes and functions according to
+    <mode>. Correct modes are :
+                            'PUB_ONLY' filter all non public attributes
+                                [DEFAULT], equivalent to PRIVATE+SPECIAL_A
+                            'ALL' no filter
+                            'SPECIAL' filter Python special functions
+                                except constructor
+                            'OTHER' filter protected and private
+                                attributes""")),
+
+("class",
+dict(short='c', action="append", metavar="<class>", dest="classes", default=[],
+    help="create a class diagram with all classes related to <class>;\
+ this uses by default the options -ASmy")),
+
+("show-ancestors",
+dict(short="a",  action="store", metavar='<ancestor>', type='int',
+    help='show <ancestor> generations of ancestor classes not in <projects>')),
+("all-ancestors",
+dict(short="A", default=None,
+    help="show all ancestors off all classes in <projects>") ),
+("show-associated",
+dict(short='s', action="store", metavar='<ass_level>', type='int',
+    help='show <ass_level> levels of associated classes not in <projects>')),
+("all-associated",
+dict(short='S', default=None,
+    help='show recursively all associated off all associated classes')),
+
+("show-builtin",
+dict(short="b", action="store_true", default=False,
+    help='include builtin objects in representation of classes')),
+
+("module-names",
+dict(short="m", default=None, type='yn', metavar='[yn]',
+    help='include module name in representation of classes')),
+# TODO : generate dependencies like in pylint
+#("package-dependencies",
+#dict(short="M", action="store", metavar='<package_depth>', type='int',
+    #help='show <package_depth> module dependencies beyond modules in \
+#<projects> (for the package diagram)')),
+("only-classnames",
+dict(short='k', action="store_true", default=False,
+    help="don't show attributes and methods in the class boxes; \
+this disables -f values")),
+("output", dict(short="o", dest="output_format", action="store",
+                 default="dot", metavar="<format>",
+                help="create a *.<format> output file if format available.")),
+)
+# FIXME : quiet mode
+#( ('quiet', 
+                #dict(help='run quietly', action='store_true', short='q')), )
+
+
+class PyreverseCommand(ConfigurationMixIn):
+    """base class providing common behaviour for pyreverse commands"""
+
+    options = OPTIONS
+
+    def __init__(self, args):
+        ConfigurationMixIn.__init__(self, usage=__doc__)
+        insert_default_options()
+        self.manager = ASTNGManager()
+        self.register_options_provider(self.manager)
+        args = self.load_command_line_configuration()
+        self.run(args)
+
+    def run(self, args):
+        """checking arguments and run project"""
+        if not args:
+            print self.help()
+            return
+        project = self.manager.project_from_files(args, astng_wrapper)
+        linker = Linker(project, tag=True)
+        handler = DiadefsHandler(self.config)
+        diadefs = handler.get_diadefs(project, linker)
+        if self.config.output_format == "vcg":
+            writer.VCGWriter(self.config).write(diadefs)
+        else:
+            writer.DotWriter(self.config).write(diadefs)
+
+
+class Run:
+    """pyreverse main class"""
+    def __init__(self, args):
+        """run pyreverse"""
+        PyreverseCommand(args)
+
+if __name__ == '__main__':
+    Run(sys.argv[1:])