Implemented some enhancement request and fixed some bugs

Fixed #2 : Variables are not recognized when inside a rule token
Fixed #15 : Rule: rete attributes are lost when a new ontology is created
Fixed #14 : ReteNetwork: Format rules must not be added to Rete network
Fixed #16 : DefConcept: Variables are not recognized when they are keyword arguments
Fixed #4 : Comparison are not correctly set when comparison property is a concept
Fixed #14 : Parser: merge FunctionParser.NamesNode and ExpressionParser.NamesNode
Fixed #18 : Parser: Add SourceCodeNode test to UnrecognizedNodeParser
Fixed #20 : At startup Number concept is saved in db a numerous number of time
Fixed #21 : CacheManager: I can remove all elements from a ListIfNeededCache and fill it again
Fixed #22 : CacheManager: I can remove all elements from a SetCache and fill it again
Fixed #23 : HistoryManager: history() no longer works
Fixed #24 : HistoryManager: history() no longer works after creating an exec rule
Fixed #25 : SheerkaMemory: Use MemoryObject instead of sheerka.local
Fixed #26 : Debugger: add the list all available services..
Fixed #27 : CONCEPTS_GRAMMARS_ENTRY does not seems to be in use any more
Fixed #28 : Give order to services

tests/cache/test_ListIfNeededCache.py

@@ -418,7 +418,22 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
         assert cache.to_remove == set()
         assert cache.to_add == {"key"}
 
-    def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self):
+    def test_i_can_delete_when_alt_sdp_a_value_from_cache_and_then_put_back(self):
+        # There is a value in alt_cache_manager,
+        # No remaining value in current cache after deletion
+        # The key must be flagged as Removed
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+        cache.put("key", "value")
+
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
+        cache.delete("key", value="value", alt_sdp=alt_sdp)  # remove all values
+        cache.put("key", "value")
+
+        assert cache.copy() == {"key": "value"}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}
+
+    def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_one_value(self):
         # There is a value in alt_cache_manager,
         # But this, there are remaining values in current cache after deletion
         cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
@@ -431,11 +446,26 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
         assert cache.to_remove == set()
         assert cache.to_add == {"key"}
 
+    def test_i_can_delete_when_alt_sdp_a_value_from_cache_remaining_values(self):
+        # There is a value in alt_cache_manager,
+        # But this, there are remaining values in current cache after deletion
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+        cache.put("key", "value")
+        cache.put("key", "value2")
+        cache.put("key", "value3")
+
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
+        cache.delete("key", value="value", alt_sdp=alt_sdp)
+        assert cache.copy() == {"key": ['value2', 'value3']}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}
+
     def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository(self):
         # There is a value in alt_cache_manager,
         # No remaining value in current cache after deletion
         # The key must be flagged as Removed
-        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure("cache_name")
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
+            "cache_name")
 
         alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
         cache.delete("key", value=None, alt_sdp=alt_sdp)
@@ -455,10 +485,23 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
         assert cache.to_remove == set()
         assert cache.to_add == {"key"}
 
-    def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_values(self):
+    def test_i_can_delete_when_alt_sdp_a_key_from_remote_repository_and_then_put_back(self):
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
+            "cache_name")
+
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
+        cache.delete("key", value=None, alt_sdp=alt_sdp)  # remove all values
+        cache.put("key", "value")
+
+        assert cache.copy() == {"key": "value"}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}
+
+    def test_i_can_delete_when_alt_sdp_a_value_from_remote_repository_remaining_one_value(self):
         # There is a value in alt_cache_manager,
         # But this, there are remaining values in current cache after deletion
-        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure("cache_name")
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: ["value1", "value2"])).auto_configure(
+            "cache_name")
 
         alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "xxx", extend_exists=lambda cache_name, key: True)
         cache.delete("key", value="value1", alt_sdp=alt_sdp)
@@ -492,6 +535,21 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
         assert cache.to_add == {"key"}
         assert cache.to_remove == set()
 
+    def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_and_then_put_back(self):
+        # alt_cache_manager is used because no value in cache or in remote repository
+        # After value deletion, the key is empty
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: "value1",
+                          extend_exists=lambda cache_name, key: True)
+
+        cache.delete("key", value="value1", alt_sdp=alt_sdp)
+        cache.put("key", "value")
+
+        assert cache.copy() == {"key": "value"}
+        assert cache.to_add == {"key"}
+        assert cache.to_remove == set()
+
     def test_i_can_delete_when_alt_sdp_a_value_from_alt_sdp_one_value_remaining(self):
         # alt_cache_manager is used because no value in cache or in remote repository
         # After value deletion, one value remains in the cache
@@ -567,3 +625,24 @@ class TestListIfNeededCache(TestUsingMemoryBasedSheerka):
         assert cache.copy() == {}
         assert cache.to_add == set()
         assert cache.to_remove == set()
+
+    def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository(self):
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: Removed)).auto_configure("cache_name")
+        cache.put("key", "value")
+
+        assert cache.copy() == {"key": "value"}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}
+
+    def test_i_can_add_when_alt_sdp_from_a_removed_remote_repository_from_alt_sdp(self):
+        # The key is removed in the sub layers
+        # We can put it back
+        cache = ListIfNeededCache(sdp=FakeSdp(get_value=lambda entry, k: NotFound)).auto_configure("cache_name")
+        alt_sdp = FakeSdp(get_alt_value=lambda cache_name, key: Removed,
+                          extend_exists=lambda cache_name, key: False)
+
+        cache.put("key", "value", alt_sdp=alt_sdp)
+
+        assert cache.copy() == {"key": "value"}
+        assert cache.to_remove == set()
+        assert cache.to_add == {"key"}