screw_server 0.1.4

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

@@ -0,0 +1,158 @@
+Screw.Unit(function() {
+  describe("Print", function() {
+    describe('when given undefined', function() {
+      it("returns 'undefined'", 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');
+        expect($.print(1.01)).to(equal, '1.01');
+        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() {
+      it('should print the regexp', function() {
+        expect($.print(/abc/i)).to(equal, '/abc/i');
+      });
+    });
+
+    describe('when given NaN', function() {
+      it('should print the string "NaN"', function() {
+        expect($.print(NaN)).to(equal, 'NaN');
+      });
+    });
+
+    describe('when given 0', function() {
+      it('should print the string "0"', 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>');
+        expect($.print($('<div foo="bar"></div>').get(0))).to(equal, '<div>');
+        expect($.print($('<div class="foo" id="bar"></div>').get(0))).to(equal, '<div class="foo" id="bar">');
+      });
+
+      describe('when the element is an img', function() {
+        it('prints out the img src attribute', function() {
+          expect($.print($('<img src="test.png"/>'))).to(match, /<img src=".*?test.png">/);
+        })
+      });
+    });
+
+    describe('when given an array', function() {
+      it("returns the printed elements, comma separated, encircled by square brackets", function() {
+        expect($.print([])).to(equal, '[]');
+        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, '[ [] ]');
+          expect($.print([ [1, 2, 3], 4 ])).to(equal, '[ [ 1, 2, 3 ], 4 ]');
+        });
+      });
+
+      describe('when the array has objects as its elements', function() {
+        it("returns recursively printed array", function() {
+          expect($.print([{}])).to(equal, '[ {} ]');
+          expect($.print([ { foo: 'bar' }, 'baz' ])).to(equal, '[ { foo: "bar" }, "baz" ]');
+        });
+      });
+    });
+
+    describe('when given arguments', function() {
+      it("returns the printed array of elements ", function() {
+        var args = null;
+        (function(){ args = arguments })(1,2,3);
+        expect($.print(args)).to(equal, '[ 1, 2, 3 ]');
+      });
+    });
+
+    describe('when given a jQuery', function() {
+      it("returns the printed array of elements engirthed in '$()'", 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> ]');
+      });
+    });
+
+    describe('when given an object', function() {
+      it("returns the keys and values of the object, enraptured with curly braces", 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 = {};
+            circular[0] = circular;
+            expect($.print(circular)).to(equal, '{ 0: ... }');
+          });
+        });
+      });
+    });
+  });
+});

data/assets/vendor/screw-unit/spec/suite.html

@@ -0,0 +1,18 @@
+<html>
+  <head>
+    <script src="../lib/jquery-1.2.6.js"></script>
+    <script src="../lib/jquery.fn.js"></script>
+    <script src="../lib/jquery.print.js"></script>
+    <script src="../lib/screw.builder.js"></script>
+    <script src="../lib/screw.matchers.js"></script>
+    <script src="../lib/screw.events.js"></script>
+    <script src="../lib/screw.behaviors.js"></script>
+    <script src="spec_helper.js"></script>
+    <script src="behaviors_spec.js"></script>
+    <script src="matchers_spec.js"></script>
+    <script src="print_spec.js"></script>
+
+    <link rel="stylesheet" href="../lib/screw.css">
+  </head>
+  <body></body>
+</html>

data/assets/vendor/smoke/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Andy Kent
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/assets/vendor/smoke/README.markdown

