extjs-rails 4.1.0.alpha5 → 4.1.0.alpha6

data/app/assets/javascripts/src/core/test/unit/spec/lang/String.js

@@ -1,451 +0,0 @@
-describe("Ext.String", function() {
-
-    describe("ellipsis", function() {
-        var shortString = "A short string",
-            longString  = "A somewhat longer string";
-        
-        it("should keep short strings intact", function() {
-            expect(Ext.String.ellipsis(shortString, 100)).toEqual(shortString);
-        });
-        
-        it("should truncate a longer string", function() {
-            expect(Ext.String.ellipsis(longString, 10)).toEqual("A somew...");
-        });
-        
-        describe("word break", function() {
-            var longStringWithDot  = "www.sencha.com",
-                longStringWithExclamationMark = "Yeah!Yeah!Yeah!",
-                longStringWithQuestionMark = "Who?When?What?";
-                           
-            it("should find a word break on ' '", function() {
-                expect(Ext.String.ellipsis(longString, 10, true)).toEqual("A...");
-            });      
-            
-            it("should be able to break on '.'", function() {
-                expect(Ext.String.ellipsis(longStringWithDot, 9, true)).toEqual("www...");
-            });  
-            
-            it("should be able to break on '!'", function() {
-                expect(Ext.String.ellipsis(longStringWithExclamationMark, 9, true)).toEqual("Yeah...");
-            }); 
-            
-            it("should be able to break on '?'", function() {
-                expect(Ext.String.ellipsis(longStringWithQuestionMark, 8, true)).toEqual("Who...");
-            });       
-        });
-    });
-    
-    describe("escapeRegex", function() {
-        var str;
-        
-        it("should escape minus", function() {
-            str = "12 - 175";
-            expect(Ext.String.escapeRegex(str)).toEqual("12 \\- 175");
-        });
-        
-        it("should escape dot", function() {
-            str = "Brian is in the kitchen.";
-            expect(Ext.String.escapeRegex(str)).toEqual("Brian is in the kitchen\\.");
-        });
-        
-        it("should escape asterisk", function() {
-            str = "12 * 175";
-            expect(Ext.String.escapeRegex(str)).toEqual("12 \\* 175");
-        });
-        
-        it("should escape plus", function() {
-            str = "12 + 175";
-            expect(Ext.String.escapeRegex(str)).toEqual("12 \\+ 175");
-        });
-        
-        it("should escape question mark", function() {
-            str = "What else ?";
-            expect(Ext.String.escapeRegex(str)).toEqual("What else \\?");
-        });
-        
-        it("should escape caret", function() {
-            str = "^^";
-            expect(Ext.String.escapeRegex(str)).toEqual("\\^\\^");
-        });
-        
-        it("should escape dollar", function() {
-            str = "500$";
-            expect(Ext.String.escapeRegex(str)).toEqual("500\\$");
-        });
-        
-        it("should escape open brace", function() {
-            str = "something{stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\{stupid");
-        });
-        
-        it("should escape close brace", function() {
-            str = "something}stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\}stupid");
-        });
-        
-        it("should escape open bracket", function() {
-            str = "something[stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\[stupid");
-        });
-        
-        it("should escape close bracket", function() {
-            str = "something]stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\]stupid");
-        });
-        
-        it("should escape open parenthesis", function() {
-            str = "something(stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\(stupid");
-        });
-        
-        it("should escape close parenthesis", function() {
-            str = "something)stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\)stupid");
-        });
-        
-        it("should escape vertival bar", function() {
-            str = "something|stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\|stupid");
-        });
-        
-        it("should escape forward slash", function() {
-            str = "something/stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\/stupid");
-        });
-        
-        it("should escape backslash", function() {
-            str = "something\\stupid";
-            expect(Ext.String.escapeRegex(str)).toEqual("something\\\\stupid");
-        });
-    });
-    
-    describe("htmlEncode", function() {
-        var str;
-
-        it("should replace ampersands", function() {
-            str = "Fish & Chips";
-            expect(Ext.String.htmlEncode(str)).toEqual("Fish & Chips");
-        });
-        
-        it("should replace less than", function() {
-            str = "Fish > Chips";
-            expect(Ext.String.htmlEncode(str)).toEqual("Fish > Chips");
-        });
-        
-        it("should replace greater than", function() {
-            str = "Fish < Chips";
-            expect(Ext.String.htmlEncode(str)).toEqual("Fish &lt; Chips");
-        });
-        
-        it("should replace double quote", function() {
-            str = 'Fish " Chips';
-            expect(Ext.String.htmlEncode(str)).toEqual("Fish &quot; Chips");
-        });
-
-        it("should replace apostraphes", function() {
-            str = "Fish ' Chips";
-            expect(Ext.String.htmlEncode(str)).toEqual("Fish &#39; Chips");
-        });
-
-        describe("adding character entities", function(){
-
-            var src = "A string with entities: èÜçñ¶",
-                encoded = "A string with entities: &egrave;&Uuml;&ccedil;&ntilde;&para;";
-
-            beforeEach(function(){
-                Ext.String.addCharacterEntities({
-                    '&Uuml;':'\u00dc',
-                    '&ccedil;':'\u00e7',
-                    '&ntilde;':'ñ',
-                    '&egrave;':'è',
-                    '&para;':'¶'
-                });
-            });
-
-            afterEach(function(){
-                Ext.String.resetCharacterEntities();
-            });
-
-
-            it("should allow extending the character entity set", function(){
-                expect(Ext.String.htmlEncode(src)).toBe(encoded);
-            });
-        });
-    });
-    
-    describe("htmlDecode", function() {
-        var str;
-
-        it("should replace ampersands", function() {
-            str = "Fish &amp; Chips";
-            expect(Ext.String.htmlDecode(str)).toEqual("Fish & Chips");
-        });
-        
-        it("should replace less than", function() {
-            str = "Fish &gt; Chips";
-            expect(Ext.String.htmlDecode(str)).toEqual("Fish > Chips");
-        });
-        
-        it("should replace greater than", function() {
-            str = "Fish &lt; Chips";
-            expect(Ext.String.htmlDecode(str)).toEqual("Fish < Chips");
-        });
-        
-        it("should replace double quote", function() {
-            str = 'Fish &quot; Chips';
-            expect(Ext.String.htmlDecode(str)).toEqual('Fish " Chips');
-        });
-
-        it("should replace apostraphes", function() {
-            str = "Fish &#39; Chips";
-            expect(Ext.String.htmlDecode(str)).toEqual("Fish ' Chips");
-        });
-
-        describe("adding character entities", function(){
-
-            var src = "A string with entities: èÜçñ¶",
-                encoded = "A string with entities: &egrave;&Uuml;&ccedil;&ntilde;&para;";
-
-            beforeEach(function(){
-                Ext.String.addCharacterEntities({
-                    '&Uuml;':'\u00dc',
-                    '&ccedil;':'\u00e7',
-                    '&ntilde;':'ñ',
-                    '&egrave;':'è',
-                    '&para;':'¶'
-                });
-            });
-
-            afterEach(function(){
-                Ext.String.resetCharacterEntities();
-            });
-
-            it("should allow extending the character entity set", function(){
-                expect(Ext.String.htmlDecode(encoded)).toBe(src);
-            });
-        });
-    });
-    
-    describe("escaping", function() {
-        it("should leave an empty string alone", function() {
-            expect(Ext.String.escape('')).toEqual('');
-        });
-        
-        it("should leave a non-empty string without escapable characters alone", function() {
-            expect(Ext.String.escape('Ed')).toEqual('Ed');
-        });
-        
-        it("should correctly escape a double backslash", function() {
-            expect(Ext.String.escape("\\")).toEqual("\\\\");
-        });
-        
-        it("should correctly escape a single backslash", function() {
-            expect(Ext.String.escape('\'')).toEqual('\\\'');
-        });
-        
-        it("should correctly escape a mixture of escape and non-escape characters", function() {
-            expect(Ext.String.escape('\'foo\\')).toEqual('\\\'foo\\\\');
-        });
-    });
-    
-    describe("formatting", function() {
-        it("should leave a string without format parameters alone", function() {
-            expect(Ext.String.format('Ed')).toEqual('Ed');
-        });
-        
-        it("should ignore arguments that don't map to format params", function() {
-            expect(Ext.String.format("{0} person", 1, 123)).toEqual("1 person");
-        });
-        
-        it("should accept several format parameters", function() {
-            expect(Ext.String.format("{0} person {1}", 1, 'came')).toEqual('1 person came');
-        });
-    });
-    
-    describe("leftPad", function() {
-        it("should pad the left side of an empty string", function() {
-            expect(Ext.String.leftPad("", 5)).toEqual("     ");
-        });
-        
-        it("should pad the left side of a non-empty string", function() {
-            expect(Ext.String.leftPad("Ed", 5)).toEqual("   Ed");
-        });
-        
-        it("should not pad a string where the character count already exceeds the pad count", function() {
-            expect(Ext.String.leftPad("Abraham", 5)).toEqual("Abraham");
-        });
-        
-        it("should allow a custom padding character", function() {
-            expect(Ext.String.leftPad("Ed", 5, "0")).toEqual("000Ed");
-        });
-    });
-    
-    describe("when toggling between two values", function() {
-        it("should use the first toggle value if the string is not already one of the toggle values", function() {
-            expect(Ext.String.toggle("Aaron", "Ed", "Abe")).toEqual("Ed");
-        });
-        
-        it("should toggle to the second toggle value if the string is currently the first", function() {
-            expect(Ext.String.toggle("Ed", "Ed", "Abe")).toEqual("Abe");
-        });
-        
-        it("should toggle to the first toggle value if the string is currently the second", function() {
-            expect(Ext.String.toggle("Abe", "Ed", "Abe")).toEqual("Ed");
-        });
-    });
-    
-    describe("trimming", function() {
-        it("should not modify an empty string", function() {
-            expect(Ext.String.trim("")).toEqual("");
-        });
-        
-        it("should not modify a string with no whitespace", function() {
-            expect(Ext.String.trim("Abe")).toEqual("Abe");
-        });
-        
-        it("should trim a whitespace-only string", function() {
-            expect(Ext.String.trim("     ")).toEqual("");
-        });
-        
-        it("should trim leading whitespace", function() {
-            expect(Ext.String.trim("  Ed")).toEqual("Ed");
-        });
-        
-        it("should trim trailing whitespace", function() {
-            expect(Ext.String.trim("Ed   ")).toEqual("Ed");
-        });
-        
-        it("should trim leading and trailing whitespace", function() {
-            expect(Ext.String.trim("   Ed  ")).toEqual("Ed");
-        });
-        
-        it("should not trim whitespace between words", function() {
-            expect(Ext.String.trim("Fish and chips")).toEqual("Fish and chips");
-            expect(Ext.String.trim("   Fish and chips  ")).toEqual("Fish and chips");
-        });
-        
-        it("should trim tabs", function() {
-            expect(Ext.String.trim("\tEd")).toEqual("Ed");
-        });
-        
-        it("should trim a mixture of tabs and whitespace", function() {
-            expect(Ext.String.trim("\tEd   ")).toEqual("Ed");
-        });
-    });
-    
-    describe("urlAppend", function(){
-        it("should leave the string untouched if the second argument is empty", function(){
-            expect(Ext.String.urlAppend('sencha.com')).toEqual('sencha.com');    
-        });
-        
-        it("should append a ? if one doesn't exist", function(){
-            expect(Ext.String.urlAppend('sencha.com', 'foo=bar')).toEqual('sencha.com?foo=bar');
-        });
-        
-        it("should append any new values with & if a ? exists", function(){
-            expect(Ext.String.urlAppend('sencha.com?x=y', 'foo=bar')).toEqual('sencha.com?x=y&foo=bar');
-        });
-    });
-    
-    describe("capitalize", function(){
-        it("should handle an empty string", function(){
-            expect(Ext.String.capitalize('')).toEqual('');
-        });
-        
-        it("should capitalize the first letter of the string", function(){
-            expect(Ext.String.capitalize('open')).toEqual('Open');
-        });
-        
-        it("should leave the first letter capitalized if it is already capitalized", function(){
-            expect(Ext.String.capitalize('Closed')).toEqual('Closed');
-        });
-        
-        it("should capitalize a single letter", function(){
-            expect(Ext.String.capitalize('a')).toEqual('A');
-        });
-        
-        it("should capitalize even when spaces are included", function(){
-            expect(Ext.String.capitalize('this is a sentence')).toEqual('This is a sentence');
-        });
-    });
-
-    describe("uncapitalize", function(){
-        it("should handle an empty string", function(){
-            expect(Ext.String.uncapitalize('')).toEqual('');
-        });
-        
-        it("should uncapitalize the first letter of the string", function(){
-            expect(Ext.String.uncapitalize('Foo')).toEqual('foo');
-        });
-        
-        it("should ignore case in the rest of the string", function() {
-            expect(Ext.String.uncapitalize('FooBar')).toEqual('fooBar'); 
-        });
-        
-        it("should leave the first letter uncapitalized if it is already uncapitalized", function(){
-            expect(Ext.String.uncapitalize('fooBar')).toEqual('fooBar');
-        });
-        
-        it("should uncapitalize a single letter", function(){
-            expect(Ext.String.uncapitalize('F')).toEqual('f');
-        });
-
-        it("should uncapitalize even when spaces are included", function(){
-            expect(Ext.String.uncapitalize('This is a sentence')).toEqual('this is a sentence');
-        });
-    });
-    
-    describe('repeat', function() {
-        it('should return an empty string if count == 0', function() {
-            expect(Ext.String.repeat('an ordinary string', 0)).toBe('');
-        });
-        it('should repeat the pattern as many times as required using the specified separator', function() {
-            expect(Ext.String.repeat('an ordinary string', 1, '/')).toBe('an ordinary string');
-            expect(Ext.String.repeat('an ordinary string', 2, '&')).toBe('an ordinary string&an ordinary string');
-            expect(Ext.String.repeat('an ordinary string', 3, '%')).toBe('an ordinary string%an ordinary string%an ordinary string');
-        });
-        it('should concatenate the repetitions if no separator is specified', function() {
-            expect(Ext.String.repeat('foo', 3)).toBe('foofoofoo');
-            expect(Ext.String.repeat('bar baz', 3)).toBe('bar bazbar bazbar baz');
-        });
-    });
-
-    describe('splitWords', function () {
-        it('should handle no args', function () {
-            var words = Ext.String.splitWords();
-            expect(Ext.encode(words)).toEqual('[]');
-        });
-        it('should handle null', function () {
-            var words = Ext.String.splitWords(null);
-            expect(Ext.encode(words)).toEqual('[]');
-        });
-        it('should handle an empty string', function () {
-            var words = Ext.String.splitWords('');
-            expect(Ext.encode(words)).toEqual('[]');
-        });
-        it('should handle one trimmed word', function () {
-            var words = Ext.String.splitWords('foo');
-            expect(Ext.encode(words)).toEqual('["foo"]');
-        });
-        it('should handle one word with spaces around it', function () {
-            var words = Ext.String.splitWords(' foo ');
-            expect(Ext.encode(words)).toEqual('["foo"]');
-        });
-        it('should handle two trimmed words', function () {
-            var words = Ext.String.splitWords('foo bar');
-            expect(Ext.encode(words)).toEqual('["foo","bar"]');
-        });
-        it('should handle two untrimmed words', function () {
-            var words = Ext.String.splitWords('  foo  bar  ');
-            expect(Ext.encode(words)).toEqual('["foo","bar"]');
-        });
-        it('should handle five trimmed words', function () {
-            var words = Ext.String.splitWords('foo bar bif boo foobar');
-            expect(Ext.encode(words)).toEqual('["foo","bar","bif","boo","foobar"]');
-        });
-        it('should handle five untrimmed words', function () {
-            var words = Ext.String.splitWords(' foo   bar   bif   boo  foobar    \t');
-            expect(Ext.encode(words)).toEqual('["foo","bar","bif","boo","foobar"]');
-        });
-    })
-});

