bee_python 0.0.3 → 0.0.4

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

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

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

@@ -1,229 +0,0 @@
-# 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

@@ -1,247 +0,0 @@
-# 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

@@ -1,123 +0,0 @@
-# # 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:])