fixed tests

Author: swilly22

code_graph/analyzers/source_analyzer.py

@@ -155,28 +155,47 @@ def analyze_github_repository(self, url: str) -> None:
 
         logger.info("Done processing repository")
 
-    def analyze_local_repository(self, path: str, ignore: Optional[List[str]]) -> None:
+    def analyze_local_folder(self, path: str, ignore: Optional[List[str]] = []) -> Graph:
         """
-        Analyze a local Git repository.
+        Analyze a local folder.
 
         Args:
-            path (str): Path to a local git repository
+            path (str): Path to a local folder containing source files to process
             ignore (List(str)): List of paths to skip
         """
 
-        ignore = ignore or []
-
-        # change working directory to repo
+        # change working directory to path
         os.chdir(path)
 
-        repo_name = os.path.split(os.path.normpath(path))[-1]
-        logger.debug(f'repo_name: {repo_name}')
+        proj_name = os.path.split(os.path.normpath(path))[-1]
+        logger.debug(f'proj_name: {proj_name}')
 
         # Initialize the graph and analyzer
-        self.graph = Graph(repo_name, self.host, self.port, self.username,
+        self.graph = Graph(proj_name, self.host, self.port, self.username,
                            self.password)
 
         # Analyze source files
         self.analyze_sources(ignore)
 
-        logger.info("Done processing repository")
+        logger.info("Done processing folder")
+
+        return self.graph
+
+    def analyze_local_repository(self, path: str, ignore: Optional[List[str]] = []) -> Graph:
+        """
+        Analyze a local Git repository.
+
+        Args:
+            path (str): Path to a local git repository
+            ignore (List(str)): List of paths to skip
+        """
+
+        self.analyze_local_folder(path, ignore)
+
+        # Save processed commit hash to the DB
+        repo = Repo(path)
+        head = repo.commit("HEAD")
+        self.graph.set_graph_commit(head.hexsha)
+
+        return self.graph
+

code_graph/git_utils/__init__.py

@@ -1 +1 @@
-from .git_utils import build_commit_graph
+from .git_utils import build_commit_graph, switch_commit, GitGraph

code_graph/git_utils/git_graph.py

@@ -1,3 +1,6 @@
+from falkordb import FalkorDB
+from typing import List, Optional
+
 class GitGraph():
     """
     Represents a git commit graph
@@ -21,16 +24,35 @@ def __init__(self, name: str, host: str = 'localhost', port: int = 6379,
             pass
 
 
-    def add_commit(self, commit_hash: str, author: str, message: str, date, int) -> None:
+    def add_commit(self, commit_hash: str, author: str, message: str, date: int) -> None:
         """
             Add a new commit to the graph
         """
         q = "MERGE (c:Commit {hash: $hash, author: $author, message: $message, date: $date})"
-        params = {'hash': commit_hash, 'author': author, 'message': message, 'date': $date}
+        params = {'hash': commit_hash, 'author': author, 'message': message, 'date': date}
         self.g.query(q, params)
 
+    def get_commits(self, hashes: List[str]) -> List[dict]:
+        q = """MATCH (c:Commit)
+               WHERE c.hash IN $hashes
+               RETURN c"""
+
+        params = {'hashes': hashes}
+        res = self.g.query(q, params).result_set
+
+        commits = []
+        for row in res:
+            commit = row[0]
+            commit = {'hash':    commit.properties['hash'],
+                      'date':    commit.properties['date'],
+                      'author':  commit.properties['author'],
+                      'message': commit.properties['message']}
 
-    def connect_commits(child: str, parent: str) -> None:
+            commits.append(commit)
+
+        return commits
+
+    def connect_commits(self, child: str, parent: str) -> None:
         """
             connect commits via both PARENT and CHILD edges
         """
@@ -41,30 +63,69 @@ def connect_commits(child: str, parent: str) -> None:
 
         params = {'child_hash': child, 'parent_hash': parent}
 
-        self.g.query(q, parent)
+        self.g.query(q, params)
+
 
-    def set_parent_transition(child: str, parent: str, queries: [tuple[str: dict]]) -> None:
+    def set_parent_transition(self, child: str, parent: str, queries: [str], params: [dict]) -> None:
         """
             Sets the queries and parameters needed to transition the code-graph
             from the child commit to the parent commit
         """
 
-        q = """MATCH (child: Commit {hash: $child})-[e:PARENT]->(parent {hash: $parent})
+        q = """MATCH (child :Commit {hash: $child})-[e:PARENT]->(parent :Commit {hash: $parent})
                SET e.queries = $queries, e.params = $params"""
 
-        params = {'child': child, 'parent': parent, 'queries': queries}
+        params = {'child': child, 'parent': parent, 'queries': queries, 'params': params}
 
         self.g.query(q, params)
 
-    def set_child_transition(child: str, parent: str, queries: [tuple[str: dict]]) -> None:
+
+    def set_child_transition(self, child: str, parent: str, queries: List[tuple[str: dict]]) -> None:
         """
             Sets the queries and parameters needed to transition the code-graph
             from the parent commit to the child commit
         """
 
-        q = """MATCH (parent {hash: $parent})-[e:CHILD]->(child: Commit {hash: $child})
+        q = """MATCH (parent :Commit {hash: $parent})-[e:CHILD]->(child :Commit {hash: $child})
                SET e.queries = $queries, e.params = $params"""
 
         params = {'child': child, 'parent': parent, 'queries': queries}
 
         self.g.query(q, params)
+
+
+    def get_parent_transition(self, child: str, parent: str) -> List[tuple[str: dict]]:
+        """
+            Get queries and parameters transitioning from child commit to parent commit
+        """
+        q = """MATCH path = (:Commit {hash: $child_hash})-[:PARENT*]->(:Commit {hash: $parent_hash})
+               WITH path
+               LIMIT 1
+               UNWIND relationships(path) AS e
+               WITH e
+               WHERE e.queries is not NULL
+               RETURN collect(e.queries), collect(e.params)
+        """
+
+        res = self.g.query(q, {'child_hash': child, 'parent_hash': parent}).result_set
+
+        return (res[0][0], res[0][1])
+
+
+    def get_child_transition(self, child: str, parent: str) -> List[tuple[str: dict]]:
+        """
+            Get queries transitioning from parent to child
+        """
+        q = """MATCH path = (:Commit {hash: $parent_hash})-[:CHILD*]->(:Commit {hash: $child_hash})
+               WITH path
+               LIMIT 1
+               UNWIND relationships(path) AS e
+               WITH e
+               WHERE e.queries is not NULL
+               RETURN collect(e.queries), collect(e.params)
+        """
+
+        res = self.g.query(q, {'child_hash': child, 'parent_hash': parent}).result_set
+
+        return (res[0][0], res[0][1])
+

code_graph/git_utils/git_utils.py

@@ -1,10 +1,13 @@
 import os
 import time
+import json
 import redis
 import threading
 import subprocess
 from git import Repo
 from ..graph import Graph
+from .git_graph import GitGraph
+from typing import List, Optional
 
 monitor_thread = None
 replica_process = None
@@ -98,23 +101,39 @@ def stop_monitor_effects():
     print("monitor thread exited")
 
 # build a graph capturing the git commit history
-def build_commit_graph(path: str):
+def build_commit_graph(path: str, ignore_list: Optional[List[str]] = []) -> GitGraph:
+    print(f"Processing git history at: {path}")
+    print(f"ignoring the following paths: {ignore_list}")
+
     repo = Repo(path)
 
     repo_name = os.path.split(os.path.normpath(path))[-1]
-    g = Graph(repo_name)
+    g =         Graph(repo_name)
+    git_graph = GitGraph('{' + repo_name + '}' + '_git')
 
     #setup_replication()
 
     # start monitoring graph effects
     # these capture the changes a graph goes through when moving from one
     # git commit to another
-    start_monitor_effects(g.g.name)
+    #start_monitor_effects(g.g.name)
 
     head_commit = repo.commit("HEAD")
+
+    # add commit to the git graph
+    git_graph.add_commit(head_commit.hexsha, head_commit.author.name,
+                 head_commit.message, head_commit.committed_date)
+
     while len(head_commit.parents) > 0:
         prev_commit = head_commit.parents[0]
 
+        # add commit to the git graph
+        git_graph.add_commit(prev_commit.hexsha, prev_commit.author.name,
+                 prev_commit.message, prev_commit.committed_date)
+
+        # connect child parent commits relation
+        git_graph.connect_commits(head_commit.hexsha, prev_commit.hexsha)
+
         # represents the changes going backward!
         # e.g. which files need to be deleted when moving back one commit
         #
@@ -134,16 +153,17 @@ def build_commit_graph(path: str):
 
         for change in diff:
             if change.new_file:
-                #print(f"new_file: {change.b_path}")
-                added.append(change.b_path)
+                if all(not change.b_path.startswith(ignore) for ignore in ignore_list):
+                    #print(f"new_file: {change.b_path}")
+                    added.append(change.b_path)
             elif change.deleted_file:
-                print(f"deleted_file: {change.a_path}")
-                deleted.append(change.a_path)
+                if all(not change.a_path.startswith(ignore) for ignore in ignore_list):
+                    print(f"deleted_file: {change.a_path}")
+                    deleted.append(change.a_path)
             elif change.change_type == 'M':
-                #print(f"modified_file: {change.a_path}")
-                modified.append(change.a_path)
-
-        head_commit = prev_commit
+                if all(not change.a_path.startswith(ignore) for ignore in ignore_list):
+                    #print(f"modified_file: {change.a_path}")
+                    modified.append(change.a_path)
 
         #-----------------------------------------------------------------------
         # apply changes
@@ -159,16 +179,62 @@ def build_commit_graph(path: str):
                      'ext' : os.path.splitext(path)[1]} for path in deleted]
 
             # remove deleted files from the graph
-            q, params = g.delete_files(deleted_files, True)
-            if(q is not None):
+            transition = g.delete_files(deleted_files, True)
+            if(transition is not None):
+                queries, params = transition
                 # log transition action
+                git_graph.set_parent_transition(head_commit.hexsha,
+                                                prev_commit.hexsha, queries,
+                                                json.dumps(params))
 
-            input("Press Enter to continue...")
+        # advance to the next commit
+        head_commit = prev_commit
 
     # clean up
     #stop_monitor_effects()
     #teardown_replica()
 
+    return git_graph
+
+def switch_commit(repo: str, to: str):
+    """switch graph state from its current commit to given commit"""
+
+    g = Graph(repo)
+    git_graph = GitGraph('{' + repo + '}' + 'git')
+
+    # Get the graph's current commit
+    current_hash = g.get_graph_commit()
+
+    # Find path from current commit to desired commit
+    commits = git_graph.get_commits([current_hash, to])
+
+    if len(commits) != 2:
+        print("missing commits")
+        return
+
+    # determine relation between commits
+    current_commit = commits[0] if commits[0]['hash'] == current_hash else commits[1]
+    new_commit     = commits[0] if commits[0]['hash'] == to else commits[1]
+
+    if current_commit['date'] > new_commit['date']:
+        print("moving backwared")
+        queries, params = git_graph.get_parent_transition(current_commit['hash'], new_commit['hash'])
+    else:
+        print("moving forwards")
+        queries, params = git_graph.get_child_transition(current_commit['hash'], new_commit['hash'])
+
+    # Apply transitions
+    for i in range(0, len(queries)):
+        q = queries[i]
+        p = json.loads(params[i])
+        print(f"query: {q}")
+        print(f"params: {p}")
+
+        g.rerun_query(q, p)
+
+    # update graph's commit
+    g.set_graph_commit(to)
+
 if __name__ == "__main__":
     build_commit_graph("/Users/roilipman/Dev/FalkorDB")
 

code_graph/graph.py

@@ -426,3 +426,23 @@ def get_struct(self, struct_id: int) -> Optional[Struct]:
         s = res.result_set[0][0]
         return self._struct_from_node(s)
 
+    def set_graph_commit(self, commit_hash: str) -> None:
+        """Save processed commit hash to the DB"""
+
+        # connect to DB
+
+        # Set STRING key {FalkorDB}_commit = commit_hash
+        self.db.connection.set('{' + self.g.name + '}' + '_commit', commit_hash)
+
+    def get_graph_commit(self) -> str:
+        """Get the current commit the graph is at"""
+
+        return self.db.connection.get('{' + self.g.name + '}' + '_commit')
+
+
+    def rerun_query(self, q: str, params: dict) -> None:
+        """
+            Re-run a query to transition the graph from one state to another
+        """
+
+        res = self.g.query(q, params)

main.py

@@ -258,11 +258,36 @@ def process_git_history():
 
     # path to local repository
     repo = data.get('repo')
+    if repo is None:
+        return jsonify({'status': f'Missing mandatory parameter "repo"'}), 400
+
+    ignore_list = data.get('ignore') or []
+
+    build_commit_graph(repo, ignore_list)
+
+    # Create a response
+    response = {
+        'status': 'success',
+    }
 
+    return jsonify(response), 200
+
+
+@app.route('/switch_commit', methods=['POST'])
+def process_switch_commit():
+    # Get JSON data from the request
+    data = request.get_json()
+
+    # path to local repository
+    repo = data.get('repo')
     if repo is None:
         return jsonify({'status': f'Missing mandatory parameter "repo"'}), 400
 
-    build_commit_graph(repo)
+    commit = data.get('commit')
+    if commit is None:
+        return jsonify({'status': f'Missing mandatory parameter "commit"'}), 400
+
+    switch_commit(repo, commit)
 
     # Create a response
     response = {

tests/git_repo

@@ -0,0 +1 @@
+Subproject commit df8d021dbae077a39693c1e76e8438006d62603e