extjs-mvc 0.4.0.j → 0.4.0.k

data/test/app/vendor/extjs-mvc/testrunner/TestGrid.js

@@ -0,0 +1,351 @@
+/**
+ * @class ExtMVC.test.TestGrid
+ * @extends Ext.grid.GridPanel
+ * Customised GridPanel which shows the results of unit tests
+ */
+ExtMVC.test.TestGrid = Ext.extend(Ext.grid.GridPanel, {
+
+  initComponent: function() {
+    var expander = new Ext.ux.grid.RowExpander({
+      tpl : new Ext.XTemplate(
+        '<tpl for="failingSpecs">',
+          '<div class="detail">',
+            '<tpl for="suite">',
+              '<h2>Suite: {name}</h2>',
+            '</tpl>',
+            'Expectation: {description}',
+            '<ul class="assertions">',
+              '<tpl for="assertions">',
+                '<li>',
+                  '{message}',
+                '</li>',
+              '</tpl>',
+            '</ul>',
+            '<div class="code">',
+              '{code}',
+            '</div>',
+          '</div>',
+        '</tpl>'
+      )
+    });
+    
+    Ext.applyIf(this, {
+      plugins: expander,
+      
+      store: new Ext.data.JsonStore({
+        data  : [],
+        fields: [
+          {name: 'passes',   type: 'int'},
+          {name: 'failures', type: 'int'},
+          {name: 'time',     type: 'int'},
+          {name: 'total',    type: 'int', mapping: 'specs'},
+          {name: 'failingSpecs'}
+        ]
+      }),
+      
+      cm: new Ext.grid.ColumnModel({
+        defaults: {
+          sortable: false
+        },
+        columns: [
+          expander,
+          {
+            header   : "Passes",
+            dataIndex: 'passes'
+          },
+          {
+            header   : "Failures",
+            dataIndex: 'failures'
+          },
+          {
+            header   : "Total",
+            dataIndex: 'total'
+          },
+          {
+            header   : "Time (ms)",
+            dataIndex: 'time'
+          }
+        ]
+      }),
+      
+      viewConfig: {
+        forceFit: true,
+        getRowClass: function(record, index) {
+          return record.get('failures') == 0 ? 'pass' : 'fail';
+        }
+      }
+    });
+    
+    ExtMVC.test.TestGrid.superclass.initComponent.apply(this, arguments);
+    
+    /**
+     * When a new row has been inserted, expand it if the tests didn't all pass
+     * We have to do a little hack to set the rowIndex inside here, as the RowExpander
+     * plugin errors otherwise :/
+     */
+    this.getView().on('rowsinserted', function(view, firstRow, lastRow) {
+      var record = this.store.getAt(firstRow);
+      
+      if (record.get('failures') > 0) {
+        //first, collapse all rows
+        this.store.each(function(record, index) {
+          var row = view.getRow(index);
+          row.rowIndex = index;
+          
+          expander.collapseRow(row);
+        });
+
+        //now, expand the last row as it contains errors
+        var row = view.getRow(firstRow);
+        row.rowIndex = firstRow;
+
+        expander.expandRow(row);
+        
+        row.scrollIntoView(this.ownerCt);
+      };
+    }, this);
+  }
+});
+
+
+/*!
+ * Ext JS Library 3.0+
+ * Copyright(c) 2006-2009 Ext JS, LLC
+ * licensing@extjs.com
+ * http://www.extjs.com/license
+ */
+Ext.ns('Ext.ux.grid');
+
+/**
+ * @class Ext.ux.grid.RowExpander
+ * @extends Ext.util.Observable
+ * Plugin (ptype = 'rowexpander') that adds the ability to have a Column in a grid which enables
+ * a second row body which expands/contracts.  The expand/contract behavior is configurable to react
+ * on clicking of the column, double click of the row, and/or hitting enter while a row is selected.
+ *
+ * @ptype rowexpander
+ */
+Ext.ux.grid.RowExpander = Ext.extend(Ext.util.Observable, {
+    /**
+     * @cfg {Boolean} expandOnEnter
+     * <tt>true</tt> to toggle selected row(s) between expanded/collapsed when the enter
+     * key is pressed (defaults to <tt>true</tt>).
+     */
+    expandOnEnter : true,
+    /**
+     * @cfg {Boolean} expandOnDblClick
+     * <tt>true</tt> to toggle a row between expanded/collapsed when double clicked
+     * (defaults to <tt>true</tt>).
+     */
+    expandOnDblClick : true,
+
+    header : '',
+    width : 20,
+    sortable : false,
+    fixed : true,
+    menuDisabled : true,
+    dataIndex : '',
+    id : 'expander',
+    lazyRender : true,
+    enableCaching : true,
+
+    constructor: function(config){
+        Ext.apply(this, config);
+
+        this.addEvents({
+            /**
+             * @event beforeexpand
+             * Fires before the row expands. Have the listener return false to prevent the row from expanding.
+             * @param {Object} this RowExpander object.
+             * @param {Object} Ext.data.Record Record for the selected row.
+             * @param {Object} body body element for the secondary row.
+             * @param {Number} rowIndex The current row index.
+             */
+            beforeexpand: true,
+            /**
+             * @event expand
+             * Fires after the row expands.
+             * @param {Object} this RowExpander object.
+             * @param {Object} Ext.data.Record Record for the selected row.
+             * @param {Object} body body element for the secondary row.
+             * @param {Number} rowIndex The current row index.
+             */
+            expand: true,
+            /**
+             * @event beforecollapse
+             * Fires before the row collapses. Have the listener return false to prevent the row from collapsing.
+             * @param {Object} this RowExpander object.
+             * @param {Object} Ext.data.Record Record for the selected row.
+             * @param {Object} body body element for the secondary row.
+             * @param {Number} rowIndex The current row index.
+             */
+            beforecollapse: true,
+            /**
+             * @event collapse
+             * Fires after the row collapses.
+             * @param {Object} this RowExpander object.
+             * @param {Object} Ext.data.Record Record for the selected row.
+             * @param {Object} body body element for the secondary row.
+             * @param {Number} rowIndex The current row index.
+             */
+            collapse: true
+        });
+
+        Ext.ux.grid.RowExpander.superclass.constructor.call(this);
+
+        if(this.tpl){
+            if(typeof this.tpl == 'string'){
+                this.tpl = new Ext.Template(this.tpl);
+            }
+            this.tpl.compile();
+        }
+
+        this.state = {};
+        this.bodyContent = {};
+    },
+
+    getRowClass : function(record, rowIndex, p, ds){
+        p.cols = p.cols-1;
+        var content = this.bodyContent[record.id];
+        if(!content && !this.lazyRender){
+            content = this.getBodyContent(record, rowIndex);
+        }
+        if(content){
+            p.body = content;
+        }
+        return this.state[record.id] ? 'x-grid3-row-expanded' : 'x-grid3-row-collapsed';
+    },
+
+    init : function(grid){
+        this.grid = grid;
+
+        var view = grid.getView();
+        view.getRowClass = view.getRowClass.createSequence(this.getRowClass, this);
+
+        view.enableRowBody = true;
+
+
+        grid.on('render', this.onRender, this);
+        grid.on('destroy', this.onDestroy, this);
+    },
+
+    // @private
+    onRender: function() {
+        var grid = this.grid;
+        var mainBody = grid.getView().mainBody;
+        mainBody.on('mousedown', this.onMouseDown, this, {delegate: '.x-grid3-row-expander'});
+        if (this.expandOnEnter) {
+            this.keyNav = new Ext.KeyNav(this.grid.getGridEl(), {
+                'enter' : this.onEnter,
+                scope: this
+            });
+        }
+        if (this.expandOnDblClick) {
+            grid.on('rowdblclick', this.onRowDblClick, this);
+        }
+    },
+    
+    // @private    
+    onDestroy: function() {
+        if(this.keyNav){
+            this.keyNav.disable();
+            delete this.keyNav;
+        }
+        /*
+         * A majority of the time, the plugin will be destroyed along with the grid,
+         * which means the mainBody won't be available. On the off chance that the plugin
+         * isn't destroyed with the grid, take care of removing the listener.
+         */
+        var mainBody = this.grid.getView().mainBody;
+        if(mainBody){
+            mainBody.un('mousedown', this.onMouseDown, this);
+        }
+    },
+    // @private
+    onRowDblClick: function(grid, rowIdx, e) {
+        this.toggleRow(rowIdx);
+    },
+
+    onEnter: function(e) {
+        var g = this.grid;
+        var sm = g.getSelectionModel();
+        var sels = sm.getSelections();
+        for (var i = 0, len = sels.length; i < len; i++) {
+            var rowIdx = g.getStore().indexOf(sels[i]);
+            this.toggleRow(rowIdx);
+        }
+    },
+
+    getBodyContent : function(record, index){
+        if(!this.enableCaching){
+            return this.tpl.apply(record.data);
+        }
+        var content = this.bodyContent[record.id];
+        if(!content){
+            content = this.tpl.apply(record.data);
+            this.bodyContent[record.id] = content;
+        }
+        return content;
+    },
+
+    onMouseDown : function(e, t){
+        e.stopEvent();
+        var row = e.getTarget('.x-grid3-row');
+        this.toggleRow(row);
+    },
+
+    renderer : function(v, p, record){
+        p.cellAttr = 'rowspan="2"';
+        return '<div class="x-grid3-row-expander">&#160;</div>';
+    },
+
+    beforeExpand : function(record, body, rowIndex){
+        if(this.fireEvent('beforeexpand', this, record, body, rowIndex) !== false){
+            if(this.tpl && this.lazyRender){
+                body.innerHTML = this.getBodyContent(record, rowIndex);
+            }
+            return true;
+        }else{
+            return false;
+        }
+    },
+
+    toggleRow : function(row){
+        if(typeof row == 'number'){
+            row = this.grid.view.getRow(row);
+        }
+        this[Ext.fly(row).hasClass('x-grid3-row-collapsed') ? 'expandRow' : 'collapseRow'](row);
+    },
+
+    expandRow : function(row){
+        if(typeof row == 'number'){
+            row = this.grid.view.getRow(row);
+        }
+        
+        var record = this.grid.store.getAt(row.rowIndex);
+        var body = Ext.DomQuery.selectNode('tr:nth(2) div.x-grid3-row-body', row);
+        if(this.beforeExpand(record, body, row.rowIndex)){
+            this.state[record.id] = true;
+            Ext.fly(row).replaceClass('x-grid3-row-collapsed', 'x-grid3-row-expanded');
+            this.fireEvent('expand', this, record, body, row.rowIndex);
+        }
+    },
+
+    collapseRow : function(row){
+        if(typeof row == 'number'){
+            row = this.grid.view.getRow(row);
+        }
+        var record = this.grid.store.getAt(row.rowIndex);
+        var body = Ext.fly(row).child('tr:nth(1) div.x-grid3-row-body', true);
+        if(this.fireEvent('beforecollapse', this, record, body, row.rowIndex) !== false){
+            this.state[record.id] = false;
+            Ext.fly(row).replaceClass('x-grid3-row-expanded', 'x-grid3-row-collapsed');
+            this.fireEvent('collapse', this, record, body, row.rowIndex);
+        }
+    }
+});
+
+Ext.preg('rowexpander', Ext.ux.grid.RowExpander);
+
+//backwards compat
+Ext.grid.RowExpander = Ext.ux.grid.RowExpander;

