| #!/usr/bin/env python3 | |
| # Copyright 2021 The Chromium Authors | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| """Command-line tool for finding differences in dependency graphs.""" | |
| import argparse | |
| import itertools | |
| from typing import List, Set, Tuple, Callable | |
| import chrome_names | |
| import count_cycles | |
| import graph | |
| import serialization | |
| def _print_diff_num_nodes(graph1: graph.Graph, graph2: graph.Graph, | |
| label: str): | |
| before: int = graph1.num_nodes | |
| after: int = graph2.num_nodes | |
| _print_diff_metric(before, after, label) | |
| def _print_diff_num_edges(graph1: graph.Graph, graph2: graph.Graph, | |
| label: str): | |
| before: int = graph1.num_edges | |
| after: int = graph2.num_edges | |
| _print_diff_metric(before, after, label) | |
| def _print_diff_metric(before: int, after: int, label: str): | |
| diff: int = after - before | |
| print(f'{label}: {diff:+} ({before} -> {after})') | |
| def _print_diff_node_list(graph1: graph.Graph, graph2: graph.Graph, | |
| label: str): | |
| before_nodes: Set[str] = set(node.name for node in graph1.nodes) | |
| after_nodes: Set[str] = set(node.name for node in graph2.nodes) | |
| _print_set_diff(before_nodes, after_nodes, label) | |
| def _print_diff_node_list_filtered(graph1: graph.Graph, graph2: graph.Graph, | |
| label: str, | |
| filter_fn: Callable[[graph.Node], bool]): | |
| before_nodes: Set[str] = set(node.name for node in graph1.nodes | |
| if filter_fn(node)) | |
| after_nodes: Set[str] = set(node.name for node in graph2.nodes | |
| if filter_fn(node)) | |
| _print_diff_metric(len(before_nodes), len(after_nodes), label) | |
| _print_set_diff(before_nodes, after_nodes, label) | |
| def _print_diff_edge_list(graph1: graph.Graph, graph2: graph.Graph, | |
| label: str): | |
| before_edges: Set[str] = set(_edge_str(edge) for edge in graph1.edges) | |
| after_edges: Set[str] = set(_edge_str(edge) for edge in graph2.edges) | |
| _print_set_diff(before_edges, after_edges, label) | |
| def _edge_str(edge: Tuple[graph.Node, graph.Node]) -> str: | |
| return f'{edge[0]} -> {edge[1]}' | |
| def _print_diff_cycle_list(cycles1: Set[count_cycles.Cycle], | |
| cycles2: Set[count_cycles.Cycle], label: str): | |
| before_cycles: Set[str] = set(_cycle_str(cycle) for cycle in cycles1) | |
| after_cycles: Set[str] = set(_cycle_str(cycle) for cycle in cycles2) | |
| _print_set_diff(before_cycles, after_cycles, label) | |
| def _cycle_str(cycle: count_cycles.Cycle) -> str: | |
| return ' > '.join(chrome_names.shorten_class(node.name) for node in cycle) | |
| def _print_set_diff(before_set: Set[str], after_set: Set[str], label: str): | |
| all_added: List[str] = sorted(after_set - before_set) | |
| all_removed: List[str] = sorted(before_set - after_set) | |
| if not all_added and not all_removed: | |
| print(f'{label} - no changes') | |
| return | |
| print(f'{label} added (+) and removed (-):') | |
| for i, added in enumerate(all_added, start=1): | |
| print(f'+ [{i:4}] {added}') | |
| for i, removed in enumerate(all_removed, start=1): | |
| print(f'- [{i:4}] {removed}') | |
| def _cycle_set(graph: graph.Graph, | |
| max_cycle_size: int) -> Set[count_cycles.Cycle]: | |
| all_cycles_by_size = count_cycles.find_cycles(graph, max_cycle_size) | |
| return set(itertools.chain(*all_cycles_by_size)) | |
| def main(): | |
| arg_parser = argparse.ArgumentParser( | |
| description='Given two JSON dependency graphs, output the differences ' | |
| 'between them. By default, outputs the differences in the sets of ' | |
| 'class and package nodes.') | |
| required_arg_group = arg_parser.add_argument_group('required arguments') | |
| required_arg_group.add_argument( | |
| '-b', | |
| '--before', | |
| required=True, | |
| help='Path to the JSON file containing the "before" dependency graph. ' | |
| 'See the README on how to generate this file.') | |
| required_arg_group.add_argument( | |
| '-a', | |
| '--after', | |
| required=True, | |
| help='Path to the JSON file containing the "after" dependency graph.') | |
| arg_parser.add_argument('-e', | |
| '--edges', | |
| action='store_true', | |
| help='Also diff the set of graph edges.') | |
| arg_parser.add_argument( | |
| '--package-cycles', | |
| type=int, | |
| help='Also diff the set of package cycles up to the specified size.') | |
| arg_parser.add_argument( | |
| '--build-target', | |
| type=str, | |
| help='Also diff the set of class nodes in the given build target, e.g. ' | |
| '"//chrome/android:chrome_java"') | |
| arguments = arg_parser.parse_args() | |
| class_graph_before, package_graph_before, _ = \ | |
| serialization.load_class_and_package_graphs_from_file(arguments.before) | |
| class_graph_after, package_graph_after, _ = \ | |
| serialization.load_class_and_package_graphs_from_file(arguments.after) | |
| _print_diff_num_nodes(class_graph_before, class_graph_after, | |
| 'Total Java class count') | |
| _print_diff_num_nodes(package_graph_before, package_graph_after, | |
| 'Total Java package count') | |
| print() | |
| _print_diff_node_list(class_graph_before, class_graph_after, | |
| 'Java classes') | |
| print() | |
| _print_diff_node_list(package_graph_before, package_graph_after, | |
| 'Java packages') | |
| if arguments.edges: | |
| print() | |
| _print_diff_num_edges(class_graph_before, class_graph_after, | |
| 'Total Java class edge count') | |
| _print_diff_num_edges(package_graph_before, package_graph_after, | |
| 'Total Java package edge count') | |
| print() | |
| _print_diff_edge_list(class_graph_before, class_graph_after, | |
| 'Java class edges') | |
| print() | |
| _print_diff_edge_list(package_graph_before, package_graph_after, | |
| 'Java package edges') | |
| if arguments.package_cycles: | |
| cycles_before = _cycle_set(package_graph_before, | |
| arguments.package_cycles) | |
| cycles_after = _cycle_set(package_graph_after, | |
| arguments.package_cycles) | |
| print() | |
| _print_diff_metric( | |
| len(cycles_before), len(cycles_after), | |
| 'Total Java package cycle count (up to size ' | |
| f'{arguments.package_cycles})') | |
| print() | |
| _print_diff_cycle_list( | |
| cycles_before, cycles_after, | |
| f'Java package cycles (up to size {arguments.package_cycles})') | |
| if arguments.build_target: | |
| def is_in_build_target(node): | |
| return arguments.build_target in node.build_targets | |
| print() | |
| _print_diff_node_list_filtered( | |
| class_graph_before, class_graph_after, | |
| f'Java classes in {arguments.build_target}', is_in_build_target) | |
| if __name__ == '__main__': | |
| main() |