extjs-rails 4.1.0.alpha1

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

@@ -0,0 +1,451 @@
+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/extjs-rails/src/core/test/unit/spec/misc/JSON.js

@@ -0,0 +1,252 @@
+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);
+        });
+    });
+});