set_builder 1.0.2

data/spec/lib/jspec.nodejs.js

@@ -0,0 +1,18 @@
+
+// JSpec - node - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+JSpec
+.include({
+  name: 'node',
+  
+  // --- Matchers
+  
+  matchers : {
+    have_enumerable_property: 'actual.propertyIsEnumerable(expected)',
+    have_writable_property: 'Object.getOwnPropertyDescriptor(actual, expected).writable === true',
+    have_configurable_property: 'Object.getOwnPropertyDescriptor(actual, expected).configurable === true',
+    have_keys: 'does(Object.keys(actual), "eql", expected)',
+    have_prototype: 'Object.getPrototypeOf(actual) === expected'
+  }
+})
+

data/spec/lib/jspec.shell.js

@@ -0,0 +1,39 @@
+
+// JSpec - Shell - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+;(function(){
+  
+  var _quit = quit
+  
+  Shell = {
+    
+    // --- Global
+    
+    main: this,
+    
+    // --- Commands
+    
+    commands: {
+      quit: ['Terminate the shell', function(){ _quit() }],
+      exit: ['Terminate the shell', function(){ _quit() }],
+      p: ['Inspect an object', function(o){ return o.toSource() }]
+    },
+    
+    /**
+     * Start the interactive shell.
+     *
+     * @api public
+     */
+    
+    start : function() {
+      for (var name in this.commands)
+        if (this.commands.hasOwnProperty(name))
+          this.commands[name][1].length ?
+            this.main[name] = this.commands[name][1] :
+              this.main.__defineGetter__(name, this.commands[name][1])
+    }
+  }
+  
+  Shell.start()
+  
+})()

data/spec/lib/jspec.timers.js

@@ -0,0 +1,154 @@
+
+// Mock Timers - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+;(function(){
+  
+  /**
+   * Localized timer stack.
+   */
+  var timers = [];
+  
+  // nodejs, rhino don't have a window object
+  var global = this;
+  
+  // if they where mocked before this library is loaded - bad luck
+  var savedGlobals = {
+    setTimeout: global.setTimeout,
+    setInterval: global.setInterval,
+    clearInterval: global.clearInterval,
+    clearTimeout: global.clearTimeout,
+    
+    // those should not be globals, but are mocked none the less, so we save them
+    resetTimers: global.resetTimers,
+    tick: global.tick
+  };
+  var hadResetTimers = 'resetTimers' in global;
+  var hadTick = 'tick' in global;
+  
+  function forEachProperty(anObject, aClosure) {
+    for (var key in anObject) {
+      if ( ! anObject.hasOwnProperty(key))
+        continue;
+      
+      aClosure(key, anObject[key]);
+    }
+  }
+  
+  global.MockTimers = {
+    
+    mockTimersVersion: '2.0.0',
+    
+    mockGlobalTimerFunctions: function() {
+      forEachProperty(this.mocks, function(aName, aFunction) {
+        global[aName] = aFunction;
+      });
+    },
+    
+    unmockGlobalTimerFunctions: function() {
+      forEachProperty(this.savedGlobals, function(aName, aFunction) {
+        global[aName] = aFunction;
+      });
+      
+      if ( ! hadResetTimers)
+        delete global['resetTimers'];
+      if ( ! hadTick)
+        delete global['tick'];
+      
+    }
+  };
+  
+  function clearTimer(id) {
+    return delete timers[--id];
+  }
+  
+  var mocks = {
+    
+    /**
+     * Set mock timeout with _callback_ and timeout of _ms_.
+     *
+     * @param  {function} callback
+     * @param  {int} ms
+     * @return {int}
+     * @api public
+     */
+    setTimeout: function(callback, ms) {
+      var id;
+      return id = setInterval(function(){
+        callback();
+        clearInterval(id);
+      }, ms);
+    },
+
+
+   /**
+    * Set mock interval with _callback_ and interval of _ms_.
+    *
+    * @param  {function} callback
+    * @param  {int} ms
+    * @return {int}
+    * @api public
+    */
+    setInterval: function(callback, ms) {
+      // REFACT: use wrapper object so callback is not changed -> state leak
+      callback.step = ms;
+      callback.current = callback.last = 0;
+      timers[timers.length] = callback;
+      return timers.length;
+    },
+    
+    /**
+     * Destroy timer with _id_.
+     *
+     * @param  {int} id
+     * @return {bool}
+     * @api public
+     */
+    clearInterval: clearTimer,
+    clearTimeout: clearTimer
+  };
+  
+  // additional functions that are not originally in the global namespace
+  /**
+   * Reset timers.
+   *
+   * @return {array}
+   * @api public
+   */
+  mocks.resetTimers = function() {
+    return timers = [];
+  };
+  
+  /**
+   * Increment each timers internal clock by _ms_.
+   *
+   * @param  {int} ms
+   * @api public
+   */
+  mocks.tick = function(ms) {
+    for (var i = 0, len = timers.length; i < len; ++i) {
+      if ( ! timers[i] || ! (timers[i].current += ms))
+        continue;
+      
+      if (timers[i].current - timers[i].last < timers[i].step)
+        continue;
+      
+      var times = Math.floor((timers[i].current - timers[i].last) / timers[i].step);
+      var remainder = (timers[i].current - timers[i].last) % timers[i].step;
+      timers[i].last = timers[i].current - remainder;
+      while (times-- && timers[i])
+        timers[i]();
+    }
+  };
+  
+  // make them available publicly
+  MockTimers.mocks = mocks;
+  
+  JSpec.include({
+    beforeSpec: function(){
+      MockTimers.mockGlobalTimerFunctions();
+    },
+    afterSpec : function() {
+      MockTimers.unmockGlobalTimerFunctions();
+    }
+  });
+})();

