Add Entity.deleteIfExist and Entity.deleteManyIfExist

Author: mhammerc

doc/doc.md

@@ -283,7 +283,9 @@ It may be useful if you have a drawing system:
         * [.add(ComponentType, ...args)](#Entity+add) ⇒ [<code>Entity</code>](#Entity)
         * [.addMany(ComponentsType)](#Entity+addMany) ⇒ [<code>Entity</code>](#Entity)
         * [.delete(ComponentType)](#Entity+delete) ⇒ [<code>Entity</code>](#Entity)
+        * [.deleteIfExist(ComponentType)](#Entity+deleteIfExist) ⇒ [<code>Entity</code>](#Entity)
         * [.deleteMany(ComponentsType)](#Entity+deleteMany) ⇒ [<code>Entity</code>](#Entity)
+        * [.deleteManyIfExist(ComponentsType)](#Entity+deleteManyIfExist) ⇒ [<code>Entity</code>](#Entity)
     * _static_
         * [.createWorld([ComponentsType])](#Entity.createWorld) ⇒ [<code>Entity</code>](#Entity)
 
@@ -491,6 +493,19 @@ found, an error will be thrown.
 | --- | --- | --- |
 | ComponentType | [<code>AComponent</code>](#AComponent) | Type of the component to delete |
 
+<a name="Entity+deleteIfExist"></a>
+
+### entity.deleteIfExist(ComponentType) ⇒ [<code>Entity</code>](#Entity)
+Delete a specific component from this entity. If the Component is not
+found, no error will be thrown.
+
+**Kind**: instance method of [<code>Entity</code>](#Entity)  
+**Returns**: [<code>Entity</code>](#Entity) - this entity (useful for chaining)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ComponentType | [<code>AComponent</code>](#AComponent) | Type of the component to delete |
+
 <a name="Entity+deleteMany"></a>
 
 ### entity.deleteMany(ComponentsType) ⇒ [<code>Entity</code>](#Entity)
@@ -504,6 +519,19 @@ an error will be thrown.
 | --- | --- | --- |
 | ComponentsType | [<code>Array.&lt;AComponent&gt;</code>](#AComponent) | Type of the components to delete |
 
+<a name="Entity+deleteManyIfExist"></a>
+
+### entity.deleteManyIfExist(ComponentsType) ⇒ [<code>Entity</code>](#Entity)
+Delete specific components from this entity. If a component is not found,
+no error will be thrown and no component will be deleted.
+
+**Kind**: instance method of [<code>Entity</code>](#Entity)  
+**Returns**: [<code>Entity</code>](#Entity) - this entity (useful for chaining)  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| ComponentsType | [<code>Array.&lt;AComponent&gt;</code>](#AComponent) | Type of the components to delete |
+
 <a name="Entity.createWorld"></a>
 
 ### Entity.createWorld([ComponentsType]) ⇒ [<code>Entity</code>](#Entity)

entity.js

@@ -485,9 +485,26 @@ class Entity extends EventEmitter
         return this;
     }
 
+    /**
+     * Delete a specific component from this entity. If the Component is not
+     * found, no error will be thrown.
+     *
+     * @param {AComponent} ComponentType Type of the component to delete
+     * @return {Entity} this entity (useful for chaining)
+     */
+    deleteIfExist(ComponentType)
+    {
+        if (this.has([ComponentType]))
+        {
+            return this.delete(ComponentType);
+        }
+        return this;
+    }
+
     /**
      * Delete specific components from this entity. If a component is not found,
      * an error will be thrown.
+     *
      * @param {Array.<AComponent>} ComponentsType Type of the components to delete
      * @return {Entity} this entity (useful for chaining)
      */
@@ -502,6 +519,22 @@ class Entity extends EventEmitter
         return this;
     }
 
+    /**
+     * Delete specific components from this entity. If a component is not found,
+     * no error will be thrown and no component will be deleted.
+     *
+     * @param {Array.<AComponent>} ComponentsType Type of the components to delete
+     * @return {Entity} this entity (useful for chaining)
+     */
+    deleteManyIfExist(ComponentsType)
+    {
+        if (this.has(ComponentsType))
+        {
+            return this.deleteMany(ComponentsType);
+        }
+        return this;
+    }
+
     /**
      * Assert (eg. throw) that the given component type is valid.
      * 

test/entity_and_acomponent.js

@@ -557,6 +557,78 @@ describe('Integration between Entity and AComponent', function()
         });
     });
 
+    describe('Entity.deleteIfExist', function()
+    {
+        it('should delete the component', function()
+        {
+            const e = Entity.createWorld();
+            e.add(PositionComponent);
+            expect(e.has([PositionComponent])).to.be.true;
+            expect(e.position.x).to.equal(0);
+
+            e.deleteIfExist(PositionComponent);
+            expect(e.has([PositionComponent])).to.be.false;
+            expect(e.position).to.be.undefined;
+        });
+
+        it('should delete the component but others should still be available', function()
+        {
+            const e = Entity.createWorld();
+            e.addMany([PositionComponent, VelocityComponent]);
+            expect(e.has([PositionComponent])).to.be.true;
+            expect(e.position.x).to.equal(0);
+            expect(e.has([VelocityComponent])).to.be.true;
+            expect(e.velocity.velocity).equal(0);
+
+            e.deleteIfExist(PositionComponent);
+            expect(e.has([PositionComponent])).to.be.false;
+            expect(e.position).to.be.undefined;
+            expect(e.has([VelocityComponent])).to.be.true;
+            expect(e.velocity.velocity).equal(0);
+        });
+
+        it('should delete the component when given a super class', function()
+        {
+            const e = Entity.createWorld();
+            e.add(SpriteComponent);
+            expect(e.has([DrawableComponent])).to.be.true;
+            e.deleteIfExist(DrawableComponent);
+            expect(e.has([DrawableComponent])).to.be.false;
+        });
+
+        it('should return this', function()
+        {
+            const e = Entity.createWorld();
+            e.add(SpriteComponent);
+            expect(e.deleteIfExist(SpriteComponent)).to.equal(e);
+        });
+
+        it('should not throw if component is not available', function()
+        {
+            const e = Entity.createWorld();
+
+            e.deleteIfExist(PositionComponent);
+        });
+
+        it('should not throw on double-delete', function()
+        {
+            const e = Entity.createWorld();
+            e.add(PositionComponent);
+            e.deleteIfExist(PositionComponent);
+            e.deleteIfExist(PositionComponent);
+        });
+
+        it('should throw if pass AComponent as it is a global super class', function()
+        {
+            const e = Entity.createWorld();
+
+            expect(() =>
+            {
+                e.deleteIfExist(AComponent);
+            }).to.throw();
+        });
+    });
+
     describe('Entity.deleteMany', function()
     {
         it('should delete all components', function()
@@ -650,6 +722,94 @@ describe('Integration between Entity and AComponent', function()
         });
     });
 
+    describe('Entity.deleteManyIfExist', function()
+    {
+        it('should delete all components', function()
+        {
+            const e = Entity.createWorld();
+            e.addMany([PositionComponent, VelocityComponent]);
+            expect(e.has([PositionComponent])).to.be.true;
+            expect(e.position.x).to.equal(0);
+            expect(e.has([VelocityComponent])).to.be.true;
+            expect(e.velocity.velocity).equal(0);
+
+            e.deleteManyIfExist([PositionComponent, VelocityComponent]);
+            expect(e.has([PositionComponent])).to.be.false;
+            expect(e.has([VelocityComponent])).to.be.false;
+        });
+
+        it('should do nothing on passing empty-array', function()
+        {
+            const e = Entity.createWorld();
+            e.addMany([PositionComponent, VelocityComponent]);
+            expect(e.has([PositionComponent])).to.be.true;
+            expect(e.position.x).to.equal(0);
+            expect(e.has([VelocityComponent])).to.be.true;
+            expect(e.velocity.velocity).equal(0);
+
+            e.deleteManyIfExist([]);
+            expect(e.has([PositionComponent])).to.be.true;
+            expect(e.position.x).to.equal(0);
+            expect(e.has([VelocityComponent])).to.be.true;
+            expect(e.velocity.velocity).equal(0);
+        });
+
+        it('should not throw if at least one component is not available and delete nothing', function()
+        {
+            const e1 = Entity.createWorld();
+            e1.add(PositionComponent);
+            e1.deleteManyIfExist([PositionComponent, VelocityComponent]);
+            expect(e1.has([PositionComponent])).to.be.true;
+
+            const e2 = Entity.createWorld();
+            e2.deleteManyIfExist([PositionComponent, VelocityComponent]);
+        });
+
+        it('should delete the component when given a super class', function()
+        {
+            const e = Entity.createWorld();
+            e.add(SpriteComponent);
+            expect(e.has([DrawableComponent])).to.be.true;
+            e.deleteManyIfExist([DrawableComponent]);
+            expect(e.has([DrawableComponent])).to.be.false;
+        });
+
+        it('should return this', function()
+        {
+            const e = Entity.createWorld();
+            e.add(SpriteComponent);
+            expect(e.deleteManyIfExist([SpriteComponent])).to.equal(e);
+        });
+
+        it('should throw on passing non-array', function()
+        {
+            const e = Entity.createWorld();
+            expect(() =>
+            {
+                e.deleteManyIfExist(42);
+            }).to.throw();
+        });
+
+        it('should throw on passing non-components in array', function()
+        {
+            const e = Entity.createWorld();
+            expect(() =>
+            {
+                e.deleteManyIfExist([42]);
+            }).to.throw();
+        });
+
+        it('should throw if pass AComponent as it is a global super class', function()
+        {
+            const e = Entity.createWorld();
+
+            expect(() =>
+            {
+                e.deleteManyIfExist([AComponent]);
+            }).to.throw();
+        });
+    });
+
     describe('#destructor', function()
     {
         it('should be called on destructing entity with components', function()