@@ -0,0 +1,68 @@
+Smoke
+=====
+Smoke is a JavaScript mocking and stubbing framework. It has a familiar RSpec style interface and whilst it is perfectly capable of being used as a free-standing tool it comes complete with a plugin for the screw-unit testing framework.
+Below are some getting started guides to get you on your way. See the included specs for further help.
+
+Getting Started (With Screw.Unit)
+---------------------------------
+See `spec/suite.html` and the test file `screw_integration_spec.js` for lots of real world usage examples.
+
+but you will need to include the Smoke files and you can get straight to work using the mock() and spec() methods...
+
+	foo = {bar: function(attribute){return 'hello'}, baz:'goodbye'};
+	stub(foo, 'bar').and_return('hi!');
+	stub(foo, 'baz').and_set_to('welcome');
+	myMock = mock('test');
+	myMock.should_receive('foo').at_least('once').and_return('hello');
+	expect(foo.baz).to(equal, 'hi!');
+
+Additionally Smoke now has a macro for mocking anonymous functions this is great for mocking and stubbing closures...
+
+	callback = mock_function();
+	callback.should_be_invoked().exactly('once');
+	$.bind('click', callback);
+	$.trigger('click');
+
+Getting Started (Free Standing)
+-------------------------------
+Include the library files in your document...
+
+	<!-- require smoke -->
+	<script src="../lib/smoke.mock.js"></script>
+	<script src="../lib/smoke.stub.js"></script>
+
+Create your stubs...
+
+	foo = {bar: function(attribute){return 'hello'}, baz:'goodbye'};
+	new Smoke.Stub(foo,'baz').and_set_to('boo');
+	new Smoke.Stub(foo,'bar').and_return('blah');
+
+Create your mocks...
+
+	var myMock = Smoke.Mock();
+	var myMockFunction = Smoke.MockFunction();
+
+Create your expectations...
+
+	myMock.should_receive('foo').with('bar').exactly(3, 'times').and_return('baz');
+
+Check you expectations...
+
+	Smoke.checkExpectations();
+
+More About Mocks
+----------------
+Mocks are the main part of the Smoke framework. But Smoke.Mock() has a bit of a dual personality depending on if you pass it a value.
+
+1. *without any arguments* it will return a fresh Mock with no more than default Object methods. You will need to mock all your interactions and check all your expectations.
+2. *with an argument* it will return a 'Mocked' version of the object that was passed in. This is very useful if you just want to mock a single method on your object whilst leaving the rest intact. It's especially helpful for just carrying out expectations on existing objects without any mocking at all.
+
+Smoke expectations are now destructive meaning that if you add an expectation then the previous method will not be invoked (if one exists) and undefined will be returned (unless you specify otherwise using and_return()).
+
+Known Issues
+------------
+* Whilst you can stub both functions and properties you can currently only carry out mock expectations on functions. Unfortunately I think this is a language limitation of JavaScript but if anyone has any bright ideas then I'm all ears.
+
+Contact
+-------
+Please send patches, comments or suggestions to andrew.d.kent@gmail.com

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

@@ -0,0 +1,49 @@
+Smoke = {
+	print: function(v) {
+		// 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) {
+    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')) {
+        a.push('');
+      } else {
+        a.push(Smoke.print(args));
+      }
+    }
+		return '(' + a.join(', ') + ')';
+	},
+
+	argumentsToArray: function(args) {
+    return Array.prototype.slice.call(args);
+  },
+
+  compare: function(a, b) {
+    if (a === b) return true;
+    if (a instanceof Array) {
+      if (b.length != a.length) return false;
+      for (var i = 0; i < b.length; i++)
+        if (!this.compare(a[i], b[i])) return false;
+    } else if (a instanceof Object) {
+      for (var key in a)
+        if (!this.compare(a[key], b[key])) return false;
+      for (var key in b)
+        if (!this.compare(b[key], a[key])) return false;
+    } else {
+      return false;
+    }
+    return true;
+	},
+
+	compareArguments: function(a, b) {
+	  return this.compare(Smoke.argumentsToArray(a), Smoke.argumentsToArray(b));
+	}
+};

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

