| #!/usr/bin/env python |
| # Copyright 2015 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """generate_idl_diff.py is a script that generates a diff of two given IDL files. |
| Usage: generate_idl_diff.py old_file.json new_file.json diff_file.json |
| old_file.json: An input json file including idl data of old Chrome version |
| new_file.json: An input json file including idl data of new Chrome version |
| diff_file.json: An output json file expressing a diff between old_file.json |
| and new_file.json |
| """ |
| |
| import json |
| import sys |
| |
| # pylint: disable=W0105 |
| """Data structure of input files of this script. |
| The format of the json files is as follows. Each json file contains multiple |
| "interface"s. Each "interface" contains 'ExtAttributes', 'Consts', 'Attributes' |
| and 'Operations'. Each item in them are called a "member". |
| {'InterfaceName': { |
| 'ExtAttributes': [{'Name': '...'}, |
| ..., |
| ], |
| 'Consts': [{'Type': '...', |
| 'Name': '...', |
| 'Value': '...' |
| }, |
| ..., |
| ], |
| 'Attributes': [{'Type': '...', |
| 'Name': '...', |
| 'ExtAttributes':[{'Name': '...'}, |
| ..., |
| ] |
| }, |
| ..., |
| ], |
| 'Operations': [{'Type': '...', |
| 'Name': '...', |
| 'ExtAttributes': [{'Name': '...'}, |
| ..., |
| ] |
| 'Arguments': [{'Type': '...', |
| 'Name': '...'}, |
| ..., |
| ] |
| }, |
| ..., |
| ], |
| 'Name': '...' |
| }, |
| ..., |
| } |
| """ |
| |
| |
| EXTATTRIBUTES_AND_MEMBER_TYPES = ['ExtAttributes', 'Consts', 'Attributes', 'Operations'] |
| DIFF_INSENSITIVE_FIELDS = ['Name'] |
| DIFF_TAG = 'diff_tag' |
| DIFF_TAG_ADDED = 'added' |
| DIFF_TAG_DELETED = 'deleted' |
| |
| |
| def load_json_file(filepath): |
| """Load a json file into a dictionary. |
| Args: |
| filepath: A json file path of a json file that we want to load |
| Returns: |
| An "interfaces" object loaded from the json file |
| """ |
| with open(filepath, 'r') as f: |
| return json.load(f) |
| |
| |
| def members_diff(old_interface, new_interface): |
| """Create a diff between two "interface" objects by adding annotations to |
| "member" objects that are not common in them. |
| Args: |
| old_interface: An "interface" object |
| new_interface: An "interface" object |
| Returns: |
| (annotated, is_changed) where |
| annotated: An annotated "interface" object |
| is_changed: True if two interfaces are not identical, otherwise False |
| """ |
| annotated = {} |
| is_changed = False |
| for member_type in EXTATTRIBUTES_AND_MEMBER_TYPES: |
| annotated_members = [] |
| unannotated_members = [] |
| for member in new_interface[member_type]: |
| if member in old_interface[member_type]: |
| unannotated_members.append(member) |
| old_interface[member_type].remove(member) |
| else: |
| is_changed = True |
| member[DIFF_TAG] = DIFF_TAG_ADDED |
| annotated_members.append(member) |
| annotated[member_type] = annotated_members |
| annotated[member_type].extend(unannotated_members) |
| for member_type in EXTATTRIBUTES_AND_MEMBER_TYPES: |
| for member in old_interface[member_type]: |
| is_changed = True |
| member[DIFF_TAG] = DIFF_TAG_DELETED |
| annotated[member_type].extend(old_interface[member_type]) |
| for field in DIFF_INSENSITIVE_FIELDS: |
| annotated[field] = old_interface[field] |
| return (annotated, is_changed) |
| |
| |
| def annotate_all_members(interface, diff_tag): |
| """Add annotations to all "member" objects of |interface|. |
| Args: |
| interface: An "interface" object whose members should be annotated with |
| |diff_tag|. |
| diff_tag: DIFF_TAG_ADDED or DIFF_TAG_DELETED |
| Returns: |
| Annotated "interface" object |
| """ |
| for member_type in EXTATTRIBUTES_AND_MEMBER_TYPES: |
| for member in interface[member_type]: |
| member[DIFF_TAG] = diff_tag |
| return interface |
| |
| |
| def interfaces_diff(old_interfaces, new_interfaces): |
| """Compare two "interfaces" objects and create a diff between them by |
| adding annotations (DIFF_TAG_ADDED or DIFF_TAG_DELETED) to each member |
| and/or interface. |
| Args: |
| old_interfaces: An "interfaces" object |
| new_interfaces: An "interfaces" object |
| Returns: |
| An "interfaces" object representing diff between |old_interfaces| and |
| |new_interfaces| |
| """ |
| annotated = {} |
| for interface_name, interface in new_interfaces.items(): |
| if interface_name in old_interfaces: |
| annotated_interface, is_changed = members_diff(old_interfaces[interface_name], interface) |
| if is_changed: |
| annotated[interface_name] = annotated_interface |
| del old_interfaces[interface_name] |
| else: |
| interface = annotate_all_members(interface, DIFF_TAG_ADDED) |
| interface[DIFF_TAG] = DIFF_TAG_ADDED |
| annotated[interface_name] = interface |
| for interface_name, interface in old_interfaces.items(): |
| interface = annotate_all_members(interface, DIFF_TAG_DELETED) |
| interface[DIFF_TAG] = DIFF_TAG_DELETED |
| annotated.update(old_interfaces) |
| return annotated |
| |
| |
| def write_diff(diff, filepath): |
| """Write a diff dictionary to a json file. |
| Args: |
| diff: An "interfaces" object that represents a diff |
| filepath: An output file path |
| """ |
| with open(filepath, 'w') as f: |
| json.dump(diff, f, indent=4) |
| |
| |
| def main(argv): |
| if len(argv) != 3: |
| sys.stdout.write( |
| 'Usage: make_diff.py <old_file.json> <new_file.json> ' |
| '<diff_file.json>\n') |
| exit(1) |
| old_json_file = argv[0] |
| new_json_file = argv[1] |
| output_file = argv[2] |
| old_interfaces = load_json_file(old_json_file) |
| new_interfaces = load_json_file(new_json_file) |
| diff = interfaces_diff(old_interfaces, new_interfaces) |
| write_diff(diff, output_file) |
| |
| |
| if __name__ == '__main__': |
| main(sys.argv[1:]) |