implica 1.2.1__tar.gz → 1.2.2__tar.gz

{implica-1.2.1 → implica-1.2.2}/Cargo.lock

@@ -254,7 +254,7 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "implica"
-version = "1.2.1"
+version = "1.2.2"
 dependencies = [
  "dashmap",
  "error-stack",

{implica-1.2.1 → implica-1.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "implica"
-version = "1.2.1"
+version = "1.2.2"
 edition = "2021"
 readme = "README.md"
 

{implica-1.2.1 → implica-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: implica
-Version: 1.2.1
+Version: 1.2.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{implica-1.2.1 → implica-1.2.2}/src/graph/base.rs

@@ -122,33 +122,84 @@ impl Graph {
         term: Option<Term>,
         properties: PropertyMap,
     ) -> ImplicaResult<Uid> {
+        let mut expand = false;
         let type_uid = self.insert_type(&r#type);
 
         if let Some(term) = term {
-            let term_uid = self.insert_term(&term);
+            if !self.term_index.contains_key(&type_uid) {
+                // TODO: term comparison?
+                let term_uid = self.insert_term(&term);
 
-            if type_uid != term_uid {
-                return Err(ImplicaError::InvalidTerm {
-                    reason: "term provided is of a different type than the type provided"
-                        .to_string(),
+                if type_uid != term_uid {
+                    return Err(ImplicaError::InvalidTerm {
+                        reason: "term provided is of a different type than the type provided"
+                            .to_string(),
+                    }
+                    .into());
                 }
-                .into());
+
+                if let Some(arr) = term.r#type().as_arrow() {
+                    let left_type = self.insert_type(&arr.left);
+                    let right_type = self.insert_type(&arr.right);
+
+                    if !self.nodes.contains_key(&left_type) {
+                        let term = self.infer_term(&left_type)?;
+                        self.add_node(arr.left.as_ref().clone(), term, PropertyMap::default())?;
+                    }
+
+                    if !self.nodes.contains_key(&right_type) {
+                        let term = self.infer_term(&right_type)?;
+                        self.add_node(arr.right.as_ref().clone(), term, PropertyMap::default())?;
+                    }
+
+                    self.add_edge(term, PropertyMap::default())?;
+                }
+
+                expand = true;
             }
         }
 
-        if self.nodes.contains_key(&type_uid) {
-            return Err(ImplicaError::NodeAlreadyExists {
-                uid: type_uid,
-                context: Some(ctx!("graph - add node")),
-            }
-            .into());
+        if !self.nodes.contains_key(&type_uid) {
+            self.nodes.insert(type_uid, properties);
+            self.start_to_edge_index
+                .insert(type_uid, Arc::new(DashSet::new()));
+            self.end_to_edge_index
+                .insert(type_uid, Arc::new(DashSet::new()));
         }
 
-        self.nodes.insert(type_uid, properties);
-        self.start_to_edge_index
-            .insert(type_uid, Arc::new(DashSet::new()));
-        self.end_to_edge_index
-            .insert(type_uid, Arc::new(DashSet::new()));
+        if expand {
+            if let Some(entry) = self.start_to_edge_index.get(&type_uid) {
+                let right_edges = entry.value().clone();
+
+                right_edges.par_iter().try_for_each(|row| -> ImplicaResult<()> {
+                    let edge = *row.key();
+
+                    if !self.term_index.contains_key(&edge.1) {
+                        let original_term = self.term_from_uid(&type_uid).attach(ctx!("graph - add node"))?;
+                        let edge_term = {
+                            let edge_type = match self.edge_to_type_index.get(&edge) {
+                                Some(t) => *t,
+                                None => return Err(ImplicaError::IndexCorruption { message: "edge exists in EdgeIndex without appearing in EdgeToTypeIndex".to_string(), context: Some("graph - add node".to_string()) }.into())
+                            };
+
+                            self.term_from_uid(&edge_type).attach(ctx!("graph - add node"))
+                        }?;
+
+                        let new_term = edge_term.apply(&original_term).attach(ctx!("graph - add node"))?;
+
+                        self.add_node(new_term.r#type().as_ref().clone(), Some(new_term), PropertyMap::default()).attach(ctx!("graph - add node"))?;
+                    }
+
+                    Ok(())
+                })?;
+            } else {
+                return Err(ImplicaError::IndexCorruption {
+                    message: "node exists without row in the StartToEdgeIndex".to_string(),
+                    context: Some("graph - add node".to_string()),
+                }
+                .into());
+            }
+        }
 
         Ok(type_uid)
     }

{implica-1.2.1 → implica-1.2.2}/src/graph/create.rs

@@ -278,7 +278,7 @@ impl Graph {
 
                         if let Some(r#type) = node_data.r#type.as_ref().or(type_update.as_ref()) {
 
-                            let type_uid = self.insert_type(r#type);                                
+                            let type_uid = self.insert_type(r#type);
 
                             term_update = match self
                             .infer_term(&type_uid){
@@ -797,10 +797,8 @@ impl Graph {
 
                         prev_uid = match self.add_node(nd.r#type.unwrap(), nd.term, nd.properties) {
                             Ok(uid) => uid,
-                            Err(e) => {match e.current_context() {
-                                ImplicaError::NodeAlreadyExists { uid, context: _ } => *uid,
-                                _ => return ControlFlow::Break(e.attach(ctx!("graph - create path")))
-                            }}
+                            Err(e) => return ControlFlow::Break(e.attach(ctx!("graph - create path")))
+
                         };
 
                         match new_match.insert(node_var, MatchElement::Node(prev_uid)) {
@@ -812,10 +810,7 @@ impl Graph {
                     match self.add_node(nd.r#type.unwrap(), nd.term, nd.properties) {
                         Ok(_) => (),
                         Err(e) => {
-                            match e.current_context() {
-                                ImplicaError::NodeAlreadyExists { .. } => (),
-                                _ => return ControlFlow::Break(e.attach(ctx!("graph - create path")))
-                            }
+                            return ControlFlow::Break(e.attach(ctx!("graph - create path")))
                         }
                     }
                 }

{implica-1.2.1 → implica-1.2.2}/tests/test_create.py

@@ -84,9 +84,9 @@ class TestCreateNodeQuery:
 
         graph.query().create("(::@f(C, D))").execute()
         nodes = graph.nodes()
-        assert len(nodes) == 1
-        assert isinstance(nodes[0], implica.Node)
-        assert str(nodes[0]) == "Node((C -> D):f {})"
+        assert len(nodes) == 3
+        assert all([isinstance(n, implica.Node) for n in nodes])
+        assert {str(n) for n in nodes} == {"Node((C -> D):f {})", "Node(C: {})", "Node(D: {})"}
 
     def test_create_more_than_one_node_in_different_queries(self):
         graph = implica.Graph()