@@ -0,0 +1,219 @@
+// Overide these functions for custom pass/fail behaviours
+Smoke.passed = function(mock){
+	Smoke.passCount++;
+};
+
+Smoke.failed = function(mock, message){
+	Smoke.failCount++;
+	throw(message);
+};
+
+// Some helpers
+Smoke.reset = function(){
+	Smoke.mocks = Smoke.mocks || [];
+	for(var i=0; i<Smoke.mocks.length; i++) Smoke.mocks[i]._resetMocks();
+	Smoke.mocks = [];
+	Smoke.passCount = 0;
+	Smoke.failCount = 0;
+};
+Smoke.reset();
+
+Smoke.checkExpectations = function(){
+	for(var i=0; i<Smoke.mocks.length; i++) Smoke.mocks[i]._checkExpectations();
+};
+
+Smoke.Mock = function(originalObj) {
+	var obj = originalObj || {} ;
+	if (obj._expectations) return obj;
+	obj._expectations = {};
+	obj._valuesBeforeMocking = {};
+
+	obj.stub = function(attr){
+		if (!this._valuesBeforeMocking.hasOwnProperty(attr)) {
+		  this._valuesBeforeMocking[attr] = this[attr];
+		}
+		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]);
+		if (!this._valuesBeforeMocking.hasOwnProperty(attr)) {
+		  this._valuesBeforeMocking[attr] = this[attr];
+		}
+		if(this._expectations[attr].length == 1) {
+  		this[attr] = Smoke.Mock.Expectation.stub(this, attr);
+		}
+		return expectation;
+	};
+
+	obj.should_not_receive = function(attr){
+		return obj.should_receive(attr).exactly(0, "times");
+	};
+
+	obj.must_receive = function(attr) {
+	  var expectation = obj.should_receive(attr);
+	  expectation.at_least("once");
+	  return expectation;
+	}
+
+	obj._checkExpectations = function(){
+		for(var e in this._expectations) {
+			var expectations = this._expectations[e]
+			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;
+		delete this._checkExpectations;
+		delete this.stub;
+		delete this.should_receive;
+	};
+
+	Smoke.mocks.push(obj);
+	return obj;
+};
+
+Smoke.MockFunction = function(originalFunction, name) {
+  name = name || 'anonymous_function';
+  var mock = Smoke.Mock(function() {
+    return arguments.callee[name].apply(this, arguments);
+  });
+  mock[name] = (originalFunction || new Function());
+  mock.should_be_invoked = function() {
+    return this.should_receive(name);
+  }
+  mock.must_be_invoked = function() {
+    return this.must_receive(name);
+  }
+  mock.should_not_be_invoked = function() {
+    return this.should_not_receive(name);
+  }
+  return mock;
+};
+
+Smoke.Mock.Expectation = function(mock, attr) {
+	this._mock = mock;
+	this._attr = attr;
+	this.callCount = 0;
+	this.returnValue = undefined;
+	this.callerArgs = undefined;
+	this.hasReturnValue = false;
+};
+
+Smoke.Mock.Expectation.stub = function(mock, attr) {
+  return function() {
+    return function() {
+      var matched, return_value, args = arguments;
+      jQuery.each(this, function() {
+        if (!matched) {
+          if (this.run(args)) {
+            matched = true;
+            return_value = this.returnValue;
+          }
+    	  }
+      });
+      if (!matched) {
+        this[0].argumentMismatchError(args)
+      }
+      return return_value;
+    }.apply(mock._expectations[attr].slice(0).reverse(), arguments);
+  }
+}
+
+
+Smoke.Mock.Expectation.prototype = {
+	exactly: function(count,type){
+		// type isn't used for now, it's just syntax ;)
+		this.minCount = this.maxCount = undefined;
+		this.exactCount = this.parseCount(count);
+		return this;
+	},
+	at_most: function(count,type){
+		this.maxCount = this.parseCount(count);
+		return this;
+	},
+	at_least: function(count,type){
+		this.minCount = this.parseCount(count);
+		return this;
+	},
+	with_arguments: function(){
+		this.callerArgs = arguments;
+		return this
+	},
+	with_any_arguments: function(){
+	  this.acceptAnyArguments = true;
+		return this
+	},
+	run: function(args){
+	  if (this.throwException) {
+	    throw this.throwException;
+	  }
+	  else if (this.executeFunction) {
+	    this.callCount+=1;
+	    this.hasReturnValue = true;
+	    this.returnValue = this.executeFunction.apply(null, args);
+	    return true;
+	  }
+		else if(this.acceptAnyArguments) {
+      this.callCount+=1;
+      return true;
+    }
+    else if((this.callerArgs === undefined) || Smoke.compareArguments(args, this.callerArgs)) {
+			return !!(this.callCount+=1);
+		};
+		return false
+	},
+	and_return: function(v){
+	  this.hasReturnValue = true;
+		this.returnValue = v;
+	},
+	and_throw: function(e){
+	  this.throwException = e;
+	  return this;
+	},
+	and_execute: function(fn){
+	  this.executeFunction = fn;
+	  return this;
+  },
+	check: function(){
+		if(this.exactCount!=undefined) this.checkExactCount();
+		if(this.minCount!=undefined) this.checkMinCount();
+		if(this.maxCount!=undefined) this.checkMaxCount();
+	},
+	checkExactCount: function(){
+		if(this.exactCount==this.callCount) Smoke.passed(this)//console.log('Mock passed!')
+		else Smoke.failed(this, 'expected '+this.methodSignature()+' to be called exactly '+this.exactCount+" times but it got called "+this.callCount+' times');
+	},
+	checkMinCount: function(){
+		if(this.minCount<=this.callCount) Smoke.passed(this);
+		else Smoke.failed(this, 'expected '+this.methodSignature()+' to be called at least '+this.minCount+" times but it only got called "+this.callCount+' times');
+	},
+	checkMaxCount: function(){
+		if(this.maxCount>=this.callCount) Smoke.passed(this);//console.log('Mock passed!')
+		else Smoke.failed(this, 'expected '+this.methodSignature()+' to be called at most '+this.maxCount+" times but it actually got called "+this.callCount+' times');
+	},
+	argumentMismatchError: function(args) {
+	  Smoke.failed(this, 'expected ' + this._attr + ' with ' + Smoke.printArguments(this.callerArgs) + ' but received it with ' + Smoke.printArguments(args));
+	},
+	methodSignature: function(){
+		return this._attr + Smoke.printArguments(this.callerArgs);
+	},
+	parseCount: function(c){
+		switch(c){
+			case 'once':
+				return 1;
+			case 'twice':
+				return 2;
+			default:
+				return c;
+		}
+	}
+};

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

