entityjs 0.2.2 → 0.3.0

data/spec/javascripts/src/core/entity_spec.js

@@ -0,0 +1,324 @@
+describe('entity', function(){
+  
+  var e;
+  var c;
+  
+  beforeEach(function(){
+    e = re.e()
+    c = re.c(f('name'))
+  });
+  
+  it('multiple', function(){
+      eq(re.e('bob', 10).length, 10);
+      eq(re.e('ki', 2).comps(), ['ki']);
+      
+  });
+  
+  it('should create 1 in query', function(){
+    eq(re.e('dfggggg', 1).length, 1)
+    
+    eq(re('dfggggg').length, 1)
+  })
+  
+  it('comp', function(){
+    e.comp('qwdqwd wer')
+    
+    ok(e.has('qwdqwd wer'))
+    
+    e.comp(['yep45', 'ok12'])
+    ok(e.has('yep45 ok12'))
+  })
+  
+  it('should define properly', function(){
+    re.c('blah1')
+    .defines({
+      f:function(){
+        return false;
+      }
+    });
+    
+    re.c('sdfdff')
+    .requires('blah1')
+    .defines({
+      f:function(){
+        return true;
+      }
+    });
+    
+    ok(re.e('sdfdff').f())
+  })
+  
+  it('should call init', function(){
+      var called = false
+      var v1, v2;
+          c.init(function(comp, val1, val2){
+              called = true
+              v1 = val1
+              v2 = val2
+          })
+          var called2 = false
+              c.on('init', function(y){
+              called2 = true
+              ok(y == e)
+              })
+              e.comp(c.name+':10:99')
+          
+          //future?
+          //e.comp(c.name, 10, 99)
+          
+          ok(called)
+          eq(v1, '10')
+          eq(v2, '99')
+          ok(called2)
+   })
+  
+  it('requires', function(){
+      c.requires('bob')
+      c.requires(['bob2'])
+      
+      e.comp(c.name)
+      
+      ok(e.has('bob bob2'))
+   })
+  
+  it('comp defaults', function(){
+      c.defaults({ok:10, b:99})
+      c.defaults('yep', 'y')
+      
+      e.ok = 'same'
+      e.comp(c.name)
+      
+      eq(e.ok, 'same')
+      eq(e.b, 99)
+      eq(e.yep, 'y')
+  })
+      
+  it('comp defines', function(){
+      c.defines({ok:10, b:99})
+      c.defines('yep', 'y')
+      
+      e.comp(c.name)
+      
+      eq(e.ok, 10)
+      eq(e.b, 99)
+      eq(e.yep, 'y')
+  })
+  
+  it('comp interface', function(){
+    re.c('temp')
+    .interfaces('yep');
+    
+      try {
+    re.e('temp');
+      }catch(e){
+      eq(e, 'Interface: yep missing')
+      }
+  })
+  
+  it('comp asserts', function(){
+     c
+    .asserts('yep');
+    
+      try {
+    re.e(c.name+' yep');
+      }catch(e){
+      eq(e, 'Assert: yep is not allowed')
+      }
+  })
+  
+  it('removeComp', function(){
+  var called = false
+      c.dispose(function(){
+          called = true
+      })
+      var called2 = false
+      var en = null
+          c.on('dispose', function(y){
+              called2 = true
+              en = y
+          })
+      
+      e.comp(c.name)
+      
+      e.removeComp(c.name)
+      not(e.has(c.name))
+      ok(called)
+      ok(called2)
+      ok(en == e)
+  })
+  
+  it('comps', function(){
+    e.comp('ok bob')
+    
+    eq(e.comps(), ['ok', 'bob'])
+  })
+  
+  it('clone', function(){
+    e.comp('yep bob')
+    eq(e.clone().comps(), e.comps())
+    eq(e.clone(2).comps(), e.comps())
+  })
+  
+  it('parent', function(){
+      c.defines('d', function(v){return v; })
+      .defaults('y', function(v){return v;})
+      
+      eq(e.parent(c.name, 'd', 100), 100)
+      eq(e.parent(c.name, 'y', 'bob'), 'bob')
+      e.comp(c.name)
+      ok(e.parent('', 'has', c.name))
+  })
+  
+  it('should throw error on undefined parent method', function(){
+    var called = false;
+    try {
+      e.parent('image', 'asdfsdf')
+    } catch(e){
+      called = true;
+    }
+    ok(called)
+  })
+  
+  it('has', function(){
+    ok(e.has('!bob'))
+    ok(!e.has('^sig'))
+    not(e.has('#asdsd'))
+    not(e.has('sdcsdc'))
+    
+        e.on('values', function(){})
+        ok(e.has('^values'))
+        
+        e.comp('tst')
+        ok(e.has('tst'))
+        ok(e.has('tst ^values'))
+        e.id = 'we'
+        ok(e.has('#we'))
+        not(e.has('!tst'))
+        
+        ok(e.has('^values tst #we'))
+  })
+  
+  it('bindings', function(){
+      var called = false, va, va2
+      e.on('values', function(v, v2){
+          called = true
+          va = v
+          va2 = v2
+          return false
+      });
+      
+      ok(e.has('^values'))
+      eq(e.trigger('values', 10, 55),e)
+      ok(called)
+      eq(va, 10)
+      eq(va2, 55)
+      not(e.has('^values'))
+      
+          var func = function(){};
+          e.on({
+          yep:function(){},
+              ok:func
+          })
+          ok(e.has('^yep'))
+          e.off('yep')
+          not(e.has('^yep'))
+           
+          ok(e.has('^ok'))
+              e.off({ok:func})
+              not(e.has('^ok'))
+              
+              //remove all
+       e.on('key', function(){});
+       is(e.off());
+      eq(e._re_signals, {});
+  })
+  
+  it('should add multiple bindings', function(){
+    
+    var called = false;
+    var called2 = false;
+    
+    e.on({
+      call:function(){called = true},
+      call2:function(){called2 = true}
+    });
+    
+    e.trigger('call');
+    e.trigger('call2');
+    
+    ok(called)
+    ok(called2)
+    
+  })
+  
+  it('attr', function(){
+    //add attributes
+      e.attr({x:10, y:'sdd', func:function(){}})
+      
+      eq(e.x, 10)
+      eq(e.y, 'sdd')
+      is(e.func, 'function')
+      
+      e.attr('ok', 87)
+      eq(e.ok, 87)
+      
+     //run setter methods
+     e.posX = function(value1){
+       this.val = value1;   
+     };
+     
+      e.attr('posX', 154)
+      eq(e.val, 154)
+      
+      //multiple
+          e.size = function(width, height){
+              this.width = width
+              this.height = height
+          };
+      e.attr({
+          size:[45, 40]
+      });
+      
+      eq(e.width, 45)
+      eq(e.height, 40)
+  })
+  
+  it('def', function(){
+      e.first = 99
+    e.def('first', 10)
+    eq(e.first, 99)
+    
+        e.def({ok:10, yep:99});
+     eq(e.ok, 10)
+     eq(e.yep, 99)
+  })
+  
+  it('dispose', function(){
+  var called = false
+  var co;
+  var en;
+  var called2 = false;
+      c.dispose(function(comp){
+          called = true
+          co = comp
+      })
+          c.on('dispose', function(e){
+          called2 = true
+          en = e
+          })
+      e.comp(c.name)
+      var called3 = false
+          e.on('dispose', function(){
+              called3 = true
+          });
+      
+      e.dispose()
+      
+      ok(called)
+      eq(co, c)
+      ok(called2)
+      eq(en, e)
+      ok(called3)
+  })
+  
+})

