durable_rules 0.34.13 → 0.34.14

data/src/rules/regex.h

@@ -0,0 +1,20 @@
+
+#define REGEX_PARSE_OK 0
+#define REGEX_PARSE_END 100
+
+unsigned int validateRegex(char *first, 
+                           char *last);
+
+unsigned int compileRegex(void *tree, 
+                          char *first, 
+                          char *last, 
+                          unsigned short *vocabularyLength,
+                          unsigned short *statesLength,
+                          unsigned int *regexStateMachineOffset);
+
+unsigned char evaluateRegex(void *tree,
+                            char *first,
+                            unsigned short length, 
+                            unsigned short vocabularyLength,
+                            unsigned short statesLength,
+                            unsigned int regexStateMachineOffset);

data/src/rules/rete.c

@@ -6,6 +6,7 @@
 #include "rules.h"
 #include "net.h"
 #include "json.h"
+#include "regex.h"
 
 #define HASH_ALL 193486302 // all
 #define HASH_ANY 193486381 // any
@@ -20,6 +21,7 @@
 #define HASH_GTE 2087883433 // $gte
 #define HASH_EQ 193419647 // $eq
 #define HASH_NEQ 2087890573 // $neq
+#define HASH_MT 193419914 // $mt
 #define HASH_EX 193419654 // $ex
 #define HASH_NEX 2087890580 // $nex
 #define HASH_OR 193419978 // $or
@@ -290,13 +292,14 @@ static unsigned int ensureBetaList(ruleset *tree, node *newNode) {
     return RULES_OK;
 }
 
