screw_server 0.1.7 → 0.1.8

data/assets/vendor/screw-unit/spec/matchers_spec.js

@@ -5,47 +5,47 @@ Screw.Unit(function() {
         expect(true).to(equal, true);
         expect(true).to_not(equal, false);
       });
-
+      
       describe('when actual is an object', function() {
         describe("when expected has the same keys and values", function() {
           it("matches successfully", function() {
             expect({a: 'b', c: 'd'}).to(equal, {a: 'b', c: 'd'});
           });
         });
-
+        
         describe("when expected has different keys and values", function() {
           it("does not match", function() {
             expect({a: 'b', c: 'd', e: 'f'}).to_not(equal, {a: 'b', c: 'd', e: 'G'});
           });
         });
-
+        
         describe("when expected is undefined", function() {
           it("does not match", function() {
             expect({}).to_not(equal, undefined);
           });
         });
       });
-
+      
       describe("when actual is undefined", function() {
         describe("when expected is undefined", function() {
           it("matches successfully", function() {
             expect(undefined).to(equal, undefined);
           });
         });
-
+        
         describe("when expected is an empty object", function() {
           it("does not match", function() {
             expect(undefined).to_not(equal, {});
           });
         });
       });
-
+      
       describe('when actual is an array', function() {
         it("matches Arrays with the same elements", function() {
           expect([1, 2, 4]).to(equal, [1, 2, 4]);
           expect([1, 2, 3]).to_not(equal, [3, 2, 1]);
         });
-
+        
         it("recursively applies equality to complex elements", function() {
           expect([{a: 'b'}, {c: 'd'}]).to(equal, [{a: 'b'}, {c: 'd'}]);
           expect([{a: 'b'}, {c: 'd'}]).to_not(equal, [{a: 'b'}, {c: 'E'}]);
@@ -71,13 +71,13 @@ Screw.Unit(function() {
           var message = null;
           try { expect(1).to(equal, 2) } catch(e) { message = e }
           expect(message).to(equal, 'expected 1 to equal 2');
-
+          
           try { expect(1).to_not(equal, 1) } catch(e) { message = e }
           expect(message).to(equal, 'expected 1 to not equal 1');
         });
       });
     });
