/ext3/src/error-checking.js

/*!
 * Ext JS Library 3.3.0
 * Copyright(c) 2006-2010 Ext JS, Inc.
 * licensing@extjs.com
 * http://www.extjs.com/license
 */
Ext.ns('Ext.debug');

Ext.debug.Assistant = function(){

    var enabled = true;

        

    return {

        enable: function(){

            enabled = true;

        },

        

        disable: function(){

            enabled = false;

        },

        

        init : function(classes){

            var klass,

                intercept = false,

                fn,

                method;

            Ext.each(classes, function(cls){

                if(this.namespaceExists(cls.name)){

                    klass = this.getClass(cls.name);

                    method = cls.instance ? this.addInstanceCheck : this.addPrototypeCheck;

                    Ext.each(cls.checks, function(check){

                        intercept = check.intercept == true;

                        fn = method.call(this, klass, check.name, check.fn, check.intercept == true);

                        if(check.after){

                            check.after(fn);

                        }

                    }, this);

                }

            }, this);  

        },

        

        namespaceExists: function(name){

            var parent = window,

                exists = true;

                

            Ext.each(name.split('.'), function(n){

                if(!Ext.isDefined(parent[n])){

                    exists = false;

                    return false;

                }

                parent = parent[n];

            });

            return exists;

        },

        

        getClass : function(name){

            var parent = window;

            Ext.each(name.split('.'), function(n){

                parent = parent[n];

            });  

            return parent;

        },

        

        warn: function(){

            if(enabled && window.console){

                console.warn.apply(console, arguments);

            }

        },

        

        error: function(){

            if(enabled && window.console){

                console.error.apply(console, arguments);

            }

        },

        

        addPrototypeCheck : function(cls, method, fn, intercept){

            return (cls.prototype[method] = cls.prototype[method][intercept ? 'createInterceptor' : 'createSequence'](fn));

        },

        

        addInstanceCheck : function(cls, method, fn, intercept){

            return (cls[method] = cls[method][intercept ? 'createInterceptor' : 'createSequence'](fn));

        }

    };

}();



