durable_rules 0.34.05 → 0.34.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 70dd56dc98b00ff1a60d63f28a0c73de3b7b0952
-  data.tar.gz: 7304422b933a526f11873486c27fcd1aacf25a83
+  metadata.gz: 298dc30af9fa87b5556c63f3e9053887fdcec4c7
+  data.tar.gz: 47c61f7ada560539a88ce3dc1166b535c0f70604
 SHA512:
-  metadata.gz: 0bb621f2105f5bf78b821749d9e42b1e402100dad77481ff26e6ed342cc573f6ccf018daf9de70f24c54df686025c5f5ebb36ca894c54a4b6a07b2002dbeddfd
-  data.tar.gz: f56006a45036255cd2a742a578b37cc0afe0ce806a9ba2e1c76bf2f9d18913a1bc426bcf244e3a1ada8f78a3abb7c7a4854b92cb2002ae8a5994f51608d620f1
+  metadata.gz: 3f753cbf98f4486f7a08d551d32d7509f9a039ba0b2038e808a9d2ece43ba9c0bc7b9f8e3b1b15791998975e701744f6c80d090f951d33b96f239dd1a4afbf3a
+  data.tar.gz: 946c9b9283724ded8302763689de2d41d333c2dc869742c07e63464a8d3998e6521aae09a5ba70677b2c850fb7bac3691fb983ec58f8deff9652d14d06c1ad75

data/librb/engine.rb

@@ -436,7 +436,7 @@ module Engine
     end
 
     def start_assert_event(message)
-      return Rules.start_assert_event @handle, JSON.generate(message)
+      Rules.start_assert_event @handle, JSON.generate(message)
     end
 
     def assert_events(messages)
@@ -444,7 +444,7 @@ module Engine
     end
 
     def start_assert_events(messages)
-      return Rules.start_assert_events @handle, JSON.generate(messages)
+      Rules.start_assert_events @handle, JSON.generate(messages)
     end
 
     def start_timer(sid, timer, timer_duration)
@@ -464,7 +464,7 @@ module Engine
     end
 
     def start_assert_fact(fact)
-      return Rules.start_assert_fact @handle, JSON.generate(fact)
+      Rules.start_assert_fact @handle, JSON.generate(fact)
     end
 
     def assert_facts(facts)
@@ -472,7 +472,7 @@ module Engine
     end
 
     def start_assert_facts(facts)
-      return Rules.start_assert_facts @handle, JSON.generate(facts)
+      Rules.start_assert_facts @handle, JSON.generate(facts)
     end
 
     def retract_fact(fact)
@@ -484,7 +484,7 @@ module Engine
     end
 
     def start_retract_fact(fact)
-      return Rules.start_retract_fact @handle, JSON.generate(fact)
+      Rules.start_retract_fact @handle, JSON.generate(fact)
     end
 
     def retract_facts(facts)
@@ -492,7 +492,7 @@ module Engine
     end
 
     def start_retract_facts(facts)
-      return Rules.start_retract_facts @handle, JSON.generate(facts)
+      Rules.start_retract_facts @handle, JSON.generate(facts)
     end
 
     def assert_state(state)
@@ -883,9 +883,9 @@ module Engine
         started = true
 
         if parent_name
-          rules[parent_name + "$start"] = {:all => [{:chart_context => {:$and => [{:label => parent_name}, {:chart => 1}]}}], run: To.new(nil, state_name, false)};
+          rules[parent_name + "$start"] = {:all => [{:chart_context => {:$and => [{:label => parent_name}, {:chart => 1}]}}], :run => To.new(nil, state_name, false)};
         else
-          rules[:$start] = {:all => [{:chart_context => {:$and => [{:$nex => {:running => 1}}, {:$s => 1}]}}], run: To.new(nil, state_name, false)};
+          rules[:$start] = {:all => [{:chart_context => {:$and => [{:$nex => {:running => 1}}, {:$s => 1}]}}], :run => To.new(nil, state_name, false)};
         end
       end
 
@@ -1123,7 +1123,7 @@ module Engine
     end
 
     def start_post_batch(ruleset_name, *events)
