Added remove funtions

Author: beatnory

docs/engine.md

@@ -44,6 +44,15 @@ engine.addFact('account-type', function getAccountType(params, almanac) {
 }, { cache: false, priority: 500 })
 ```
 
+### engine.removeFact(String id)
+
+```js
+engine.addFact('speed-of-light', 299792458)
+
+// removes the fact
+engine.removeFact('speed-of-light')
+```
+
 ### engine.addRule(Rule instance|Object options)
 
 Adds a rule to the engine.  The engine will execute the rule upon the next ```run()```
@@ -65,6 +74,22 @@ let rule = new Rule()
 engine.addRule(rule)
 ```
 
+ ### engine.removeRule(Rule instance | Object options)
+
+ Removes a rule from the engine.
+
+```javascript
+// adds a rule
+let rule = new Rule()
+engine.addRule(rule)
+
+//remove it
+engine.removeRule(rule)
+```
+
+
+
+
 ### engine.addOperator(String operatorName, Function evaluateFunc(factValue, jsonValue))
 
 Adds a custom operator to the engine.  For situations that require going beyond the generic, built-in operators (`equal`, `greaterThan`, etc).
@@ -97,6 +122,23 @@ let rule = new Rule(
 
 See the [operator example](../examples/06-custom-operators.js)
 
+
+
+### engine.removeOperator(String operatorName)
+
+Removes a operator from the engine
+
+```javascript
+engine.addOperator('startsWithLetter', (factValue, jsonValue) => {
+  if (!factValue.length) return false
+  return factValue[0].toLowerCase() === jsonValue.toLowerCase()
+})
+
+engine.removeOperator('startsWithLetter');
+```
+
+
+
 ### engine.run([Object facts], [Object options]) -> Promise (Events)
 
 Runs the rules engine.  Returns a promise which resolves when all rules have been run.

src/engine.js

@@ -57,6 +57,26 @@ class Engine extends EventEmitter {
     return this
   }
 
+  /**
+   * Remove a rule from the engine
+   * @param {object|Rule} properties - rule definition.  can be JSON representation, or instance of Rule
+   * @param {Object} properties.conditions - conditions to evaluate when processing this rule
+   */
+  removeRule (properties) {
+    if (!properties) throw new Error('Engine: removeRule() requires options')
+    if (!properties.hasOwnProperty('conditions')) throw new Error('Engine: removeRule() argument requires "conditions" property')
+
+    let index
+    if (properties instanceof Rule) {
+      index = this.rules.indexOf(properties)
+    } else {
+      index = this.rules.indexOf(r => r.conditions === properties.conditions)
+    }
+
+    if (index === -1) throw new Error('Engine: removeRule() Rule was not found')
+    this.rules.splice(index, 1)
+  }
+
   /**
    * Add a custom operator definition
    * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
@@ -73,6 +93,23 @@ class Engine extends EventEmitter {
     this.operators.set(operator.name, operator)
   }
 
+  /**
+   * Remove a custom operator definition
+   * @param {string}   operatorOrName - operator identifier within the condition; i.e. instead of 'equals', 'greaterThan', etc
+   * @param {function(factValue, jsonValue)} callback - the method to execute when the operator is encountered.
+   */
+  removeOperator (operatorOrName) {
+    let operatorName
+    if (operatorOrName instanceof Operator) {
+      operatorName = operatorOrName.name
+    } else {
+      operatorName = operatorOrName
+    }
+
+    if (!this.operators.has(operatorName)) throw new Error('Engine: removeOperator() Operator was not found')
+    this.operators.delete(operatorName)
+  }
+
   /**
    * Add a fact definition to the engine.  Facts are called by rules as they are evaluated.
    * @param {object|Fact} id - fact identifier or instance of Fact
@@ -93,6 +130,21 @@ class Engine extends EventEmitter {
     return this
   }
 
+  /**
+   * Add a fact definition to the engine.  Facts are called by rules as they are evaluated.
+   * @param {object|Fact} id - fact identifier or instance of Fact
+   */
+  removeFact (factOrId) {
+    let factId
+    if (!(factOrId instanceof Fact)) {
+      factId = factOrId
+    } else {
+      factId = factOrId.id
+    }
+    if (!this.facts.has(factId)) throw new Error('Engine: removeFact() Fact was not found')
+    this.facts.delete(factId)
+  }
+
   /**
    * Iterates over the engine rules, organizing them by highest -> lowest priority
    * @return {Rule[][]} two dimensional array of Rules.

test/engine.test.js

@@ -11,8 +11,11 @@ describe('Engine', () => {
 
   it('has methods for managing facts and rules, and running itself', () => {
     expect(engine).to.have.property('addRule')
+    expect(engine).to.have.property('removeRule')
     expect(engine).to.have.property('addOperator')
+    expect(engine).to.have.property('removeOperator')
     expect(engine).to.have.property('addFact')
+    expect(engine).to.have.property('removeFact')
     expect(engine).to.have.property('run')
     expect(engine).to.have.property('stop')
   })
@@ -71,6 +74,36 @@ describe('Engine', () => {
     })
   })
 
+  describe('removeRule()', () => {
+    describe('rule instance', () => {
+      it('removes the rule', () => {
+        let rule = new Rule(factories.rule())
+        engine.addRule(rule)
+        expect(engine.rules.length).to.equal(1)
+        engine.removeRule(rule)
+        expect(engine.rules.length).to.equal(0)
+      })
+    })
+
+    describe('required fields', () => {
+      it('.conditions', () => {
+        let rule = factories.rule()
+        delete rule.conditions
+        expect(() => {
+          engine.removeRule(rule)
+        }).to.throw(/Engine: removeRule\(\) argument requires "conditions" property/)
+      })
+    })
+
+    it('can only remove added rules', () => {
+      expect(engine.rules.length).to.equal(0)
+      let rule = new Rule(factories.rule())
+      expect(() => {
+        engine.removeRule(rule)
+      }).to.throw(/Engine: removeRule\(\) Rule was not found/)
+    })
+  })
+
   describe('addOperator()', () => {
     it('adds the operator', () => {
       expect(engine.operators.size).to.equal(10)
@@ -91,6 +124,25 @@ describe('Engine', () => {
     })
   })
 
+  describe('removeOperator()', () => {
+    it('removes the operator', () => {
+      expect(engine.operators.size).to.equal(10)
+      engine.addOperator('startsWithLetter', (factValue, jsonValue) => {
+        return factValue[0] === jsonValue
+      })
+      expect(engine.operators.size).to.equal(11)
+      engine.removeOperator('startsWithLetter')
+      expect(engine.operators.size).to.equal(10)
+    })
+
+    it('can only remove added operators', () => {
+      expect(engine.operators.size).to.equal(10)
+      expect(() => {
+        engine.removeOperator('nonExisting')
+      }).to.throw(/Engine: removeOperator\(\) Operator was not found/)
+    })
+  })
+
   describe('addFact()', () => {
     const FACT_NAME = 'FACT_NAME'
     const FACT_VALUE = 'FACT_VALUE'
@@ -142,6 +194,24 @@ describe('Engine', () => {
     })
   })
 
+  describe('removeFact()', () => {
+    it('removes a Fact', () => {
+      expect(engine.facts.size).to.equal(0)
+      let fact = new Fact('newFact', 50, { cache: false })
+      engine.addFact(fact)
+      expect(engine.facts.size).to.equal(1)
+      engine.removeFact('newFact')
+      expect(engine.facts.size).to.equal(0)
+    })
+
+    it('can only remove added facts', () => {
+      expect(engine.facts.size).to.equal(0)
+      expect(() => {
+        engine.removeFact('newFact')
+      }).to.throw(/Engine: removeFact\(\) Fact was not found/)
+    })
+  })
+
   describe('run()', () => {
     beforeEach(() => {
       let conditions = {