durable_rules 2.0.18 → 2.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5400f2cda8c4df0f9d4df9b93c5b0ce70896411
-  data.tar.gz: f2e209f3d9275874bf3c5670f81e7dadb749c8f4
+  metadata.gz: 4f68e8be526e46e47b904f1b0a0af0c00ffa58f5
+  data.tar.gz: 31f9916994a145c2c27b891ce93f9d7795b5c22b
 SHA512:
-  metadata.gz: 9a4f16be8c4fbda5abe5348bbdc114e8387cb97f2ead7797ffae0b6b89c037caad7e07a77c875505687ebff601cb293389d6f0d7e76c6c597d0e81403a885786
-  data.tar.gz: 76e38364859de5984b1ac6eb751d3e10028e7eecd723d139910cf8bf9b1d8cb12b97bda35d219eb7baf92f1149ea3dd37e2dbbb987afcbd960eaa9217dc24815
+  metadata.gz: efd950c601e441e71505e9c43935f112b1a223495d487fff180738356ad3c79431a1aa316df59663d13178c5f6e4aaf46f7e0ab4d7cc6f41c9d1c8a8a1855815
+  data.tar.gz: cdb9502e03383280a6ee9ef39ea105f5cd75ae1050744f5b0111ab73144a08e56dc79fdb094046013b9be2f4c16c4cbcf75a838afc7f75b6cc16fe571d15afbc

data/src/rules/events.c