-      return get_ruleset(ruleset_name).start_assert_events events
+      get_ruleset(ruleset_name).start_assert_events events
     end
 
     def post(ruleset_name, event)
@@ -1131,7 +1131,7 @@ module Engine
     end
 
     def start_post(ruleset_name, event)
-      return get_ruleset(ruleset_name).start_assert_event event
+      get_ruleset(ruleset_name).start_assert_event event
     end
 
     def assert(ruleset_name, fact)
@@ -1139,7 +1139,7 @@ module Engine
     end
 
     def start_assert(ruleset_name, fact)
-      return get_ruleset(ruleset_name).start_assert_fact fact
+      get_ruleset(ruleset_name).start_assert_fact fact
     end
 
     def assert_facts(ruleset_name, *facts)
@@ -1147,7 +1147,7 @@ module Engine
     end
 
     def start_assert_facts(ruleset_name, *facts)
-      return get_ruleset(ruleset_name).start_assert_facts facts
+      get_ruleset(ruleset_name).start_assert_facts facts
     end
 
     def retract(ruleset_name, fact)
@@ -1155,7 +1155,7 @@ module Engine
     end
 
     def start_retract(ruleset_name, fact)
-      return get_ruleset(ruleset_name).start_retract_fact fact
+      get_ruleset(ruleset_name).start_retract_fact fact
     end
 
     def retract_facts(ruleset_name, *facts)
@@ -1163,7 +1163,7 @@ module Engine
     end
 
     def start_retract_facts(ruleset_name, *facts)
-      return get_ruleset(ruleset_name).start_retract_facts facts
+      get_ruleset(ruleset_name).start_retract_facts facts
     end
 
     def patch_state(ruleset_name, state)

data/librb/interface.rb

@@ -23,7 +23,8 @@ module Interface
         request.body.rewind
         message = JSON.parse request.body.read
         message["sid"] = params["sid"]
-        @@host.post params["ruleset_name"], message
+        result = @@host.post(params["ruleset_name"], message)
+        JSON.generate({:outcome => result})
       rescue Exception => e
         status 500
         e.to_s
@@ -35,7 +36,8 @@ module Interface
         request.body.rewind
         state = JSON.parse request.body.read
         state["id"] = params["sid"]
-        @@host.patch_state params["ruleset_name"], state
+        result = @@host.patch_state(params["ruleset_name"], state)
+        JSON.generate({:outcome => result})
       rescue Exception => e
         status 500
         e.to_s

data/src/rules/events.c