(function(){

    var A = Ext.debug.Assistant,

        cls = [];

        

    cls.push({

        name: 'Ext.util.Observable',

        checks: [{

            name: 'addListener',

            intercept: true,

            fn: function(eventName, fn){

                if(typeof eventName == 'object'){

                    var ev, o;

                    for(ev in eventName){

                        if(!this.filterOptRe.test(ev)){

                            o = eventName[ev];

                            o = o && o.fn ? o.fn : o;

                            if(!Ext.isFunction(o)){

                                A.error('Non function passed to event listener', this, ev);

                                return false;

                            }

                        }

                    }

                }else{

                    if(!Ext.isFunction(fn)){

                        A.error('Non function passed to event listener', this, eventName);

                    }

                }

            },

            after: function(method){

                Ext.util.Observable.prototype.on = method;

            }

        }]

    });

    

    cls.push({

        name: 'Ext.Component',

        checks: [{

            name: 'render',

            intercept: true,

            fn: function(container, position){

                if(!container && !this.el){

                    A.error('Unable to render to container', this, container);

                }

            

                if(this.contentEl){

                    var el = Ext.getDom(this.contentEl);

                    if(!el){

                        A.error('Specified contentEl does not exist', this, this.contentEl);

                        return false;

                    }

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.Container',

        checks: [{

            name: 'onBeforeAdd',

            intercept: true,

            fn: function(c){

                if(c.isDestroyed){

                    A.warn('Adding destroyed component to container', c, this);

                }

                if(c.renderTo){

                    A.warn('Using renderTo while adding an item to a Container. You should use the add() method or put the item in the items configuration', c, this);

                }

                if(c.applyTo){

                    A.warn('Using applyTo while adding an item to a Container. You should use the add() method or put the item in the items configuration', c, this);

                }

                

                var type = this.layout.type;

                if(type == 'container' || type == 'auto'){

                    A.warn('A non sizing layout is being used in a container that has child components. This means the child components will not be sized.', this);

                }

            }

        },{

            name: 'lookupComponent',

            intercept: true,

            fn: function(c){

                var valid = true;

                if(Ext.isEmpty(c)){

                    valid = false;

                }

                if(Ext.isString(c)){

                    c = Ext.ComponentMgr.get(comp);

                    valid = !Ext.isEmpty(c);

                }

                if(!valid){

                    A.error('Adding invalid component to container', this, c);

                    return false;

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.DataView',

        checks: [{

            name: 'initComponent',

            fn: function(){

                if(!this.itemSelector){

                    A.error('No itemSelector specified', this);

                }

            }

        },{

            name: 'afterRender',

            fn: function(){

                if(!this.store){

                    A.error('No store attached to DataView', this);

                } 

            }

        }]

    });

    

    cls.push({

        name: 'Ext.Window',

        checks: [{

            name: 'show',

            intercept: true,

            fn: function(){

                if(this.isDestroyed){

                    A.error('Trying to show a destroyed window. If you want to reuse the window, look at the closeAction configuration.', this);

                    return false;

                } 

            }

        }]

    });

    

    cls.push({

        name: 'Ext.grid.GridPanel',

        checks: [{

            name: 'initComponent',

            fn: function(){

                if(!this.colModel){

                    A.error('No column model specified for grid', this);

                }

                if(!this.store){

                    A.error('No store specified for grid', this);

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.grid.GridView',

        checks: [{

            name: 'autoExpand',

            intercept: true,

            fn: function(){

                var g = this.grid, 

                cm = this.cm;

                if(!this.userResized && g.autoExpandColumn){

                    var tw = cm.getTotalWidth(false), 

                        aw = this.grid.getGridEl().getWidth(true) - this.getScrollOffset();

                    if(tw != aw){

                        var ci = cm.getIndexById(g.autoExpandColumn);

                        if(ci == -1){

                            A.error('The autoExpandColumn does not exist in the column model', g, g.autoExpandColumn);

                            return false;

                        }

                    }

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.chart.Chart',

        checks: [{

            name: 'initComponent',

            fn: function(){

                if(!this.store){

                    A.error('No store specified for chart', this);

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.tree.TreePanel',

        checks: [{

            name: 'afterRender',

            intercept: true,

            fn: function(){

                if(!this.root){

                    A.error('No root node specified for tree', this);

                    return false;

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext',

        instance: true,

        checks: [{

            name: 'extend',

            intercept: true,

            fn: function(){

                if(arguments.length == 2 && !arguments[0]){

                    A.error('Invalid base class passed to extend', arguments[0]);

                    return false;

                }    

                if(arguments.length == 3){

                    if(!arguments[0]){

                        A.error('Invalid class to extend', arguments[0]);

                        return false;    

                    }else if(!arguments[1]){

                        A.error('Invalid base class passed to extend', arguments[1]);

                        return false;

                    }

                }

            }

        },{

            name: 'override',

            intercept: true,

            fn: function(c){

                if(!c){

                    A.error('Invalid class passed to override', c);

                    return false;

                }

            }

        }]    

    });

    

    cls.push({

        name: 'Ext.ComponentMgr',

        instance: true,

        checks: [{

            name: 'register',

            intercept: true,

            fn: function(c){

                if(this.all.indexOfKey(c.id) > -1){

                    A.warn('A component with this id already exists', c, c.id);

                }

            }

        },{

            name: 'create',

            intercept: true,

            fn: function(config, defaultType){

                var types = Ext.ComponentMgr.types;

                if(!config.render){

                    if(config.xtype){

                        if(!types[config.xtype]){

                            A.error('Unknown xtype specified', config, config.xtype);

                            return false;

                        }

                    }else{

                        if(!types[defaultType]){

                            A.error('Unknown defaultType specified', config, defaultType);

                            return false;

                        }

                    }

                }

            }

        }]

    });

    

    cls.push({

        name: 'Ext.layout.FitLayout',

        checks: [{

            name: 'onLayout',

            intercept: true,

            fn: function(){

                var ct = this.container;

                if(ct.items.getCount() > 1){

                    A.warn('More than 1 item in the container. A fit layout will only display a single item.', ct);

                }

            }

        }]

    });

    

    if(Ext.BLANK_IMAGE_URL == 'http:/' + '/www.extjs.com/s.gif'){

        A.warn('You should set the Ext.BLANK_IMAGE_URL to reference a local copy.');

    }

    

    A.init(cls);

    

        

})();