drogus-blue-ridge 0.0.1

data/lib/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(){ checkAndResetSmoke() });
+  });
+})(jQuery);

data/lib/shell.js

@@ -0,0 +1,27 @@
+(function(){
+  var _old_quit = this.quit;
+  this.__defineGetter__("exit", function(){ _old_quit() });
+  this.__defineGetter__("quit", function(){ _old_quit() });
+  
+  print("=================================================");
+  print(" Rhino JavaScript Shell");
+  print(" To exit type 'exit', 'quit', or 'quit()'.");
+  print("=================================================");
+
+  var plugin_prefix = environment["blue.ridge.prefix"] || "vendor/plugins/blue-ridge";
+  var fixture_file = plugin_prefix + "/generators/blue_ridge/templates/application.html";
+
+  load(plugin_prefix + "/lib/env.rhino.js");
+  print(" - loaded env.js");
+
+  window.location = fixture_file;
+  print(" - sample DOM loaded");
+
+  load(plugin_prefix + "/lib/jquery-1.3.2.js");
+  print(" - jQuery-1.3.2 loaded");
+  
+  load(plugin_prefix + "/lib/jquery.print.js");
+  print(" - jQuery print lib loaded");
+
+  print("=================================================");
+})();

data/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/lib/smoke.mock.js

@@ -0,0 +1,171 @@
+// 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 || {} ;
+	obj._expectations = {};
+	obj._valuesBeforeMocking = {};
+
+	obj.stub = function(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]);
+		this._valuesBeforeMocking[attr] = this[attr];
+		if(this._expectations[attr].length == 1) {
+  		this[attr] = Smoke.Mock.Expectation.stub(this, attr);
+		} 
+		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() {
+    var return_value = arguments.callee[name].apply(this, arguments);
+    if (return_value === undefined) {
+      return_value = (originalFunction || new Function()).apply(this, arguments)
+    }
+    return return_value;
+  });
+  mock[name] = (originalFunction || new Function());
+  mock.should_be_invoked = function() {
+    return this.should_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() {
+    	  this.run(args) && (matched = true) && (return_value = this.returnValue);
+      });
+      if (!matched) {
+        this[0].argumentMismatchError(args)
+      }
+      return return_value;        
+    }.apply(mock._expectations[attr], 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
+	},
+	run: function(args){
+		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;
+	},
+	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/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/lib/test_runner.js

@@ -0,0 +1,58 @@
+if(arguments.length == 0) {
+  print("Usage: test_runner.js spec/javascripts/file_spec.js");
+  quit(1);
+}
+
+var PLUGIN_PREFIX = environment["blue.ridge.prefix"] || "../../vendor/plugins/blue-ridge";
+
+var BlueRidge = {
+  require: function(file, options){ 
+    load(file); 
+  
+    options = options || {};
+    if(options['onload']) {
+      options['onload'].call();
+    }
+  },
+  
+  css: function(url, options) {
+    // can do nothing in test_runner
+  },
+  
+  debug: function(message){
+    print(message);
+  },
+  
+  get fixtureFile(){
+    return "fixtures/" + this.specFile.replace(/^(.*?)_spec\.js$/, "$1.html");
+  }
+};
+
+BlueRidge.specFile = arguments[0];
+
+var require = require || BlueRidge.require;
+var css     = css || BlueRidge.css;
+var debug   = debug   || BlueRidge.debug;
+
+// Mock up the Firebug API for convenience.
+var console = console || {debug: debug};
+
+load(PLUGIN_PREFIX + "/lib/env.rhino.js");
+window.location = BlueRidge.fixtureFile;
+
+load(PLUGIN_PREFIX + "/lib/jquery-1.3.2.js");
+load(PLUGIN_PREFIX + "/lib/jquery.fn.js");
+load(PLUGIN_PREFIX + "/lib/jquery.print.js");
+load(PLUGIN_PREFIX + "/lib/screw.builder.js");
+load(PLUGIN_PREFIX + "/lib/screw.matchers.js");
+load(PLUGIN_PREFIX + "/lib/screw.events.js");
+load(PLUGIN_PREFIX + "/lib/screw.behaviors.js");
+load(PLUGIN_PREFIX + "/lib/smoke.core.js");
+load(PLUGIN_PREFIX + "/lib/smoke.mock.js");
+load(PLUGIN_PREFIX + "/lib/smoke.stub.js");
+load(PLUGIN_PREFIX + "/lib/screw.mocking.js");
+load(PLUGIN_PREFIX + "/lib/consoleReportForRake.js");
+
+print("Running " + BlueRidge.specFile + " with fixture '" + BlueRidge.fixtureFile + "'...");
+load(BlueRidge.specFile);
+jQuery(window).trigger("load");

data/spec/fixtures/rails_project/app/controllers/accounts_controller.rb

@@ -0,0 +1,85 @@
+class AccountsController < ApplicationController
+  # GET /accounts
+  # GET /accounts.xml
+  def index
+    @accounts = Account.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @accounts }
+    end
+  end
+
+  # GET /accounts/1
+  # GET /accounts/1.xml
+  def show
+    @account = Account.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @account }
+    end
+  end
+
+  # GET /accounts/new
+  # GET /accounts/new.xml
+  def new
+    @account = Account.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @account }
+    end
+  end
+
+  # GET /accounts/1/edit
+  def edit
+    @account = Account.find(params[:id])
+  end
+
+  # POST /accounts
+  # POST /accounts.xml
+  def create
+    @account = Account.new(params[:account])
+
+    respond_to do |format|
+      if @account.save
+        flash[:notice] = 'Account was successfully created.'
+        format.html { redirect_to(@account) }
+        format.xml  { render :xml => @account, :status => :created, :location => @account }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @account.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /accounts/1
+  # PUT /accounts/1.xml
+  def update
+    @account = Account.find(params[:id])
+
+    respond_to do |format|
+      if @account.update_attributes(params[:account])
+        flash[:notice] = 'Account was successfully updated.'
+        format.html { redirect_to(@account) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @account.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /accounts/1
+  # DELETE /accounts/1.xml
+  def destroy
+    @account = Account.find(params[:id])
+    @account.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(accounts_url) }
+      format.xml  { head :ok }
+    end
+  end
+end