extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/dom/Element.static.js

@@ -0,0 +1,201 @@
+describe("Ext.Element.static", function() {
+    var proto = Ext.Element,
+        el, testEl,
+        input, testInputEl,
+        child1, child2, child3;
+    
+    beforeEach(function() {
+        testEl = Ext.getBody().createChild({
+            id      : 'ExtElementHelper',
+            style   : 'position:absolute;',
+            children: [
+                {id: 'child1', style: 'position:absolute;'},
+                {id: 'child2', style: 'position:absolute;'},
+                {id: 'child3', style: 'position:absolute;'}
+            ]
+        });
+        
+        testInputEl = Ext.getBody().createChild({
+            id  : 'ExtElementInputHelper',
+            tag : 'input',
+            type: 'text'
+        });
+        
+        el    = new Ext.Element(Ext.getDom(testEl));
+        input = new Ext.Element(Ext.getDom(testInputEl));
+        
+        child1 = Ext.get('child1');
+        child2 = Ext.get('child2');
+        child3 = Ext.get('child3');
+    });
+    
+    afterEach(function() {
+        testEl.remove();
+        testInputEl.remove();
+    });
+    
+    it("should have a defaultUnit", function() {
+        expect(proto.defaultUnit).toEqual('px');
+    });
+    
+    describe("addUnits", function() {
+        it("should add the defualt unit", function() {
+            expect(proto.addUnits(10)).toEqual('10px');
+        });
+        
+        it("should not add the defualt unit", function() {
+            expect(proto.addUnits('10px')).toEqual('10px');
+        });
+    });
+    
+    describe("parseBox", function() {
+        describe("number", function() {
+            describe("when 1 argument", function() {
+                it("should return an object with correct values", function() {
+                    expect(proto.parseBox(10)).toEqual({
+                        top   : 10,
+                        right : 10,
+                        bottom: 10,
+                        left  : 10
+                    });
+                });
+            });
+        });
+        
+        describe("string", function() {
+            describe("when 1 argument", function() {
+                it("should return an object with correct values", function() {
+                    expect(proto.parseBox("10")).toEqual({
+                        top   : 10,
+                        right : 10,
+                        bottom: 10,
+                        left  : 10
+                    });
+                });
+            });
+            
+            describe("when 2 arguments", function() {
+                it("should return an object with correct values", function() {
+                    expect(proto.parseBox("10 5")).toEqual({
+                        top   : 10,
+                        right : 5,
+                        bottom: 10,
+                        left  : 5
+                    });
+                });
+            });
+            
+            describe("when 3 arguments", function() {
+                it("should return an object with correct values", function() {
+                    expect(proto.parseBox("10 5 15")).toEqual({
+                        top   : 10,
+                        right : 5,
+                        bottom: 15,
+                        left  : 5
+                    });
+                });
+            });
+            
+            describe("when 4 arguments", function() {
+                it("should return an object with correct values", function() {
+                    expect(proto.parseBox("10 5 15 0")).toEqual({
+                        top   : 10,
+                        right : 5,
+                        bottom: 15,
+                        left  : 0
+                    });
+                });
+            });
+        });
+    });
+    
+    describe("unitizeBox", function() {
+        it("should return a string", function() {
+            expect(proto.unitizeBox('10 5 15 0')).toEqual('10px 5px 15px 0px');
+        });
+    });
+    
+    describe("normalize", function() {
+        it("should change border-radius > borderRadius", function() {
+            expect(proto.normalize('border-radius')).toEqual('borderRadius');
+        });
+    });
+    
+    describe("getXY", function(){
+        it("should return the x/y position", function(){
+            var myEl = Ext.getBody().createChild({
+                style: {
+                    width: '5px',
+                    height: '5px',
+                    left: '6px',
+                    top: '7px',
+                    position: 'absolute'
+                }
+            }), xy = myEl.getXY();
+            
+            expect(xy[0]).toBe(6);
+            expect(xy[1]).toBe(7);
+            myEl.remove();
+        });  
+    });
+    
+    describe("getDocumentHeight", function() {
+        it("should return the document height", function() {
+            var result = proto.getDocumentHeight();
+            
+            expect(result).toBeDefined();
+            expect(Ext.isNumber(result)).toBeTruthy();
+        });
+    });
+    
+    describe("getDocumentWidth", function() {
+        it("should return the document width", function() {
+            var result = proto.getDocumentWidth();
+            
+            expect(result).toBeDefined();
+            expect(Ext.isNumber(result)).toBeTruthy();
+        });
+    });
+    
+    describe("getViewportHeight", function() {
+        it("should return the window height", function() {
+            var result = proto.getViewportHeight();
+            
+            expect(result).toBeDefined();
+            expect(Ext.isNumber(result)).toBeTruthy();
+        });
+    });
+    
+    describe("getViewportWidth", function() {
+        it("should return the window width", function() {
+            var result = proto.getViewportWidth();
+            
+            expect(result).toBeDefined();
+            expect(Ext.isNumber(result)).toBeTruthy();
+        });
+    });
+    
+    describe("getViewSize", function() {
+        it("should return the window height and width", function() {
+            expect(proto.getViewSize()).toEqual({
+                width : window.innerWidth,
+                height: window.innerHeight
+            });
+        });
+    });
+    
+    describe("getOrientation", function() {
+        it("should return the correct orientation", function() {
+            expect(proto.getOrientation()).toEqual((window.innerHeight > window.innerWidth) ? 'portrait' : 'landscape');
+        });
+    });
+    
+    // See EXTJSIV-5800
+    if (!Ext.isSafari3 && !Ext.isSafari4 && !Ext.isOpera && !Ext.isIE6 && !Ext.isIE7 && !Ext.isIE8) {
+        describe("fromPoint", function() {
+            it("should return nothing", function() {
+                    expect(proto.fromPoint(-550000, -550000)).toBeNull();
+            });
+        });
+    }
+}, "/src/dom/Element.static.js");

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/dom/Element.style.js

