Implement LogicManager and Explanation

src/answer/concept_map.rs

@@ -73,14 +73,6 @@ pub struct Explainables {
 }
 
 impl Explainables {
-    pub(crate) fn new(
-        relations: HashMap<String, Explainable>,
-        attributes: HashMap<String, Explainable>,
-        ownerships: HashMap<(String, String), Explainable>,
-    ) -> Self {
-        Self { relations, attributes, ownerships }
-    }
-
     pub fn is_empty(&self) -> bool {
         self.relations.is_empty() && self.attributes.is_empty() && self.ownerships.is_empty()
     }

src/connection/network/proto/concept.rs

@@ -100,11 +100,9 @@ impl TryFromProto<ConceptMapGroupProto> for ConceptMapGroup {
 impl TryFromProto<ConceptMapProto> for ConceptMap {
     fn try_from_proto(proto: ConceptMapProto) -> Result<Self> {
         let ConceptMapProto { map: map_proto, explainables: explainables_proto } = proto;
-        let mut map = HashMap::with_capacity(map_proto.len());
-        for (k, v) in map_proto {
-            map.insert(k, Concept::try_from_proto(v)?);
-        }
-        let Some(explainables) = explainables_proto else { return Err(ConnectionError::MissingResponseField("explainables").into()) };
+        let map = map_proto.into_iter().map(|(k, v)| Concept::try_from_proto(v).map(|v| (k, v))).try_collect()?;
+        let explainables = explainables_proto
+            .ok_or::<ConnectionError>(ConnectionError::MissingResponseField("explainables").into())?;
         Ok(Self { map, explainables: Explainables::from_proto(explainables) })
     }
 }
@@ -379,22 +377,16 @@ impl FromProto<ExplainablesProto> for Explainables {
             attributes: attributes_proto,
             ownerships: ownerships_proto,
         } = proto;
-        let mut relations = HashMap::with_capacity(relations_proto.len());
-        for (k, v) in relations_proto {
-            relations.insert(k, Explainable::from_proto(v));
-        }
-        let mut attributes = HashMap::with_capacity(attributes_proto.len());
-        for (k, v) in attributes_proto {
-            attributes.insert(k, Explainable::from_proto(v));
-        }
+        let relations = relations_proto.into_iter().map(|(k, v)| (k, Explainable::from_proto(v))).collect();
+        let attributes = attributes_proto.into_iter().map(|(k, v)| (k, Explainable::from_proto(v))).collect();
         let mut ownerships = HashMap::new();
         for (k1, owned) in ownerships_proto {
             for (k2, v) in owned.owned {
                 ownerships.insert((k1.clone(), k2), Explainable::from_proto(v));
             }
         }
 
-        Self::new(relations, attributes, ownerships)
+        Self { relations, attributes, ownerships }
     }
 }
 
@@ -410,7 +402,7 @@ impl TryFromProto<ExplanationProto> for Explanation {
         let ExplanationProto { rule, conclusion, condition, var_mapping } = proto;
         let mut variable_mapping = HashMap::with_capacity(var_mapping.len());
         for (k, v) in var_mapping {
-            variable_mapping.insert(k, v.vars.clone());
+            variable_mapping.insert(k, v.vars);
         }
 
         Ok(Self {

src/connection/network/proto/logic.rs

@@ -31,10 +31,9 @@ use crate::{common::Result, error::ConnectionError, logic::Rule};
 impl TryFromProto<RuleProto> for Rule {
     fn try_from_proto(proto: RuleProto) -> Result<Self> {
         let RuleProto { label: label_proto, when: when_proto, then: then_proto } = proto;
-        let when = match parse_pattern(&when_proto) {
-            Ok(Pattern::Conjunction(conjunction)) => conjunction,
-            Ok(_) => return Err(ConnectionError::InvalidResponseField("when").into()),
-            Err(error) => return Err(error.into()),
+        let when = match parse_pattern(&when_proto)? {
+            Pattern::Conjunction(conjunction) => conjunction,
+            _ => return Err(ConnectionError::InvalidResponseField("when").into()),
         };
         let then = match parse_variable(&then_proto) {
             Ok(Variable::Thing(thing)) => thing,

tests/behaviour/typeql/reasoner/attribute_attachment/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/attribute-attachment.feature").await);
+}

tests/behaviour/typeql/reasoner/compound_queries/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/compound-queries.feature").await);
+}

tests/behaviour/typeql/reasoner/concept_inequality/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/concept-inequality.feature").await);
+}

tests/behaviour/typeql/reasoner/mod.rs

@@ -19,25 +19,14 @@
  * under the License.
  */
 
-use serial_test::serial;
-
-use crate::behaviour::Context;
-
-#[tokio::test]
-#[serial]
-async fn test() {
-    // Bazel specific path: when running the test in bazel, the external data from
-    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
-    // the working directory.
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/attribute-attachment.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/compound-queries.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/concept-inequality.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/negation.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/recursion.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/relation-inference.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/rule-interaction.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/schema-queries.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/type-hierarchy.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/value-predicate.feature").await);
-    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/variable-roles.feature").await);
-}
+mod attribute_attachment;
+mod compound_queries;
+mod concept_inequality;
+mod negation;
+mod recursion;
+mod relation_inference;
+mod rule_interaction;
+mod schema_queries;
+mod type_hierarchy;
+mod value_predicate;
+mod variable_roles;

tests/behaviour/typeql/reasoner/negation/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/negation.feature").await);
+}

tests/behaviour/typeql/reasoner/recursion/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/recursion.feature").await);
+}

tests/behaviour/typeql/reasoner/relation_inference/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/relation-inference.feature").await);
+}

tests/behaviour/typeql/reasoner/rule_interaction/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/rule-interaction.feature").await);
+}

tests/behaviour/typeql/reasoner/schema_queries/mod.rs

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2022 Vaticle
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use serial_test::serial;
+
+use crate::behaviour::Context;
+
+#[tokio::test]
+#[serial]
+async fn test() {
+    // Bazel specific path: when running the test in bazel, the external data from
+    // @vaticle_typedb_behaviour is stored in a directory that is a sibling to
+    // the working directory.
+    assert!(Context::test("../vaticle_typedb_behaviour/typeql/reasoner/schema-queries.feature").await);
+}