@@ -1293,18 +1293,9 @@ static unsigned int handleMessages(void *handle,
                                    char *messages, 
                                    char **commands,
                                    unsigned int *commandCount,
-                                   unsigned int *resultsLength,  
-                                   unsigned int **results,
                                    void **rulesBinding) {
-    unsigned int messagesLength = 64;
-    unsigned int *resultsArray = malloc(sizeof(unsigned int) * messagesLength);
-    if (!resultsArray) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    *results = resultsArray;
-    *resultsLength = 0;
     unsigned int result;
+    unsigned int returnResult = RULES_OK;
     jsonProperty properties[MAX_EVENT_PROPERTIES];
     unsigned int propertiesLength = 0;
     unsigned int propertiesMidIndex = UNDEFINED_INDEX;
@@ -1348,21 +1339,13 @@ static unsigned int handleMessages(void *handle,
         
         *last = lastTemp;
         if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
-            free(resultsArray);
             return result;
         }
 
-        if (*resultsLength >= messagesLength) {
-            messagesLength = messagesLength * 2;
-            resultsArray = realloc(resultsArray, sizeof(unsigned int) * messagesLength);
-            if (!resultsArray) {
-                return ERR_OUT_OF_MEMORY;
-            }
-            *results = resultsArray;
+        if (result == ERR_EVENT_NOT_HANDLED) {
+            returnResult = ERR_EVENT_NOT_HANDLED;
         }
 
-        resultsArray[*resultsLength] = result;
-        ++*resultsLength;
         propertiesLength = 0;
         propertiesMidIndex = UNDEFINED_INDEX;
         propertiesSidIndex = UNDEFINED_INDEX;        
@@ -1373,7 +1356,7 @@ static unsigned int handleMessages(void *handle,
         }
     }
 
-    return RULES_OK;
+    return returnResult;
 }
 
 static unsigned int handleState(ruleset *tree, 
@@ -1523,8 +1506,6 @@ static unsigned int executeHandleMessage(void *handle,
 static unsigned int startHandleMessages(void *handle, 
                                         char *messages, 
                                         unsigned char actionType,
-                                        unsigned int *resultsLength, 
-                                        unsigned int **results,
                                         void **rulesBinding,
                                         unsigned int *replyCount) {
     char *commands[MAX_COMMAND_COUNT];
@@ -1534,8 +1515,6 @@ static unsigned int startHandleMessages(void *handle,
                                          messages,
                                          commands,
                                          &commandCount,
-                                         resultsLength,
-                                         results,
                                          rulesBinding);
     if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
         freeCommands(commands, commandCount);
@@ -1552,9 +1531,7 @@ static unsigned int startHandleMessages(void *handle,
 
 static unsigned int executeHandleMessages(void *handle, 
                                           char *messages, 
-                                          unsigned char actionType,
-                                          unsigned int *resultsLength, 
-                                          unsigned int **results) {
+                                          unsigned char actionType) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
@@ -1563,8 +1540,6 @@ static unsigned int executeHandleMessages(void *handle,
                                          messages,
                                          commands,
                                          &commandCount,
-                                         resultsLength,
-                                         results,
                                          &rulesBinding);
     if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
         freeCommands(commands, commandCount);
@@ -1580,7 +1555,12 @@ static unsigned int executeHandleMessages(void *handle,
 }
 
 unsigned int complete(void *rulesBinding, unsigned int replyCount) {
-    return completeNonBlockingBatch(rulesBinding, replyCount);
+    unsigned int result = completeNonBlockingBatch(rulesBinding, replyCount);
+    if (result != RULES_OK && result != ERR_EVENT_OBSERVED) {
+        return result;
+    }
+
+    return RULES_OK;
 }
 
 unsigned int assertEvent(void *handle, char *message) {
@@ -1595,19 +1575,15 @@ unsigned int startAssertEvent(void *handle,
 }
 
 unsigned int assertEvents(void *handle, 
-                          char *messages, 
-                          unsigned int *resultsLength, 
-                          unsigned int **results) {
-    return executeHandleMessages(handle, messages, ACTION_ASSERT_EVENT, resultsLength, results);
+                          char *messages) {
+    return executeHandleMessages(handle, messages, ACTION_ASSERT_EVENT);
 }
 
 unsigned int startAssertEvents(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                               void **rulesBinding, 
                               unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_ASSERT_EVENT, resultsLength, results, rulesBinding, replyCount);
+    return startHandleMessages(handle, messages, ACTION_ASSERT_EVENT, rulesBinding, replyCount);
 }
 
 unsigned int retractEvent(void *handle, char *message) {
@@ -1627,18 +1603,14 @@ unsigned int assertFact(void *handle, char *message) {
 
 unsigned int startAssertFacts(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                              void **rulesBinding, 
                              unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_ASSERT_FACT, resultsLength, results, rulesBinding, replyCount);
+    return startHandleMessages(handle, messages, ACTION_ASSERT_FACT, rulesBinding, replyCount);
 }
 
 unsigned int assertFacts(void *handle, 
-                          char *messages, 
-                          unsigned int *resultsLength, 
-                          unsigned int **results) {
-    return executeHandleMessages(handle, messages, ACTION_ASSERT_FACT, resultsLength, results);
+                          char *messages) {
+    return executeHandleMessages(handle, messages, ACTION_ASSERT_FACT);
 }
 
 unsigned int retractFact(void *handle, char *message) {
@@ -1653,19 +1625,15 @@ unsigned int startRetractFact(void *handle,
 }
 
 unsigned int retractFacts(void *handle, 
-                          char *messages, 
-                          unsigned int *resultsLength, 
-                          unsigned int **results) {
-    return executeHandleMessages(handle, messages, ACTION_REMOVE_FACT, resultsLength, results);
+                          char *messages) {
+    return executeHandleMessages(handle, messages, ACTION_REMOVE_FACT);
 }
 
 unsigned int startRetractFacts(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                               void **rulesBinding, 
                               unsigned int *replyCount) {
-    return startHandleMessages(handle, messages, ACTION_REMOVE_FACT, resultsLength, results, rulesBinding, replyCount);
+    return startHandleMessages(handle, messages, ACTION_REMOVE_FACT, rulesBinding, replyCount);
 }
 
 unsigned int assertState(void *handle, char *state) {
@@ -1703,7 +1671,12 @@ unsigned int assertTimers(void *handle) {
         return result;
     }
 
-    return executeBatch(rulesBinding, commands, commandCount);
+    result = executeBatch(rulesBinding, commands, commandCount);
+    if (result != RULES_OK && result != ERR_EVENT_OBSERVED) {
+        return result;
+    }
+
+    return RULES_OK;
 }
 
 unsigned int startAction(void *handle, 
@@ -1786,14 +1759,14 @@ unsigned int completeAction(void *handle,
     }
 
     result = executeBatch(rulesBinding, commands, commandCount); 
-    if (result != RULES_OK) {
+    if (result != RULES_OK && result != ERR_EVENT_OBSERVED) {
         //reply object should be freed by the app during abandonAction
         return result;
     }
 
     freeReplyObject(reply);
     free(actionHandle);
-    return result;
+    return RULES_OK;
 }
 
 unsigned int completeAndStartAction(void *handle, 
@@ -1837,7 +1810,7 @@ unsigned int completeAndStartAction(void *handle,
                                    commands, 
                                    commandCount, 
                                    &newReply);  
-    if (result != RULES_OK) {
+    if (result != RULES_OK && result != ERR_EVENT_OBSERVED) {
         //reply object should be freed by the app during abandonAction
         return result;
     }

data/src/rules/net.c

@@ -667,11 +667,11 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "if redis.call(\"hsetnx\", visited_hashset, message[\"id\"], 1) == 0 then\n"
 "    if assert_fact == 0 then\n"
 "        if not redis.call(\"hget\", events_hashset, mid) then\n"
-"            return false\n"
+"            return %d\n"
 "        end\n"
 "    else\n"
 "        if not redis.call(\"hget\", facts_hashset, mid) then\n"
-"            return false\n"
+"            return %d\n"
 "        end\n"
 "    end\n"
 "end\n"
@@ -692,7 +692,9 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "end\n",
                 name,
                 name,
-                name, 
+                name,
+                ERR_EVENT_OBSERVED,
+                ERR_EVENT_OBSERVED,
                 addMessageLua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -1988,11 +1990,11 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "if redis.call(\"hsetnx\", visited_hashset, mid, 1) == 0 then\n"
 "    if assert_fact == 0 then\n"
 "        if message and redis.call(\"hexists\", events_hashset, mid) == 0 then\n"
-"            return false\n"
+"            return %d\n"
 "        end\n"
 "    else\n"
 "        if message and redis.call(\"hexists\", facts_hashset, mid) == 0 then\n"
-"            return false\n"
+"            return %d\n"
 "        end\n"
 "    end\n"
 "end\n"
@@ -2025,13 +2027,14 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "    if not redis.call(\"zscore\", actions_key, sid) then\n"
 "        redis.call(\"zadd\", actions_key , score, sid)\n"
 "    end\n"
-"end\n"
-"return nil\n",
+"end\n",
                  name,
                  name,
                  name,
                  name,
                  name,
+                 ERR_EVENT_OBSERVED,
+                 ERR_EVENT_OBSERVED,
                  lua)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -2662,6 +2665,10 @@ unsigned int completeNonBlockingBatch(void *rulesBinding,
             if (reply->type == REDIS_REPLY_ERROR) {
                 printf("complete non blocking batch error %d %s\n", i, reply->str);
                 result = ERR_REDIS_ERROR;
+            } else if (reply->type == REDIS_REPLY_INTEGER) {
+                if (reply->integer == ERR_EVENT_OBSERVED && result == RULES_OK) {
+                    result = ERR_EVENT_OBSERVED;
+                }
             }
 
             freeReplyObject(reply);    
@@ -2725,6 +2732,12 @@ unsigned int executeBatchWithReply(void *rulesBinding,
 
                     *lastReply = reply;
                 }
+            } else if (reply->type == REDIS_REPLY_INTEGER) {
+                if (reply->integer == ERR_EVENT_OBSERVED && result == RULES_OK) {
+                    result = ERR_EVENT_OBSERVED;
+                }
+
+                freeReplyObject(reply);
             } else {
                 freeReplyObject(reply);    
             }

data/src/rules/rules.h

@@ -26,6 +26,7 @@
 #define ERR_MAX_COMMAND_COUNT 209
 #define ERR_MAX_ADD_COUNT 210
 #define ERR_MAX_EVAL_COUNT 211
+#define ERR_EVENT_OBSERVED 212
 #define ERR_CONNECT_REDIS 301
 #define ERR_REDIS_ERROR 302
 #define ERR_NO_ACTION_AVAILABLE 303
@@ -81,14 +82,10 @@ unsigned int startAssertEvent(void *handle,
                              unsigned int *replyCount);
 
 unsigned int assertEvents(void *handle, 
-                          char *messages, 
-                          unsigned int *resultsLength, 
-                          unsigned int **results);
+                          char *messages);
 
 unsigned int startAssertEvents(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 
@@ -105,15 +102,11 @@ unsigned int assertFact(void *handle,
 
 unsigned int startAssertFacts(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 
 unsigned int assertFacts(void *handle, 
-                         char *messages, 
-                         unsigned int *resultsLength, 
-                         unsigned int **results);
+                         char *messages);
 
 unsigned int retractFact(void *handle, 
                          char *message);
@@ -124,14 +117,10 @@ unsigned int startRetractFact(void *handle,
                              unsigned int *replyCount);
 
 unsigned int retractFacts(void *handle, 
-                          char *messages, 
-                          unsigned int *resultsLength, 
-                          unsigned int **results);
+                          char *messages);
 
 unsigned int startRetractFacts(void *handle, 
                               char *messages, 
-                              unsigned int *resultsLength, 
-                              unsigned int **results, 
                               void **rulesBinding, 
                               unsigned int *replyCount);
 

data/src/rulesrb/rules.c

@@ -115,16 +115,11 @@ static VALUE rbStartAssertEvent(VALUE self, VALUE handle, VALUE event) {
     unsigned int replyCount;
     void *rulesBinding = NULL;
     unsigned int result = startAssertEvent((void *)FIX2LONG(handle), RSTRING_PTR(event), &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -141,10 +136,8 @@ static VALUE rbAssertEvent(VALUE self, VALUE handle, VALUE event) {
     Check_Type(event, T_STRING);
 
     unsigned int result = assertEvent((void *)FIX2LONG(handle), RSTRING_PTR(event));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        return INT2FIX(0);    
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+        return INT2FIX(result);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -178,31 +171,18 @@ static VALUE rbStartAssertEvents(VALUE self, VALUE handle, VALUE events) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(events, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events), &resultsLength, &results, &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
+    unsigned int result = startAssertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events), &rulesBinding, &replyCount);
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not assert events, error code: %d", result);
         }
     }
@@ -214,21 +194,11 @@ static VALUE rbAssertEvents(VALUE self, VALUE handle, VALUE events) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(events, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
-    unsigned int result = assertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events), &resultsLength, &results);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
-        return INT2FIX(resultsLength);   
-    } else {
+    unsigned int result = assertEvents((void *)FIX2LONG(handle), RSTRING_PTR(events));
+    if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not assert events, error code: %d", result);
         }
     }
@@ -241,10 +211,8 @@ static VALUE rbRetractEvent(VALUE self, VALUE handle, VALUE event) {
     Check_Type(event, T_STRING);
 
     unsigned int result = retractEvent((void *)FIX2LONG(handle), RSTRING_PTR(event));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        return INT2FIX(0);    
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+        return INT2FIX(result);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -263,16 +231,11 @@ static VALUE rbStartAssertFact(VALUE self, VALUE handle, VALUE fact) {
     unsigned int replyCount;
     void *rulesBinding = NULL;
     unsigned int result = startAssertFact((void *)FIX2LONG(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -289,10 +252,8 @@ static VALUE rbAssertFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(fact, T_STRING);
 
     unsigned int result = assertFact((void *)FIX2LONG(handle), RSTRING_PTR(fact));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        return INT2FIX(0);    
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+        return INT2FIX(result);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -326,31 +287,18 @@ static VALUE rbStartAssertFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startAssertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &resultsLength, &results, &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
+    unsigned int result = startAssertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not assert facts, error code: %d", result);
         }
     }
@@ -362,21 +310,11 @@ static VALUE rbAssertFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
-    unsigned int result = assertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &resultsLength, &results);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
-        return INT2FIX(resultsLength);   
-    } else {
+    unsigned int result = assertFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts));
+    if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not assert facts, error code: %d", result);
         }
     }
@@ -391,16 +329,11 @@ static VALUE rbStartRetractFact(VALUE self, VALUE handle, VALUE fact) {
     unsigned int replyCount;
     void *rulesBinding = NULL;
     unsigned int result = startRetractFact((void *)FIX2LONG(handle), RSTRING_PTR(fact), &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -417,10 +350,8 @@ static VALUE rbRetractFact(VALUE self, VALUE handle, VALUE fact) {
     Check_Type(fact, T_STRING);
 
     unsigned int result = retractFact((void *)FIX2LONG(handle), RSTRING_PTR(fact));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        return INT2FIX(0);    
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+        return INT2FIX(result);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -454,31 +385,18 @@ static VALUE rbStartRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
     unsigned int replyCount;
     void *rulesBinding = NULL;
-    unsigned int result = startRetractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &resultsLength, &results, &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
+    unsigned int result = startRetractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &rulesBinding, &replyCount);
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output; 
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not retract facts, error code: %d", result);
         }
     }
@@ -490,21 +408,11 @@ static VALUE rbRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
 
-    unsigned int *results = NULL;
-    unsigned int resultsLength = 0;
-    unsigned int result = retractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts), &resultsLength, &results);
-    if (result == RULES_OK) {
-        if (results) {
-            free(results);
-        }
-        return INT2FIX(resultsLength);   
-    } else {
+    unsigned int result = retractFacts((void *)FIX2LONG(handle), RSTRING_PTR(facts));
+    if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            if (results) {
-                free(results);
-            }
             rb_raise(rb_eException, "Could not retract facts, error code: %d", result);
         }
     }