-
+    
     describe('#match', function() {
       describe('when actual is a regular expression', function() {
         it("matches Strings produced by the grammar", function() {
@@ -85,7 +85,7 @@ Screw.Unit(function() {
           expect("The wheels of the bus").to_not(match, /boat/);
         });
       });
-
+      
       describe('when actual is a string', function() {
         it("matches [expected]s containing [actual]s", function() {
           expect("The wheels of the bus").to(match, "wheels");
@@ -99,31 +99,31 @@ Screw.Unit(function() {
           expect("2 times").to_not(match, 3);
         });
       });
-
+      
       describe(".failure_message", function() {
         it('prints "expected [actual] to (not) match [expected]', function() {
           var message = null;
           try { expect("hello").to(match, "schmello") } catch(e) { message = e }
           expect(message).to(equal, 'expected "hello" to match "schmello"');
-
+          
           try { expect("hello").to_not(match, "ello") } catch(e) { message = e }
           expect(message).to(equal, 'expected "hello" to not match "ello"');
         });
       });
     });
-
+    
     describe('#be_empty', function() {
       it("matches Arrays with no elements", function() {
         expect([]).to(be_empty);
         expect([1]).to_not(be_empty);
       });
-
+      
       describe(".failure_message", function() {
         it("prints 'expected [actual] to (not) be empty", function() {
           var message = null;
           try { expect([1]).to(be_empty) } catch(e) { message = e }
           expect(message).to(equal, 'expected [ 1 ] to be empty');
-
+          
           try { expect([]).to_not(be_empty) } catch(e) { message = e }
           expect(message).to(equal, 'expected [] to not be empty');
         });
@@ -142,7 +142,7 @@ Screw.Unit(function() {
           var message = null;
           try { expect([1, 2]).to(have_length, 4) } catch(e) { message = e }
           expect(message).to(equal, 'expected [ 1, 2 ] to have length 4');
-
+          
           try { expect([1]).to_not(have_length, 1) } catch(e) { message = e }
           expect(message).to(equal, 'expected [ 1 ] to not have length 1');
         });
@@ -243,7 +243,7 @@ Screw.Unit(function() {
           var message = false;
           try { expect(elt).to(match_selector, 'div.bar') } catch(e) { message = e }
           expect(message).to(equal, 'expected $([ <div class="foo"> ]) to match selector div.bar');
-
+          
           try { expect(elt).to_not(match_selector, 'div.foo') } catch(e) { message = e }
           expect(message).to(equal, 'expected $([ <div class="foo"> ]) to not match selector div.foo');
         });
@@ -289,7 +289,7 @@ Screw.Unit(function() {
           var message = null;
           try { expect(1).to(be_gt, 2) } catch(e) { message = e }
           expect(message).to(equal, 'expected 1 to be greater than 2');
-
+          
           try { expect(2).to_not(be_gt, 1) } catch(e) { message = e }
           expect(message).to(equal, 'expected 2 to not be greater than 1');
         });
@@ -314,7 +314,7 @@ Screw.Unit(function() {
           var message = null;
           try { expect(1).to(be_gte, 2) } catch(e) { message = e }
           expect(message).to(equal, 'expected 1 to be greater than or equal to 2');
-
+          
           try { expect(2).to_not(be_gte, 1) } catch(e) { message = e }
           expect(message).to(equal, 'expected 2 to not be greater than or equal to 1');
         });
@@ -337,7 +337,7 @@ Screw.Unit(function() {
           var message = null;
           try { expect(2).to(be_lt, 1) } catch(e) { message = e }
           expect(message).to(equal, 'expected 2 to be less than 1');
-
+          
           try { expect(1).to_not(be_lt, 2) } catch(e) { message = e }
           expect(message).to(equal, 'expected 1 to not be less than 2');
         });

data/assets/vendor/screw-unit/spec/print_spec.js

@@ -5,13 +5,13 @@ Screw.Unit(function() {
         expect($.print(undefined)).to(equal, 'undefined');
       });
     });
-
+    
     describe('when given null', function() {
       it("returns 'null'", function() {
         expect($.print(null)).to(equal, 'null');
       });
     });
-
+    
     describe('when given a number', function() {
       it("returns the string representation of the number", function() {
         expect($.print(1)).to(equal, '1');
@@ -19,39 +19,39 @@ Screw.Unit(function() {
         expect($.print(-1)).to(equal, '-1');
       });
     });
-
+    
     describe('when given a boolean', function() {
       it("returns the string representation of the boolean", function() {
         expect($.print(true)).to(equal, 'true');
         expect($.print(false)).to(equal, 'false');
       });
     });
-
+    
     describe('when given a string', function() {
       it("returns the string, quoted", function() {
         expect($.print('asdf')).to(equal, '"asdf"');
       });
-
+      
       describe('when the string is longer than the [max_string] option', function() {
         it("returns the string, truncated", function() {
           expect($.print('asdf', { max_string: 3 })).to(equal, '"asd..."');
-        });
+        });        
       });
-
+      
       describe('when the strings has quotes or escaped characters', function() {
         it("returns the string, with quotes and escaped characters escaped", function() {
           expect($.print('as"df')).to(equal, '"as\\"df"');
           expect($.print('as\tdf')).to(equal, '"as\\tdf"');
-        });
+        });        
       });
     });
-
+    
     describe('when given a function', function() {
       it("returns the function's signature", function() {
         expect($.print(function() {})).to(match, /function\s*\(\)/);
         expect($.print(function foo() {})).to(match, /function\s*foo\(\)/);
         expect($.print(function foo(bar) {})).to(match, /function\s*foo\(bar\)/);
-      });
+      });        
     });
 
     describe('when given a RegExp', function() {
@@ -71,7 +71,7 @@ Screw.Unit(function() {
         expect($.print(0)).to(equal, '0');
       });
     });
-
+    
     describe('when given an element', function() {
       it("returns the string representation of the element", function() {
         expect($.print($('<div></div>').get(0))).to(equal, '<div>');
@@ -92,13 +92,13 @@ Screw.Unit(function() {
         expect($.print([1])).to(equal, '[ 1 ]');
         expect($.print([1, 2, 3])).to(equal, '[ 1, 2, 3 ]');
       });
-
+      
       describe('when the array is longer than the [max_array] option', function() {
         it("returns the printed array, truncated", function() {
           expect($.print([1, 2, 3, 4], { max_array: 2 })).to(equal, '[ 1, 2, 2 more... ]');
         });
       });
-
+      
       describe('when the array has arrays as its elements', function() {
         it("returns the recursively printed array", function() {
           expect($.print([[]])).to(equal, '[ [] ]');
@@ -127,7 +127,7 @@ Screw.Unit(function() {
         expect($.print($('<div></div>'))).to(equal, '$([ <div> ])');
       });
     });
-
+    
     describe('when given a NodeList', function() {
       it("returns the printed array of elements in the list", function() {
         expect($.print(document.getElementsByTagName('body'))).to(equal, '[ <body> ]');
@@ -139,12 +139,12 @@ Screw.Unit(function() {
         expect($.print({})).to(equal, '{}');
         expect($.print({ foo: 1, bar: 2 })).to(equal, '{ foo: 1, bar: 2 }');
       });
-
+      
       describe('when the values of the object are non-primitive', function() {
         it("recursively prints the keys and values", function() {
           expect($.print({ foo: [1, 2] })).to(equal, '{ foo: [ 1, 2 ] }');
         });
-
+        
         describe('when the object has circular references', function() {
           it("returns elipses for circularities", function() {
             var circular = {};

data/assets/vendor/smoke/lib/smoke.core.js

@@ -3,14 +3,14 @@ Smoke = {
 		// use the jquery print plugin if it is available or fall back to toString();
 		return (jQuery && jQuery.print) ? jQuery.print(v) : v.toString();
 	},
-
-	printArguments: function(args) {
+	
+	printArguments: function(args) {    
     var a = [];
     if (args === undefined) args = '';
     if ((args && args.callee) || (args instanceof Array)) {
       for(var i = 0; i < args.length; i++) {
         a.push(Smoke.print(args[i]));
-      }
+      }      
     } else {
       // Workaround for jQuery.print returning "null" when called with an empty string.
       if (!args && (typeof args == 'string')) {
@@ -21,11 +21,11 @@ Smoke = {
     }
 		return '(' + a.join(', ') + ')';
 	},
-
-	argumentsToArray: function(args) {
+	
+	argumentsToArray: function(args) {	  
     return Array.prototype.slice.call(args);
   },
-
+  
   compare: function(a, b) {
     if (a === b) return true;
     if (a instanceof Array) {
@@ -42,7 +42,7 @@ Smoke = {
     }
     return true;
 	},
-
+	
 	compareArguments: function(a, b) {
 	  return this.compare(Smoke.argumentsToArray(a), Smoke.argumentsToArray(b));
 	}

data/assets/vendor/smoke/lib/smoke.mock.js

@@ -34,7 +34,7 @@ Smoke.Mock = function(originalObj) {
 		}
 		return new Smoke.Stub(this, attr);
 	};
-
+	
 	obj.should_receive = function(attr){
 		var expectation = new Smoke.Mock.Expectation(this, attr);
 		this._expectations[attr] = (this._expectations[attr] || []).concat([expectation]);
@@ -43,7 +43,7 @@ Smoke.Mock = function(originalObj) {
 		}
 		if(this._expectations[attr].length == 1) {
   		this[attr] = Smoke.Mock.Expectation.stub(this, attr);
-		}
+		} 
 		return expectation;
 	};
 
@@ -63,12 +63,12 @@ Smoke.Mock = function(originalObj) {
 			for(var i=0; i < expectations.length; i++) expectations[i].check();
 		};
 	};
-
+	
 	obj._resetMocks = function(){
 		for(var attr in this._valuesBeforeMocking) {
 			this[attr] = this._valuesBeforeMocking[attr];
 		}
-
+		
 		delete this._valuesBeforeMocking;
 		delete this._expectations;
 		delete this._resetMocks;
@@ -76,7 +76,7 @@ Smoke.Mock = function(originalObj) {
 		delete this.stub;
 		delete this.should_receive;
 	};
-
+	
 	Smoke.mocks.push(obj);
 	return obj;
 };
@@ -208,7 +208,7 @@ Smoke.Mock.Expectation.prototype = {
 	},
 	parseCount: function(c){
 		switch(c){
-			case 'once':
+			case 'once': 
 				return 1;
 			case 'twice':
 				return 2;

data/assets/vendor/smoke/lib/smoke.stub.js

@@ -5,7 +5,7 @@ Smoke.Stub = function(obj,attr) {
 };
 
 Smoke.Stub.prototype = {
-	defaultReturn: null,
+	defaultReturn: null, 
 	property: function(p){
 		this.property = p;
 		this.and_set_to(this.defaultReturn);

data/assets/vendor/smoke/spec/core_spec.js

@@ -1,5 +1,5 @@
 Screw.Unit(function() {
-	describe("core", function() {
+	describe("core", function() {    
     var anonymous_function = function() { return arguments };
     describe("printArguments", function() {
       it("should return '()' is the arguments are empty", function() {
@@ -14,20 +14,20 @@ Screw.Unit(function() {
         var args = anonymous_function(1,2);
         expect(Smoke.printArguments(args)).to(equal, '(1, 2)');
       });
-
+      
       it("should handle being passed something other than an array or arguments object", function() {
         expect(Smoke.printArguments(false)).to(equal, '(false)');
       });
     });
-
+    
     describe("argumentsToArray", function() {
       it("should return an array", function() {
         expect(Smoke.argumentsToArray(anonymous_function(1,2)) instanceof Array).to(equal, true);
       });
-
+      
       it("should return the arguments in an array", function() {
-        expect(Smoke.argumentsToArray(anonymous_function(1,2))).to(equal, [1,2]);
-      });
+        expect(Smoke.argumentsToArray(anonymous_function(1,2))).to(equal, [1,2]);        
+      });      
     });
 
     describe("compare", function() {
@@ -40,7 +40,7 @@ Screw.Unit(function() {
         it("should return true if the two nested arrays are equal", function() {
           expect(Smoke.compare(nested_array, [[1,2], [3,4]])).to(equal, true);
         });
-
+        
         it("should return false if the two arrays are not equal", function() {
           expect(Smoke.compare(array, [1,2,3,4])).to(equal, false);
         })
@@ -49,7 +49,7 @@ Screw.Unit(function() {
           expect(Smoke.compare(nested_array, [[1,2],[3]])).to(equal, false);
         })
       });
-
+      
       describe("with objects", function() {
         var object = { foo: 'bar' }, nested_object = { foo: { a: 'b' }, bar: { c: 'd'} };
         it("should return true if the two objects are equal", function() {
@@ -59,7 +59,7 @@ Screw.Unit(function() {
         it("should return true if the two nested objects are equal", function() {
           expect(Smoke.compare(nested_object, { foo: { a: 'b' }, bar: { c: 'd'} })).to(equal, true);
         });
-
+        
         it("should return false if the two objects are not equal", function() {
           expect(Smoke.compare(object, {bar: 'foo'})).to(equal, false);
         });
@@ -67,9 +67,9 @@ Screw.Unit(function() {
         it("should return false if the two nested objects are not equal", function() {
           expect(Smoke.compare(nested_object, { foo: { c: 'd' }, bar: { a: 'b' } })).to(equal, false);
         });
-
+        
         it("should return false if an one of the objects has an additional property", function() {
-          expect(Smoke.compare(object, { foo: 'bar', bar: 'foo' })).to(equal, false);
+          expect(Smoke.compare(object, { foo: 'bar', bar: 'foo' })).to(equal, false);          
         })
       });
 
@@ -82,7 +82,7 @@ Screw.Unit(function() {
         it("should return true if the two numbers are equal", function() {
           expect(Smoke.compare(number, 1)).to(equal, true);
         });
-
+        
         it("should return false if the two strings are not equal", function() {
           expect(Smoke.compare(string, 'bar')).to(equal, false);
         });
@@ -101,7 +101,7 @@ Screw.Unit(function() {
         it("should return false if the two arrays with mixed types are not equal", function() {
           expect(Smoke.compare(array, [1, { foo: 'bar'}, 3])).to(equal, false);
         });
-
+        
         it("should return true if the two objects with mixed types are equal", function() {
           expect(Smoke.compare(object, { foo: [1,2,3], bar: 'foo', one: 1 })).to(equal, true);
         });
@@ -110,6 +110,6 @@ Screw.Unit(function() {
           expect(Smoke.compare(object, { foo: [1,2,3], bar: 'foo', two: 3 })).to(equal, false);
         });
       })
-    });
+    });    
 	});
 });