data/spec/javascripts/src/core/load_spec.js

@@ -0,0 +1,71 @@
+describe('load', function(){
+    
+    it('load', function(){
+        //add images
+        re.load.path = '__spec__/'
+        var img = 'helpers/accept.png'
+        var sfx = 'helpers/alligator.mp3'
+        var sfx2 = 'helpers/alligator.ogg'
+        
+        var called = false
+        var prog = false
+        
+        re.load([img, sfx, sfx2])
+        .complete(function(assets){
+          called = true
+          is(assets, 'array')
+          ok(prog)
+          is(re.c('accept.png').image)
+          
+          is(re.c('accept.img').image)
+          is(re.c('alligator.sfx').sound)
+          
+          var b = re.e('accept.png')
+          is(b._image)
+            eq(b.sizeX, b._image.width)
+            eq(b.sizeY, b._image.height)
+            eq(b.bisect, b._image.width)
+          
+          b = re.e('alligator.sfx')
+          is(b._sound)
+        })
+        .progress(function(current, total, name){
+          prog = true
+          is(name, 'string')
+          is(current, 'number')
+          is(total, 'number')
+        })
+        .error(function(){
+          ok(false)
+        })
+        
+        waits(500)
+        runs(function(){
+          ok(called)
+        })
+    });
+    
+    it('should call complete on empty load', function(){
+     var called = false
+       re.load([])
+           .complete(function(){
+           called = true
+           });
+       ok(called)
+    });
+    
+    it('should throw error on not found image', function(){
+      var called = false
+        
+        re.load('sdfsdf.png')
+            .error(function(e){
+            called = true
+            })
+            
+        waits(200)
+       runs(function(){
+         ok(called)
+      })
+    });
+    
+});

