Ca ne fait pas longtemps que je re-code en AS2 au quotidien. Et depuis que j'ai repris, j'utilise ma classe Debug intensivement, et la fait donc évoluer en fonction de mes besoins, et aussi des bugs qu'elle peut comporter...

Au programme de cette nouvelle version, tout d'abord le fait d'éviter une boucle infinie dans le cas ou un object est composé d'un autre, qui lui-même pointe vers son parent. En gros, c'est comme si on parcourait récursivement un clip, et sa propriété _parent...

Ensuite, une méthode éxécutée au premier appel de dump(), qui va parcourir toutes les classes présentes et leur créer une propriété contenant le nom de la classe, et une propriété conternant le nom du package. Cela permet d'afficher tout ca lors du dump d'un objet... En fait, c'est le seul moyen de retrouver le nom d'une classe sans le préciser dans le code de cette classe... Je crois me souvenir que Liguorien avait déjà évoqué ce sujet, s'inspirant de la partie reflection de la librairie as2lib...

Et troisièmement, la possibilité de spécifier un caractère qui permettra d'ignorer toute propriété dont le nom commence par celui-ci... Par exemple, il m'arrive d'utiliser une propriété contenant un XML dans mes classes. Il me suffit de faire commencer son nom par '$' (caractère par défaut) pour qu'elle ne soit pas incluses dans l'affichage...

/**
* Debug
* @version 0.2
* @package com.lalex.utils
*
* @author LAlex
* @since 2005-08-16
*/
class com.lalex.utils.Debug {
   /**
   * Property used to store class names
   */
   public static var classNameProperty:String = "__className";
   public static var packNameProperty:String = "__packName";
   private static var ignoreChar:String = "$";
   private static var __classInit:Boolean = false;
   /**
   * Trace an object detailled content
   * @param o Object to display
   */
   public static function dump(o) {
                if (!__classInit) {
                        initClassNames();
                        __classInit = true;
                }
                trace(dumpToString(o));
   }
        /**
        * Browse all classes and create a property for class name
        * and a property for package name
        * Browse is recursive
        * @param o Object containing classes
        * @param pa Package name
        */
   public static function initClassNames(o, pa:String) {
                if (!__classInit) {
                        o = o ? o : _global;
                        pa = pa.length ? pa : "";
                        for (var p in o) {
                                if (typeof o[p] == "function") {
                                        o[p][classNameProperty] = p;
                                        o[p][packNameProperty] = pa.length ? pa.substr(0, pa.length-1) : "";
                                        _global["ASSetPropFlags"](o[p], classNameProperty + "," + packNameProperty, 7);
                                } else if (typeof o[p] == "object") {
                                        initClassNames(o[p], pa + p + ".");
                                }
                        }
                }
        }
   /**
   * Return a string containing the object content. Recursive method
   * @param o Target object
   * @param d Depth. Used to generate tabs
   * @param a Array containing already dumped objects
   */
        private static function dumpToString(o, d:Number, id:Number):String {
                var ret:String = "[";
                d = d ? d : 0;
                id = id ? id : _dumped.push(new Array())-1;
                var dp:Number = d;
                var sp:String = "";
                while (d-- > 0) {
                        sp += "  ";
                }
                if (typeof o == "object") {
                        if ( o["__constructor__"][classNameProperty] ) {
                                ret += o["__constructor__"][classNameProperty] + " (" + o["__constructor__"][packNameProperty] + ")";
                        } else if (o instanceof Array) {
                                ret += "Array";
                        } else {
                                ret += "Object";
                        }
                        if (!o.__dumped) {
                                ret += "
" + sp;
                                o.__dumped = true;
                                _global["ASSetPropFlags"](o, "__dumped", 1);
                                _dumped[id].push(o);
                                for (var p in o) {
                                        if (typeof p != "function") {
                                                if (p.substr(0,1) != ignoreChar) {
                                                        ret += p + ": " + dumpToString(o[p], dp+1, id) + "
" + sp;
                                                }
                                        }
                                }
                        }
                        ret += "]";
                } else {
                        ret = o.toString();
                }
                var nd:Number = _dumped[id].length;
                while (nd-- > 0) {
                        var df = _dumped[id].pop();
                        df.__dumped = false;
                        delete df.__dumped;
                }
                return ret;
        }
        private static var _dumped:Array;
}

En prévision, pourquoi pas de pouvoir retrouver l'héritage d'une classe, comme l'a suggéré ekameleon dans le premier post de cette classe ?

::Télécharger Debug 0.2::