eric: comparison eric6/Graphics/UMLClassDiagramBuilder.py

-:197414ba11cc
+:b3eefd7e58d1
 """
 Module implementing a dialog showing a UML like class diagram.
 """
 from itertools import zip_longest
+import os
 from PyQt5.QtWidgets import QGraphicsTextItem
 import Utilities
 import Preferences
 """
 def __init__(self, dialog, view, project, file, 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 file file name of a python module to be shown (string)
+@type UMLGraphicsView
+@param project reference to the project object
+@type Project
+@param file file name of a python module 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("UMLClassDiagramBuilder")
 self.file = file
 self.noAttrs = noAttrs
+self.__relFile = (
+self.project.getRelativePath(self.file)
+if self.project.isProjectSource(self.file) 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 (QGraphicsItem)
+@type str
+@return shape
+@rtype QGraphicsItem
 """
 return self.allClasses.get(name)
 def buildDiagram(self):
 """
 )
 module = Utilities.ModuleParser.readModule(
 self.file, extensions=extensions, caching=False)
 except ImportError:
 ct = QGraphicsTextItem(None)
-ct.setHtml(
+ct.setHtml(self.buildErrorMessage(
 self.tr("The module <b>'{0}'</b> could not be found.")
-.format(self.file))
+.format(self.file)
+))
 self.scene.addItem(ct)
 return
 if self.file not in self.allModules:
 self.allModules[self.file] = []
 self.__arrangeClasses(nodes, routes[:])
 self.__createAssociations(routes)
 self.umlView.autoAdjustSceneSize(limit=True)
 else:
 ct = QGraphicsTextItem(None)
-ct.setHtml(self.tr(
+ct.setHtml(self.buildErrorMessage(
-"The module <b>'{0}'</b> does not contain any classes.")
+self.tr("The module <b>'{0}'</b> does not contain any"
-.format(self.file))
+" classes.").format(self.file)
+))
 self.scene.addItem(ct)
 def __arrangeClasses(self, nodes, routes, whiteSpaceFactor=1.2):
 """
 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
 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
 if _class.name not in self.allModules[self.file]:
 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 __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 "file={0}, no_attributes={1}".format(self.file, 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("file=") 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["file"] = (
+Utilities.fromNativeSeparators(self.__relFile)
+if self.__relFile else
+Utilities.fromNativeSeparators(self.file)
+)
+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"]
+file = Utilities.toNativeSeparators(data["file"])
+if os.path.isabs(file):
+self.file = file
+self.__relFile = ""
+else:
+# relative file paths indicate a project file
+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.__relFile = file
+self.file = self.project.getAbsolutePath(file)
+except KeyError:
+return False, ""
+self.initialize()
+return True, ""

Mercurial Repositories > eric / file comparison

comparison: eric6/Graphics/UMLClassDiagramBuilder.py

eric6/Graphics/UMLClassDiagramBuilder.py