data/spec/javascripts/src/core/query_spec.js

@@ -0,0 +1,157 @@
+describe('query', function(){
+  
+    it('should query', function(){
+        re.e('tesee');
+        re.e('tesee bob99');
+        
+        eq(re('bob99 tesee').length, 1);
+        eq(re('tesee').length, 2);
+        
+        re.e('tesee ttt')
+        eq(re('tesee').length, 3);
+        eq(re('tesee !ttt').length, 2);
+        
+        re.e('tesee').on('sig', function(){});
+        eq(re('tesee ^sig').length, 1);
+        
+        re.e('tesee').attr('id', 'id');
+        ok(re('tesee').length != 0);
+        eq(re('#id').length, 1);
+    });
+  
+  it('should be right length', function(){
+    var g = f('name')
+    re.e(g)
+    eq(re(g).length, 1)
+  });
+  
+  it('should select *', function(){
+      var c = re._e.length;
+      eq(re('*').length, c);
+  });
+  
+    it('should filter', function(){
+        re.e().attr({k:99});
+        
+        eq(re(function(){
+            return this.k == 99
+        }).length, 1)
+    });
+  
+    it('method', function(){
+        eq(re.e('ok', 3).method('comp', 'b').comps(), ['ok', 'b'])
+    });
+  
+    it('each', function(){
+      var i = 0;
+      is(re('dd', 3).each(function(c, l){
+        eq(i++, c);
+        eq(l, 3)
+      }))
+    });
+    
+    it('tilemap', function(){
+    
+      is(re.e('tile', 10).tilemap(5, function(x, y, i, l){
+        ok(x < 5)
+        ok(y < 2)
+        eq(l, 10)
+      }));
+      
+    });
+    
+    it('comps', function(){
+      eq(re('tile').comps(), ['tile'])
+    });
+    
+    it('random', function(){
+      is(re('tile').random(), 'object')
+    });
+    
+    it('pluck', function(){
+      re('tile').attr({f:10, y:'d'});
+      var k = re('tile').pluck('f y');
+      eq(k.length, re('tile').length);
+      eq(k[0].f, re('tile')[0].f);
+      eq(k[0].y, re('tile')[0].y);
+    });
+        
+    it('attr', function(){
+        re('tile').attr('first', 'asdf');
+        re('tile').each(function(){
+          eq(this.first, 'asdf')
+        })
+        
+        re('tile').attr({yap:'1232'});
+        re('tile').each(function(){
+          eq(this.yap, '1232')
+        })
+    });
+    
+    it('def', function(){
+      re('tile').def('first', 'asdf');
+      re('tile').each(function(){
+        eq(this.first, 'asdf')
+      })
+      
+      re('tile').def({yap:'1232', first:'d'});
+      re('tile').each(function(){
+        eq(this.yap, '1232')
+        eq(this.first, 'asdf')
+      })
+    
+    });
+
+    it('comp', function(){
+      is(re.e('re',3).comp('yy'));
+      
+      ok(re('re').has('yy'));
+    });
+    
+    it('removeComp', function(){
+        is(re.e('kw gg33', 2).removeComp('gg33'))
+        
+        eq(re('gg33').length, 0)
+    });
+    
+    it('on', function(){
+        is(re.e('ssss', 1).on('mousedown', function(){}));
+        
+        eq(re('ssss ^mousedown').length, 1)
+    });
+    
+    it('off', function(){
+        is(re.e('k54',1).on('mouse', function(){}).off());
+        ok(re('k54 ^mouse').length == 0)
+    });
+    
+    it('trigger', function(){
+        re.e('g55');
+        var called = null;
+        re('g55').on('bind', function(v){called=v});
+        re('g55').trigger('bind', 'bob');
+        
+        eq('bob', called);
+    });
+    
+    it('has', function(){
+        var k = re.e('bob ref',2).on('key', function(){});
+        
+        ok(k.has('bob'));
+        ok(k.has('ref'));
+        ok(k.has('^key'));
+        ok(k.has('!sddd'));
+        ok(k.has('bob ref ^key !sddd'));
+        
+        //empty query should always return false
+        not(re().has('ok'))
+        
+        not(re.e('sdf',2).has('^wef'));
+    });
+    
+    it('dispose', function(){
+        is(re.e('rgfdvdvdfv', 2).dispose());
+        eq(re('rgfdvdvdfv').length, 0);
+    });
+    
+})