@@ -0,0 +1,29 @@
+Smoke.Stub = function(obj,attr) {
+	this.obj = obj;
+	this.attribute = attr;
+	this.and_return(this.defaultReturn);
+};
+
+Smoke.Stub.prototype = {
+	defaultReturn: null,
+	property: function(p){
+		this.property = p;
+		this.and_set_to(this.defaultReturn);
+		return this
+	},
+	method: function(f){
+		this.func = f;
+		this.and_return(this.defaultReturn);
+		return this
+	},
+	and_return: function(v){
+		this.obj[this.attribute] = function() {
+			return v
+		};
+		return this.obj
+	},
+	and_set_to: function(v){
+		this.obj[this.attribute] = v;
+		return this.obj
+	}
+};

data/assets/vendor/smoke/plugins/screw.mocking.js

@@ -0,0 +1,26 @@
+// This is a lightweight bridge between Smoke and Screw.Unit.
+// It shadows mocking and stubbing onto the matchers to make them available within tests.
+
+Screw.Matchers.mock = function(m) {
+  return Smoke.Mock(m);
+};
+
+Screw.Matchers.mock_function = function(func,name) {
+  return Smoke.MockFunction(func,name);
+};
+
+Screw.Matchers.stub = function(obj, attr) {
+  return new Smoke.Stub(obj,attr);
+};
+
+(function($) {
+  $(Screw).bind("before", function(){
+    function checkAndResetSmoke() {
+      Smoke.checkExpectations();
+      Smoke.reset();
+    }
+
+    $('.it').bind('passed', function(){ checkAndResetSmoke() });
+    $('.it').bind('failed', function(){ Smoke.reset() });
+  });
+})(jQuery);