-static void copyValue(ruleset *tree, 
-                      jsonValue *right, 
-                      char *first, 
-                      char *last,
-                      unsigned int idiomOffset,
-                      reference *ref,
-                      unsigned char type) {
+static unsigned int copyValue(ruleset *tree, 
+                              jsonValue *right, 
+                              char *first, 
+                              char *last,
+                              unsigned int idiomOffset,
+                              reference *ref,
+                              unsigned char type) {
+    unsigned int result = RULES_OK;
     right->type = type;
     unsigned int leftLength;
     char temp;
@@ -313,7 +316,7 @@ static void copyValue(ruleset *tree,
             break;
         case JSON_STRING:
             leftLength = last - first;
-            storeString(tree, first, &right->value.stringOffset, leftLength);
+            result = storeString(tree, first, &right->value.stringOffset, leftLength);
             break;
         case JSON_INT:
             temp = last[1];
@@ -335,7 +338,23 @@ static void copyValue(ruleset *tree,
             }
             right->value.b = leftb;
             break;
+        case JSON_REGEX:
+            leftLength = last - first;
+            result = storeString(tree, first, &right->value.regex.stringOffset, leftLength);
+            if (result != RULES_OK) {
+                return result;
+            }
+
+            result = compileRegex(tree, 
+                                  first, 
+                                  last,
+                                  &right->value.regex.vocabularyLength,
+                                  &right->value.regex.statesLength,
+                                  &right->value.regex.stateMachineOffset);
+            break;
     }
+
+    return result;
 }
 
 static unsigned char compareValue(ruleset *tree, 
@@ -364,10 +383,18 @@ static unsigned char compareValue(ruleset *tree,
         case JSON_EVENT_IDIOM:
             return 0;
         case JSON_STRING:
-            leftLength = last - first;
-            char *rightString = &tree->stringPool[right->value.stringOffset];
-            unsigned int rightLength = strlen(rightString);
-            return (leftLength == rightLength ? !strncmp(rightString, first, rightLength): 0);
+            {
+                char *rightString;
+                if (right->type == JSON_REGEX) {
+                    rightString = &tree->stringPool[right->value.regex.stringOffset];
+                } else {
+                    rightString = &tree->stringPool[right->value.stringOffset];
+                }
+
+                leftLength = last - first;
+                unsigned int rightLength = strlen(rightString);
+                return (leftLength == rightLength ? !strncmp(rightString, first, rightLength): 0);
+            }
         case JSON_INT:
             temp = last[1];
             last[1] = '\0';
@@ -560,6 +587,9 @@ static unsigned int validateExpression(char *rule) {
         case HASH_NEX:
             operator = OP_NEX;
             break;
+        case HASH_MT:
+            operator = OP_MT;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;
@@ -610,6 +640,17 @@ static unsigned int validateExpression(char *rule) {
         return result;
     }
 
+    if (operator == OP_MT) {
+        if (type != JSON_STRING) {
+            return ERR_UNEXPECTED_TYPE; 
+        }  
+
+        result = validateRegex(first, last);
+        if (result != PARSE_OK) {
+            return result;
+        }
+    }
+
     if (type == JSON_ARRAY) {
         return ERR_UNEXPECTED_TYPE;
     }
@@ -807,42 +848,62 @@ static unsigned int linkAlpha(ruleset *tree,
     return RULES_OK;
 }
 
-static unsigned char readReference(ruleset *tree, char *rule, reference *ref) {
+static unsigned int readReference(ruleset *tree, char *rule, unsigned char *idiomType, reference *ref) {
     char *first;
     char *last;
     unsigned char type;
     unsigned int hash;
-    unsigned char returnType = JSON_EVENT_PROPERTY;
+    unsigned int result;
+    *idiomType = JSON_EVENT_PROPERTY;
     
     ref->idOffset = 0;
     readNextName(rule, &first, &last, &hash);
     if (hash != HASH_S) {
-        storeString(tree, first, &ref->idOffset, last - first);   
+        result = storeString(tree, first, &ref->idOffset, last - first); 
+        if (result != RULES_OK) {
+            return result;
+        }  
+
         readNextString(last, &first, &last, &hash);
         ref->hash = hash;
-        storeString(tree, first, &ref->nameOffset, last - first);
+        result = storeString(tree, first, &ref->nameOffset, last - first);
+        if (result != RULES_OK) {
+            return result;
+        } 
     } else {
-        returnType = JSON_STATE_PROPERTY;
+        *idiomType = JSON_STATE_PROPERTY;
         if (readNextString(last, &first, &last, &hash) == PARSE_OK) {
             ref->hash = hash;
-            storeString(tree, first, &ref->nameOffset, last - first);
+            result = storeString(tree, first, &ref->nameOffset, last - first);
+            if (result != RULES_OK) {
+                return result;
+            } 
         }
         else {
             readNextValue(last, &first, &last, &type);
-            unsigned int result = readNextName(first, &first, &last, &hash);
+            result = readNextName(first, &first, &last, &hash);
             while (result == PARSE_OK) {
                 switch (hash) {
                     case HASH_NAME:
                         readNextString(last, &first, &last, &hash);
                         ref->hash = hash;
-                        storeString(tree, first, &ref->nameOffset, last - first);
+                        result = storeString(tree, first, &ref->nameOffset, last - first);
+                        if (result != RULES_OK) {
+                            return result;
+                        } 
                         break;
                     case HASH_ID:
                         readNextValue(last, &first, &last, &type);
                         if (type == JSON_STRING) {
-                            storeString(tree, first, &ref->idOffset, last - first);
+                            result = storeString(tree, first, &ref->idOffset, last - first);
+                            if (result != RULES_OK) {
+                                return result;
+                            } 
                         } else{
-                            storeString(tree, first, &ref->idOffset, last - first + 1);
+                            result = storeString(tree, first, &ref->idOffset, last - first + 1);
+                            if (result != RULES_OK) {
+                                return result;
+                            } 
                         }
 
                         break;
@@ -856,7 +917,7 @@ static unsigned char readReference(ruleset *tree, char *rule, reference *ref) {
         }
     }
 
-    return returnType;
+    return RULES_OK;
 }
 
 static unsigned int readIdiom(ruleset *tree, char *rule, unsigned char *idiomType, unsigned int *idiomOffset, reference *ref) {
@@ -884,7 +945,10 @@ static unsigned int readIdiom(ruleset *tree, char *rule, unsigned char *idiomTyp
     }
 
     if (operator == OP_NOP) {
-        *idiomType = readReference(tree, rule, ref);
+        result = readReference(tree, rule, idiomType, ref);
+        if (result != RULES_OK) {
+            return result;
+        }
     } else {
         idiom *newIdiom = NULL;
         result = storeIdiom(tree, &newIdiom, idiomOffset);
@@ -1001,13 +1065,21 @@ static unsigned int findAlpha(ruleset *tree,
     newAlpha->type = NODE_ALPHA;
     newAlpha->value.a.hash = hash;
     newAlpha->value.a.operator = operator;
-    copyValue(tree, &newAlpha->value.a.right, first, last, idiomOffset, &ref, type);
+    if (operator == OP_MT) {
+        type = JSON_REGEX;
+    }
+
+    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);
 }
@@ -1097,6 +1169,9 @@ static unsigned int createAlpha(ruleset *tree,
         case HASH_NEX:
             operator = OP_NEX;
             break;
+        case HASH_MT:
+            operator = OP_MT;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;
@@ -1642,6 +1717,10 @@ static unsigned int createTree(ruleset *tree, char *rules) {
                     result = createBeta(tree, first, OP_ALL, actionOffset, NULL, &betaPath);
                     break;
             }
+            if (result != RULES_OK) {
+                return result;
+            }
+            
             result = readNextName(last, &first, &last, &hash);
         }
 
@@ -1682,6 +1761,8 @@ unsigned int createRuleset(void **handle, char *name, char *rules, unsigned int
     tree->idiomOffset = 0;
     tree->joinPool = NULL;
     tree->joinOffset = 0;
+    tree->regexStateMachinePool = NULL;
+    tree->regexStateMachineOffset = 0;
     tree->actionCount = 0;
     tree->bindingsList = NULL;
     tree->stateLength = 0;

data/src/rules/rete.h

@@ -20,6 +20,7 @@
 #define OP_DIV 0x11
 #define OP_TYPE 0x12
 #define OP_NOT 0x13
+#define OP_MT 0x14
 
 #define NODE_ALPHA 0
 #define NODE_BETA_CONNECTOR 1
@@ -32,6 +33,13 @@ typedef struct reference {
     unsigned int idOffset;
 } reference;
 
+typedef struct regexReference {
+    unsigned int stringOffset;
+    unsigned int stateMachineOffset;
+    unsigned short statesLength;
+    unsigned short vocabularyLength;
+} regexReference;
+
 typedef struct jsonValue {
     unsigned char type;
     union { 
@@ -40,6 +48,7 @@ typedef struct jsonValue {
         unsigned char b; 
         unsigned int stringOffset;
         unsigned int idiomOffset;
+        regexReference regex;
         reference property;
     } value;
 } jsonValue;
@@ -102,6 +111,7 @@ typedef struct node {
     } value;
 } node;
 
+
 typedef struct ruleset {
     unsigned int nameOffset;
     node *nodePool;
@@ -116,6 +126,8 @@ typedef struct ruleset {
     unsigned int idiomOffset;
     join *joinPool;
     unsigned int joinOffset;
+    char *regexStateMachinePool;
+    unsigned int regexStateMachineOffset;
     unsigned int actionCount;
     void *bindingsList;
     unsigned int *stateBuckets;

data/src/rules/rules.h

@@ -39,6 +39,13 @@
 #define ERR_STALE_STATE 404
 #define ERR_PROPERTY_NOT_FOUND 405
 #define ERR_MAX_PROPERTY_NAME_LENGTH 406
+#define ERR_PARSE_REGEX 501
+#define ERR_REGEX_MAX_TRANSITIONS 502
+#define ERR_REGEX_MAX_STATES 503
+#define ERR_REGEX_QUEUE_FULL 504
+#define ERR_REGEX_LIST_FULL 505
+#define ERR_REGEX_SET_FULL 506
+#define ERR_REGEX_CONFLICT 507
 
 #define NEXT_BUCKET_LENGTH 512
 #define NEXT_LIST_LENGTH 32
@@ -69,7 +76,8 @@ unsigned int deleteClient(void *handle);
 unsigned int bindRuleset(void *handle, 
                          char *host, 
                          unsigned int port, 
-                         char *password);
+                         char *password,
+                         unsigned char db);
 
 unsigned int complete(void *rulesBinding, 
                       unsigned int replyCount);

data/src/rulesrb/rules.c

@@ -67,16 +67,17 @@ static VALUE rbDeleteClient(VALUE self, VALUE handle) {
     return Qnil;
 }
 
-static VALUE rbBindRuleset(VALUE self, VALUE handle, VALUE host, VALUE port, VALUE password) {
+static VALUE rbBindRuleset(VALUE self, VALUE handle, VALUE host, VALUE port, VALUE password, VALUE db) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(host, T_STRING);
     Check_Type(port, T_FIXNUM);
-    
+    Check_Type(db, T_FIXNUM);
+
     unsigned int result;
     if (TYPE(password) == T_STRING) {
-        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), RSTRING_PTR(password));
+        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), RSTRING_PTR(password), FIX2INT(db));
     } else if (TYPE(password) == T_NIL) {
-        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), NULL);
+        result = bindRuleset((void *)FIX2LONG(handle), RSTRING_PTR(host), FIX2INT(port), NULL, FIX2INT(db));
     } else {
         rb_raise(rb_eTypeError, "Wrong argument type for password");   
     }
@@ -654,7 +655,7 @@ void Init_rules() {
     rb_define_singleton_method(rulesModule, "delete_ruleset", rbDeleteRuleset, 1);
     rb_define_singleton_method(rulesModule, "create_client", rbCreateClient, 2);
     rb_define_singleton_method(rulesModule, "delete_client", rbDeleteClient, 1);
-    rb_define_singleton_method(rulesModule, "bind_ruleset", rbBindRuleset, 4);
+    rb_define_singleton_method(rulesModule, "bind_ruleset", rbBindRuleset, 5);
     rb_define_singleton_method(rulesModule, "complete", rbComplete, 2);
     rb_define_singleton_method(rulesModule, "assert_event", rbAssertEvent, 2);
     rb_define_singleton_method(rulesModule, "queue_assert_event", rbQueueAssertEvent, 4);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.13
+  version: 0.34.14
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-24 00:00:00.000000000 Z
+date: 2017-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -79,10 +79,12 @@ files:
 - src/rules/events.c
 - src/rules/json.c
 - src/rules/net.c
+- src/rules/regex.c
 - src/rules/rete.c
 - src/rules/state.c
 - src/rules/json.h
 - src/rules/net.h
+- src/rules/regex.h
 - src/rules/rete.h
 - src/rules/rules.h
 - src/rules/state.h