@@ -517,10 +425,8 @@ static VALUE rbAssertState(VALUE self, VALUE handle, VALUE state) {
     Check_Type(state, T_STRING);
 
     unsigned int result = assertState((void *)FIX2LONG(handle), RSTRING_PTR(state));
-    if (result == RULES_OK) {
-        return INT2FIX(1);    
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        return INT2FIX(0);    
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+        return INT2FIX(result);    
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -540,16 +446,11 @@ static VALUE rbStartUpdateState(VALUE self, VALUE handle, VALUE actionHandle, VA
     unsigned int replyCount;
     void *rulesBinding = NULL;
     unsigned int result = startUpdateState((void *)FIX2LONG(handle), (void *)FIX2LONG(actionHandle), RSTRING_PTR(state), &rulesBinding, &replyCount);
-    if (result == RULES_OK) {
+    if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
         VALUE output = rb_ary_new(); 
         rb_ary_push(output, INT2FIX(rulesBinding));
         rb_ary_push(output, INT2FIX(replyCount));
         return output;  
-    } else if (result == ERR_EVENT_NOT_HANDLED) {
-        VALUE output = rb_ary_new(); 
-        rb_ary_push(output, INT2FIX(0));
-        rb_ary_push(output, INT2FIX(0));
-        return output;   
     } else {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.05
+  version: 0.34.06
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake