Compute Editmap with APTED

Author: cedricrupb

code_diff/gumtree/__init__.py

@@ -1,8 +1,15 @@
-from .isomap import gumtree_isomap
+from .isomap  import gumtree_isomap
+from .editmap import gumtree_editmap
 
 # Edit script ----------------------------------------------------------------
 
 def compute_edit_script(source_ast, target_ast):
 
     isomap = gumtree_isomap(source_ast, target_ast)
-    print(isomap)
+    print(isomap)
+    print("----------------------------------------------------------------")
+
+    editmap = gumtree_editmap(isomap, source_ast, target_ast)
+
+    print(editmap)
+    

code_diff/gumtree/editmap.py

@@ -0,0 +1,109 @@
+from apted import APTED, Config
+
+from .utils import subtree_dice, postorder_traversal
+
+# Minimal edit mapping to make source isomorph to target --------------------------------
+
+# We compute a mapping between source and target tree
+# If a source node is mapped to a target node with different label,
+#  the source node has to be updated with the target label
+# If a source node is unmapped,
+#  the source node has to be deleted
+# If a target node is unmapped,
+#   the target node has to be added to the source tree
+#
+# Edits are chosen to be (approximately) minimal
+
+
+# APTED for computing a minimal edit --------------------------------
+
+class APTEDConfig(Config):
+
+    def rename(self, node1, node2):
+        
+        if node1.type == node2.type:
+            return 1 if node1.text != node2.text else 0
+
+        return 1
+    
+    def children(self, node):
+        return node.children
+
+
+def _minimal_edit(isomap, source, target, max_size = 1000):
+    if source.subtree_weight > max_size or target.subtree_weight > max_size: return
+
+    apted = APTED(source, target, APTEDConfig())
+    mapping = apted.compute_edit_mapping()
+
+    for source_node, target_node in mapping:
+        if source_node is None: continue
+        if target_node is None: continue
+        if source_node.type != target_node.type: continue
+
+        if (source_node, None) in isomap: continue
+        if (None, target_node) in isomap: continue
+
+        yield source_node, target_node
+
+
+# Select node heuristically that is close to isomorph --------------------
+
+def _select_near_candidate(source_node, mapping):
+
+    dst_seeds = []
+
+    for src in source_node.descandents():
+        for _, dst in mapping[src, None]:
+            dst_seeds.append(dst)
+
+    candidates = []
+    seen = set()
+
+    for dst in dst_seeds:
+        while dst.parent is not None:
+            parent = dst.parent
+            if parent in seen: break
+            seen.add(parent)
+
+            if (parent.type == source_node.type
+                    and parent.parent is not None
+                    and (None, parent) not in mapping):
+                candidates.append(parent)
+            dst = parent
+
+    if len(candidates) == 0: return None, 0.0
+
+    candidates = [(x, subtree_dice(source_node, x, mapping)) for x in candidates]
+
+    return max(candidates, key=lambda x: x[1])
+
+
+# Gumtree Edit Mapping ---------------------------------------------------
+
+def gumtree_editmap(isomap, source, target, max_size = 1000, min_dice = 0.5):
+    # Caution: This method does change the isomap
+    if len(isomap) == 0: return isomap
+
+    for source_node in postorder_traversal(source):
+
+        if source_node == source: # source_node is root
+            isomap.add(source_node, target)
+
+            for s, t in _minimal_edit(isomap, source_node, target, max_size):
+                isomap.add(s, t)
+
+            break
+
+        if len(source_node.children) == 0: continue # source_node is leaf
+        if (source_node, None) in isomap: continue  # source_node is now mapped
+
+        target_node, dice = _select_near_candidate(source_node, isomap)
+
+        if target_node is None or dice <= min_dice: continue 
+        
+        for s, t in _minimal_edit(isomap, source_node, target_node, max_size):
+            isomap.add(s, t)
+        isomap.add(source_node, target_node)
+
+    return isomap

code_diff/gumtree/isomap.py

@@ -4,6 +4,8 @@
 
 from collections import defaultdict
 
+from .utils import NodeMapping, subtree_dice
+
 # API method ----------------------------------------------------------------
 
 def gumtree_isomap(source_ast, target_ast, min_height = 1):
@@ -65,74 +67,6 @@ def gumtree_isomap(source_ast, target_ast, min_height = 1):
 
 # Collections ----------------------------------------------------------------
 
-class NodeMapping:
-
-    def __init__(self):
-        self._src_to_dst = defaultdict(set)
-        self._dst_to_src = defaultdict(set)
-        self._length = 0
-
-    def __getitem__(self, key):
-        if not isinstance(key, tuple): key = (key, None)
-
-        src_key, dst_key = key
-
-        if src_key is not None and dst_key is not None:
-            return dst_key in self._src_to_dst[src_key]
-
-        if src_key is None and dst_key is None:
-            return self.__iter__()
-
-        if src_key is None:
-            return ((src, dst_key) for src in self._dst_to_src[dst_key])
-        
-        if dst_key is None:
-            return ((src_key, dst) for dst in self._src_to_dst[src_key])
-    
-    def __iter__(self):
-
-        def _iter_maps():
-            for k, V in self._src_to_dst.items():
-                for v in V: yield (k, v)
-
-        return _iter_maps()
-
-    def __contains__(self, key):
-        if not isinstance(key, tuple): key = (key, None)
-
-        src_key, dst_key = key
-
-        if src_key is not None and dst_key is not None:
-            return self[src_key, dst_key]
-
-        return next(self[src_key, dst_key], None) is not None
-
-    def __len__(self):
-        return self._length
-
-    def add(self, src, dst):
-        if not self[src, dst]:
-            self._src_to_dst[src].add(dst)
-            self._dst_to_src[dst].add(src)
-            self._length += 1
-
-    def __copy__(self):
-        output = NodeMapping()
-
-        for a, b in self:
-            output.add(a, b)
-        
-        return output
-
-    def __str__(self):
-        approx_str = []
-
-        for src, dst in self:
-            approx_str.append("%s ≈ %s" % (str(src), str(dst)))
-        
-        return "\n".join(approx_str)
-
-
 class NodeCounter:
 
     def __init__(self):
