durable_rules 0.34.17 → 0.34.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f088b9135a5d4ad9a64d29156986df9307d40fc
-  data.tar.gz: 3fa59ec7a1b268240235aadcfe1ea91563afd156
+  metadata.gz: ede28c26f0087d55595d6e8262fa6937cb26625f
+  data.tar.gz: bd5ac33cbe9887938d2ebe9fbb60121d870538b3
 SHA512:
-  metadata.gz: b3c5a66e5cdcc3c813985d221e6933cd63692eccfee45cbd1fab0bda5283d203bd1b26a62d4ebdda671cab3e138a7e79c14bfc72aa2392bacb5d173b829a0548
-  data.tar.gz: 49f9def662c46765994e89d35df408e20fc2eafe2d6650803403dc9b57e48652fe18e4533e9b77700987f28ac9d9f90df64d4d70c0fdd3741b40e466680a73cb
+  metadata.gz: fa7d9872f33c0de2c4aadb736bec251f760293708d09c7dd9562fa88e3c06cdaa7db031a603caacf930ed453d1955f1513fc40fbf71fb629abb739d59c11994d
+  data.tar.gz: 5a73610275300a5e6e35fdad63ba31cb1dd83edb746aad890bbd1a86093b943c44c0d0458ff8ce1dd1edd26a7f003481afddb10b4ae3cfb16e2bcc6495de4b75

data/src/rules/events.c

