Produits Entr'ouvert » w.c.s.

Ah zut.

La logique actuelle dans Combo est : « on tente de faire une addition si le membre de gauche est un décimal ou est convertible en décimal, sinon on fait le add de Django »

Le risque est de faire planter les usages actuels de add sur une variable non existante ou égale à None (des choses comme {{ form_var_nb_mails_envoyes_Stat_raw|add:"1" }} sur Chambéry)

J'ai envie de conserver la magie et de ne pas imposer le "|decimal|add".

• si gauche est convertible en décimal, alors on converti "de force" droite en décimal (avec échec = 0) et on additionne
• si droite est convertible en décimal, alors on tente de convertir le gauche en décimal : si ça marche, on additionne. Si le gauche est vide ou inexistant, il vaut 0 et on additionne.
• dans les autres cas : on bascule vers le add de Django

Il restera le cas de deux variables inexistantes ou vides dont l'addition valait 0... ça ne sera plus vrai, mais ça reverra le vide, alors je considère que "ça va".

(et si c'est cette logique qu'on adopte, il faudra aussi la renvoyer vers Combo).

Je serais, sans me soucier de la position des termes,

• nombre et nombre → addition
• nombre et None → nombre (+ 0)
• nombre et chaine vide → nombre (+ 0)
• nombre et autre chose → django add
• None et None → None
• chaine et None → chaine (+ "")
• autre chose et autre chose → django add

en définissant comme nombre ce qui sort sans erreur de Decimal(value).quantize(Decimal('1.0000')).normalize() (ex: "12,3").

Et j'oublie peut-être des situations.

Le filtre add Django retourne "" si on l'utilise avec None.

Mais tu n'as pas mis "native" dans la matrice pour ce cas, semble-t-il.

Aussi, quand un terme est "?" et que l'autre est None, tu renvoies vers onNone. Il faut plutôt faire du natif dans ce cas, je crois.

Et je ne suis pas très à l'aise avec l'idée de répondre "None" dans None+None, je préférerais qu'on réponde "". Pourquoi pensais-tu mieux de répondre None, Frédéric ?

Je n'ai pas de souvenir particulier d'exemple me menant à ça, c'était il y a plusieurs heures déjà...

Je préfère que None+None renvoie "" comme le fait Django par défaut.

En reprenant les règles de Frédéric qui me vont bien :

• nombre et nombre → addition
• nombre et None → nombre (+ 0)
• nombre et chaine vide → nombre (+ 0)
• chaine et None → chaine (+ "")

et "tout le reste" via django add, dans ce que listait Frédéric :

• nombre et autre chose → django add
• None et None → django add
• autre chose et autre chose → django add

On voit qu'avec cette logique, les None peuvent être remplacés par "" avant les tests, et il ne reste que :

• nombre et nombre → addition
• nombre et chaine vide → nombre (+ 0)

Dans les tests, il faudrait aussi vérifier ce que tout ça va donner avec des variables non existantes à droite comme à gauche (il faudrait qu'elles soient considérées comme vides).

Nicolas, la notion de matrice est jolie, mais si essaye de voir quelques instants si on ne peut pas écrire ça sous une suite de "if" plus parlante, sait-on jamais.

Pour info le code de Django:

###################
# INTEGERS        #
###################

@register.filter(is_safe=False)
def add(value, arg):
    """Add the arg to the value.""" 
    try:
        return int(value) + int(arg)
    except (ValueError, TypeError):
        try:
            return value + arg
        except Exception:
            return ''

(ouaip, c'est rangé dans le code comme faisant partie des additions sur des entiers, amusant)

fail-back → fallback.

both termes → both terms.

Dans les tests, c'est bizarre d'avoir des lignes qui disparaissent et ne pas savoir ce qu'elles deviennent, genre :

-    assert tmpl.render({'term1': 'not a number', 'term2': 1.2}) == '1.2'

je préférerais que la ligne reste, avec son résultat différent. (pareil pour les autres).

Manquent des tests avec la virgule comme séparateur décimal.