durable_rules 0.34.35 → 0.34.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4dac8eb12717b1ab1df781c340385dd775089e2
-  data.tar.gz: 203c76635664dfbcabac912ac74093c3a0b5677a
+  metadata.gz: 47e6483313e3fe7047cb09fea58da4f5bf3c0c25
+  data.tar.gz: fcc1f99df7b9cb4b932af7bb9eb749265c82dfa4
 SHA512:
-  metadata.gz: 5f2c2d3e579ad6d486a4c71879baafb6879260c88b80652600c7de7f061fbdb8c4491e2a4facc9331b16709b2de737893a7f0cc95921bd411a56d3a1e5d9ea9f
-  data.tar.gz: c22086988ac401f2f2a3502dac8151d63e5c02128108325dc4e01b3ec9a4427b9edc67aadff855d8a580a7cee62de0e462c7ff43e0c03811fc0a6f21b8fcb720
+  metadata.gz: 32bbe82822555390ca0a164945fb9a1ec6017f14a8f492e2fe5b9e1d6830ae7bc6a5c31e0b9e47017839c9f85cea0b6201875d9c43363acc4e9e845598243783
+  data.tar.gz: 1214ab05cdd4ebc38344378394fb7f4cb979b9921a8975701c4389aefc0f6df3d8a7c4b89ef2bbe6e6b3f4909426f2b53c06d10951c1abc8f63fb7a770a5a994

data/librb/durable.rb

@@ -175,12 +175,13 @@ module Durable
     attr_reader :__type, :__op
     attr_accessor :__name
 
-    def initialize(type, left = nil)
+    def initialize(type, left = nil, op = nil, right = nil, definitions = nil, name = nil)
       @__type = type
       @left = left
-      @right = nil
-      @definitions = nil
-      @__name = nil
+      @__op = op
+      @right = right
+      @definitions = definitions
+      @__name = name
     end
     
     def definition(parent_name=nil)
@@ -190,7 +191,7 @@ module Durable
         new_definition = {@__op => @definitions}
       else
         if not @left
-          raise ArgumentError, "Property for #{@__op} not defined"
+          raise ArgumentError, "Property for #{@__type} and #{@__op} not defined"
         end 
         righ_definition = @right
         if (@right.kind_of? Expression) || (@right.kind_of? Arithmetic)
@@ -216,63 +217,51 @@ module Durable
     end
 
     def ==(other)
-      @__op = :$eq
-      @right = other
-      self
+      Expression.new(@__type, @left, :$eq, other, @definitions, @__name)
     end
 
     def !=(other)
-      @__op = :$neq
-      @right = other
-      self
+      Expression.new(@__type, @left, :$neq, other, @definitions, @__name)
     end
 
     def <(other)
-      @__op = :$lt
-      @right = other
-      self
+      Expression.new(@__type, @left, :$lt, other, @definitions, @__name)
     end
 
     def <=(other)
-      @__op = :$lte
-      @right = other
-      self
+      Expression.new(@__type, @left, :$lte, other, @definitions, @__name)
     end
 
     def >(other)
-      @__op = :$gt
-      @right = other
-      self
+      Expression.new(@__type, @left, :$gt, other, @definitions, @__name)
     end
 
     def >=(other)
-      @__op = :$gte
-      @right = other
-      self
+      Expression.new(@__type, @left, :$gte, other, @definitions, @__name)
     end
 
     def matches(other)
-      @__op = :$mt
-      @right = other
-      self
+      Expression.new(@__type, @left, :$mt, other, @definitions, @__name)
     end
 
     def imatches(other)
-      @__op = :$imt
-      @right = other
-      self
+      Expression.new(@__type, @left, :$imt, other, @definitions, @__name)
+    end
+
+    def allItems(other)
+      Expression.new(@__type, @left, :$iall, other, @definitions, @__name)
+    end
+
+    def anyItem(other)
+      Expression.new(@__type, @left, :$iany, other, @definitions, @__name)
     end
 
     def -@
