Assignment 2.1: Build Automation Tool

solutions/ankurdubey521/Build Automation Tool/.gitignore

@@ -0,0 +1,3 @@
+/venv/
+.idea
+.gitignore

solutions/ankurdubey521/Build Automation Tool/Builder/global_constants.py

@@ -0,0 +1,9 @@
+"""
+Global Constants
+"""
+
+
+class GlobalConstants:
+    CONFIG_FILE_NAME = "build.json"
+    FILE_WATCH_INTERVAL_SECONDS = 1
+

solutions/ankurdubey521/Build Automation Tool/Builder/lib/algorithms.py

@@ -0,0 +1,59 @@
+from typing import List, Dict, TypeVar
+from queue import Queue
+
+T = TypeVar('T')
+
+
+class TopologicalSort:
+    """Topological Sort
+    Provides methods for generating Topological Sort of a DAG.
+    """
+    class GraphContainsCycleException(Exception):
+        pass
+
+    @staticmethod
+    def sort(graph_adj_list: Dict[T, List[T]]) -> List[T]:
+        """
+        Generates topological sort and raises exception if cycle in found
+        :param graph_adj_list: .
+        :return: topologically sort of graph
+        """
+        toposort = []
+        visited = {}
+        queue = Queue()
+        in_degree = {}
+
+        # Calculate  In-Degree of Each Vertex
+        for source_node in graph_adj_list:
+            visited[source_node] = False
+            for dest_node in graph_adj_list[source_node]:
+                visited[dest_node] = False
+                if dest_node in in_degree:
+                    in_degree[dest_node] = in_degree[dest_node] + 1
+                else:
+                    in_degree[dest_node] = 1
+
+        # Find all vertices that have 0 In-degree.
+        for source_node in graph_adj_list:
+            if source_node not in in_degree:
+                queue.put(source_node)
+
+        # BFS
+        while not queue.empty():
+            front = queue.get()
+            visited[front] = True
+            toposort.append(front)
+            if front in graph_adj_list:
+                for dest_node in graph_adj_list[front]:
+                    if not visited[dest_node]:
+                        in_degree[dest_node] = in_degree[dest_node] - 1
+                        if in_degree[dest_node] == 0:
+                            queue.put(dest_node)
+
+        # If any vertex exists whose In-Degree has not been exhausted, then graph must contain a cycle
+        for node in in_degree:
+            if in_degree[node] != 0:
+                raise TopologicalSort.GraphContainsCycleException()
+
+        return toposort
+

solutions/ankurdubey521/Build Automation Tool/Builder/lib/buildconfig.py

@@ -0,0 +1,84 @@
+"""" Sample build.json
+[
+  {
+    "name": "clean",
+    "deps": ["algorithms/clean"],
+    "files": ["test.cpp"],
+    "command": "rm -f test.o && rm -f test.out"
+  },
+  {
+    "name": "test",
+    "files": ["test.cpp"],
+    "command": "g++ -std=c++11 -c test.cpp"
+  },
+  {
+    "name": "run",
+    "deps": ["test", "algorithms/sort_bubble", "algorithms/sort_merge", "algorithms/sort_quick"],
+    "command": "g++ algorithms/sort_bubble.o algorithms/sort_merge.o ..."
+  }
+]
+"""
+
+import json
+from typing import List
+from Builder.global_constants import GlobalConstants
+
+
+class BuildRule:
+    """Stores Command Information"""
+    def __init__(self, *, name: str, command_string: str, deps: List[str] = [], files: List[str] = []) -> None:
+        self._name = name
+        self._command_string = command_string
+        self._files = files
+        self._dependencies = deps
+
+    def get_name(self) -> str:
+        return self._name
+
+    def get_files(self) -> List[str]:
+        return self._files
+
+    def get_command_string(self) -> str:
+        return self._command_string
+
+    def get_dependencies(self) -> List[str]:
+        return self._dependencies
+
+    class NoDependenciesException(Exception):
+        pass
+
+    class NoFilesException(Exception):
+        pass
+
+
+class BuildConfig:
+    """Parses and Stores build.config in the form of BuildRule objects"""
+    def __init__(self, json_containing_folder: str) -> None:
+        # Parse JSON
+        json_path = json_containing_folder + "/" + GlobalConstants.CONFIG_FILE_NAME
+        with open(json_path) as file_handle:
+            self._raw_json = json.load(file_handle)
+
+        self._name_to_command_object = {}
+        for command_entry in self._raw_json:
+            name = command_entry['name']
+            command_string = command_entry['command']
+            if 'deps' in command_entry:
+                deps = command_entry['deps']
+            else:
+                deps = []
+            if 'files' in command_entry:
+                files = command_entry['files']
+            else:
+                files = []
+            self._name_to_command_object[name] =\
+                BuildRule(name=name, command_string=command_string, deps=deps, files=files)
+
+    def get_command(self, command_name: str) -> BuildRule:
+        if command_name in self._name_to_command_object:
+            return self._name_to_command_object[command_name]
+        else:
+            raise BuildConfig.UnknownCommandException('No such command "{}" found.'.format(command_name))
+
+    class UnknownCommandException(Exception):
+        pass

solutions/ankurdubey521/Build Automation Tool/Builder/lib/file_watcher.py

@@ -0,0 +1,33 @@
+from os import stat
+from typing import List, Callable, Dict
+from Builder.global_constants import GlobalConstants
+from time import sleep
+
+
+class FileWatcher:
+    FILE_WATCH_INTERVAL_SECONDS = GlobalConstants.FILE_WATCH_INTERVAL_SECONDS
+
+    @staticmethod
+    def _get_file_edit_times(file_list: List[str]) -> Dict[str, int]:
+        """Populate a Dict of last edit times of files and return it"""
+        file_edit_times = {}
+        for file_path in file_list:
+            file_edit_times[file_path] = stat(file_path).st_mtime
+        return file_edit_times
+
+    @staticmethod
+    def watch_and_execute(file_list: List[str], function: Callable[[any], any], *args: any) -> None:
+        """Execute a function whenever a file from file_list changes"""
+        print("Listening for changes on {}...".format(file_list))
+        file_edit_times = FileWatcher._get_file_edit_times(file_list)
+        print("Executing for the first time...")
+        function(*args)
+        while True:
+            sleep(FileWatcher.FILE_WATCH_INTERVAL_SECONDS)
+            new_file_edit_times = FileWatcher._get_file_edit_times(file_list)
+            if new_file_edit_times != file_edit_times:
+                file_edit_times = new_file_edit_times
+                print("Detected change of file. Executing...")
+                function(*args)
+
+