Noyau/N_CR.py

   1 # coding=utf-8
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19
  20
  21 """ Ce module contient la classe compte-rendu de validation
  22 """
  23
  24 from __future__ import absolute_import
  25 try :
  26    from builtins import str
  27    from builtins import object
  28 except :
  29    pass
  30 import six
  31
  32
  33 class CR(object):
  34
  35     """
  36          Classe servant a la construction et a l'affichage des objets Comptes-rendus
  37     """
  38
  39     def __init__(self, verbeux='non', debut='', fin='', dec='   '):
  40         """
  41            Attributs
  42             - verbeux
  43             - debut
  44             - fin
  45             - dec
  46         """
  47         self.verbeux = verbeux
  48         self.debut = debut
  49         self.fin = fin
  50         self.dec = dec
  51         self.crok = []
  52         self.crwarn = []
  53         self.crfatal = []
  54         self.crexception = []
  55         self.subcr = []
  56
  57     def ok(self, comment):
  58         """ Ajoute un commentaire OK a la liste crok"""
  59         self.crok.append(comment)
  60
  61     def warn(self, comment):
  62         """ Ajoute un commentaire Warning a la liste crwarn"""
  63         self.crwarn.append(comment)
  64
  65     def fatal(self, comment, *args):
  66         """Ajoute un commentaire Erreur Fatale a la liste crfatal a formater"""
  67         self.crfatal.append(comment)
  68         self.crfatal.append(str( *args))
  69
  70     def exception(self, comment):
  71         """ Ajoute un commentaire Exception a la liste crexception"""
  72         self.crexception.append(comment)
  73
  74     def add(self, cr):
  75         """ Ajoute un objet CR a la liste subcr :il s'agit de l'objet CR d'un fils de self """
  76         self.subcr.append(cr)
  77
  78     def estvide(self):
  79         """
  80              Retourne 1 si self ne contient aucun message grave (fatal ou exception)
  81              et aucun CR qui en contienne, 0 sinon
  82         """
  83         if self.crexception:
  84             return 0
  85         if self.crfatal:
  86             return 0
  87         for s in self.subcr:
  88             if not s.estvide():
  89                 return 0
  90         return 1
  91
  92     def purge(self):
  93         """
  94              Purge complètement le CR sauf les exceptions
  95         """
  96         self.debut = ''
  97         self.fin = ''
  98         self.dec = '   '
  99         self.crok = []
 100         self.crwarn = []
 101         self.crfatal = []
 102         self.subcr = []
 103
 104     def beautifie_messages(self):
 105         """
 106           Beautifie les messages stockés dans crok,crfatal,crexception et crwarn
 107         """
 108         l = []
 109         for mess in self.crok:
 110             l.append(mess + '\n')
 111         self.crok_belle = l
 112         l = []
 113         for mess in self.crwarn:
 114             l.append(encadre_message(mess, '*'))
 115         self.crwarn_belle = l
 116         l = []
 117         for mess in self.crfatal:
 118             l.append(encadre_message(mess, '!'))
 119         self.crfatal_belle = l
 120         l = []
 121         for mess in self.crexception:
 122             l.append(encadre_message(mess, '!'))
 123         self.crexception_belle = l
 124
 125     def indent(self, s):
 126         """
 127           Insère en tete de chaque ligne du texte s la chaine self.dec
 128         """
 129         l = s.split( '\n')
 130         a='\n' + self.dec
 131         return self.dec + a.join(l)[:-3]
 132
 133     def __unicode__(self):
 134         """
 135           Retourne une chaine de caractères décorée et représentative de self
 136         """
 137         s = ''
 138         self.beautifie_messages()
 139         s = s + ''.join(self.crok_belle)
 140         s = s + ''.join(self.crwarn_belle)
 141         s = s + ''.join(self.crfatal_belle)
 142         s = s + ''.join(self.crexception_belle)
 143         for subcr in self.subcr:
 144             if self.verbeux == 'oui':
 145                 s = s + six.text_type(subcr) + '\n'
 146             else:
 147                 if not subcr.estvide():
 148                     s = s + six.text_type(subcr)
 149         if s != '':
 150             s = self.debut + '\n' + self.indent(s) + self.fin + '\n'
 151         else:
 152             s = self.debut + '\n' + self.fin + '\n'
 153         return s
 154
 155     def __str__(self):
 156         """Return the report representation"""
 157         txt = self.__unicode__()
 158         return txt
 159
 160     def report(self, decalage=2):
 161         """
 162           Retourne une chaine de caractères non encadrée mais représentative de self
 163         """
 164         s = ''
 165         # on stocke dans s les messages de premier niveau
 166         for mess in self.crok:
 167             s = s + decalage * self.dec + mess + self.dec + '\n'
 168         for mess in self.crwarn:
 169             s = s + decalage * self.dec + mess + self.dec + '\n'
 170         for mess in self.crfatal:
 171             s = s + decalage * self.dec + mess + self.dec + '\n'
 172         for mess in self.crexception:
 173             s = s + decalage * self.dec + mess + self.dec + '\n'
 174         # on récupère les messages des sous comptes-rendus ...
 175         for subcr in self.subcr:
 176             if not subcr.estvide():
 177                 s = s + subcr.report(decalage=decalage + 1)
 178         # on rajoute les flags de début et de fin ... (si self n'est pas vide)
 179         if not self.estvide():
 180             s = (decalage - 1) * self.dec + self.debut + '\n' + s + \
 181                 (decalage - 1) * self.dec + self.fin + '\n'
 182         return s
 183
 184     def get_mess_fatal(self):
 185         """
 186             Retourne une chaine de caractères contenant les messages de
 187             la liste crfatal (du dernier au premier)
 188         """
 189         self.crfatal.reverse()
 190         s = ''
 191         for elem in self.crfatal:
 192             s = s + elem
 193         self.crfatal.reverse()
 194         return s
 195
 196     def get_mess_exception(self):
 197         """
 198             Retourne une chaine de caractères contenant les messages
 199             de la liste crexception (du dernier au premier)
 200         """
 201         self.crexception.reverse()
 202         s = ''
 203         for elem in self.crexception:
 204             s = s + elem
 205         self.crexception.reverse()
 206         return s
 207
 208
 209 separateurs = (' ', ',', '/')
 210
 211
 212 def split(ligne, cesure):
 213     ligne = ligne.rstrip()
 214     if len(ligne) <= cesure:
 215         return ligne
 216     else:
 217         coupure = cesure
 218         while ligne[coupure] not in separateurs and coupure > 0:
 219             coupure = coupure - 1
 220         if coupure == 0:
 221             # Il faut augmenter la cesure
 222             coupure = cesure
 223             while ligne[coupure] not in separateurs and coupure < len(ligne) - 1:
 224                 coupure = coupure + 1
 225         if coupure == len(ligne) - 1:
 226             return ligne
 227         else:
 228             return ligne[:coupure + 1] + '\n' + split(ligne[coupure + 1:], cesure)
 229
 230
 231 def justify_text(texte='', cesure=50):
 232     if not isinstance (texte,str) :  texte = ''.join(texte)
 233     texte = texte.strip()
 234     liste_lignes = texte.split('\n')
 235     l = [split(l, cesure) for l in liste_lignes]
 236     texte_justifie = '\n'.join(l)
 237     return texte_justifie
 238
 239
 240 def encadre_message(texte, motif):
 241     """
 242        Retourne la chaine de caractères texte entourée d'un cadre formés
 243        d'éléments 'motif'
 244     """
 245     texte = justify_text(texte, cesure=80)
 246     if texte.strip() == "" : return ''
 247     lignes = texte.split( '\n')
 248     longueur = 0
 249     for ligne in lignes:
 250         ligne = ligne.rstrip()
 251         if len(ligne) > longueur:
 252             longueur = len(ligne)
 253     longueur = longueur + 4
 254     txt = motif * longueur + '\n'
 255     for ligne in lignes:
 256         if ligne == '' : continue
 257         txt = txt + motif + ' ' + ligne + ' ' * \
 258             (longueur - len(motif + ligne) - 2) + motif + '\n'
 259     txt = txt + motif * longueur + '\n'
 260     return txt