@@ -272,7 +272,6 @@ static unsigned int handleAction(ruleset *tree,
                                  node *node, 
                                  unsigned char actionType, 
                                  char **evalKeys,
-                                 unsigned short *evalPriorities,
                                  unsigned int *evalCount,
                                  char **addKeys,
                                  unsigned int *addCount,
@@ -303,15 +302,7 @@ static unsigned int handleAction(ruleset *tree,
             }
 
             strcpy(evalKey, prefix);
-            unsigned int index = *evalCount;
-            while (index > 0 && node->value.c.priority < evalPriorities[index - 1]) {
-                evalKeys[index] = evalKeys[index - 1];
-                evalPriorities[index] = evalPriorities[index - 1];
-                --index;
-            }
-
-            evalKeys[index] = evalKey;
-            evalPriorities[index] = node->value.c.priority;
+            evalKeys[*evalCount] = evalKey;
             ++*evalCount;
             break;
 
@@ -354,7 +345,6 @@ static unsigned int handleBeta(ruleset *tree,
                                node *betaNode,
                                unsigned short actionType, 
                                char **evalKeys,
-                               unsigned short *evalPriorities,
                                unsigned int *evalCount,
                                char **addKeys,
                                unsigned int *addCount,
@@ -420,7 +410,6 @@ static unsigned int handleBeta(ruleset *tree,
                         actionNode, 
                         actionType,
                         evalKeys,
-                        evalPriorities,
                         evalCount,
                         addKeys,
                         addCount,
@@ -923,7 +912,6 @@ static unsigned int handleAlpha(ruleset *tree,
                                 alpha *alphaNode, 
                                 unsigned char actionType,
                                 char **evalKeys,
-                                unsigned short *evalPriorities,
                                 unsigned int *evalCount,
                                 char **addKeys,
                                 unsigned int *addCount,
@@ -1010,7 +998,6 @@ static unsigned int handleAlpha(ruleset *tree,
                                     &tree->nodePool[betaList[entry]],  
                                     actionType, 
                                     evalKeys,
-                                    evalPriorities,
                                     evalCount,
                                     addKeys,
                                     addCount,
@@ -1126,7 +1113,6 @@ static unsigned int handleMessageCore(ruleset *tree,
     char *addKeys[MAX_ADD_COUNT];
     unsigned int addCount = 0;
     char *evalKeys[MAX_EVAL_COUNT];
-    unsigned short evalPriorities[MAX_EVAL_COUNT];
     unsigned int evalCount = 0;
     result = handleAlpha(tree, 
                          sid, 
@@ -1137,7 +1123,6 @@ static unsigned int handleMessageCore(ruleset *tree,
                          &tree->nodePool[NODE_M_OFFSET].value.a, 
                          actionType, 
                          evalKeys,
-                         evalPriorities,
                          &evalCount,
                          addKeys,
                          &addCount,
@@ -1201,7 +1186,6 @@ static unsigned int handleMessageCore(ruleset *tree,
                                         evalKeys,
                                         evalCount,
                                         &evalCommand);
-
             for (unsigned int i = 0; i < evalCount; ++i) {
                 free(evalKeys[i]);
             }

data/src/rules/net.c

@@ -1216,6 +1216,23 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
     return RULES_OK;
 }
 
+static void sortActions(ruleset *tree, node **sortedActions, unsigned int *actionCount) {
+    *actionCount = 0;
+     for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
+        node *currentNode = &tree->nodePool[i];   
+        if (currentNode->type == NODE_ACTION) {
+            unsigned int index = *actionCount;
+            while (index > 0 && currentNode->value.c.priority < sortedActions[index - 1]->value.c.priority) {
+                sortedActions[index] = sortedActions[index - 1];
+                --index;
+            }
+
+            sortedActions[index] = currentNode;
+            ++*actionCount;
+        }
+    }
+}
+
 static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding) {
     char *name = &tree->stringPool[tree->nameOffset];
     int nameLength = strlen(name);
@@ -1223,13 +1240,16 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
     redisReply *reply;
     char *lua = NULL;
     char *oldLua;
-    
+    unsigned int actionCount = 0;
+
 #ifdef _WIN32
-    char *actionKey = (char *)_alloca(sizeof(char)*(nameLength + 3));
+    char *actionKey = (char *)_alloca(sizeof(char) * (nameLength + 3));
     sprintf_s(actionKey, nameLength + 3, "%s!a", name);
+    node **sortedActions = (node **)_alloca(sizeof(node *) * tree->nodeOffset);
 #else
     char actionKey[nameLength + 3];
     snprintf(actionKey, nameLength + 3, "%s!a", name);
+    node *sortedActions[tree->nodeOffset];
 #endif
     
     lua = (char*)calloc(1, sizeof(char));
@@ -1237,30 +1257,29 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
         return ERR_OUT_OF_MEMORY;
     }
 
-    for (unsigned int i = 0; i < tree->nodeOffset; ++i) {
-        node *currentNode = &tree->nodePool[i];
-        
-        if (currentNode->type == NODE_ACTION) {
-            char *packFrameLua = NULL;
-            char *unpackFrameLua = NULL;
-            char *oldPackFrameLua = NULL;
-            char *oldUnpackFrameLua = NULL;
-            char *actionName = &tree->stringPool[currentNode->nameOffset];
-            char *actionLastName = strchr(actionName, '!');
+    sortActions(tree, sortedActions, &actionCount);
+    for (unsigned int i = 0; i < actionCount; ++i) {
+        node *currentNode = sortedActions[i];
+        char *packFrameLua = NULL;
+        char *unpackFrameLua = NULL;
+        char *oldPackFrameLua = NULL;
+        char *oldUnpackFrameLua = NULL;
+        char *actionName = &tree->stringPool[currentNode->nameOffset];
+        char *actionLastName = strchr(actionName, '!');
 #ifdef _WIN32
-            char *actionAlias = (char *)_alloca(sizeof(char)*(actionLastName - actionName + 1));
+        char *actionAlias = (char *)_alloca(sizeof(char)*(actionLastName - actionName + 1));
 #else
-            char actionAlias[actionLastName - actionName + 1];
+        char actionAlias[actionLastName - actionName + 1];
 #endif
-            
-            strncpy(actionAlias, actionName, actionLastName - actionName);
-            actionAlias[actionLastName - actionName] = '\0';
-
-            for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
-                unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
-                join *currentJoin = &tree->joinPool[currentJoinOffset];
-                oldLua = lua;
-                if (asprintf(&lua, 
+        
+        strncpy(actionAlias, actionName, actionLastName - actionName);
+        actionAlias[actionLastName - actionName] = '\0';
+
+        for (unsigned int ii = 0; ii < currentNode->value.c.joinsLength; ++ii) {
+            unsigned int currentJoinOffset = tree->nextPool[currentNode->value.c.joinsOffset + ii];
+            join *currentJoin = &tree->joinPool[currentJoinOffset];
+            oldLua = lua;
+            if (asprintf(&lua, 
 "%stoggle = false\n"
 "context_directory = {}\n"
 "context = {}\n"
@@ -1282,51 +1301,51 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "context[\"directory\"] = directory\n"
 "context[\"results_key\"] = \"%s!%d!r!\" .. sid\n"
 "context[\"expressions_count\"] = %d\n",
-                            lua,
-                            actionName,
-                            ii,
-                            currentJoin->expressionsLength)  == -1) {
-                    return ERR_OUT_OF_MEMORY;
-                }  
-                free(oldLua);
-
-                for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
-                    unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
-                    expression *expr = &tree->expressionPool[expressionOffset];
-                    char *currentKey = &tree->stringPool[expr->nameOffset];
-                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
-                    char *nextKeyTest;
-
-                    if (iii == (currentJoin->expressionsLength - 1)) {
-                        nextKeyTest = (char*)calloc(1, sizeof(char));
-                        if (!nextKeyTest) {
-                            return ERR_OUT_OF_MEMORY;
-                        }
-                    } else {
-                        unsigned int nextExpressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii + 1];
-                        expression *nextExpr = &tree->expressionPool[nextExpressionOffset];
-                        if (asprintf(&nextKeyTest, 
+                        lua,
+                        actionName,
+                        ii,
+                        currentJoin->expressionsLength)  == -1) {
+                return ERR_OUT_OF_MEMORY;
+            }  
+            free(oldLua);
+
+            for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
+                unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
+                expression *expr = &tree->expressionPool[expressionOffset];
+                char *currentKey = &tree->stringPool[expr->nameOffset];
+                char *currentAlias = &tree->stringPool[expr->aliasOffset];
+                char *nextKeyTest;
+
+                if (iii == (currentJoin->expressionsLength - 1)) {
+                    nextKeyTest = (char*)calloc(1, sizeof(char));
+                    if (!nextKeyTest) {
+                        return ERR_OUT_OF_MEMORY;
+                    }
+                } else {
+                    unsigned int nextExpressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii + 1];
+                    expression *nextExpr = &tree->expressionPool[nextExpressionOffset];
+                    if (asprintf(&nextKeyTest, 
 "or input_keys[\"%s\"]", 
-                                     &tree->stringPool[nextExpr->nameOffset])  == -1) {
-                            return ERR_OUT_OF_MEMORY;
-                        }
+                                 &tree->stringPool[nextExpr->nameOffset])  == -1) {
+                        return ERR_OUT_OF_MEMORY;
                     }
-                    
-                    if (iii == 0) {
-                        if (expr->not) { 
-                            if (asprintf(&packFrameLua,
+                }
+                
+                if (iii == 0) {
+                    if (expr->not) { 
+                        if (asprintf(&packFrameLua,
 "    result[1] = \"$n\"\n")  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
+                            return ERR_OUT_OF_MEMORY;
+                        }
 
-                            if (asprintf(&unpackFrameLua,
+                        if (asprintf(&unpackFrameLua,
 "    result[\"%s\"] = \"$n\"\n",
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
+                                    currentAlias)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
 
-                            oldLua = lua;
-                            if (asprintf(&lua, 
+                        oldLua = lua;
+                        if (asprintf(&lua, 
 "%sif input_keys[\"%s\"] %s then\n"
 "    toggle = true\n"
 "    context_directory[\"%s\"] = context\n"
@@ -1356,43 +1375,43 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return \"\"\n"
 "    end\n"
 "end\n",
-                                         lua,
-                                         currentKey,
-                                         nextKeyTest,
-                                         currentKey,
-                                         currentKey,
-                                         currentKey,
-                                         currentAlias,
-                                         packFrameLua,
-                                         unpackFrameLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
-                        // not (expr->not)
-                        } else {
-                            if (asprintf(&packFrameLua,
+                                     lua,
+                                     currentKey,
+                                     nextKeyTest,
+                                     currentKey,
+                                     currentKey,
+                                     currentKey,
+                                     currentAlias,
+                                     packFrameLua,
+                                     unpackFrameLua)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldLua);
+                    // not (expr->not)
+                    } else {
+                        if (asprintf(&packFrameLua,
 "    message = frame[\"%s\"]\n"
 "    if full_encode and not message[\"$f\"] then\n"
 "        result[1] = message\n"
 "    else\n"
 "        result[1] = message[\"id\"]\n"
 "    end\n",
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
+                                    currentAlias)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
 
-                            if (asprintf(&unpackFrameLua,
+                        if (asprintf(&unpackFrameLua,
 "    message = fetch_message(frame[1])\n"
 "    if not message then\n"
 "        return nil\n"
 "    end\n"
 "    result[\"%s\"] = message\n",
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
+                                    currentAlias)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
 
-                            oldLua = lua;
-                            if (asprintf(&lua, 
+                        oldLua = lua;
+                        if (asprintf(&lua, 
 "%sif input_keys[\"%s\"] %s then\n"
 "    toggle = true\n"
 "    context_directory[\"%s\"] = context\n"
@@ -1424,51 +1443,51 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return \"\"\n"
 "    end\n"
 "end\n",
-                                         lua,
-                                         currentKey,
-                                         nextKeyTest,
-                                         currentKey,
-                                         currentKey,
-                                         currentKey,
-                                         currentAlias,
-                                         packFrameLua,
-                                         unpackFrameLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
-                        }
-                    // not (iii == 0)
-                    } else {
-                        char *test = NULL;
-                        char *primaryKeyLua = NULL;
-                        char *primaryFrameKeyLua = NULL;
-                        
-                        unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
-                        if (result != RULES_OK) {
-                            return result;
+                                     lua,
+                                     currentKey,
+                                     nextKeyTest,
+                                     currentKey,
+                                     currentKey,
+                                     currentKey,
+                                     currentAlias,
+                                     packFrameLua,
+                                     unpackFrameLua)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
                         }
+                        free(oldLua);
+                    }
+                // not (iii == 0)
+                } else {
+                    char *test = NULL;
+                    char *primaryKeyLua = NULL;
+                    char *primaryFrameKeyLua = NULL;
+                    
+                    unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
+                    if (result != RULES_OK) {
+                        return result;
+                    }
 
-                        if (expr->not) { 
-                            oldPackFrameLua = packFrameLua;
-                            if (asprintf(&packFrameLua,
+                    if (expr->not) { 
+                        oldPackFrameLua = packFrameLua;
+                        if (asprintf(&packFrameLua,
 "%s    result[%d] = \"$n\"\n",
-                                         packFrameLua,
-                                         iii + 1)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldPackFrameLua);
+                                     packFrameLua,
+                                     iii + 1)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldPackFrameLua);
 
-                            oldUnpackFrameLua = unpackFrameLua;
-                            if (asprintf(&unpackFrameLua,
+                        oldUnpackFrameLua = unpackFrameLua;
+                        if (asprintf(&unpackFrameLua,
 "%s    result[\"%s\"] = \"$n\"\n",
-                                        unpackFrameLua,
-                                        currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldUnpackFrameLua);
+                                    unpackFrameLua,
+                                    currentAlias)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldUnpackFrameLua);
 
-                            oldLua = lua;
-                            if (asprintf(&lua,
+                        oldLua = lua;
+                        if (asprintf(&lua,
 "%sif toggle %s then\n"
 "    toggle = true\n"
 "    context_directory[\"%s\"] = context\n"
@@ -1502,63 +1521,63 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return result\n"
 "    end\n"
 "end\n",
-                                         lua,
-                                         nextKeyTest,
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         iii + 1,
-                                         iii + 1,
-                                         test,
-                                         currentAlias,
-                                         iii + 1,
-                                         packFrameLua,
-                                         iii + 1,
-                                         unpackFrameLua,
-                                         iii + 1,
-                                         primaryKeyLua,
-                                         iii + 1,
-                                         primaryFrameKeyLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
+                                     lua,
+                                     nextKeyTest,
+                                     currentKey,
+                                     iii + 1, 
+                                     currentKey,
+                                     iii + 1, 
+                                     currentKey,
+                                     iii + 1,
+                                     iii + 1,
+                                     test,
+                                     currentAlias,
+                                     iii + 1,
+                                     packFrameLua,
+                                     iii + 1,
+                                     unpackFrameLua,
+                                     iii + 1,
+                                     primaryKeyLua,
+                                     iii + 1,
+                                     primaryFrameKeyLua)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldLua);
 
-                        // not (expr->not)
-                        } else {
-                            oldPackFrameLua = packFrameLua;
-                            if (asprintf(&packFrameLua,
+                    // not (expr->not)
+                    } else {
+                        oldPackFrameLua = packFrameLua;
+                        if (asprintf(&packFrameLua,
 "%s    message = frame[\"%s\"]\n"
 "    if full_encode and not message[\"$f\"] then\n"
 "        result[%d] = message\n"
 "    else\n"
 "        result[%d] = message[\"id\"]\n"
 "    end\n",
-                                         packFrameLua,
-                                         currentAlias,
-                                         iii + 1,
-                                         iii + 1)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldPackFrameLua);
+                                     packFrameLua,
+                                     currentAlias,
+                                     iii + 1,
+                                     iii + 1)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldPackFrameLua);
 
-                            oldUnpackFrameLua = unpackFrameLua;
-                            if (asprintf(&unpackFrameLua,
+                        oldUnpackFrameLua = unpackFrameLua;
+                        if (asprintf(&unpackFrameLua,
 "%s    message = fetch_message(frame[%d])\n"
 "    if not message then\n"
 "        return nil\n"
 "    end\n"
 "    result[\"%s\"] = message\n",
-                                         unpackFrameLua,
-                                         iii + 1,
-                                         currentAlias)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldUnpackFrameLua);
+                                     unpackFrameLua,
+                                     iii + 1,
+                                     currentAlias)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
+                        }
+                        free(oldUnpackFrameLua);
 
-                            oldLua = lua;
-                            if (asprintf(&lua,
+                        oldLua = lua;
+                        if (asprintf(&lua,
 "%sif toggle %s then\n"
 "    toggle = true\n"
 "    context_directory[\"%s\"] = context\n"
@@ -1591,40 +1610,40 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return result\n"
 "    end\n"
 "end\n",
-                                         lua,
-                                         nextKeyTest,
-                                         currentKey,
-                                         iii + 1, 
-                                         currentKey,
-                                         currentKey,
-                                         iii + 1,
-                                         iii + 1,
-                                         test,
-                                         currentAlias,
-                                         iii + 1,
-                                         packFrameLua,
-                                         iii + 1,
-                                         unpackFrameLua,
-                                         iii + 1,
-                                         primaryKeyLua,
-                                         iii + 1,
-                                         primaryFrameKeyLua)  == -1) {
-                                return ERR_OUT_OF_MEMORY;
-                            }
-                            free(oldLua);
-                        // done not (expr->not)
+                                     lua,
+                                     nextKeyTest,
+                                     currentKey,
+                                     iii + 1, 
+                                     currentKey,
+                                     currentKey,
+                                     iii + 1,
+                                     iii + 1,
+                                     test,
+                                     currentAlias,
+                                     iii + 1,
+                                     packFrameLua,
+                                     iii + 1,
+                                     unpackFrameLua,
+                                     iii + 1,
+                                     primaryKeyLua,
+                                     iii + 1,
+                                     primaryFrameKeyLua)  == -1) {
+                            return ERR_OUT_OF_MEMORY;
                         }
-                        free(nextKeyTest);
-                        free(test);
-                        free(primaryKeyLua);
-                        free(primaryFrameKeyLua);
-                    // done not (iii == 0)
+                        free(oldLua);
+                    // done not (expr->not)
                     }
+                    free(nextKeyTest);
+                    free(test);
+                    free(primaryKeyLua);
+                    free(primaryFrameKeyLua);
+                // done not (iii == 0)
                 }
+            }
 
-                if (currentNode->value.c.span > 0) {
-                    oldLua = lua;
-                    if (asprintf(&lua,
+            if (currentNode->value.c.span > 0) {
+                oldLua = lua;
+                if (asprintf(&lua,
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_span\n"
 "    context[\"process_key_count\"] = %d\n"
@@ -1632,15 +1651,15 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return\n"
 "    end\n"
 "end\n",
-                                 lua,
-                                 currentNode->value.c.span)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
+                             lua,
+                             currentNode->value.c.span)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
+                }
+                free(oldLua);
 
-                } else if (currentNode->value.c.cap > 0) {
-                    oldLua = lua;
-                    if (asprintf(&lua,
+            } else if (currentNode->value.c.cap > 0) {
+                oldLua = lua;
+                if (asprintf(&lua,
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_cap\n"
 "    context[\"process_key_count\"] = %d\n"
@@ -1648,15 +1667,15 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return\n"
 "    end\n"
 "end\n",
-                                 lua,
-                                 currentNode->value.c.cap)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
+                             lua,
+                             currentNode->value.c.cap)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
+                }
+                free(oldLua);
 
-                } else {
-                    oldLua = lua;
-                    if (asprintf(&lua,
+            } else {
+                oldLua = lua;
+                if (asprintf(&lua,
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_window\n"
 "    context[\"process_key_count\"] = %d\n"
@@ -1664,17 +1683,16 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        return\n"
 "    end\n"
 "end\n",
-                                 lua,
-                                 currentNode->value.c.count)  == -1) {
-                        return ERR_OUT_OF_MEMORY;
-                    }
-                    free(oldLua);
+                             lua,
+                             currentNode->value.c.count)  == -1) {
+                    return ERR_OUT_OF_MEMORY;
                 }
+                free(oldLua);
             }
-
-            free(unpackFrameLua);
-            free(packFrameLua);
         }
+
+        free(unpackFrameLua);
+        free(packFrameLua);
     }
 
     oldLua = lua;
@@ -2073,22 +2091,22 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "        key = ARGV[index]\n"
 "        context = context_directory[key]\n"
 "        if context then\n"
-"        keys = context[\"keys\"]\n"
-"        reviewers = context[\"reviewers\"]\n"
-"        frame_packers = context[\"frame_packers\"]\n"
-"        frame_unpackers = context[\"frame_unpackers\"]\n"
-"        primary_message_keys = context[\"primary_message_keys\"]\n"
-"        primary_frame_keys = context[\"primary_frame_keys\"]\n"
-"        directory = context[\"directory\"]\n"
-"        results_key = context[\"results_key\"]\n"
-"        inverse_directory = context[\"inverse_directory\"]\n"
-"        expressions_count = context[\"expressions_count\"]\n"
-"        local process_key = context[\"process_key\"]\n"
-"        local process_key_count = context[\"process_key_count\"]\n"
-"        queue_action = process_key(message, process_key_count) or queue_action\n"
-"        if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
-"            break\n"
-"        end\n"
+"            keys = context[\"keys\"]\n"
+"            reviewers = context[\"reviewers\"]\n"
+"            frame_packers = context[\"frame_packers\"]\n"
+"            frame_unpackers = context[\"frame_unpackers\"]\n"
+"            primary_message_keys = context[\"primary_message_keys\"]\n"
+"            primary_frame_keys = context[\"primary_frame_keys\"]\n"
+"            directory = context[\"directory\"]\n"
+"            results_key = context[\"results_key\"]\n"
+"            inverse_directory = context[\"inverse_directory\"]\n"
+"            expressions_count = context[\"expressions_count\"]\n"
+"            local process_key = context[\"process_key\"]\n"
+"            local process_key_count = context[\"process_key_count\"]\n"
+"            queue_action = process_key(message, process_key_count) or queue_action\n"
+"            if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
+"                break\n"
+"            end\n"
 "        end\n"
 "    end\n"
 "    if queue_action then\n"

data/src/rules/regex.c

@@ -189,7 +189,6 @@ unsigned int utf8ToUnicode(char **first, char *last, unsigned int *result) {
     if (*first + byteNumber >= last) {
         return ERR_PARSE_REGEX;
     }
-    
     *result = 0;
     switch (byteNumber) {
         case 3: 
@@ -460,6 +459,10 @@ static unsigned int readNextToken(char **first,
                                   char *last, 
                                   token *nextToken) {
     unsigned int result = REGEX_PARSE_OK;
+    nextToken->low = 0;
+    nextToken->high = 0;
+    nextToken->symbolsLength = 0;
+    nextToken->inverseSymbolsLength = 0;
     if (*first >= last) {
         return REGEX_PARSE_END;
     }

data/src/rules/rete.c

@@ -1084,23 +1084,6 @@ static unsigned int findAlpha(ruleset *tree,
     return linkAlpha(tree, parentOffset, *resultOffset);
 }
 
-static void getSymbolSetting(unsigned int settingHash, char *rule, unsigned int *symbolHash) {
-    char *first;
-    char *last;
-    unsigned int hash;
-    unsigned char type;
-    unsigned int result = readNextName(rule, &first, &last, &hash);
-    while (result == PARSE_OK) {
-        if (hash == settingHash) {
-            readNextString(last, &first, &last, symbolHash);
-            break;
-        } else {
-            readNextValue(last, &first, &last, &type);
-            result = readNextName(last, &first, &last, &hash);
-        }
-    }
-}
-
 static void getSetting(unsigned int settingHash, char *rule, unsigned short *value) {
     char *first;
     char *last;
@@ -1696,12 +1679,10 @@ static unsigned int createTree(ruleset *tree, char *rules) {
         ruleAction->value.c.count = 0;
         ruleAction->value.c.span = 0;
         ruleAction->value.c.cap = 0;
-        ruleAction->value.c.partitionBy = 0;
         getSetting(HASH_PRI, first, &ruleAction->value.c.priority);
         getSetting(HASH_COUNT, first, &ruleAction->value.c.count);
         getSetting(HASH_SPAN, first, &ruleAction->value.c.span);
         getSetting(HASH_CAP, first, &ruleAction->value.c.cap);
-        getSymbolSetting(HASH_BY, first, &ruleAction->value.c.partitionBy);
         if (!ruleAction->value.c.count && !ruleAction->value.c.span && !ruleAction->value.c.cap) {
             ruleAction->value.c.count = 1;
         }

data/src/rules/rete.h

@@ -95,7 +95,6 @@ typedef struct action {
     unsigned short span;
     unsigned short count;
     unsigned short cap;
-    unsigned int partitionBy;
     unsigned short priority;
     unsigned int joinsOffset;
     unsigned short joinsLength;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.17
+  version: 0.34.18
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-23 00:00:00.000000000 Z
+date: 2017-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake