eric: comparison eric6/Graphics/PackageDiagramBuilder.py

-:197414ba11cc
+:b3eefd7e58d1
 # Copyright (c) 2007 - 2021 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
-Module implementing a dialog showing a UML like class diagram of a package.
+Module implementing a dialog showing an UML like class diagram of a package.
 """
 import glob
 import os.path
 from itertools import zip_longest
 """
 def __init__(self, dialog, view, project, package, noAttrs=False):
 """
 Constructor
-@param dialog reference to the UML dialog (UMLDialog)
+@param dialog reference to the UML dialog
-@param view reference to the view object (UMLGraphicsView)
+@type UMLDialog
-@param project reference to the project object (Project)
+@param view reference to the view object
-@param package name of a python package to be shown (string)
+@type UMLGraphicsView
+@param project reference to the project object
+@type Project
+@param package name of a python package to be shown
+@type str
 @param noAttrs flag indicating, that no attributes should be shown
-(boolean)
+@type bool
 """
 super().__init__(dialog, view, project)
 self.setObjectName("PackageDiagram")
 self.package = os.path.abspath(package)
 self.noAttrs = noAttrs
+self.__relPackage = (
+self.project.getRelativePath(self.package)
+if self.project.isProjectSource(self.package) else
+""
+)
 def initialize(self):
 """
 Public method to initialize the object.
 """
 def __getCurrentShape(self, name):
 """
 Private method to get the named shape.
-@param name name of the shape (string)
+@param name name of the shape
-@return shape (QCanvasItem)
+@type str
+@return shape
+@rtype QCanvasItem
 """
 return self.allClasses.get(name)
 def __buildModulesDict(self):
 """
 Private method to build a dictionary of modules contained in the
 package.
-@return dictionary of modules contained in the package.
+@return dictionary of modules contained in the package
+@rtype dict
 """
 import Utilities.ModuleParser
 supportedExt = (
 ['*{0}'.format(ext) for ext in
 """
 Private method to build a dictionary of sub-packages contained in this
 package.
 @return dictionary of sub-packages contained in this package
+@rtype dict
 """
 import Utilities.ModuleParser
 supportedExt = (
 ['*{0}'.format(ext) for ext in
 self.tr("The directory <b>'{0}'</b> is not a package.")
 .format(self.package))
 return
 modules = self.__buildModulesDict()
-if not modules:
+subpackages = self.__buildSubpackagesDict()
+if not modules and not subpackages:
 ct = QGraphicsTextItem(None)
 self.scene.addItem(ct)
-ct.setHtml(
+ct.setHtml(self.buildErrorMessage(
-self.tr(
+self.tr("The package <b>'{0}'</b> does not contain any modules"
-"The package <b>'{0}'</b> does not contain any modules.")
+" or subpackages.").format(self.package)
-.format(self.package))
+))
 return
 # step 1: build all classes found in the modules
 classesFound = False
 for modName in list(modules.keys()):
 module = modules[modName]
 for cls in list(module.classes.keys()):
 classesFound = True
 self.__addLocalClass(cls, module.classes[cls], 0, 0)
-if not classesFound:
+if not classesFound and not subpackages:
 ct = QGraphicsTextItem(None)
 self.scene.addItem(ct)
-ct.setHtml(
+ct.setHtml(self.buildErrorMessage(
-self.tr(
+self.tr("The package <b>'{0}'</b> does not contain any"
-"The package <b>'{0}'</b> does not contain any classes.")
+" classes or subpackages.").format(self.package)
-.format(self.package))
+))
 return
 # step 2: build the class hierarchies
 routes = []
 nodes = []
 for modName in list(modules.keys()):
 module = modules[modName]
 todo = [module.createHierarchy()]
 while todo:
 hierarchy = todo[0]
-for className in list(hierarchy.keys()):
+for className in hierarchy:
 cw = self.__getCurrentShape(className)
 if not cw and className.find('.') >= 0:
 cw = self.__getCurrentShape(className.split('.')[-1])
 if cw:
 self.allClasses[className] = cw
 routes.append((className, child))
 del todo[0]
 # step 3: build the subpackages
-subpackages = self.__buildSubpackagesDict()
 for subpackage in sorted(subpackages.keys()):
 self.__addPackage(subpackage, subpackages[subpackage], 0, 0)
 nodes.append(subpackage)
 self.__arrangeClasses(nodes, routes[:])
 Private method to arrange the shapes on the canvas.
 The algorithm is borrowed from Boa Constructor.
 @param nodes list of nodes to arrange
+@type list of str
 @param routes list of routes
+@type list of tuple of (str, str)
 @param whiteSpaceFactor factor to increase whitespace between
-items (float)
+items
+@type float
 """
 from . import GraphicsUtilities
 generations = GraphicsUtilities.sort(nodes, routes)
 # calculate width and height of all elements
 height += currentHeight
 # store generation info
 widths.append(currentWidth)
 heights.append(currentHeight)
 # add in some whitespace
 width *= whiteSpaceFactor
 height = height * whiteSpaceFactor - 20
 verticalWhiteSpace = 40.0
 sceneRect = self.umlView.sceneRect()
 width += 50.0
 height += 50.0
-swidth = width < sceneRect.width() and sceneRect.width() or width
+swidth = sceneRect.width() if width < sceneRect.width() else width
-sheight = height < sceneRect.height() and sceneRect.height() or height
+sheight = sceneRect.height() if height < sceneRect.height() else height
 self.umlView.setSceneSize(swidth, sheight)
 # distribute each generation across the width and the
 # generations across height
 y = 10.0
 def __addLocalClass(self, className, _class, x, y, isRbModule=False):
 """
 Private method to add a class defined in the module.
-@param className name of the class to be as a dictionary key (string)
+@param className name of the class to be as a dictionary key
-@param _class class to be shown (ModuleParser.Class)
+@type str
-@param x x-coordinate (float)
+@param _class class to be shown
-@param y y-coordinate (float)
+@type ModuleParser.Class
-@param isRbModule flag indicating a Ruby module (boolean)
+@param x x-coordinate
+@type float
+@param y y-coordinate
+@type float
+@param isRbModule flag indicating a Ruby module
+@type bool
 """
 from .ClassItem import ClassItem, ClassModel
-meths = sorted(_class.methods.keys())
-attrs = sorted(_class.attributes.keys())
 name = _class.name
 if isRbModule:
 name = "{0} (Module)".format(name)
-cl = ClassModel(name, meths[:], attrs[:])
+cl = ClassModel(
+name,
+sorted(_class.methods.keys())[:],
+sorted(_class.attributes.keys())[:],
+sorted(_class.globals.keys())[:]
+)
 cw = ClassItem(cl, False, x, y, noAttrs=self.noAttrs, scene=self.scene,
 colors=self.umlView.getDrawingColors())
 cw.setId(self.umlView.getItemId())
 self.allClasses[className] = cw
 Private method to add a class defined outside the module.
 If the canvas is too small to take the shape, it
 is enlarged.
-@param _class class to be shown (string)
+@param _class class to be shown
-@param x x-coordinate (float)
+@type ModuleParser.Class
-@param y y-coordinate (float)
+@param x x-coordinate
+@type float
+@param y y-coordinate
+@type float
 """
 from .ClassItem import ClassItem, ClassModel
 cl = ClassModel(_class)
 cw = ClassItem(cl, True, x, y, noAttrs=self.noAttrs, scene=self.scene,
 colors=self.umlView.getDrawingColors())
 def __addPackage(self, name, modules, x, y):
 """
 Private method to add a package to the diagram.
-@param name package name to be shown (string)
+@param name package name to be shown
+@type str
 @param modules list of module names contained in the package
-(list of strings)
+@type list of str
-@param x x-coordinate (float)
+@param x x-coordinate
-@param y y-coordinate (float)
+@type float
+@param y y-coordinate
+@type float
 """
 from .PackageItem import PackageItem, PackageModel
 pm = PackageModel(name, modules)
 pw = PackageItem(pm, x, y, scene=self.scene,
 colors=self.umlView.getDrawingColors())
 def __createAssociations(self, routes):
 """
 Private method to generate the associations between the class shapes.
 @param routes list of relationsships
+@type list of tuple of (str, str)
 """
 from .AssociationItem import AssociationItem, AssociationType
 for route in routes:
 if len(route) > 1:
 assoc = AssociationItem(
 def getPersistenceData(self):
 """
 Public method to get a string for data to be persisted.
-@return persisted data string (string)
+@return persisted data string
+@rtype str
 """
 return "package={0}, no_attributes={1}".format(
 self.package, self.noAttrs)
 def parsePersistenceData(self, version, data):
 """
 Public method to parse persisted data.
-@param version version of the data (string)
+@param version version of the data
-@param data persisted data to be parsed (string)
+@type str
-@return flag indicating success (boolean)
+@param data persisted data to be parsed
+@type str
+@return flag indicating success
+@rtype bool
 """
 parts = data.split(", ")
 if (
 len(parts) != 2 or
 not parts[0].startswith("package=") or
 self.noAttrs = Utilities.toBool(parts[1].split("=", 1)[1].strip())
 self.initialize()
 return True
+def toDict(self):
+"""
+Public method to collect data to be persisted.
+@return dictionary containing data to be persisted
+@rtype dict
+"""
+data = {
+"project_name": self.project.getProjectName(),
+"no_attributes": self.noAttrs,
+}
+data["package"] = (
+Utilities.fromNativeSeparators(self.__relPackage)
+if self.__relPackage else
+Utilities.fromNativeSeparators(self.package)
+)
+return data
+def fromDict(self, version, data):
+"""
+Public method to populate the class with data persisted by 'toDict()'.
+@param version version of the data
+@type str
+@param data dictionary containing the persisted data
+@type dict
+@return tuple containing a flag indicating success and an info
+message in case the diagram belongs to a different project
+@rtype tuple of (bool, str)
+"""
+try:
+self.noAttrs = data["no_attributes"]
+package = Utilities.toNativeSeparators(data["package"])
+if os.path.isabs(package):
+self.package = package
+self.__relPackage = ""
+else:
+# relative package paths indicate a project package
+if data["project_name"] != self.project.getProjectName():
+msg = self.tr(
+"<p>The diagram belongs to project <b>{0}</b>."
+" Please open it and try again.</p>"
+).format(data["project_name"])
+return False, msg
+self.__relPackage = package
+self.package = self.project.getAbsolutePath(package)
+except KeyError:
+return False, ""
+self.initialize()
+return True, ""

Mercurial Repositories > eric / file comparison

comparison: eric6/Graphics/PackageDiagramBuilder.py

eric6/Graphics/PackageDiagramBuilder.py