-      @__op = :$nex
-      @right = 1
-      self
+      Expression.new(@__type, @left, :$nex, 1, @definitions, @__name)
     end
 
     def +@
-      @__op = :$ex
-      @right = 1
-      self
+      Expression.new(@__type, @left, :$ex, 1, @definitions, @__name)
     end
 
     def |(other)
@@ -440,6 +429,10 @@ module Durable
       Expression.new(:$m)
     end
     
+    def item
+      Expression.new(:$i, :$i)
+    end
+
     def c
       Closure.new()
     end

data/librb/engine.rb

@@ -435,6 +435,7 @@ module Engine
         end
       end
 
+      puts JSON.generate(ruleset_definition)
       @handle = Rules.create_ruleset name, JSON.generate(ruleset_definition), state_cache_size
       @definition = ruleset_definition
     end

data/src/rules/events.c

@@ -45,6 +45,8 @@
 #define OP_NIL_STRING 0x0701
 #define OP_NIL_NIL 0x0707
 
+#define HASH_I 1622948014 //$i
+
 typedef struct actionContext {
     void *rulesBinding;
     redisReply *reply;
@@ -727,13 +729,12 @@ static unsigned int isMatch(ruleset *tree,
     unsigned char alphaOp = currentAlpha->operator;
     unsigned char propertyType = currentProperty->type;
     unsigned int result = RULES_OK;
-    
     *propertyMatch = 0;
     if (alphaOp == OP_EX) {
         *propertyMatch = 1;
         return RULES_OK;
     }
-    
+
     rehydrateProperty(currentProperty, message);
     jsonProperty rightValue;
     jsonProperty *rightProperty = &rightValue;
@@ -929,6 +930,142 @@ static unsigned int isMatch(ruleset *tree,
     return result;
 }
 
+static unsigned int isArrayMatch(ruleset *tree,
+                                 char *sid,
+                                 char *message,
+                                 jsonObject *messageObject,
+                                 jsonProperty *currentProperty,
+                                 alpha *arrayAlpha,
+                                 unsigned char *propertyMatch,
+                                 void **rulesBinding) {
+    *propertyMatch = 0;
+    unsigned int result = RULES_OK;
+    if (currentProperty->type != JSON_ARRAY) {
+        return RULES_OK;
+    }
+
+    char *first = currentProperty->valueString;
+    char *last;
+    unsigned char type;
+    jsonObject jo;
+    result = readNextArrayValue(first, &first, &last, &type);
+    while (result == PARSE_OK) {
+        unsigned short top = 1;
+        alpha *stack[MAX_STACK_SIZE];
+        stack[0] = arrayAlpha;
+        alpha *currentAlpha;
+        if (type == JSON_OBJECT) {
+            char *next;
+            jo.propertiesLength = 0;
+            result = constructObject(first,
+                                     "$i", 
+                                     NULL, 
+                                     JSON_OBJECT_SEQUENCED, 
+                                     0,
+                                     &jo, 
+                                     &next);
+            if (result != RULES_OK) {
+                return result;
+            }
+        } else {
+            jo.propertiesLength = 1;
+            jo.properties[0].hash = HASH_I;
+            jo.properties[0].type = type;
+            jo.properties[0].isMaterial = 0;
+            jo.properties[0].valueString = first;
+            jo.properties[0].valueLength = last - first;
+            jo.properties[0].nameLength = 2;
+            strcpy(jo.properties[0].name, "$i");
+        }
+
+        while (top) {
+            --top;
+            currentAlpha = stack[top];
+            if (currentAlpha->nextListOffset) {
+                unsigned int *nextList = &tree->nextPool[currentAlpha->nextListOffset];
+                for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
+                    node *listNode = &tree->nodePool[nextList[entry]];
+                    char exists = 0;
+                    for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
+                        if (listNode->value.a.hash == jo.properties[propertyIndex].hash) {
+                            exists = 1;
+                            break;
+                        }
+                    }
+
+                    if (!exists) {
+                        if (top == MAX_STACK_SIZE) {
+                            return ERR_MAX_STACK_SIZE;
+                        }
+                        
+                        stack[top] = &listNode->value.a; 
+                        ++top;
+                    }
+                }
+            }
+
+            if (currentAlpha->nextOffset) {
+                unsigned int *nextHashset = &tree->nextPool[currentAlpha->nextOffset];
+                for(unsigned int propertyIndex = 0; propertyIndex < jo.propertiesLength; ++propertyIndex) {
+                    jsonProperty *currentProperty = &jo.properties[propertyIndex];
+                    for (unsigned int entry = currentProperty->hash & HASH_MASK; nextHashset[entry] != 0; entry = (entry + 1) % NEXT_BUCKET_LENGTH) {
+                        node *hashNode = &tree->nodePool[nextHashset[entry]];
+                        if (currentProperty->hash == hashNode->value.a.hash) {
+                            unsigned char match = 0;
+                            if (hashNode->value.a.operator == OP_IALL || hashNode->value.a.operator == OP_IANY) {
+                                result = isArrayMatch(tree, 
+                                                      sid, 
+                                                      message,
+                                                      messageObject,
+                                                      currentProperty, 
+                                                      &hashNode->value.a,
+                                                      &match,
+                                                      rulesBinding);
+                            } else {
+                                result = isMatch(tree,
+                                                 sid,
+                                                 message,
+                                                 messageObject,
+                                                 currentProperty,
+                                                 &hashNode->value.a,
+                                                 &match,
+                                                 rulesBinding);
+                            }
+
+                            if (result != RULES_OK) {
+                                return result;
+                            }
+
+                            if (match) {
+                                if (top == MAX_STACK_SIZE) {
+                                    return ERR_MAX_STACK_SIZE;
+                                }
+
+                                stack[top] = &hashNode->value.a; 
+                                ++top;
+                            }
+                        }
+                    }               
+                }
+            }
+
+            if(currentAlpha->betaListOffset && currentAlpha != arrayAlpha) {
+                *propertyMatch = 1;
+                break;
+            }
+        }
+        
+        if ((arrayAlpha->operator == OP_IALL && !*propertyMatch) ||
+            (arrayAlpha->operator == OP_IANY && *propertyMatch)) {
+            break;
+        }
+
+        result = readNextArrayValue(last, &first, &last, &type);   
+    }
+
+    return (result == PARSE_END ? RULES_OK: result);
+}
+
 static unsigned int handleAlpha(ruleset *tree, 
                                 char *sid, 
                                 char *mid,
@@ -941,7 +1078,7 @@ static unsigned int handleAlpha(ruleset *tree,
                                 char **addKeys,
                                 unsigned int *addCount,
                                 char **removeCommand,
-                                void **rulesBinding) {
+                                void **rulesBinding) {                        
     unsigned int result = ERR_EVENT_NOT_HANDLED;
     unsigned short top = 1;
     unsigned int entry;
@@ -965,7 +1102,6 @@ static unsigned int handleAlpha(ruleset *tree,
 
                 if (!exists) {
                     if (top == MAX_STACK_SIZE) {
-                        printf("exiting 1\n");
                         return ERR_MAX_STACK_SIZE;
                     }
                     
@@ -990,14 +1126,27 @@ static unsigned int handleAlpha(ruleset *tree,
                             ++top;
                         } else {
                             unsigned char match = 0;
-                            unsigned int mresult = isMatch(tree, 
-                                                           sid, 
-                                                           message,
-                                                           jo,
-                                                           currentProperty, 
-                                                           &hashNode->value.a,
-                                                           &match,
-                                                           rulesBinding);
+                            unsigned int mresult = RULES_OK;
+                            if (hashNode->value.a.operator == OP_IALL || hashNode->value.a.operator == OP_IANY) {
+                                mresult = isArrayMatch(tree, 
+                                                       sid, 
+                                                       message,
+                                                       jo,
+                                                       currentProperty, 
+                                                       &hashNode->value.a,
+                                                       &match,
+                                                       rulesBinding);
+                            } else {
+                                mresult = isMatch(tree, 
+                                                  sid, 
+                                                  message,
+                                                  jo,
+                                                  currentProperty, 
+                                                  &hashNode->value.a,
+                                                  &match,
+                                                  rulesBinding);
+                            }
+
                             if (mresult != RULES_OK){
                                 return mresult;
                             }

data/src/rules/rete.c

@@ -21,6 +21,8 @@
 #define HASH_NEQ 2488026869 // $neq
 #define HASH_MT 576092554 // $mt
 #define HASH_IMT 1472564215 // $imt
+#define HASH_IALL 3261766877 // $iall
+#define HASH_IANY 3379504400 // $iany
 #define HASH_EX 373481198 // $ex
 #define HASH_NEX 2605470202 // $nex
 #define HASH_OR 340911698 // $or
@@ -615,6 +617,12 @@ static unsigned int validateExpression(char *rule) {
         case HASH_IMT:
             operator = OP_IMT;
             break;
+        case HASH_IALL:
+            operator = OP_IALL;
+            break;
+        case HASH_IANY:
+            operator = OP_IANY;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;
@@ -665,6 +673,11 @@ static unsigned int validateExpression(char *rule) {
         return result;
     }
 
+    if (operator == OP_IALL || operator == OP_IANY) {
+        result = validateExpression(first);
+        return result;
+    }
+
     if (operator == OP_MT || operator == OP_IMT) {
         if (type != JSON_STRING) {
             return ERR_UNEXPECTED_TYPE; 
@@ -825,8 +838,7 @@ static unsigned int linkAlpha(ruleset *tree,
         }
 
         parentBetaList[entry] = nextOffset;
-    }
-    else if (nextNode->value.a.operator == OP_NEX) {
+    } else if (nextNode->value.a.operator == OP_NEX) {
         result = ensureNextList(tree, parentAlpha);
         if (result != RULES_OK) {
             return result;
@@ -841,8 +853,7 @@ static unsigned int linkAlpha(ruleset *tree,
         }
 
         parentNextList[entry] = nextOffset;
-    }
-    else {
+    } else {
         result = ensureNextHashset(tree, parentAlpha);
         if (result != RULES_OK) {
             return result;
@@ -896,8 +907,7 @@ static unsigned int readReference(ruleset *tree, char *rule, unsigned char *idio
             if (result != RULES_OK) {
                 return result;
             } 
-        }
-        else {
+        } else {
             readNextValue(last, &first, &last, &type);
             result = readNextName(first, &first, &last, &hash);
             while (result == PARSE_OK) {
@@ -1034,7 +1044,7 @@ static unsigned int findAlpha(ruleset *tree,
     
     readNextName(rule, &firstName, &lastName, &hash);
     readNextValue(lastName, &first, &last, &type);
-    if (type == JSON_OBJECT) {
+    if (type == JSON_OBJECT && operator != OP_IALL && operator != OP_IANY) {
         result = readIdiom(tree, first, &type, &idiomOffset, &ref);
         if (result != RULES_OK) {
             return result;
@@ -1049,9 +1059,11 @@ static unsigned int findAlpha(ruleset *tree,
             node *currentNode = &tree->nodePool[parentNext[entry]];
             if (currentNode->value.a.hash == hash && 
                 currentNode->value.a.operator == operator) {
-                if (compareValue(tree, &currentNode->value.a.right, first, last, &ref, type)) {
-                    *resultOffset = parentNext[entry];
-                    return RULES_OK;
+                if (operator != OP_IALL && operator != OP_IANY) {
+                    if (compareValue(tree, &currentNode->value.a.right, first, last, &ref, type)) {
+                        *resultOffset = parentNext[entry];
+                        return RULES_OK;
+                    }
                 }
             }
         }
@@ -1061,11 +1073,13 @@ static unsigned int findAlpha(ruleset *tree,
         parentNext = &tree->nextPool[parent->value.a.nextListOffset];
         for (entry = 0; parentNext[entry] != 0; ++entry) {
             node *currentNode = &tree->nodePool[parentNext[entry]];
-            if (currentNode->value.a.hash == hash&& 
+            if (currentNode->value.a.hash == hash && 
                 currentNode->value.a.operator == operator) {
-                if (compareValue(tree, &currentNode->value.a.right, first, last, &ref, type)) {
-                    *resultOffset = parentNext[entry];
-                    return RULES_OK;
+                if (operator != OP_IALL && operator != OP_IANY) {
+                    if (compareValue(tree, &currentNode->value.a.right, first, last, &ref, type)) {
+                        *resultOffset = parentNext[entry];
+                        return RULES_OK;
+                    }
                 }
             }
         }
@@ -1095,17 +1109,21 @@ static unsigned int findAlpha(ruleset *tree,
         type = JSON_IREGEX;
     }
 
-    result = copyValue(tree, &newAlpha->value.a.right, first, last, idiomOffset, &ref, type);
-    if (result != RULES_OK) {
-        return result;
-    }
-
-    if (type == JSON_EVENT_PROPERTY || type == JSON_EVENT_IDIOM) {
-        result = appendTerm(expr, *resultOffset);
+    if (operator == OP_IANY || operator == OP_IALL) {
+        type = JSON_NIL;
+    } else {
+        result = copyValue(tree, &newAlpha->value.a.right, first, last, idiomOffset, &ref, type);
         if (result != RULES_OK) {
             return result;
         }
-    } 
+
+        if (type == JSON_EVENT_PROPERTY || type == JSON_EVENT_IDIOM) {
+            result = appendTerm(expr, *resultOffset);
+            if (result != RULES_OK) {
+                return result;
+            }
+        } 
+    }
 
     return linkAlpha(tree, parentOffset, *resultOffset);
 }
@@ -1184,6 +1202,12 @@ static unsigned int createAlpha(ruleset *tree,
         case HASH_IMT:
             operator = OP_IMT;
             break;
+        case HASH_IALL:
+            operator = OP_IALL;
+            break;
+        case HASH_IANY:
+            operator = OP_IANY;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;
@@ -1268,6 +1292,23 @@ static unsigned int createAlpha(ruleset *tree,
         readNextValue(last, &first, &last, &type);
     }
     
+    if (operator == OP_IANY || operator == OP_IALL) {
+        unsigned int result = findAlpha(tree, parentOffset, operator, first, expr, newOffset);
+        if (result != RULES_OK) {
+            return result;
+        }   
+
+        unsigned int inner_offset = *newOffset;
+        readNextName(first, &first, &last, &hash);
+        readNextValue(last, &first, &last, &type);
+        result = createAlpha(tree, first, expr, nextOffset, &inner_offset);
+        if (result != RULES_OK) {
+            return result;
+        }
+
+        return linkAlpha(tree, *newOffset, nextOffset);
+    }
+
     if (nextOffset == 0) {
         return findAlpha(tree, parentOffset, operator, first, expr, newOffset);
     } else {
@@ -1662,6 +1703,66 @@ static unsigned int fixupQueries(ruleset *tree, unsigned int actionOffset, char*
     return RULES_OK;
 }
 
+#ifdef _PRINT
+
+static void printActionNode(ruleset *tree, node *actionNode, int level) {
+    for (int i = 0; i < level; ++ i) {
+        printf("    ");
+    }
+
+    printf("-> action: name %s, count %d, cap %d, priority %d\n", 
+          &tree->stringPool[actionNode->nameOffset],
+          actionNode->value.c.count,
+          actionNode->value.c.cap,
+          actionNode->value.c.priority);
+}
+
+static void printBetaNode(ruleset *tree, node *betaNode, int level) {
+    for (int i = 0; i < level; ++ i) {
+        printf("    ");
+    }
+
+    printf("-> beta: name %s, not %d\n", &tree->stringPool[betaNode->nameOffset], betaNode->value.b.not);
+    node *currentNode = &tree->nodePool[betaNode->value.b.nextOffset];
+    if (currentNode->type == NODE_ACTION) {
+        printActionNode(tree, currentNode, level + 1);
+    } else {
+        printBetaNode(tree, currentNode, level + 1);
+    }
+}
+
+static void printAlphaNode(ruleset *tree, node *alphaNode, int level) {
+    for (int i = 0; i < level; ++ i) {
+        printf("    ");
+    }
+
+    printf("-> alpha: name %s, operator %x\n", &tree->stringPool[alphaNode->nameOffset], alphaNode->value.a.operator);
+    if (alphaNode->value.a.nextOffset) {
+        unsigned int *nextHashset = &tree->nextPool[alphaNode->value.a.nextOffset];
+        for (unsigned int entry = 0; entry < NEXT_BUCKET_LENGTH; ++entry) { 
+            if (nextHashset[entry]) {
+                printAlphaNode(tree, &tree->nodePool[nextHashset[entry]], level + 1);  
+            }
+        }  
+    }
+
+    if (alphaNode->value.a.nextListOffset) {
+        unsigned int *nextList = &tree->nextPool[alphaNode->value.a.nextListOffset];
+        for (unsigned int entry = 0; nextList[entry] != 0; ++entry) {
+            printAlphaNode(tree, &tree->nodePool[nextList[entry]], level + 1);
+        }
+    }
+
+    if (alphaNode->value.a.betaListOffset) {
+        unsigned int *betaList = &tree->nextPool[alphaNode->value.a.betaListOffset];
+        for (unsigned int entry = 0; betaList[entry] != 0; ++entry) {
+            printBetaNode(tree, &tree->nodePool[betaList[entry]], level + 1);
+        }
+    }
+}
+
+#endif
+
 static unsigned int createTree(ruleset *tree, char *rules) {
     char *first;
     char *last;
@@ -1706,12 +1807,11 @@ static unsigned int createTree(ruleset *tree, char *rules) {
         readNextValue(lastName, &first, &lastRuleValue, &type);
         ruleAction->value.c.priority = 0;
         ruleAction->value.c.count = 0;
-        ruleAction->value.c.span = 0;
         ruleAction->value.c.cap = 0;
         getSetting(HASH_PRI, first, &ruleAction->value.c.priority);
         getSetting(HASH_COUNT, first, &ruleAction->value.c.count);
         getSetting(HASH_CAP, first, &ruleAction->value.c.cap);
-        if (!ruleAction->value.c.count && !ruleAction->value.c.span && !ruleAction->value.c.cap) {
+        if (!ruleAction->value.c.count && !ruleAction->value.c.cap) {
             ruleAction->value.c.count = 1;
         }
 
@@ -1741,6 +1841,10 @@ static unsigned int createTree(ruleset *tree, char *rules) {
         result = readNextName(lastRuleValue, &firstName, &lastName, &hash);
     }
 
+#ifdef _PRINT
+    printAlphaNode(tree, &tree->nodePool[NODE_M_OFFSET], 0);
+#endif
+
     return RULES_OK;
 }
 

data/src/rules/rete.h

@@ -22,6 +22,8 @@
 #define OP_NOT 0x13
 #define OP_MT 0x14
 #define OP_IMT 0x15
+#define OP_IALL 0x16
+#define OP_IANY 0x17
 
 #define NODE_ALPHA 0
 #define NODE_BETA_CONNECTOR 1
@@ -93,7 +95,6 @@ typedef struct betaConnector {
 
 typedef struct action {
     unsigned int index;
-    unsigned short span;
     unsigned short count;
     unsigned short cap;
     unsigned short priority;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.35
+  version: 0.34.36
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-12 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake