Noyau/N_BLOC.py

   1 """
   2     Ce module contient la classe de definition BLOC
   3     qui permet de spécifier les caractéristiques des blocs de mots clés
   4 """
   5
   6 import types,string
   7 import traceback
   8
   9 import N_ENTITE
  10 import N_MCBLOC
  11 from N_Exception import AsException
  12
  13 class BLOC(N_ENTITE.ENTITE):
  14    """
  15     Classe pour definir un bloc de mots-cles
  16
  17     Cette classe a deux attributs de classe :
  18
  19     - class_instance qui indique la classe qui devra etre utilisée
  20             pour créer l'objet qui servira à controler la conformité d'un
  21             bloc de mots-clés avec sa définition
  22
  23     - label qui indique la nature de l'objet de définition (ici, BLOC)
  24
  25    """
  26    class_instance = N_MCBLOC.MCBLOC
  27    label = 'BLOC'
  28
  29    def __init__(self,fr="",ang="",docu="",regles=(),statut='f',condition=None,
  30                      **args):
  31
  32       """
  33           Un bloc est caractérisé par les attributs suivants :
  34
  35           - fr   : chaine de caractere commentaire pour aide en ligne (en francais)
  36
  37           - ang : chaine de caractere commentaire pour aide en ligne (en anglais)
  38
  39           - regles : liste d'objets de type REGLE pour vérifier la cohérence des sous-objets
  40
  41           - statut : obligatoire ('o') ou facultatif ('f')
  42
  43           - condition : chaine de caractère evaluable par l'interpreteur Python
  44
  45           - entites : dictionnaire contenant les sous-objets de self (mots-clés). La clé du dictionnaire
  46                      est le nom du mot-clé et la valeur l'objet de définition correspondant. Cet attribut
  47                      est initialisé avec l'argument args de la méthode __init__
  48
  49       """
  50       # Initialisation des attributs
  51       self.fr=fr
  52       self.ang=ang
  53       self.docu=docu
  54       if type(regles)== types.TupleType:
  55           self.regles=regles
  56       else:
  57           self.regles=(regles,)
  58       self.statut=statut
  59       self.condition=condition
  60       self.entites=args
  61       self.affecter_parente()
  62
  63    def __call__(self,val,nom,parent=None):
  64       """
  65           Construit un objet MCBLOC a partir de sa definition (self)
  66           de sa valeur (val), de son nom (nom) et de son parent dans l arboresence (parent)
  67       """
  68       return self.class_instance(nom=nom,definition=self,val=val,parent=parent)
  69
  70    def verif_cata(self):
  71       """
  72          Cette méthode vérifie si les attributs de définition sont valides.
  73          Les éventuels messages d'erreur sont écrits dans l'objet compte-rendu (self.cr).
  74       """
  75       if type(self.fr) != types.StringType :
  76         self.cr.fatal("L'attribut 'fr' doit être une chaîne de caractères : %s" %`self.fr`)
  77       if type(self.docu) != types.StringType :
  78         self.cr.fatal("L'attribut 'docu' doit être une chaîne de caractères : %s" %`self.docu`)
  79       if type(self.regles) != types.TupleType :
  80         self.cr.fatal("L'attribut 'regles' doit être un tuple : %s" %`self.regles` )
  81       if self.statut not in ['f','o'] :
  82         self.cr.fatal("L'attribut 'statut' doit valoir 'o' ou 'f' : %s" %`self.statut` )
  83       if self.condition != None :
  84         if type(self.condition) != types.StringType :
  85           self.cr.fatal("L'attribut 'condition' doit être une chaîne de caractères : %s" %`self.condition`)
  86       else:
  87         self.cr.fatal("La condition ne doit pas valoir None !")
  88       self.verif_cata_regles()
  89
  90    def verif_presence(self,dict):
  91       """
  92          Cette méthode vérifie si le dictionnaire passé en argument (dict)
  93          est susceptible de contenir un bloc de mots-clés conforme à la
  94          définition qu'il porte.
  95
  96          Si la réponse est oui, la méthode retourne 1
  97
  98          Si la réponse est non, la méthode retourne 0
  99
 100          Le dictionnaire dict a pour clés les noms des mots-clés et pour valeurs
 101          les valeurs des mots-clés
 102       """
 103       # On recopie le dictionnaire pour protéger l'original
 104       dico=dict.copy()
 105       # XXX on ajoute AsType pour permettre les évaluations
 106       # XXX pour le moment en commentaire. Voir si on ne peut pas faire autrement.
 107       #dico['AsType']=AsType
 108       if self.condition != None :
 109         try:
 110           test = eval(self.condition,dico)
 111           return test
 112         except NameError:
 113           # erreur 'normale' : un mot-clé n'est pas présent et on veut l'évaluer dans la condition
 114           return 0
 115         except SyntaxError:
 116           # le texte de la condition n'est pas du Python correct --> faute de catalogue
 117           l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
 118           raise AsException("Catalogue entite : ", self.nom,", de pere : ", self.pere.nom,
 119                      '\n',"Erreur dans la condition : ", self.condition,string.join(l))
 120         except:
 121           l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
 122           raise AsException("Catalogue entite : ", self.nom,", de pere : ", self.pere.nom,
 123                      '\n',"Erreur dans la condition : ", self.condition,string.join(l))
 124       else :
 125         return 0
 126