Salut les mecs,
Je viens de finir de polir une fonction sensée ajuster un code python qui lui
serait passé en paramètre.
Par ajuster, je veux dire concrètement:
* séparer les opérateurs des autres caractères par un espace à gauche et à
droite;
* mettre un caractère d'espace à gauche avant les englobants ouvrants que sont
les caractères "([{" et veiller à ce qu'il n'y en ait pas à droite;
* éliminer les espaces à gauche des englobants fermants que sont les caractères
")]}"
* éliminer les espaces à gauches du caractère ":";
* éliminer les espaces superflux (c'est-à-dire plus de 2 espaces hormis les
chaînes string ou commentaires) dans tout le code;
* éliminer les espaces et tabulation à la fin des lignes nonvides.
D'autres traitements peuvent encore être réalisés, mais ceux sus-cités rendent
déjà le code plus homogène, plus synchrone et plus propre.
Petite précision: cette fonction prend le soin d'écarter du code toutes les
chaînes string et commentaires avant d'appliquer ces ajustement, pour finir par
restaurer ces chaînes string et commentaires exactement aux endroits qu'ils
occupaient.
Je pense que cette fonctionnalité peut se proposer sous la forme d'un élément
de menu pour permettre à l'utilisateur d'ajuster/formatter le code au moment
voulu;
ou être intégrée à la vérification automatique d'une ligne qui vient d'être
modifiée afin de rapidement correctement formatter la dite ligne.
Mais pour le moment, à la fin de cette fonction, au lieu de remplacer le texte,
je me contente d'un print qui sert à apprécier la convertions dans la pseudo
console de 6pad++.
Je réfléchis actuellement sur l'étape supérieure vers son évolution qui est la
re-écriture des mots clés.
Essayez d'imaginer la possibilité que si vous avez déjà écrit un nom de
variable plus haut dans le code, que vous n'ayez plus à vous soucier du respect
de la cass lors de son écriture plus bas à cause du fait que le script ajuste
automatiquement cette cass.
Cependant, ce comportement sous-entendrait par exemple que les variables a
(minuscule) et A (majuscule) ne seraient plus différenciées et que leur cass
serait ajusté selon la première de leur écriture, d'où ma préoccupation
d'aujourd'hui.
Je trouve que ceci n'est pas anodin et va au dela d'une simple mise en forme du
code.
Peut-on véritablement coder en python comme on coderait en vb6 sans ce soucier
de la cass ?
Ce serait toute une autre philosophie de programmation et les conséquences pour
les anciens codes risquent de ne pas être si négligeables que ça.
Souhaitez-vous que j'aille dans cette direction ?
Y trouvez-vous des inconvénients ? Des raisons de me dissuader de
volontairement ainsi brider le python ?
Je vous colle quand même le code de la fonction que j'ai fais jusqu'ici.
Début du code python
def adjustCode(s):
# ajuste le code
lstPt = []
lstString = []
# recencement des chaînes string
# string avec triples quotes en appostrophes
lstPt.append ("'{3,5}[\w\W]+?'{3,5}")
# string avec triples quotes en guillemets
lstPt.append("\"{3,5}[\\w\\W]+?\"{3,5}")
# string avec appostrophes
lstPt.append (r"'.*?((?<!\\\\\\\\\\)|(?<!\\\\\\)|(?<!\\))'")
# string avec guillemets
lstPt.append (r'".*?((?<!\\\\\\\\\\)|(?<!\\\\\\)|(?<!\\))"')
# commentaire uniligne
lstPt.append ("\\#[^\\r\\n]*")
# concaténation
pt = "("+"|".join(lstPt)+")"
# recherche
lstString = re.finditer(pt, s)
# remplacement des strings et commentaires par des génériques
i = 0
iStart = 0
iEnd = 0
s2=s
s = ""
tag = "[___tag___yyd"
for e in lstString:
i=i+1
d, f = e.span(0)
iEnd = d-1
s= s + s2[iStart: iEnd+1] + tag + str(i) + "]"
iStart = f
# end for
# ajout de la dernière portion
try: s = s + s2[f:]
except: pass
# séparation des opérateurs des autres caractères par des espaces
pt = r"[ ]*(\+=|-=|\*=|/=|<=|>=|==|!=|=|\+|-|\*|/|!=|<|>|%)[ ]*"
s = re.sub(pt, " \\1 ", s)
# les englobeurs ouvrants doivent être
# séparés des autres caractères par un espace à gauche
pt = r"([\(\[\{]+)[ ]*"
s = re.sub(pt, " \\1", s)
# ceux desquels On doit retirer les espaces avant
pt = r"([_]*[a-z][a-z_\d]*)[ ]+([\(\[\{]+)"
s = re.sub(pt, "\\1\\2", s, re.I)
# les englobeurs fermants
pt = r"[ ]*([\)\]\}:]+)"
s = re.sub(pt, "\\1", s)
# ceux qui doivent avoir un espace avant, mais pas après
pt = r"[ ]*([\\]+)[ ]*"
s = re.sub(pt, " \\1", s)
# ceux qui doivent avoir un espace après, mais pas avant
pt = r"[ ]*([,]+)[ ]*"
s = re.sub(pt, "\\1 ", s)
# les espaces trop grands
pt = r"[ ]{2,}"
s = re.sub(pt, " ", s)
# élimination des espaces et tabulations en fin de ligne
pt = r"([^ \t]+)[ \t]+$"
s = re.sub(pt, "\\1", s, re.M)
# restauration des string à partir des génériques
i = 0
for e in lstString:
i = i+1
s = s.replace(tag+str(i)+"]", e.group(0), 1)
# end for
print(s)
# end def
Fin du code python
Yannick Daniel Youalé
La programmation est une religion. Aimez-la, ou quittez-la.
www.visuweb.net
