defects_dump_graph Namespace Reference

Classes
class	Node

Functions
dict[str, Node]	build_tree (Mapping[str, DefectLogic] all_logic)
def	walk (Node node, set[Node] visited, bool visit_primary, TextIO fd)
def	dump_visited (TextIO fd, Node current_node, set[Node] nodes, Mapping[Union[str, int], str] descs, bool parents)
def	build_dependency_graph (str output_dir, Node node, Mapping[Union[str, int], str] descs)
def	build_parent_tree (str output_dir, Node node, Mapping[Union[str, int], str] descs)
def	render_all_flags (str output_dir, dict[str, Node] all_nodes, Mapping[Union[str, int], str] descs)
def	main ()

Variables
string	DEPENDSON_DIR = "dependson"

Function Documentation

build_dependency_graph()

def defects_dump_graph.build_dependency_graph	(	str	output_dir,
		Node	node,
		Mapping[Union[str, int], str]	descs
	)

Definition at line 115 of file defects_dump_graph.py.

def build_dependency_graph(output_dir: str, node: Node, descs: Mapping[Union[str, int], str]):
 
    with open("%s/%s.dot" % (output_dir, node.name), "w") as fd:
        print(f"strict digraph {node.name} {{", file=fd)
        print("rankdir=LR;\n", file=fd)
 
        visited = set()
 
        for parent in sorted(node.parents, key=Node.get_name):
            print(f"{parent.name} -> {node.name}", file=fd)
            visited.add(parent)
 
        walk(node, visited, node.has_primary_children, fd)
 
        dump_visited(fd, node, visited, descs, parents=False)
 
        print("}", file=fd)
 

build_parent_tree()

def defects_dump_graph.build_parent_tree	(	str	output_dir,
		Node	node,
		Mapping[Union[str, int], str]	descs
	)

Definition at line 133 of file defects_dump_graph.py.

def build_parent_tree(output_dir: str, node: Node, descs: Mapping[Union[str, int], str]):
 
    visited = set([node])
 
    with open(f"{output_dir}/{DEPENDSON_DIR}/{node.name}.dot", "w") as fd:
        def walk_parents(node):
            visited.add(node)
            for parent in node.parents:
                print(f"{parent.name} -> {node.name}", file=fd)
                walk_parents(parent)
 
        print(f"strict digraph {node.name} {{", file=fd)
        print("rankdir=LR;\n", file=fd)
 
        walk_parents(node)
 
        dump_visited(fd, node, visited, descs, parents=True)
 
        print("}", file=fd)
 

build_tree()

dict[str, Node] defects_dump_graph.build_tree

(

Mapping[str, DefectLogic]

all_logic

)

Definition at line 65 of file defects_dump_graph.py.

def build_tree(all_logic: Mapping[str, DefectLogic]) -> dict[str, Node]:
 
    all_nodes: dict[str, Node] = {}
 
    def make_primary(current_logic: str) -> Node:
        if current_logic in all_nodes:
            return all_nodes[current_logic]
        all_nodes[current_logic] = node = Node(current_logic)
        return node
 
    def explore_virtual(current_logic: str) -> Node:
        if current_logic in all_nodes:
            return all_nodes[current_logic]
 
        this_logic = all_logic[current_logic]
        all_nodes[current_logic] = node = Node(current_logic)
 
        for name in this_logic.clauses:
            if name in all_logic:
                child = explore_virtual(name)
            else:
                child = make_primary(name)
 
            child.parents.add(node)
            node.children.add(child)
 
        return node
 
    for name in all_logic:
        explore_virtual(name)
 
    return all_nodes
 

dump_visited()

def defects_dump_graph.dump_visited	(	TextIO	fd,
		Node	current_node,
		set[Node]	nodes,
		Mapping[Union[str, int], str]	descs,
		bool	parents
	)

Definition at line 106 of file defects_dump_graph.py.

def dump_visited(fd: TextIO, current_node: Node, nodes: set[Node],
                 descs: Mapping[Union[str, int], str], parents: bool):
    for node in sorted(nodes, key=Node.get_name):
        at_current_node = node.name == current_node.name
        description = descs.get(node.name, node.name)
        # Line breaks in defect descriptions mess up the svg generation
        description = description.replace('\n', ' ')
        print(node.dot(at_current_node, description, parents), file=fd)
 

main()

def defects_dump_graph.main

(

)

Definition at line 163 of file defects_dump_graph.py.

def main():
 
    parser = ArgumentParser(description="Dump defect viewer information")
 
    parser.add_argument("-t", "--tag", default="HEAD", help="Defect tag")
    parser.add_argument("-o", "--output", default=".", help="Directory to dump files")
 
    args = parser.parse_args()
 
    # Instantiate the Defect DB
    db = DefectsDB(tag=args.tag)
 
    descs = db.all_defect_descriptions
 
    # Build node objects
    all_nodes = build_tree(db.virtual_defect_logics)
 
    # Write outputs
    output_dir = "%s/%s" % (args.output, args.tag)
    render_all_flags(output_dir, all_nodes, descs)
 

render_all_flags()

def defects_dump_graph.render_all_flags	(	str	output_dir,
		dict[str, Node]	all_nodes,
		Mapping[Union[str, int], str]	descs
	)

Definition at line 153 of file defects_dump_graph.py.

def render_all_flags(output_dir: str, all_nodes: dict[str, Node], descs: Mapping[Union[str, int], str]):
 
    path = "%s/%s" % (output_dir, DEPENDSON_DIR)
    if not isdir(path):
        makedirs(path)
 
    for _, node in sorted(all_nodes.items()):
        build_dependency_graph(output_dir, node, descs)
        build_parent_tree(output_dir, node, descs)
 

walk()

def defects_dump_graph.walk	(	Node	node,
		set[Node]	visited,
		bool	visit_primary,
		TextIO	fd
	)

Definition at line 98 of file defects_dump_graph.py.

def walk(node: Node, visited: set[Node], visit_primary: bool, fd: TextIO):
    visited.add(node)
 
    for subnode in sorted(node.children, key=Node.get_name):
        if subnode.virtual or (subnode.primary and visit_primary):
            print(f"{node.name} -> {subnode.name}", file=fd)
            walk(subnode, visited, visit_primary, fd)
 

Variable Documentation

DEPENDSON_DIR

string defects_dump_graph.DEPENDSON_DIR = "dependson"

Definition at line 11 of file defects_dump_graph.py.