Improved comments and indentations (#32)

* Update cmd-call-graph.py
* Improved comments and indentations
* Update core.py
* Update cmd-call-graph.py
* Update core.py

Author: ankitsaxena21

callgraph/__main__.py

@@ -1,3 +1,3 @@
 from .callgraph import main
 
-main()
+main()

callgraph/core.py

@@ -9,6 +9,8 @@
 Command = collections.namedtuple("Command", ["command", "target"])
 
 # Line of code. Not a namedtuple because we need mutability.
+
+
 class CodeLine:
     def __init__(self, number, text, terminating=False, noop=False):
         self.number = number
@@ -24,15 +26,18 @@ def AddCommand(self, command):
 
     def __repr__(self):
         return "[{0} (terminating: {1}, noop: {2}, commands: {3})] {4}".format(self.number, self.terminating, self.noop, self.commands, self.text)
-    
+
     def __eq__(self, other):
         return other is not None and self.number == other.number and self.text == other.text and self.terminating == other.terminating
 
 # Connection between two nodes.
-# dst is the name of the target node, kind is the type of connection, line_number is the line where the call/goto happens.
+# dst is the name of the target node, kind is the type of connection,
+# line_number is the line where the call/goto happens.
 Connection = collections.namedtuple("Connection", ["dst", "kind", "line_number"])
 
 # Node in the call graph.
+
+
 class Node:
     def __init__(self, name):
         self.name = name
@@ -46,38 +51,38 @@ def __init__(self, name):
 
     def AddConnection(self, dst, kind, line_number=NO_LINE_NUMBER):
         self.connections.add(Connection(dst, kind, line_number))
-    
+
     def AddCodeLine(self, line_number, code):
         self.code.append(CodeLine(line_number, code.strip().lower(), False))
         self.loc += 1
-    
+
     def GetCommandCount(self):
         node_counter = collections.Counter()
 
         for line in self.code:
             for command, count in line.commands_counter.items():
                 node_counter[command] += count
-        
         return node_counter
-    
+
     def __repr__(self):
         return "{0}. {1}, {2}".format(self.name, self.code, self.connections)
 
     def __lt__(self, other):
-        if other == None:
+        if other is None:
             return False
         return self.name < other.name
 
+
 class CallGraph:
     def __init__(self, log_file=sys.stderr):
         self.nodes = {}
         self.log_file = log_file
         self.first_node = None
-    
+
     def GetOrCreateNode(self, name):
         if name in self.nodes:
             return self.nodes[name]
-        
+
         node = Node(name)
         self.nodes[name] = node
         return node
@@ -86,7 +91,8 @@ def _MarkExitNodes(self):
         # A node is an exit node if:
         # 1. it contains an "exit" command with no target
         # or
-        # 2. it's reached from the starting node via "goto" or "nested" connections
+        # 2. it's reached from the starting node via "goto" or
+        # "nested" connections
         #    and it contains an exit command or a "goto eof" command.
 
         # Identify all nodes with an exit command with no targets.
@@ -98,7 +104,7 @@ def _MarkExitNodes(self):
 
         # Visit the call graph to find nodes satisfying condition #2.
         q = [self.first_node]
-        visited = set()     # Used to avoid loops, since the call graph is not acyclic.
+        visited = set()   # Used to avoid loops, since the call graph is not acyclic.
 
         while q:
             cur = q.pop()
@@ -119,19 +125,22 @@ def _MarkExitNodes(self):
                     continue
                 if connection.kind == "nested" or connection.kind == "goto":
                     q.append(self.nodes[connection.dst])
-            
 
-    # Adds to each node information depending on the contents of the code, such as connections
-    # deriving from goto/call commands and whether the node is terminating or not.
+    # Adds to each node information depending on the
+    # contents of the code, such as connections
+    # deriving from goto/call commands and
+    # whether the node is terminating or not.
     def _AnnotateNode(self, node):
         print(u"Annotating node {0} (line {1})".format(node.original_name, node.line_number), file=self.log_file)
         for i in range(len(node.code)):
             line = node.code[i]
             line_number = line.number
             text = line.text
 
-            # Tokenize the line of code, and store all elements that warrant augmenting the
-            # node in a list (interesting_commands), which will then be processed later.
+            # Tokenize the line of code, and store all elements that
+            #  warrant augmenting the
+            # node in a list (interesting_commands), which will then
+            # be processed later.
             tokens = text.strip().lower().split()
             if not tokens:
                 line.noop = True
@@ -164,31 +173,32 @@ def _AnnotateNode(self, node):
                         continue
                     line.AddCommand(Command("call", block_name))
                     continue
-                
+
                 if token == "exit" or token == "@exit":
                     target = ""
                     if i+1 < len(tokens):
                         target = tokens[i+1]
                     line.AddCommand(Command("exit", target))
-            
+
             for command, target in line.commands:
                 if command == "call" or command == "goto":
                     node.AddConnection(target, command, line_number)
                     print(u"Line {} has a goto towards: <{}>. Current block: {}".format(line_number, target, node.name), file=self.log_file)
-                
+
                 if (command == "goto" and target == "eof") or command == "exit":
                     line.terminating = True
 
                 if command == "exit" and target == "":
                     line.terminating = True
-    
+
     @staticmethod
     def Build(input_file, log_file=sys.stderr):
         call_graph = CallGraph._ParseSource(input_file, log_file)
         for node in call_graph.nodes.values():
             call_graph._AnnotateNode(node)
-        
-        # Prune away EOF if it is a virtual node (no line number) and there are no call/nested connections to it.
+
+        # Prune away EOF if it is a virtual node (no line number) and
+        # there are no call/nested connections to it.
         eof = call_graph.GetOrCreateNode("eof")
         all_connections = itertools.chain.from_iterable(n.connections for n in call_graph.nodes.values())
         destinations = set((c.dst, c.kind) for c in all_connections)
@@ -200,8 +210,9 @@ def Build(input_file, log_file=sys.stderr):
                 print(u"Removing {} eof connections in node {}".format(len(eof_connections), node.name), file=log_file)
                 for c in eof_connections:
                     node.connections.remove(c)
-        
-        # Warn the user if there are goto connections to eof, which will not be executed by CMD.
+
+        # Warn the user if there are goto connections to eof
+        # which will not be executed by CMD.
         if eof.line_number != NO_LINE_NUMBER and ("eof", "goto") in destinations:
             print(u"WARNING: there are goto connections to eof, but CMD will not execute that code via goto.", file=log_file)
 
@@ -212,7 +223,8 @@ def Build(input_file, log_file=sys.stderr):
             cur_node = nodes_by_line_number[i]
             prev_node = nodes_by_line_number[i-1]
 
-            # Special case: the previous node has no code or all lines are comments / empty lines.
+            # Special case: the previous node has no code or all lines are
+            # comments / empty lines.
             all_noop = all(line.noop for line in prev_node.code)
             if not prev_node.code or all_noop:
                 print(u"Adding nested connection between {0} and {1} because all_noop ({2}) or empty code ({3})".format(
@@ -221,15 +233,16 @@ def Build(input_file, log_file=sys.stderr):
                 break
 
             # Heuristic for "nested" connections:
-            # iterate the previous node's commands, and create a nested connection
-            # only if the command that logically precedes the current node does not
-            # contain a goto or an exit (which would mean that the current node is not reached
-            # by "flowing" from the previous node to the current node.)
+            # iterate the previous node's commands, and create a nested
+            # connection only if the command that logically precedes the
+            # current node does not contain a goto or an exit (which would mean
+            # that the current node is not reached by "flowing" from the
+            # previous node to the current node.)
             for line in reversed(prev_node.code):
                 # Skip comments and empty lines.
                 if line.noop:
                     continue
-                
+
                 commands = set(c.command for c in line.commands)
                 if "exit" not in commands and "goto" not in commands:
                     print(u"Adding nested connection between {0} and {1} because there is a non-exit or non-goto command.".format(
@@ -246,10 +259,10 @@ def Build(input_file, log_file=sys.stderr):
 
         return call_graph
 
-    # Creates a call graph from an input file, parsing the file in blocks and creating
-    # one node for each block. Note that the nodes don't contain any information that
-    # depend on the contents of the node, as this is just the starting point for the
-    # processing.
+    # Creates a call graph from an input file, parsing the file in blocks and
+    # creating one node for each block. Note that the nodes don't contain any
+    # information that depend on the contents of the node, as this is just the
+    # starting point for the processing.
     @staticmethod
     def _ParseSource(input_file, log_file=sys.stderr):
         call_graph = CallGraph(log_file)
@@ -267,10 +280,12 @@ def _ParseSource(input_file, log_file=sys.stderr):
 
             # Start of new block.
             if line.startswith(":") and not line.startswith("::"):
-                # In the off chance that there are multiple words, cmd considers the first word the label name.
+                # In the off chance that there are multiple words,
+                # cmd considers the first word the label name.
                 original_block_name = line[1:].split()[0].strip()
 
-                # Since cmd is case-insensitive, let's convert block names to lowercase.
+                # Since cmd is case-insensitive, let's convert block names to
+                # lowercase.
                 block_name = original_block_name.lower()
 
                 print(u"Line {} defines a new block: <{}>".format(line_number, block_name), file=log_file)
@@ -279,14 +294,15 @@ def _ParseSource(input_file, log_file=sys.stderr):
                     next_node.line_number = line_number
                     next_node.original_name = original_block_name
 
-                    # If this node is defined on line one, remove __begin__, so we avoid having two
+                    # If this node is defined on line one, remove __begin__,
+                    # so we avoid having two
                     # nodes with the same line number.
                     if line_number == 1:
                         del call_graph.nodes["__begin__"]
                         call_graph.first_node = next_node
 
                     cur_node = next_node
-            
+
             cur_node.AddCodeLine(line_number, line)
 
         return call_graph

callgraph/render.py

@@ -4,15 +4,16 @@
 
 from . import core
 
+
 def _Escape(input_string):
     return input_string.replace("%", r"\%")
 
 
 COLORS = {
-    'goto':         '"#d83b01"', # Orange
-    'nested':       '"#008575"', # Teal
-    'call':         '"#0078d4"', # Blue
-    'terminating':  '"#e6e6e6"', # Light gray
+    'goto':         '"#d83b01"',  # Orange
+    'nested':       '"#008575"',  # Teal
+    'call':         '"#0078d4"',  # Blue
+    'terminating':  '"#e6e6e6"',  # Light gray
 }
 
 def PrintDot(call_graph, out_file=sys.stdout, log_file=sys.stderr, show_all_calls=True, show_node_stats=False, nodes_to_hide=None):
@@ -28,7 +29,7 @@ def PrintDot(call_graph, out_file=sys.stdout, log_file=sys.stderr, show_all_call
         pretty_name = name
         if node.original_name != "":
             pretty_name = node.original_name
-        
+
         print(u"Processing node {0} (using name: {1})".format(node.name, pretty_name), file=log_file)
 
         attributes = []
@@ -45,7 +46,7 @@ def PrintDot(call_graph, out_file=sys.stdout, log_file=sys.stderr, show_all_call
             if external_call_count > 0:
                 text = "call" if external_call_count == 1 else "calls"
                 label_lines.append("<sub>[{} external {}]</sub>".format(external_call_count, text))
-            
+
         if node.is_exit_node:
             attributes.append("color={}".format(COLORS["terminating"]))
             attributes.append("style=filled")
@@ -56,11 +57,12 @@ def PrintDot(call_graph, out_file=sys.stdout, log_file=sys.stderr, show_all_call
         if attributes:
             print(u"\"{}\" [{}]".format(name, ",".join(attributes)), file=out_file)
 
-        # De-duplicate connections by line number if show_all_calls is set to False.
+        # De-duplicate connections by line number if show_all_calls is set to
+        # False.
         connections = node.connections
         if not show_all_calls:
             connections = list(set(core.Connection(c.dst, c.kind, core.NO_LINE_NUMBER) for c in connections))
-        
+
         for c in sorted(connections):
             # Remove EOF connections if necessary.
             if nodes_to_hide and (c.dst in nodes_to_hide):

scripts/generate-sample-cmd.py

@@ -23,14 +23,14 @@
 for function in functions:
     code.append(":{}".format(function))
     loc = random.randint(1, MAX_LENGTH)
-    
+
     for i in range(loc):
         if random.random() < CALL_PROBABILITY:
             target = random.choice(functions)
             code.append(u"  call :{}".format(target))
         else:
             code.append(u"  ; some code goes here.")
-    
+
     if random.random() > NESTED_PROBABILITY:
         code.append(u"exit /b 0")