Prepare for SSTub computation

Author: cedricrupb

code_diff/__init__.py

@@ -1,17 +1,23 @@
-from .ast import parse_ast
+from code_tokenize.config import load_from_lang_config
+from code_tokenize.tokens import match_type
+
+from .ast    import parse_ast
+from .utils  import cached_property
+from .sstubs import SStubPattern, classify_sstub
 
 
 # Main method --------------------------------------------------------
 
 def difference(source, target, lang = "guess", **kwargs):
 
+    config     = load_from_lang_config(lang, **kwargs)
     source_ast = parse_ast(source, lang = lang, **kwargs)
     target_ast = parse_ast(target, lang = lang, **kwargs)
 
     # Concretize Diff
     source_ast, target_ast = diff_search(source_ast, target_ast)
 
-    return ASTDiff(source_ast, target_ast)
+    return ASTDiff(config, source_ast, target_ast)
 
 
 # Diff Search --------------------------------------------------------
@@ -40,12 +46,92 @@ def diff_search(source_ast, target_ast):
             return (source_node, target_node)
 
 
-
-
 # AST Difference --------------------------------------------------------
 
 class ASTDiff:
 
-    def __init__(self, source_ast, target_ast):
+    def __init__(self, config, source_ast, target_ast):
+        self.config     = config
         self.source_ast = source_ast
-        self.target_ast = target_ast
+        self.target_ast = target_ast
+
+    @cached_property
+    def is_single_statement(self):
+        return (is_single_statement(self.config.statement_types, self.source_ast)
+                    and is_single_statement(self.config.statement_types, self.target_ast))
+
+    @cached_property
+    def source_text(self):
+        return tokenize_tree(self.source_ast)
+
+    @cached_property
+    def target_text(self):
+        return tokenize_tree(self.target_ast)
+
+    def statement_diff(self):
+        source_stmt = parent_statement(self.config.statement_types, self.source_ast)
+        target_stmt = parent_statement(self.config.statement_types, self.target_ast)
+
+        if source_stmt is None or target_stmt is None: 
+            raise ValueError("AST diff is not enclosed in a statement")
+        
+        return ASTDiff(self.config, source_stmt, target_stmt)
+
+    def sstub_pattern(self):
+        if not self.is_single_statement:
+            return SStubPattern.MULTI_STMT
+        
+        return classify_sstub(*diff_search(self.source_ast, self.target_ast))
+
+    def edit_script(self):
+        pass
+
+    def __repr__(self):
+        return "%s -> %s" % (self.source_text, self.target_text)
+
+    
+
+
+# AST Utils -----------------------------------------------------------
+
+def is_single_statement(statement_types, ast):
+
+    if parent_statement(statement_types, ast) is None: return False
+        
+    def is_statement_type(node_type):
+        return any(match_type(r, node_type) for r in statement_types)
+
+    # Test if any other statement as child
+    queue = list(ast.children)
+    while len(queue) > 0:
+        node = queue.pop(0)
+        if is_statement_type(node.type): return False
+
+        queue.extend(node.children)
+    
+    return True
+
+
+def parent_statement(statement_types, ast):
+    
+    def is_statement_type(node_type):
+        return any(match_type(r, node_type) for r in statement_types)
+
+    # Test if node in statement
+    parent_node = ast
+    while parent_node is not None and not is_statement_type(parent_node.type):
+        parent_node = parent_node.parent
+    
+    return parent_node
+
+
+def tokenize_tree(ast):
+    tokens = []
+
+    # Test if any other statement as child
+    if ast.text: tokens.append(ast.text)
+
+    for child in ast.children:
+        tokens.append(tokenize_tree(child))
+    
+    return " ".join(tokens)

code_diff/sstubs.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class SStubPattern(Enum):
+
+    MULTI_STMT      = 0
+    SINGLE_STMT     = 1
+
+
+# SStub classification -------------------------------
+
+def classify_sstub(source_ast, target_ast):
+    pass

code_diff/utils.py

@@ -0,0 +1,13 @@
+
+def cached_property(fnc):
+    name = fnc.__name__
+
+    def load_from_cache(self):
+        if not hasattr(self, "_cache"): self._cache = {}
+
+        if name not in self._cache:
+            self._cache[name] = fnc(self)
+        
+        return self._cache[name]
+    
+    return property(load_from_cache)