entityjs 0.2.2 → 0.3.0

data/public/qunit/qunit.entity.js

@@ -0,0 +1,190 @@
+EUnit = {
+  stack:[],
+  
+  runStack:function(){
+    for(var i in EUnit.stack){
+      var k = EUnit.stack[i];
+      
+      ok(k.called, k.message);
+    }
+  },
+  
+  push:function(obj){
+    this.stack.push(obj);
+    
+    return QUnit.config.queue.unshift(EUnit.runStack);
+  }
+};
+/*
+Expects a trigger call from the given obj.
+
+var e = re.e('flicker');
+
+expectTrigger(e, 'flicker:end', function(){
+  //if triggered this will be called
+});
+
+*/
+function expectTrigger(obj, trigger, func){
+  var trig = {
+    called:0,
+    message:"Expected "+trigger+" to be triggered"
+  };
+  
+  trig.meth = function(){
+    trig.called++;
+    if(func) func.apply(obj, arguments);
+  };
+  
+  obj.on(trigger, trig.meth);
+  
+  EUnit.push(trig);
+}
+
+/*
+Expects the given entity to have the given flicker present
+
+var e = re.e();
+
+expectFlicker(e, 'run'); //false
+
+e.comps('flicker').addFlicker('run', 123, 21, [2]);
+
+expectFlicker(e, 'run') //true
+
+*/
+function expectFlicker(ent, flick){
+  ok(ent.flicker_reels[flick] != null, "Expected entity to have flicker "+flick);
+}
+
+/*
+Expects an entity or component to have a current listener attached.
+
+var e = re.e();
+
+expectListener(e, 'update'); //false
+
+e.on('update', function(){
+  
+});
+
+expectListener(e, 'update') //true
+
+*/
+function expectListener(ent, trigger, func){
+  if(arguments.length == 2){
+    ok(ent.has('^'+trigger), "Expected entity to have listener "+trigger);
+  } else {
+    var fin = false;
+    for(var i in ent._re_signals[trigger]){
+      fin = (ent._re_signals[trigger][i] == func)
+      if(fin) break;
+    }
+    
+    ok(fin, "Expected entity to have listener "+trigger+" with function");
+    
+  }
+}
+
+/*
+Generates a factory for creating complex entities.
+
+//create coin factory
+factory('coin', function(){
+  //set values on the newly created coin
+  this.value = 10;
+  
+  //has all normal methods
+  this.def('blah', 10);
+  this.on('update', function(){
+  });
+});
+
+//create coin
+var e = factory('coin');
+e.value // 10
+e.has('coin') //true
+
+//can also use f
+var coin2 = f('coin');
+coin2.value //10
+
+*/
+var _factories = {};
+function factory(comps, func){
+  var e = re.e(comps);
+  
+  //don't enter in arrays, strings only
+  if(func) _factories[comps] = func;
+  
+  if(_factories[comps]) _factories[comps].call(e);
+  
+  return e;
+}
+var f = factory;
+
+/*
+Generates a factory entity for easy use in the module()
+
+//light weight
+//a new coin in e will be created for every test()
+module('coin', lazy('coin'));
+
+//do something after coin creation
+module('coin', lazy('coin', function(e){
+  //called on coin creation.
+}));
+
+//setup teardown methods together
+module('coin', lazy('coin', {
+setup:function(e){
+  //called on coin creation.
+},
+teardown:function(e){
+  //called after each test
+}
+}));
+
+test('coin should have valid of 10', function(){
+  equal(e.value, 10);
+})
+
+etc..
+
+*/
+var e;
+function lazy(comps, obj){
+  return {
+    setup:function(){
+      e = f(comps);
+      if(typeof obj == 'function') obj(e);
+      if(obj && obj.setup) obj.setup(e);
+    },
+    teardown:function(){
+      if(obj && obj.teardown) obj.teardown(e);
+      e.dispose();
+    }
+  }
+}
+
+/*
+Some super lazy evaluations
+*/
+var eq = equal;
+var not = function(arg, message){ok(!arg, message);}
+function is(obj, type){
+  if(arguments.length == 1){
+    ok(obj != null, "Expected to be present");
+  } else{
+    ok(obj != null && Object.prototype.toString.call(obj).slice(8, -1).toLowerCase() == type.toLowerCase())
+  }
+}
+
+function match(test, reg, i){
+  if(typeof reg == 'string'){
+    reg = new RegExp(reg, i)
+  }
+  
+  ok(test.match(reg) != null, "Expected to match "+reg)
+  
+}

data/public/qunit/qunit.input.js