@@ -202,31 +136,11 @@ def _map_recursively(mapping, source_node, target_node):
 
 # Heuristic selection ----------------------------------------------------------------
 
-def _subtree_dice(A, B, mapping):
-
-    if A is None or B is None:
-        return 1.0 if all(x is None for x in [A, B]) else 0.0
-
-    DA, DB = set(A.descandents()), set(B.descandents())
-
-    norm = len(DA) + len(DB)
-
-    if norm == 0: return 1.0
-
-    mapped = defaultdict(set)
-    for a, b in mapping: mapped[a].add(b)
-
-    mapped_children = set(m for t1 in DA if t1 in mapped for m in mapped[t1])
-    dice_score = len(set.intersection(mapped_children, DB))
-
-    return 2 * dice_score / norm
-
 
 def create_default_heuristic(isomorphic_mapping):
 
     def _heuristic(source_node, target_node):
-        dice = _subtree_dice(source_node, target_node, isomorphic_mapping)
-        return dice
+        return subtree_dice(source_node, target_node, isomorphic_mapping)
 
     return _heuristic
 

code_diff/gumtree/utils.py

@@ -0,0 +1,133 @@
+from collections import defaultdict
+
+# Collections -------------------------------------------------------------------
+
+class NodeMapping:
+
+    def __init__(self):
+        self._src_to_dst = defaultdict(set)
+        self._dst_to_src = defaultdict(set)
+        self._length = 0
+
+    def __getitem__(self, key):
+        if not isinstance(key, tuple): key = (key, None)
+
+        src_key, dst_key = key
+
+        if src_key is not None and dst_key is not None:
+            return dst_key in self._src_to_dst[src_key]
+
+        if src_key is None and dst_key is None:
+            return self.__iter__()
+
+        if src_key is None:
+            return ((src, dst_key) for src in self._dst_to_src[dst_key])
+        
+        if dst_key is None:
+            return ((src_key, dst) for dst in self._src_to_dst[src_key])
+    
+    def __iter__(self):
+
+        def _iter_maps():
+            for k, V in self._src_to_dst.items():
+                for v in V: yield (k, v)
+
+        return _iter_maps()
+
+    def __contains__(self, key):
+        if not isinstance(key, tuple): key = (key, None)
+
+        src_key, dst_key = key
+
+        if src_key is not None and dst_key is not None:
+            return self[src_key, dst_key]
+
+        return next(self[src_key, dst_key], None) is not None
+
+    def __len__(self):
+        return self._length
+
+    def add(self, src, dst):
+        if not self[src, dst]:
+            self._src_to_dst[src].add(dst)
+            self._dst_to_src[dst].add(src)
+            self._length += 1
+
+    def __copy__(self):
+        output = NodeMapping()
+
+        for a, b in self:
+            output.add(a, b)
+        
+        return output
+
+    def __str__(self):
+        approx_str = []
+
+        for src, dst in self:
+            approx_str.append("%s ≈ %s" % (str(src), str(dst)))
+        
+        return "\n".join(approx_str)
+
+
+# Tree heuristic ----------------------------------------------------------------
+
+def subtree_dice(A, B, mapping):
+
+    if A is None or B is None:
+        return 1.0 if all(x is None for x in [A, B]) else 0.0
+
+    DA, DB = set(A.descandents()), set(B.descandents())
+
+    norm = len(DA) + len(DB)
+
+    if norm == 0: return 1.0
+
+    mapped = defaultdict(set)
+    for a, b in mapping: mapped[a].add(b)
+
+    mapped_children = set(m for t1 in DA if t1 in mapped for m in mapped[t1])
+    dice_score = len(set.intersection(mapped_children, DB))
+
+    return 2 * dice_score / norm
+
+
+# Tree traversal ----------------------------------------------------------------
+
+def bfs_traversal(tree):
+    queue = [tree]
+
+    while len(queue) > 0: 
+        node = queue.pop(0)
+
+        yield node
+
+        for c in node.children: 
+            queue.append(c)   
+
+
+def dfs_traversal(tree):
+    stack = [tree]
+
+    while len(stack) > 0: 
+        node = stack.pop(-1)
+
+        yield node
+
+        for c in node.children: 
+            stack.append(c)   
+
+
+def postorder_traversal(tree):
+    
+    stack = [(tree, 0)]
+
+    while len(stack) > 0:
+        node, ix = stack.pop(-1)
+
+        if ix >= len(node.children):
+            yield node
+        else:
+            stack.append((node, ix + 1))
+            stack.append((node.children[ix], 0))
+