feat: cover more cases in merge

bin/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+merge = { path = "../merge" }
 model = { path = "../model" }
 parsing = { path = "../parsing" }
 matching = { path = "../matching" }

bin/src/main.rs

@@ -1,4 +1,6 @@
 use matching::ordered_tree_matching;
+use merge::merge;
+use model::CSTNode;
 
 fn main() {
     let base = parsing::parse_string(
@@ -31,10 +33,31 @@ fn main() {
     )
     .unwrap();
 
-    let result = ordered_tree_matching(&left, &base);
+    let matchings_left_base = ordered_tree_matching(&left, &base);
+    let matchings_right_base = ordered_tree_matching(&right, &base);
+    let matchings_lef_right = ordered_tree_matching(&left, &right);
+    let result = merge(
+        &base,
+        &left,
+        &right,
+        &matchings_left_base,
+        &matchings_right_base,
+        &matchings_lef_right,
+    );
 
-    // result.into_iter().for_each(|(pair, matching)| {
-    //     println!("{:#?}", pair);
-    //     println!("{:?}", matching);
-    // });
+    println!("{:#?}", pretty_print(result))
+}
+
+pub fn pretty_print(node: CSTNode) -> String {
+    match node {
+        CSTNode::Terminal { value, .. } => value,
+        CSTNode::NonTerminal { children, .. } => {
+            children.iter().fold(String::new(), |acc, current| {
+                let mut result = acc.to_owned();
+                result.push_str(" ");
+                result.push_str(&pretty_print(current.clone()));
+                result
+            })
+        }
+    }
 }

matching/src/matching.rs

@@ -4,4 +4,5 @@ use model::CSTNode;
 pub struct Matching<'a> {
     pub matching_node: &'a CSTNode,
     pub score: usize,
+    pub is_perfect_match: bool,
 }

matching/src/matching_entry.rs

@@ -1,10 +1,14 @@
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct MatchingEntry {
     pub score: usize,
+    pub is_perfect_match: bool,
 }
 
 impl MatchingEntry {
-    pub fn with_score(score: usize) -> Self {
-        return MatchingEntry { score };
+    pub fn new(score: usize, is_perfect_match: bool) -> Self {
+        return MatchingEntry {
+            score,
+            is_perfect_match,
+        };
     }
 }

matching/src/matchings.rs

@@ -31,6 +31,7 @@ impl Matchings {
                 Matching {
                     matching_node,
                     score: matching.score,
+                    is_perfect_match: matching.is_perfect_match,
                 }
             })
     }
@@ -64,13 +65,14 @@ mod tests {
         let mut matchings = HashMap::new();
         matchings.insert(
             UnorderedPair(a_node.clone(), a_node.clone()),
-            MatchingEntry::with_score(1),
+            MatchingEntry::new(1, true),
         );
 
         assert_eq!(
             Some(Matching {
                 matching_node: &a_node,
-                score: 1
+                score: 1,
+                is_perfect_match: true
             }),
             Matchings::new(matchings).find_matching_for(&a_node)
         )

matching/src/ordered_tree_matching.rs

@@ -100,9 +100,10 @@ fn ordered_tree_matching_helper(
                 }
             }
 
-            let matching = MatchingEntry {
-                score: matrix_m[m][n] + root_matching,
-            };
+            let matching = MatchingEntry::new(
+                matrix_m[m][n] + root_matching,
+                2 * matrix_m[m][n] / (m + n) == 1,
+            );
             let mut result = HashMap::new();
             result.insert(
                 UnorderedPair::new(left.to_owned(), right.to_owned()),
@@ -126,19 +127,18 @@ fn ordered_tree_matching_helper(
             },
         ) => {
             let mut result = HashMap::new();
+            let is_perfetch_match = kind_left == kind_right && value_left == value_right;
             result.insert(
                 UnorderedPair::new(left.to_owned(), right.to_owned()),
-                MatchingEntry {
-                    score: (kind_left == kind_right && value_left == value_right).into(),
-                },
+                MatchingEntry::new(is_perfetch_match.into(), is_perfetch_match),
             );
             result
         }
         (_, _) => {
             let mut result = HashMap::new();
             result.insert(
                 UnorderedPair::new(left.to_owned(), right.to_owned()),
-                MatchingEntry { score: 0 },
+                MatchingEntry::new(0, false),
             );
             result
         }
@@ -164,7 +164,7 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(1)),
+            Some(&MatchingEntry::new(1, true)),
             matchings.get_matching_entry(left, right)
         )
     }
@@ -183,7 +183,7 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(0)),
+            Some(&MatchingEntry::new(0, false)),
             matchings.get_matching_entry(left, right)
         )
     }
@@ -202,7 +202,7 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(0)),
+            Some(&MatchingEntry::new(0, false)),
             matchings.get_matching_entry(left, right)
         )
     }
@@ -221,7 +221,7 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(0)),
+            Some(&MatchingEntry::new(0, false)),
             matchings.get_matching_entry(left, right)
         )
     }
@@ -244,7 +244,7 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(1)),
+            Some(&MatchingEntry::new(1, true)),
             matchings.get_matching_entry(child.clone(), child)
         )
     }
@@ -297,7 +297,31 @@ mod tests {
         let matchings = ordered_tree_matching(&left, &right);
 
         assert_eq!(
-            Some(&MatchingEntry::with_score(2)),
+            Some(&MatchingEntry::new(2, false)),
+            matchings.get_matching_entry(left, right)
+        )
+    }
+
+    #[test]
+    fn perfect_matching_deep_nodes() {
+        let common_child = CSTNode::Terminal {
+            kind: "kind_b".into(),
+            value: "value_b".into(),
+        };
+
+        let left = CSTNode::NonTerminal {
+            kind: "kind_a".to_owned(),
+            children: vec![common_child.clone()],
+        };
+        let right = CSTNode::NonTerminal {
+            kind: "kind_a".to_owned(),
+            children: vec![common_child.clone()],
+        };
+
+        let matchings = ordered_tree_matching(&left, &right);
+
+        assert_eq!(
+            Some(&MatchingEntry::new(2, true)),
             matchings.get_matching_entry(left, right)
         )
     }