data/test/app/vendor/extjs-mvc/testrunner/TestRunner.js

@@ -0,0 +1,110 @@
+/**
+ * @class ExtMVC.test.TestRunner
+ * @extends Ext.util.Observable
+ * Wraps JSpec to provide normal Ext-style events
+ */
+ExtMVC.test.TestRunner = Ext.extend(Ext.util.Observable, {
+
+  constructor: function(config) {
+    ExtMVC.test.TestRunner.superclass.constructor.apply(this, arguments);
+    
+    Ext.apply(this, {
+      /**
+       * @property hasRecentFailures
+       * @type Boolean
+       * True if the last full suite run had failures
+       */
+      hasRecentFailures: false,
+      
+      /**
+       * @property fullRun
+       * @type Boolean
+       * True if the last run was a full run (as opposed to only running a subset of suites)
+       */
+      fullRun: false
+    });
+    
+    this.addEvents(
+      /**
+       * @event starting
+       * Fires when the runner starts running specs
+       */
+      'starting',
+      
+      /**
+       * @event finished
+       * Fires when the runner has finished running a batch of tests
+       * @param {Object} stats Test pass stats
+       */
+      'finished'
+    );
+    
+    this.tests = [];
+  },
+  
+  onJSpecFinish: function(options) {
+    runner.fireEvent('finished', JSpec.stats);
+    
+    if (runner.fullRun == true) {
+      runner.hasRecentFailures = JSpec.stats.failures > 0;
+    }
+  },
+  
+  /**
+   * Adds an array of test suites
+   * @param {Array} tests Array of urls to load test suites from
+   */
+  addTests: function(tests) {
+    this.tests = this.tests.concat(tests);
+  },
+  
+  /**
+   * Executes an array of test files and fires the 'finished' event when complete
+   * @param {Array} tests Optional array of test files to run (defaults to all tests)
+   */
+  runTests: function(tests) {
+    //we're doing a full run if a test subset array was not passed in
+    this.fullRun = !Ext.isArray(tests);
+    
+    tests = tests || this.tests;
+    
+    delete JSpec;
+    var filename = "../vendor/jspec/lib/jspec.js",
+        callback = function() {
+          this.fireEvent('starting');
+          
+          JSpec.options.formatter = ExtMVC.test.JSpecFormatter;
+          
+          Ext.each(tests, function(test) {
+            JSpec.exec(test);
+          }, this);
+
+          JSpec.include({
+            utilities : {
+              runner: this
+            },
+            reporting : this.onJSpecFinish
+          });
+
+          JSpec.run({ failuresOnly: false }).report();
+        }.createDelegate(this);
+    
+    var script = document.createElement('script');
+    script.type = "text/javascript";
+    script.src = filename;
+    
+    //IE has a different way of handling <script> loads, so we need to check for it here
+    if (script.readyState) {
+      script.onreadystatechange = function(){
+        if (script.readyState == "loaded" || script.readyState == "complete") {
+          script.onreadystatechange = null;
+          callback();
+        }
+      };
+    } else {
+      script.onload = callback;
+    }
+    
+    document.getElementsByTagName("head")[0].appendChild(script);
+  }
+});