data/app/assets/javascripts/src/core/test/unit/spec/misc/JSON.js

@@ -1,252 +0,0 @@
-describe("Ext.JSON", function() {
-    var nativeJson;
-
-    beforeEach(function() {
-        nativeJson = Ext.USE_NATIVE_JSON;
-        Ext.USE_NATIVE_JSON = false;
-
-    });
-
-    afterEach(function() {
-        Ext.USE_NATIVE_JSON = nativeJson;
-    });
-
-    describe("encode", function() {
-        var encode = Ext.JSON.encode;
-
-        describe("numbers encoding", function() {
-            it("should convert integer to string", function() {
-                expect(encode(15)).toEqual("15");
-            });
-
-            it("should convert float to string", function() {
-                expect(encode(14.7)).toEqual("14.7");
-            });
-
-            it("should convert Infinity to null string", function() {
-                expect(encode(Infinity)).toEqual("null");
-            });
-
-            it("should convert NaN to null string", function() {
-                expect(encode(NaN)).toEqual("null");
-            });
-        });
-
-        describe("encoding of not defined values", function() {
-            it("should convert undefined to null string", function() {
-                expect(encode(undefined)).toEqual("null");
-            });
-
-            it("should convert null to null string", function() {
-                expect(encode(null)).toEqual("null");
-            });
-        });
-
-        describe("encoding function", function() {
-            it("should convert function to null string", function() {
-                expect(encode(Ext.emptyFn)).toEqual("null");
-            });
-        });
-
-        describe("boolean encoding", function() {
-            it("should convert true to 'true'' string", function() {
-                expect(encode(true)).toEqual("true");
-            });
-
-            it("should convert null to 'false' string", function() {
-                expect(encode(false)).toEqual("false");
-            });
-        });
-
-        describe("array encoding", function() {
-            it("should convert empty array", function() {
-                expect(encode([])).toEqual("[]");
-            });
-            
-            it("should convert array of numbers to string", function() {
-                expect(encode([1, 2, 3])).toEqual("[1,2,3]");
-            });
-
-            it("should convert array of strings to string", function() {
-                expect(encode(["a", "b", "c"])).toEqual("[\"a\",\"b\",\"c\"]");
-            });
-
-            it("should encode array including function member to string", function() {
-                expect(encode([1, Ext.emptyFn, 3])).toEqual("[1,null,3]");
-            });
-
-            it("should convert array including undefined member to string", function() {
-                expect(encode([1, undefined, 3])).toEqual("[1,null,3]");
-            });
-
-            it("should convert array including null member to string", function() {
-                expect(encode([1, null, 3])).toEqual("[1,null,3]");
-            });
-        });
-
-        describe("string encoding", function() {
-            it("should convert string", function() {
-                expect(encode("You're fired!")).toEqual("\"You're fired!\"");
-            });
-
-            it("should convert string with international character", function() {
-                expect(encode("You're fired!")).toEqual("\"You're fired!\"");
-            });
-
-            it("should convert string with tab character", function() {
-                expect(encode("a\tb")).toEqual("\"a\\tb\"");
-            });
-
-            it("should convert string with carriage return character", function() {
-                expect(encode("a\rb")).toEqual("\"a\\rb\"");
-            });
-
-            it("should convert string with form feed character", function() {
-                expect(encode("a\fb")).toEqual("\"a\\fb\"");
-            });
-
-            it("should convert string with new line character", function() {
-                expect(encode("a\nb")).toEqual("\"a\\nb\"");
-            });
-
-            it("should convert string with vertical tab character", function() {
-                expect(encode("a\x0bb")).toEqual("\"a\\u000bb\"");
-            });
-
-            it("should convert string with backslash character", function() {
-                expect(encode("a\\b")).toEqual("\"a\\\\b\"");
-            });
-        });
-
-        describe("object encoding", function() {
-            it("should convert empty object", function() {
-                expect(encode({})).toEqual("{}");
-            });
-            
-            it("should convert empty object with undefined property", function() {
-                expect(encode({
-                    foo: "bar",
-                    bar: undefined
-                })).toEqual("{\"foo\":\"bar\",\"bar\":null}");
-            });
-            
-            it("should convert empty object with null property", function() {
-                expect(encode({
-                    foo: "bar",
-                    bar: null
-                })).toEqual("{\"foo\":\"bar\",\"bar\":null}");
-            });
-            
-            it("should convert empty object with function property", function() {
-                expect(encode({
-                    foo: "bar",
-                    bar: Ext.emptyFn
-                })).toEqual("{\"foo\":\"bar\",\"bar\":null}");
-            });
-            
-            it("should not encode dom object", function() {
-               expect(encode(Ext.getBody().dom)).toBe('undefined');
-            });
-            
-            it("should handle encoding unknown child objects", function(){
-                expect(encode({
-                    prop: Ext.getBody().dom
-                })).toBe('{"prop":undefined}');
-            });
-        });
-
-        describe('encodeDate', function() {
-            var date;
-            
-            it("should encode a date object", function() {
-                date = new Date("October 13, 1983 04:04:00");
-    
-                expect(encode(date)).toEqual("\"1983-10-13T04:04:00\"");
-            });
-            
-            it("should format integers to have at least two digits", function() {
-                date = new Date("August 9, 1983 06:03:02");
-                
-                expect(encode(date)).toEqual("\"1983-08-09T06:03:02\"");            
-            });
-        });
-        
-        describe("mix all possibilities", function() {
-            it("should encode data", function() {
-                 expect(encode({
-                    arr: [1, Ext.emptyFn, undefined, 2, [1, 2, 3], {a: 1, b: null}],
-                    foo: "bar",
-                    woo: {
-                        chu: "a\tb"
-                    }
-                 })).toEqual("{\"arr\":[1,null,null,2,[1,2,3],{\"a\":1,\"b\":null}],\"foo\":\"bar\",\"woo\":{\"chu\":\"a\\tb\"}}");
-            });
-        });
-    });
-
-    describe("decode", function() {
-        it("should decode data", function() {
-            expect(Ext.decode("{\"arr\":[1,null,null,2,[1,2,3],{\"a\":1,\"b\":null}],\"foo\":\"bar\",\"woo\":{\"chu\":\"a\\tb\"}}")).toEqual({
-                    arr: [1, null, null, 2, [1, 2, 3], {a: 1, b: null}],
-                    foo: "bar",
-                    woo: {
-                        chu: "a\tb"
-                    }            
-            });
-        });
-        
-        it("should raise an Ext.Error with invalid data", function() {
-            expect(function(){
-                Ext.decode('{foo:"bar", x}');
-            }).toRaiseExtError();
-        });
-            
-        describe("with safe param", function(){
-            it("should decode valid data", function() {
-                expect(Ext.decode("{\"foo\":\"bar\"}", true)).toEqual({
-                    foo: "bar"        
-                });
-            });
-            
-            it("should return null with invalid data", function() {
-                expect(Ext.decode('{foo+"bar"}', true)).toBeNull();
-            });
-        });
-    });
-    
-    it('should encode and decode an object', function(){
-        var object = {
-            a: [0, 1, 2],
-            s: "It's-me-Jacky!!",
-            ss: "!@#$%^&*()~=_-+][{};:?/.,<>'\"",
-            u: '\x01',
-            i: 1,
-            f: 3.14,
-            b: false,
-            n: null,
-            tree: {
-                sub: {
-                    subMore: {
-                        subEvenMore: {
-                            arr: [5,6,7, {
-                                complex: true
-                            }]
-                        }
-                    }
-                }
-            }
-        };
-
-        expect(Ext.JSON.decode(Ext.JSON.encode(object))).toEqual(object);
-    });
-    
-    describe("aliases", function() {
-        it("should alias Ext.JSON.decode with Ext.decode", function() {
-            expect(Ext.decode).toBe(Ext.JSON.decode);
-        });
-
-        it("should alias Ext.JSON.encode with Ext.encode", function() {
-            expect(Ext.encode).toBe(Ext.JSON.encode);
-        });
-    });
-});