@@ -0,0 +1,200 @@
+/*
+EntityJS methods to simulate user inputs.
+*/
+
+function _findKeyCode(code){
+  var codes = re.c('keyboard').keyCodes;
+  
+  for(var i in codes){
+    if(codes[i] == code){
+      return i;
+    }
+  }
+  return null;
+}
+
+//sim keyboard presses
+
+/*
+Calls keydown. This will keep it down until keyup is called.
+keydown('w');
+*/
+function keydown(key, e){
+  e = e || {};
+  
+  e.type = 'keydown';
+  e.keyCode = _findKeyCode(key);
+  
+  re.c('keyboard').event(e);
+};
+
+/*
+Calls keyup, even if keydown was not pressed beforehand.
+keyup('w');
+*/
+function keyup(key, e){
+  e = e || {};
+  
+  e.type = 'keyup';
+  e.keyCode = _findKeyCode(key);
+  
+  re.c('keyboard').event(e);
+};
+
+/*
+Calls keydown before the callback and then keyup after.
+
+keypress('w', function(){
+  
+  //w is down
+  
+  //w is up
+});
+
+//w is not down
+
+//Can also enter in an array of keys
+keypress(['w','a','s','d'], function(key, event){
+  
+})
+
+//Can also send custom attributes to the event object.
+var e = re.e('keyboard')
+.on('keydown', function(key, event){
+  re.log(event.myCustom); //cake
+});
+keypress('w', null, {myCustom:'cake'});
+
+//key in mind the callback method is also optional
+
+*/
+function keypress(key, callback, e){
+  if(typeof key == 'object'){
+    for(var i in key){
+        keypress(key[i], callback, e);
+    }
+    return;
+  }
+  keydown(key, e);
+  if(callback) callback(key, e);
+  keyup(key, e);
+};
+
+function _mouseEvent(e, type, x, y, key){
+  e = e || {};
+  
+  e.type = type;
+  e.clientX = x + document.body.scrollLeft + document.documentElement.scrollLeft;
+  e.clientX = y + document.body.scrollTop + document.documentElement.scrollTop;
+  
+  if(key){
+    re.c('mouse').press(e);
+  } else {
+    re.c('mouse').event(e);
+  }
+}
+
+//sim mouse clicks
+
+/*
+Will hold the mouse down until mouse up is called.
+
+//click at 10,20 with the middle key
+//add custom to the event object.
+mousedown(10, 20, 'middle', {custom:234});
+
+*/
+function mousedown(x, y, key, e){
+  
+  _mouseEvent(e, 'mousedown', x, y, key || 'left');
+};
+
+/*
+Will call mouse up on the given x, y.
+Mousedown does not need to be called for this to work.
+
+mouseup(20, 40, 'right');
+*/
+function mouseup(x, y, key, e){
+  _mouseEvent(e, 'mouseup', x, y, key || 'left');
+};
+
+/*
+Calls mousemove on the given coordinate.
+
+mousemove(20, 30);
+
+*/
+function mousemove(x, y, e){
+  _mouseEvent(e, 'mousemove', x, y);
+};
+
+/*
+Calls contextmenu on the given coordiante.
+
+contextmenu(30, 50)
+*/
+function contextmenu(x, y, e){
+  _mouseEvent(e, 'contextmenu', x, y);
+  
+};
+
+/*
+Clicks on the given coordinate and optionally call a method inbetween.
+
+click(20, 30);
+
+//with callback
+click(40, 50, function(x, y, key, event){
+  //mousedown..  
+
+  
+  //mouseup..
+});
+
+//mouse not down
+
+//call with custom key and event
+click(20, 50, null, 'middle', {blah:23});
+
+//multiple clicks
+
+click([[0,1], [30, 20], [34, 73]], function(x, y, key, event){
+  
+  re.log('clicks', x, y, key, event);
+
+}, 'right', {extra:10});
+
+*/
+function click(x, y, callback, key, e){
+  
+  if(typeof x == 'object'){
+    
+    for(var i in x){
+      click(x[i][0], x[i][1], y, callback, key);
+    }
+    
+    return;
+  }
+  
+  mousedown(x, y, key, e);
+  _mouseEvent(e, 'click', x, y);
+  if(callback) callback(x, y, key, e);
+  mouseup(x, y, key, e);
+};
+
+/*
+Same as the click method, except it calls click twice and then dispatches the callback.
+
+
+dblclick(20, 40, function(x, y, key, e){
+  //blah
+}, 'left', {bl:sdf});
+
+*/
+function dblclick(x, y, callback, key, e){
+  click(x, y, null, key, e);
+  click(x, y, null, key, e);
+  _mouseEvent(e, 'dblclick', x, y);
+  if(callback) callback(x, y, key, e);
+};