@@ -474,7 +474,7 @@ static unsigned int reduceExpression(ruleset *tree,
                                      jsonObject *leftMessageObject,
                                      jsonObject *rightMessageObject,
                                      leftFrameNode *context,
-                                     jsonProperty *targetProperty) {
+                                     jsonProperty *targetProperty) {        
     jsonProperty leftValue;
     jsonProperty *leftProperty = &leftValue;
     CHECK_RESULT(reduceOperand(tree,
@@ -505,10 +505,12 @@ static unsigned int reduceExpression(ruleset *tree,
                                context,
                                &rightProperty));
 
-    return reduceProperties(currentExpression->operator, 
+    unsigned int result = reduceProperties(currentExpression->operator, 
                             leftProperty, 
                             rightProperty, 
                             targetProperty);
+
+    return result;
 }
 
 static unsigned int reduceExpressionSequence(ruleset *tree,
@@ -527,56 +529,40 @@ static unsigned int reduceExpressionSequence(ruleset *tree,
             return RULES_OK;          
         } 
 
-        if ((operator != OP_NOP) &&
-            ((operator == OP_OR && targetProperty->value.b) || 
-             (operator == OP_AND && !targetProperty->value.b))) {
-            if (currentExpression->operator == OP_AND || currentExpression->operator == OP_OR) {
-                jsonProperty dummyProperty;
-                dummyProperty.type = JSON_BOOL;
-                if (currentExpression->operator == OP_AND) {
-                    dummyProperty.value.b = 0;
-                } else {
-                    dummyProperty.value.b = 1;
-                }
-
-                ++*i;
-                CHECK_RESULT(reduceExpressionSequence(tree,
-                                                      state,
-                                                      exprs,
-                                                      currentExpression->operator,
-                                                      messageObject,
-                                                      context,
-                                                      i,
-                                                      &dummyProperty));
-            }
+        if (currentExpression->operator == OP_AND || currentExpression->operator == OP_OR) {
+            ++*i;
+            CHECK_RESULT(reduceExpressionSequence(tree,
+                                                  state,
+                                                  exprs,
+                                                  currentExpression->operator,
+                                                  messageObject,
+                                                  context,
+                                                  i,
+                                                  targetProperty));
         } else {
-            if (currentExpression->operator == OP_AND || currentExpression->operator == OP_OR) {
+            CHECK_RESULT(reduceExpression(tree,
+                                          state,
+                                          currentExpression,
+                                          messageObject,
+                                          messageObject,
+                                          context,
+                                          targetProperty));
+            ++*i;
+        }
+
+        if (targetProperty->type != JSON_BOOL) {
+            return ERR_OPERATION_NOT_SUPPORTED;
+        }
+        
+
+        if ((operator == OP_AND && !targetProperty->value.b) || 
+            (operator == OP_OR && targetProperty->value.b)) {
+            while (currentExpression->operator != OP_END) {
                 ++*i;
-                CHECK_RESULT(reduceExpressionSequence(tree,
-                                                      state,
-                                                      exprs,
-                                                      currentExpression->operator,
-                                                      messageObject,
-                                                      context,
-                                                      i,
-                                                      targetProperty));
-            } else if (currentExpression->operator == OP_IALL || currentExpression->operator == OP_IANY) {
-                
-            } else {
-                CHECK_RESULT(reduceExpression(tree,
-                                              state,
-                                              currentExpression,
-                                              messageObject,
-                                              messageObject,
-                                              context,
-                                              targetProperty));
-                if (targetProperty->type != JSON_BOOL) {
-                    return ERR_OPERATION_NOT_SUPPORTED;
-                }
+                currentExpression = &exprs->expressions[*i];
             }
+            return RULES_OK;
         }
-
-        ++*i;
     }
 
     return RULES_OK;
@@ -665,27 +651,32 @@ static unsigned int getFrameHash(ruleset *tree,
                                              context,
                                              hash);
         }
-    } else if (exprs->length > 0) {
-        if (exprs->expressions[0].operator == OP_AND) {
-            *hash = FNV_32_OFFSET_BASIS;
-            unsigned int result;
-            for (unsigned int i = 1; i < exprs->length; ++ i) {
-
-                if (exprs->expressions[i].operator == OP_EQ) {
-                    unsigned int newHash;
-                    result = getFrameHashForExpression(tree,
-                                                       state,
-                                                       &exprs->expressions[i],
-                                                       messageObject,
-                                                       context,
-                                                       &newHash);
-                    if (result == RULES_OK) {
-                        *hash ^= newHash;
-                        *hash *= FNV_32_PRIME;
-                    }
+    } else if (exprs->length > 0 && exprs->expressions[0].operator == OP_AND) {
+        
+        unsigned int result;
+        unsigned int i = 1;
+        while (exprs->expressions[i].operator != OP_OR && exprs->expressions[i].operator != OP_END) {
+            if (i == 1) {
+                *hash = FNV_32_OFFSET_BASIS;
+            }
+
+            if (exprs->expressions[i].operator == OP_EQ) {
+                unsigned int newHash;
+                result = getFrameHashForExpression(tree,
+                                                   state,
+                                                   &exprs->expressions[i],
+                                                   messageObject,
+                                                   context,
+                                                   &newHash);
+                if (result == RULES_OK) {
+                    *hash ^= newHash;
+                    *hash *= FNV_32_PRIME;
                 }
             }
+
+            ++i;
         }
+        
     }
     
     return RULES_OK;
@@ -1381,21 +1372,47 @@ static unsigned int handleBetaMessage(ruleset *tree,
                                sideEffect);
     }
 
+    unsigned int messageHash;
+    CHECK_RESULT(getFrameHash(tree,
+                              state,
+                              &betaNode->value.b,
+                              messageObject,
+                              NULL,
+                              &messageHash));
+
     frameLocation rightFrameLocation;
     rightFrameNode *rightFrame;
 
+    CHECK_RESULT(getLastRightFrame(state,
+                                   betaNode->value.b.index,
+                                   messageHash,
+                                   &rightFrame));
+
+    while (rightFrame) {
+        if (rightFrame->messageOffset == currentMessageOffset) {
+            return RULES_OK;
+
+        }
+        
+        unsigned int rightFrameOffset = rightFrame->prevOffset;
+        rightFrame = NULL;
+        while (rightFrameOffset != UNDEFINED_HASH_OFFSET && !rightFrame) {
+            rightFrame = RIGHT_FRAME_NODE(state,
+                                          betaNode->value.b.index, 
+                                          rightFrameOffset); 
+            if (rightFrame->hash != messageHash) {
+                rightFrameOffset = rightFrame->prevOffset;
+                rightFrame = NULL;
+            } 
+        }
+    }
+
     CHECK_RESULT(createRightFrame(state,
                                   betaNode,
                                   &rightFrame,
                                   &rightFrameLocation));
 
-    unsigned int messageHash;
-    CHECK_RESULT(getFrameHash(tree,
-                              state,
-                              &betaNode->value.b,
-                              messageObject,
-                              NULL,
-                              &messageHash));
+
 
     rightFrame->messageOffset = currentMessageOffset;
     CHECK_RESULT(addFrameLocation(state,

data/src/rules/rete.c

@@ -348,7 +348,6 @@ static unsigned char compareValue(ruleset *tree,
                                   char *last,
                                   identifier *id,
                                   unsigned char type) {
-    
     if (right->type != type) {
         return 0;
     }
@@ -1009,6 +1008,7 @@ static unsigned int findAlpha(ruleset *tree,
                     }
                 }
             }
+            
         }
     }
     
@@ -1251,7 +1251,6 @@ static unsigned int createAlpha(ruleset *tree,
                                        0,
                                        single_offset, 
                                        *newOffset));
-                
 
                 result = readNextArrayValue(last, 
                                             &first, 

data/src/rules/rete.h

@@ -1,6 +1,6 @@
 #include "state.h"
 
-// #define _PRINT 1
+//#define _PRINT 1
 
 #define OP_NOP 0
 #define OP_LT 0x01

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 2.0.18
+  version: 2.0.19
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-26 00:00:00.000000000 Z
+date: 2020-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake