Ce collect rc

lib/compile/index.js

@@ -94,7 +94,7 @@ var createRuleFromObject = (function () {
     function parseRule(rule, conditions, identifiers, defined, name) {
         if (rule.length) {
             var r0 = rule[0];
-            if (r0 === "not" || r0 === "exists") {
+            if (r0 === "not" || r0 === "exists" || r0 === "collect" ) {
                 var temp = [];
                 rule.shift();
                 __resolveRule(rule, identifiers, temp, defined, name);
@@ -135,7 +135,10 @@ var createRuleFromObject = (function () {
         forEach(constraints, function (rule) {
             parseRule(rule, conditions, identifiers, defined, name);
         });
-        return rules.createRule(name, options, conditions, parseAction(action, identifiers, defined, scope));
+		var ruleScope = merge(defined, scope);
+		var copyOptions = merge({}, options);
+		copyOptions.scope = ruleScope;
+        return rules.createRule(name, copyOptions, conditions, parseAction(action, identifiers, defined, scope));
     };
 })();
 
@@ -158,7 +161,7 @@ exports.compile = function (flowObj, options, cb, Container) {
         throw new Error("Name must be present in JSON or options");
     }
     var flow = new Container(name);
-    var defined = merge({Array: Array, String: String, Number: Number, Boolean: Boolean, RegExp: RegExp, Date: Date, Object: Object}, options.define || {});
+    var defined = merge({Array: Array, String: String, Number: Number, Boolean: Boolean, RegExp: RegExp, Date: Date, Object: Object}, ( (options.define || options.defines || options.defined) || {}));
     if (typeof Buffer !== "undefined") {
         defined.Buffer = Buffer;
     }

lib/context.js

@@ -5,6 +5,8 @@ var extd = require("./extended"),
     indexOf = extd.indexOf,
     pPush = Array.prototype.push;
 
+var Match = require('./match.js');
+
 function createContextHash(paths, hashCode) {
     var ret = "",
         i = -1,
@@ -16,77 +18,28 @@ function createContextHash(paths, hashCode) {
     return ret;
 }
 
-function merge(h1, h2, aliases) {
-    var i = -1, l = aliases.length, alias;
-    while (++i < l) {
-        alias = aliases[i];
-        h1[alias] = h2[alias];
-    }
-}
-
-function unionRecency(arr, arr1, arr2) {
-    pPush.apply(arr, arr1);
-    var i = -1, l = arr2.length, val, j = arr.length;
+function createPathstHash(paths, hashCode) {
+    var ret = "",
+        i = -1,
+        l = paths.length;
     while (++i < l) {
-        val = arr2[i];
-        if (indexOf(arr, val) === -1) {
-            arr[j++] = val;
-        }
+        ret += paths[i].id + ":";
     }
+    return ret;
 }
 
-var Match = declare({
-    instance: {
 
-        isMatch: true,
-        hashCode: "",
-        facts: null,
-        factIds: null,
-        factHash: null,
-        recency: null,
-        aliases: null,
 
-        constructor: function () {
-            this.facts = [];
-            this.factIds = [];
-            this.factHash = {};
-            this.recency = [];
-            this.aliases = [];
-        },
-
-        addFact: function (assertable) {
-            pPush.call(this.facts, assertable);
-            pPush.call(this.recency, assertable.recency);
-            pPush.call(this.factIds, assertable.id);
-            this.hashCode = this.factIds.join(":");
-            return this;
-        },
-
-        merge: function (mr) {
-            var ret = new Match();
-            ret.isMatch = mr.isMatch;
-            pPush.apply(ret.facts, this.facts);
-            pPush.apply(ret.facts, mr.facts);
-            pPush.apply(ret.aliases, this.aliases);
-            pPush.apply(ret.aliases, mr.aliases);
-            ret.hashCode = this.hashCode + ":" + mr.hashCode;
-            merge(ret.factHash, this.factHash, this.aliases);
-            merge(ret.factHash, mr.factHash, mr.aliases);
-            unionRecency(ret.recency, this.recency, mr.recency);
-            return ret;
-        }
-    }
-});
 
 var Context = declare({
     instance: {
-        match: null,
-        factHash: null,
-        aliases: null,
-        fact: null,
-        hashCode: null,
-        paths: null,
-        pathsHash: null,
+        match: null,        
+        factHash: null,    
+        aliases: null,     
+        fact: null,         
+        hashCode: null,     
+        paths: null,      
+        pathsHash: null,    
 
         constructor: function (fact, paths, mr) {
             this.fact = fact;

lib/extended.js

@@ -1,4 +1,5 @@
 var arr = require("array-extended"),
+	is = require("is-extended"),
     unique = arr.unique,
     indexOf = arr.indexOf,
     map = arr.map,
@@ -126,6 +127,27 @@ function diffHash(h1, h2) {
 function union(arr1, arr2) {
     return unique(arr1.concat(arr2));
 }
+
+function findIndex(coll, item) {
+	var target = -1;
+	if( 'function' === typeof item ) {
+		coll.some(function(e, i) {
+			if(item(e,i)) {
+				target = i;
+				return true;
+			};
+		});
+	}
+	else {
+		coll.some(function(e, i) {
+			if(is.deepEqual(e, item)) {
+				target = i;
+				return true;
+			};
+		});
+	}
+	return target;
+}
 
 module.exports = require("extended")()
     .register(require("date-extended"))
@@ -145,5 +167,6 @@ module.exports = require("extended")()
     .register("HashTable", require("ht"))
     .register("declare", require("declare.js"))
     .register(require("leafy"))
+	.register('findIndex', findIndex)
     .register("LinkedList", require("./linkedList"));
 

lib/match.js

@@ -0,0 +1,73 @@
+"use strict";
+var extd = require("./extended"),
+    isBoolean = extd.isBoolean,
+    declare = extd.declare,
+    indexOf = extd.indexOf,
+    pPush = Array.prototype.push;
+
+
+function merge(h1, h2, aliases) {
+    var i = -1, l = aliases.length, alias;
+    while (++i < l) {
+        alias = aliases[i];
+        h1[alias] = h2[alias];
+    }
+}
+
+function unionRecency(arr, arr1, arr2) {
+    pPush.apply(arr, arr1);
+    var i = -1, l = arr2.length, val, j = arr.length;
+    while (++i < l) {
+        val = arr2[i];
+        if (indexOf(arr, val) === -1) {
+            arr[j++] = val;
+        }
+    }
+}
+
+var Match = declare({
+    instance: {
+
+        isMatch: true,
+        hashCode: "",
+        facts: null,
+        factIds: null,
+        factHash: null,
+        recency: null,
+        aliases: null,
+
+        constructor: function () {
+            this.facts = [];
+            this.factIds = [];
+            this.factHash = {};
+            this.recency = [];
+            this.aliases = [];
+        },
+
+        addFact: function (assertable) {
+            pPush.call(this.facts, assertable);
+            pPush.call(this.recency, assertable.recency);
+            pPush.call(this.factIds, assertable.id);
+            this.hashCode = this.factIds.join(":");
+            return this;
+        },
+        merge: function (mr) {
+            var ret = new Match();
+            ret.isMatch = mr.isMatch;
+            pPush.apply(ret.facts, this.facts);
+            pPush.apply(ret.facts, mr.facts);
+			pPush.apply(ret.factIds, this.factIds);
+			 pPush.apply(ret.factIds, mr.factIds);
+            pPush.apply(ret.aliases, this.aliases);
+            pPush.apply(ret.aliases, mr.aliases);
+            ret.hashCode = this.hashCode + ":" + mr.hashCode;
+            merge(ret.factHash, this.factHash, this.aliases);
+            merge(ret.factHash, mr.factHash, mr.aliases);
+            unionRecency(ret.recency, this.recency, mr.recency);
+            return ret;
+        }
+    }
+}).as(module);
+
+
+