@@ -0,0 +1,118 @@
+describe("Ext.Element.style", function() {
+    var testEl;
+    
+    beforeEach(function() {
+        testEl = Ext.getBody().createChild({
+            id      : 'ExtElementHelper',
+            style   : 'position:absolute;'
+        });
+    });
+    
+    afterEach(function() {
+        testEl.remove();
+    });
+    
+    describe('addCls', function () {
+        xit('should add one class', function () {
+            testEl.addCls('foo');
+            expect(testEl.dom.className).toEqual('foo');
+        });
+
+        it('should add two class', function () {
+            testEl.addCls('foo').addCls('bar');
+            expect(testEl.dom.className).toEqual('foo bar');
+        });
+
+        xit('should add one class when given duplicates', function () {
+            testEl.addCls('foo').addCls('foo');
+            expect(testEl.dom.className).toEqual('foo');
+        });
+
+        xit('should add two class at once', function () {
+            testEl.addCls('foo bar').addCls('bar');
+            expect(testEl.dom.className).toEqual('foo bar');
+        });
+
+        xit('should add two class at once and handle duplicates', function () {
+            testEl.addCls('foo bar').addCls('bar foo');
+            expect(testEl.dom.className).toEqual('foo bar');
+        });
+    });
+
+    describe('removeCls', function () {
+        it('should remove nothing if no classes', function () {
+            testEl.removeCls('bar');
+            expect(testEl.dom.className).toEqual('');
+        });
+
+        it('should remove nothing if class is not present', function () {
+            testEl.dom.className = 'foo bar';
+            testEl.removeCls('fbar');
+            expect(testEl.dom.className).toEqual('foo bar');
+        });
+
+        it('should remove only class', function () {
+            testEl.dom.className = 'foo';
+            testEl.removeCls('foo');
+            expect(testEl.dom.className).toEqual('');
+        });
+
+        it('should remove last class', function () {
+            testEl.dom.className = 'foo bar';
+            testEl.removeCls('bar');
+            expect(testEl.dom.className).toEqual('foo');
+        });
+
+        it('should remove first class', function () {
+            testEl.dom.className = 'foo bar';
+            testEl.removeCls('bar');
+            expect(testEl.dom.className).toEqual('foo');
+        });
+
+        it('should remove middle class', function () {
+            testEl.dom.className = 'foo bar jazz';
+            testEl.removeCls('bar');
+            expect(testEl.dom.className).toEqual('foo jazz');
+        });
+
+        it('should remove multiple classes', function () {
+            testEl.dom.className = 'foo bar jazz spud';
+            testEl.removeCls('jazz bar fff');
+            expect(testEl.dom.className).toEqual('foo spud');
+        });
+
+        it('should remove multiple classes sequentially', function () {
+            testEl.dom.className = 'foo bar jazz spud';
+            testEl.removeCls('jazz').removeCls('bar').removeCls('fff');
+            expect(testEl.dom.className).toEqual('foo spud');
+        });
+    });
+
+    describe('getStyle', function(){
+        var el, dom;
+        beforeEach(function(){
+            dom = document.createElement('div');
+            testEl.appendChild(dom);
+            el = new Ext.Element(dom);
+        });
+        afterEach(function(){
+            dom.parentNode.removeChild(dom);
+            el = dom = null;
+        });
+
+        describe('border-*-width', function(){
+            Ext.Array.forEach('top right bottom left'.split(' '), function(side){
+                it('must report the correct border-'+ side +'-width when the border-'+ side +'-style is "solid"', function(){
+                    dom.style.cssText = 'border:5px solid';
+                    expect(el.getStyle('border-'+ side +'-width')).toBe('5px');
+                });
+                it('must report 0px for border-'+ side +'-width when the border-'+ side +'-style is "none"', function(){
+                    dom.style.cssText = 'border:5px solid; border-' + side + '-style:none';
+                    expect(el.getStyle('border-'+ side +'-width')).toBe('0px');
+                });
+            });
+        });
+
+    });
+
+}, "/src/dom/Element.style.js");

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/dom/Element.traversal.js