data/spec/lib/jspec.xhr.js

@@ -0,0 +1,210 @@
+
+// JSpec - XHR - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+(function(){
+
+  var lastRequest
+
+  // --- Original XMLHttpRequest
+
+  var OriginalXMLHttpRequest = 'XMLHttpRequest' in this ?
+                                 XMLHttpRequest :
+                                   function(){}
+  var OriginalActiveXObject = 'ActiveXObject' in this ?
+                                 ActiveXObject :
+                                   undefined
+
+  // --- MockXMLHttpRequest
+
+  var MockXMLHttpRequest = function() {
+    this.requestHeaders = {}
+  }
+
+  MockXMLHttpRequest.prototype = {
+    status: 0,
+    async: true,
+    readyState: 0,
+	  responseXML: null,
+    responseText: '',
+    abort: function(){},
+    onreadystatechange: function(){},
+
+   /**
+    * Return response headers hash.
+    */
+
+    getAllResponseHeaders : function(){
+      return JSpec.inject(this.responseHeaders, '', function(buf, key, val){
+        return buf + key + ': ' + val + '\r\n'
+      })
+    },
+
+    /**
+     * Return case-insensitive value for header _name_.
+     */
+
+    getResponseHeader : function(name) {
+      return this.responseHeaders[name.toLowerCase()]
+    },
+
+    /**
+     * Set case-insensitive _value_ for header _name_.
+     */
+
+    setRequestHeader : function(name, value) {
+      this.requestHeaders[name.toLowerCase()] = value
+    },
+
+    /**
+     * Open mock request.
+     */
+
+    open : function(method, url, async, user, password) {
+      this.user = user
+      this.password = password
+      this.url = url
+      this.readyState = 1
+      this.method = method.toUpperCase()
+      if (async != undefined) this.async = async
+      if (this.async) this.onreadystatechange()
+    },
+
+    /**
+     * Send request _data_.
+     */
+
+    send : function(data) {
+      var self = this
+      this.data = data
+      this.readyState = 4
+      if (this.method == 'HEAD') this.responseText = null
+      this.responseHeaders['content-length'] = (this.responseText || '').length
+      if(this.async) this.onreadystatechange()
+	    this.populateResponseXML()
+      lastRequest = function(){
+        return self
+      }
+    },
+
+	/**
+	 * Parse request body and populate responseXML if response-type is xml
+	 * Based on the standard specification : http://www.w3.org/TR/XMLHttpRequest/
+	 */
+	populateResponseXML: function() {
+		var type = this.getResponseHeader("content-type")
+		if (!type || !this.responseText || !type.match(/(text\/xml|application\/xml|\+xml$)/g))
+			return
+		this.responseXML = JSpec.parseXML(this.responseText)
+	  }
+  }
+
+  // --- Response status codes
+
+  JSpec.statusCodes = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    300: 'Multiple Choice',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    307: 'Temporary Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Request Entity Too Large',
+    414: 'Request-URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Requested Range Not Satisfiable',
+    417: 'Expectation Failed',
+    422: 'Unprocessable Entity',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported'
+  }
+
+  /**
+   * Mock XMLHttpRequest requests.
+   *
+   *   mockRequest().and_return('some data', 'text/plain', 200, { 'X-SomeHeader' : 'somevalue' })
+   *
+   * @return {hash}
+   * @api public
+   */
+
+  function mockRequest() {
+    return { and_return : function(body, type, status, headers) {
+      XMLHttpRequest = MockXMLHttpRequest
+      ActiveXObject = false
+      status = status || 200
+      headers = headers || {}
+      headers['content-type'] = type
+      JSpec.extend(XMLHttpRequest.prototype, {
+        responseText: body,
+        responseHeaders: headers,
+        status: status,
+        statusText: JSpec.statusCodes[status]
+      })
+    }}
+  }
+
+  /**
+   * Unmock XMLHttpRequest requests.
+   *
+   * @api public
+   */
+
+  function unmockRequest() {
+    XMLHttpRequest = OriginalXMLHttpRequest
+    ActiveXObject = OriginalActiveXObject
+  }
+
+  JSpec.include({
+    name: 'Mock XHR',
+
+    // --- Utilities
+
+    utilities : {
+      mockRequest: mockRequest,
+      unmockRequest: unmockRequest
+    },
+
+    // --- Hooks
+
+    afterSpec : function() {
+      unmockRequest()
+    },
+
+    // --- DSLs
+
+    DSLs : {
+      snake : {
+        mock_request: mockRequest,
+        unmock_request: unmockRequest,
+        last_request: function(){ return lastRequest() }
+      }
+    }
+
+  })
+})()

data/spec/node.js

@@ -0,0 +1,10 @@
+
+require.paths.unshift('spec', './spec/lib', 'lib')
+require('jspec')
+require('unit/spec.helper')
+require('yourlib')
+
+JSpec
+  .exec('spec/unit/spec.js')
+  .run({ reporter: JSpec.reporters.Terminal, fixturePath: 'spec/fixtures', failuresOnly: true })
+  .report()

data/spec/rhino.js

@@ -0,0 +1,10 @@
+
+load('./spec/lib/jspec.js')
+load('./spec/lib/jspec.xhr.js')
+load('lib/yourlib.js')
+load('spec/unit/spec.helper.js')
+
+JSpec
+.exec('spec/unit/spec.js')
+.run({ reporter: JSpec.reporters.Terminal, fixturePath: 'spec/fixtures' })
+.report()