data/spec/javascripts/src/core/re_spec.js

@@ -0,0 +1,61 @@
+describe('re', function(){
+  
+  re.e('queryre')
+  
+  it('should query', function(){
+    eq(re('queryre').length, 1)
+  })
+  
+  it('should get element by id', function(){
+    setup_canvas()
+    
+    is(re.$('#game-canvas'))
+    is(re.$('#game-canvas'))
+    is(re.$('#game-canvas'))
+    
+    teardown_canvas()
+  })
+  
+  it('should get element by tag', function(){
+    setup_canvas()
+    
+    is(re.$('canvas'))
+    is(re.$('canvas'))
+    is(re.$('canvas'))
+    
+    teardown_canvas()
+  })
+  
+  it('should create element', function(){
+    is(re.$new('canvas'), 'htmlcanvaselement')
+  })
+  
+  it('should re.is work', function(){
+    ok(re.is({}))
+    ok(re.is(1))
+    ok(re.is(1, 'Number'))
+    
+    not(re.is(null))
+    not(re.is(undefined))
+    
+    not(re.is(null, 'array'))
+    not(re.is(1, 'string'))
+    not(re.is('', 'number'))
+    not(re.is('', 'Number'))
+    
+    ok(re.is('', 'string'))
+    ok(re.is(1, 'number'))
+    ok(re.is([], 'array'))
+    ok(re.is(/sd/, 'regexp'))
+    ok(re.is(re.$new('canvas'), 'htmlcanvaselement'))
+    var k = {};
+    ok(re.is(k, 'object'))
+    var f = function(){};
+    ok(re.is(f, 'function'))
+  })
+  
+  it('should define indexof', function(){
+    is(Array.prototype.indexOf, 'function')
+  })
+  
+})

data/spec/javascripts/src/core/system_spec.js

@@ -0,0 +1,41 @@
+describe('system', function(){
+    
+    var s;
+    
+    it('init', function(){
+      
+        is(re.sys.context);
+    });
+    
+    it('clear', function(){
+      var s = re.sys;
+        is(re.sys.start());
+        
+        spyOn(s.context, 'fillRect');
+        
+        is(s.clear('#FF0000'));
+        called(s.context.fillRect);
+        
+        is(s.clear('rgb(200, 0, 0)'));
+        called(s.context.fillRect);
+        
+        is(s.clear());
+        
+        is(s.stop());
+    });
+    
+    it('loop', function(){
+        var called = false;
+        var old = re.sys.system_loop;
+        //setup custom loop
+        re.sys
+        .loop(function(){
+            called = true;
+        }).start().stop();
+        
+        re.sys.loop(old)
+        
+        ok(called);
+    });
+    
+});