@@ -0,0 +1,336 @@
+describe("Ext.Element.traversal", function() {
+    var proto = Ext.Element,
+        el, testEl,
+        input, testInputEl,
+        child1, child2, child3, child4, child4_1, child4_1_1;
+    
+    beforeEach(function() {
+        testEl = Ext.getBody().createChild({
+            id      : 'ExtElementHelper',
+            cls     : 'wrapper',
+            style   : 'position:absolute;',
+            children: [
+                {id: 'child1', style: 'position:absolute;'},
+                {id: 'child2', style: 'position:absolute;'},
+                {id: 'child3', style: 'position:absolute;'},
+                {
+                    id: 'child4',
+                    children: [
+                        {
+                            id : 'child4_1',
+                            cls: 'findIt',
+                            children: [
+                                {
+                                    id : 'child4_1_1'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        });
+        
+        testInputEl = Ext.getBody().createChild({
+            id  : 'ExtElementInputHelper',
+            tag : 'input',
+            type: 'text'
+        });
+        
+        el    = new Ext.Element(Ext.getDom(testEl));
+        input = new Ext.Element(Ext.getDom(testInputEl));
+        
+        child1 = Ext.get('child1');
+        child2 = Ext.get('child2');
+        child3 = Ext.get('child3');
+        child4 = Ext.get('child4');
+        child4_1 = Ext.get('child4_1');
+        child4_1_1 = Ext.get('child4_1_1');
+    });
+
+    afterEach(function() {
+        testEl.remove();
+        testInputEl.remove();
+    });
+    
+    describe("findParentNode", function() {
+        it("should return document.body", function() {
+            expect(el.findParentNode('body')).toEqual(document.body);
+        });
+        
+        it("should return a dom", function() {
+            expect(child1.findParentNode('.wrapper')).toEqual(Ext.getDom(el));
+        });
+        
+        it("should return an el", function() {
+            expect(child1.findParentNode('.wrapper', null, true)).toEqual(el);
+        });
+        
+        describe("when maxDepth", function() {
+            describe("1", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.findParentNode('.wrapper', 1)).toBeNull();
+                });
+            });
+            
+            describe("2", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.findParentNode('.wrapper', 2)).toEqual(Ext.getDom(el));
+                });
+            });
+        });
+    });
+    
+    describe("up", function() {
+        it("should return Ext.getBody()", function() {
+            expect(el.up('body')).toEqual(Ext.getBody());
+        });
+        
+        it("should return a el", function() {
+            expect(child1.up('.wrapper')).toEqual(el);
+        });
+        
+        describe("when maxDepth", function() {
+            describe("1", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.up('.wrapper', 1)).toBeNull();
+                });
+            });
+            
+            describe("2", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.up('.wrapper', 2)).toEqual(el);
+                });
+            });
+        });
+    });
+    
+    describe("select", function() {
+        it("should return an Ext.CompositeELementLite", function() {
+            var result = el.select('div');
+            expect(result).toBeDefined();
+            expect(result.elements.length).toEqual(6);
+            expect(result instanceof Ext.CompositeElementLite).toBe(true);
+        });
+    });
+    
+    describe("query", function() {
+        it("should return elements", function() {
+            var result = el.query('div');
+            
+            expect(result).toBeDefined();
+            expect(result.length).toEqual(6);
+            expect(result.isComposite).toBeFalsy();
+            expect(Ext.isArray(result)).toBeTruthy();
+        });
+    });
+    
+    describe("down", function() {
+        it("should return an el", function() {
+            var result = el.down('.findIt');
+            
+            expect(result).toBeDefined();
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = el.down('.findIt', true);
+            
+            expect(result).toBeDefined();
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+
+    describe("child", function() {
+        it("should return null", function() {
+            var result = el.child('.findIt');
+            
+            expect(result).toBeNull();
+        });
+        
+        it("should return an el", function() {
+            var result = child4.child('.findIt');
+            
+            expect(result).toBeDefined();
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = child4.child('.findIt', true);
+            
+            expect(result).toBeDefined();
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("parent", function() {
+        it("should return an el", function() {
+            var result = child1.parent();
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(el);
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = child1.parent(null, true);
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(Ext.getDom(el));
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("next", function() {
+        it("should return an el", function() {
+            var result = child1.next();
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(child2);
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = child1.next(null, true);
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(Ext.getDom(child2));
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("prev", function() {
+        it("should return an el", function() {
+            var result = child2.prev();
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(child1);
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = child2.prev(null, true);
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(Ext.getDom(child1));
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("first", function() {
+        it("should return an el", function() {
+            var result = el.first();
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(child1);
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = el.first(null, true);
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(Ext.getDom(child1));
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("last", function() {
+        it("should return an el", function() {
+            var result = el.last();
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(child4);
+            expect(Ext.isElement(result)).toBeFalsy();
+        });
+        
+        it("should return a dom", function() {
+            var result = el.last(null, true);
+            
+            expect(result).toBeDefined();
+            expect(result).toEqual(Ext.getDom(child4));
+            expect(Ext.isElement(result)).toBeTruthy();
+        });
+    });
+    
+    describe("findParent", function() {
+        it("should return document.body", function() {
+            expect(el.findParent('body')).toEqual(document.body);
+        });
+        
+        it("should return a dom", function() {
+            expect(child1.findParent('.wrapper')).toEqual(Ext.getDom(el));
+        });
+        
+        it("should return an el", function() {
+            expect(child1.findParent('.wrapper', null, true)).toEqual(el);
+        });
+        
+        describe("when maxDepth", function() {
+            describe("1", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.findParent('.wrapper', 1)).toBeNull();
+                });
+            });
+            
+            describe("2", function() {
+                it("should not return the el", function() {
+                    expect(child4_1.findParent('.wrapper', 2)).toBeNull();
+                });
+            });
+            
+            describe("3", function() {
+                it("should return the el", function() {
+                    expect(child4_1.findParent('.wrapper', 3)).toEqual(Ext.getDom(el));
+                });
+            });
+            
+            describe("NaN", function() {
+                it("should use Number.MAX_VALUE", function() {
+                    expect(child4_1.findParent('.wrapper', Ext.getBody())).toEqual(Ext.getDom(el));
+                });
+            });
+        });
+    });
+    
+    describe("contains", function(){
+        describe("contains", function(){
+            it('should return false for siblings', function(){
+                expect(Ext.fly(child1).contains(child4_1_1)).toBe(false);
+                expect(Ext.fly(child2).contains(child4_1_1)).toBe(false);
+            });
+            it('should return true for parents', function(){
+                expect(Ext.fly(child4_1).contains(child4_1_1)).toBe(true);
+            });
+            it('should return true for grandparents', function(){
+                expect(Ext.fly(child4).contains(child4_1_1)).toBe(true);
+            });
+            it('should return true for self', function(){
+                expect(Ext.fly(child4_1_1).contains(child4_1_1)).toBe(true);
+            });
+        });
+        
+        if (Ext.core.Element.prototype.isDescendent) describe("isDescendent", function(){
+            it('should return false for grandchildren', function(){
+                expect(Ext.fly(child4).isDescendent(child4_1_1)).toBe(false);
+            });
+            it('should return false for children', function(){
+                expect(Ext.fly(child4_1).isDescendent(child4_1_1)).toBe(false);
+            });
+            it('should return false for siblings', function(){
+                expect(Ext.fly(child4_1_1).isDescendent(child1)).toBe(false);
+                expect(Ext.fly(child4_1_1).isDescendent(child2)).toBe(false);
+            });
+            it('should return true for parents', function(){
+                expect(Ext.fly(child4_1_1).isDescendent(child4_1)).toBe(true);
+            });
+            it('should return true for grandparents', function(){
+                expect(Ext.fly(child4_1_1).isDescendent(child4)).toBe(true);
+            });
+            it('should return true for self', function(){
+                expect(Ext.fly(child4_1_1).isDescendent(child4_1_1)).toBe(true);
+            });
+
+        });
+    })
+    
+}, "/src/dom/Element.traversal.js");