Noyau/N_CR.py

   1 """ Ce module contient la classe compte-rendu de validation
   2 """
   3
   4 import string
   5
   6 class CR :
   7    """
   8         Classe servant à la construction et à l'affichage des objets Comptes-rendus
   9    """
  10    def __init__(self,verbeux = 'non',debut='',fin='',dec='   '):
  11       """
  12          Attributs
  13           - verbeux
  14           - debut
  15           - fin
  16           - dec
  17       """
  18       self.verbeux = verbeux
  19       self.debut=debut
  20       self.fin=fin
  21       self.dec=dec
  22       self.crok=[]
  23       self.crwarn=[]
  24       self.crfatal=[]
  25       self.crexception=[]
  26       self.subcr=[]
  27
  28    def ok(self,comment):
  29       """ Ajoute un commentaire OK à la liste crok"""
  30       self.crok.append(comment)
  31
  32    def warn(self,comment):
  33       """ Ajoute un commentaire Warning à la liste crwarn"""
  34       self.crwarn.append(comment)
  35
  36    def fatal(self,comment):
  37       """ Ajoute un commentaire Erreur Fatale à la liste crfatal"""
  38       self.crfatal.append(comment)
  39
  40    def exception(self,comment):
  41       """ Ajoute un commentaire Exception à la liste crexception"""
  42       self.crexception.append(comment)
  43
  44    def add(self,cr):
  45       """ Ajoute un objet CR à la liste subcr :il s'agit de l'objet CR d'un fils de self """
  46       self.subcr.append(cr)
  47
  48    def estvide(self):
  49       """
  50            Retourne 1 si self ne contient aucun message grave (fatal ou exception) et
  51                           aucun CR qui en contienne,
  52                     0 sinon
  53       """
  54       if self.crexception : return 0
  55       if self.crfatal : return 0
  56       for s in self.subcr :
  57         if not s.estvide(): return 0
  58       return 1
  59
  60    def purge(self):
  61       """
  62            Purge complètement le CR sauf les exceptions
  63       """
  64       self.debut=''
  65       self.fin=''
  66       self.dec='   '
  67       self.crok=[]
  68       self.crwarn=[]
  69       self.crfatal=[]
  70       self.subcr=[]
  71
  72    def beautifie_messages(self):
  73       """
  74         Beautifie les messages stockés dans crok,crfatal,crexception et crwarn
  75       """
  76       l=[]
  77       for mess in self.crok:
  78          l.append(mess+'\n')
  79       self.crok_belle=l
  80       l=[]
  81       for mess in self.crwarn:
  82          l.append(encadre_message(mess,'*'))
  83       self.crwarn_belle = l
  84       l=[]
  85       for mess in self.crfatal:
  86          l.append(encadre_message(mess,'!'))
  87       self.crfatal_belle = l
  88       l=[]
  89       for mess in self.crexception:
  90          l.append(encadre_message(mess,'!'))
  91       self.crexception_belle = l
  92
  93    def indent(self,s):
  94       """
  95         Insère en tete de chaque ligne du texte s la chaine self.dec
  96       """
  97       l = string.split(s,'\n')
  98       return self.dec+string.join(l,'\n'+self.dec)[:-3]
  99
 100    def __str__(self):
 101       """
 102         Retourne une chaîne de caractères décorée et représentative de self
 103       """
 104       s=''
 105       self.beautifie_messages()
 106       s=s+string.join(self.crok_belle)
 107       s=s+string.join(self.crwarn_belle)
 108       s=s+string.join(self.crfatal_belle)
 109       s=s+string.join(self.crexception_belle)
 110       for subcr in self.subcr:
 111          if self.verbeux == 'oui':
 112             s=s+str(subcr)+'\n'
 113          else:
 114             if not subcr.estvide():
 115                s=s+str(subcr)
 116       if s != '':
 117          s=self.debut+'\n'+self.indent(s)+self.fin+'\n'
 118       else :
 119          s=self.debut+'\n'+self.fin+'\n'
 120       return s
 121
 122    def report(self,decalage = 2):
 123       """
 124         Retourne une chaîne de caractères non encadrée mais représentative de self
 125       """
 126       s=''
 127       # on stocke dans s les messages de premier niveau
 128       for mess in self.crok :
 129         s=s + decalage*self.dec + mess + self.dec + '\n'
 130       for mess in self.crwarn:
 131         s=s + decalage*self.dec + mess + self.dec + '\n'
 132       for mess in self.crfatal:
 133         s=s + decalage*self.dec + mess + self.dec + '\n'
 134       for mess in self.crexception:
 135         s=s + decalage*self.dec + mess + self.dec + '\n'
 136       # on récupère les messages des sous comptes-rendus ...
 137       for subcr in self.subcr:
 138         if not subcr.estvide():
 139             s=s+subcr.report(decalage = decalage + 1)
 140       # on rajoute les flags de début et de fin ... (si self n'est pas vide)
 141       if not self.estvide() :
 142         s = (decalage-1)*self.dec+self.debut+'\n'+s+ \
 143             (decalage-1)*self.dec+self.fin+'\n'
 144       return s
 145
 146    def get_mess_fatal(self):
 147       """
 148           Retourne une chaîne de caractères contenant les messages de
 149           la liste crfatal (du dernier au premier)
 150       """
 151       self.crfatal.reverse()
 152       s=''
 153       for elem in self.crfatal :
 154         s=s+elem
 155       self.crfatal.reverse()
 156       return s
 157
 158    def get_mess_exception(self):
 159       """
 160           Retourne une chaîne de caractères contenant les messages
 161           de la liste crexception (du dernier au premier)
 162       """
 163       self.crexception.reverse()
 164       s=''
 165       for elem in self.crexception :
 166         s=s+elem
 167       self.crexception.reverse()
 168       return s
 169
 170
 171
 172
 173 def justify_text(texte='',cesure=50):
 174   """
 175       Prend la chaîne de caractères 'texte' et la retourne avec un retour chariot
 176       tous les 'cesure' caractères s'il y a lieu (le retour chariot est placé dans un blanc
 177       et non au milieu d'un mot
 178   """
 179   texte = string.strip(texte)
 180   if len(texte) < cesure : return texte
 181   liste_lignes = string.split(texte,'\n')
 182   texte_justifie = ''
 183   for ligne in liste_lignes :
 184     ligne = string.strip(ligne)
 185     if len(ligne) <= cesure :
 186       texte_justifie = texte_justifie + ligne + '\n'
 187       continue
 188     longueur = 0
 189     new_text = ''
 190     liste_mots = string.split(ligne,' ')
 191     for mot in liste_mots :
 192       new_longueur = longueur + len(mot)+1
 193       if new_longueur < cesure :
 194         new_text = new_text+' '+mot
 195         longueur = longueur + len(mot) + 1
 196       else :
 197         longueur = 0
 198         new_text = new_text + '\n'+mot
 199     texte_justifie = texte_justifie + string.strip(new_text) + '\n'
 200   return texte_justifie[0:-1]
 201
 202 def encadre_message(texte,motif):
 203   """
 204      Retourne la chaîne de caractères texte entourée d'un cadre formés
 205      d'éléments 'motif'
 206   """
 207   texte = justify_text(texte,cesure=80)
 208   lignes = string.split(texte,'\n')
 209   longueur = 0
 210   for ligne in lignes :
 211     if len(ligne)> longueur : longueur = len(ligne)
 212   longueur = longueur + 4
 213   txt = motif*longueur+'\n'
 214   for ligne in lignes :
 215     txt = txt + motif + ' '+ligne+' '*(longueur-len(motif+ligne)-2)+motif+'\n'
 216   txt = txt + motif*longueur+'\n'
 217   return txt
 218
 219
 220
 221