import os
import json
import re
import argparse
from prettytable import PrettyTable, ALL
def get_args():
parser = argparse.ArgumentParser(add_help=True)
parser.add_argument(
"-p",
"--project_path",
default=r"./",
type=str,
help="root path of project. default: ./",
)
parser.add_argument(
"-t",
"--check_target",
type=str,
choices=["component_codec", "component_sdk", "sdk_codec"],
required=True,
help="the target to be compared",
)
parser.add_argument(
"-b",
"--bundles",
nargs="*",
type=str,
help="option take effect only when the check_target is component_codec. allow multiple json file. "
"default: all bundle.json file",
)
args = parser.parse_args()
return args
def list_to_multiline(target_list: list):
return str(target_list).lstrip("[").rstrip("]").replace(", ", "\n")
def convert_set_to_sorted_list(target_set) -> list:
return sorted(list(target_set))
def add_dict_as_table_row(f_table: PrettyTable, d_dict: dict, out_converter=list_to_multiline) -> None:
s_keys = convert_set_to_sorted_list(d_dict.keys())
for i, k in enumerate(s_keys):
f_table.add_row([i + 1, k, out_converter(convert_set_to_sorted_list(d_dict.get(k)))])
def bundle_syscap_post_handler(syscap: str) -> str:
return syscap.split('=')[0].strip()
def read_value_from_json(filepath: str,
key_hierarchy: tuple,
result_dict: dict,
post_handler=None
) -> None:
if os.path.exists(filepath) is False:
print('error: file "{}" not exist.'.format(filepath))
return
if not os.path.isfile(filepath):
print('error: "{}" is not a file.')
return
with open(filepath, 'r', encoding='utf-8') as f:
data = json.load(f)
for key in key_hierarchy:
try:
data = data[key]
except KeyError:
return
finally:
pass
data = [post_handler(x) for x in data if len(x) != 0 and not x.isspace()]
if len(data) != 0:
result_dict[filepath] = data
def collect_syscap_from_codec(filepath: str, pattern: str = r'{"(.*)"') -> tuple:
"""
从syscap_define.h收集syscap
:param filepath: 文件的路径
:param pattern: 匹配syscap的规则
:return: syscap_define.h中声明的syscap集合
"""
array_syscap_set = set()
array_syscap_dict = dict()
ptrn = re.compile(pattern)
with open(filepath, "r") as f:
content = f.read()
array_syscap_set.update(re.findall(ptrn, content))
array_syscap_dict[filepath] = list()
for v in array_syscap_set:
array_syscap_dict.get(filepath).append(v)
return array_syscap_set, array_syscap_dict
def collect_syscap_from_component(project_path: str,
black_dirs: tuple,
key_heirarchy: tuple,
bundles: list = None) -> tuple:
"""
从部件的bundle.json中收集syscap
:param project_path: 项目根路径
:param black_dirs: 根路径下的一级目录的黑名单，不扫描这些bundle.json下面的内容
:param key_heirarchy: bundle.json中syscap所在的key的元组
:param bundles: 指定的bundle.json
:return: syscap_set，文件名和其syscap list组成的dict
"""
result_dict = dict()
if bundles is None:
search_dir_list = [
os.path.join(project_path, x)
for x in os.listdir(project_path)
if os.path.isdir(os.path.join(project_path, x)) and x not in black_dirs
]
for folder in search_dir_list:
output = os.popen("find {} -name bundle.json".format(folder))
for line in output:
line = line.strip()
read_value_from_json(line, key_heirarchy, result_dict, post_handler=bundle_syscap_post_handler)
output.close()
else:
for bundle in bundles:
read_value_from_json(bundle, key_heirarchy, result_dict, post_handler=bundle_syscap_post_handler)
result_set = set()
for v in result_dict.values():
result_set.update(v)
return result_set, result_dict
def sdk_syscap_post_handler(syscap: str) -> str:
return syscap.strip().lstrip("*").lstrip().lstrip("*@syscap").strip()
def collect_syscap_from_sdk(ts_path: str,
pattern: str = r"\* *@syscap +((?i)SystemCapability\..*)",
post_handler=None
) -> tuple:
"""
从sdk下的*.d.ts中收集syscap
:param ts_path: ts文件的所在路径
:param pattern: 匹配syscap的pattern
:param post_handler: 对匹配到的syscap进行后置处理
:return: syscap_set，和由文件名、syscap list组成的dict
"""
ts_list = list()
for item in os.listdir(ts_path):
file_path = os.path.join(ts_path, item)
if file_path.endswith(".d.ts") and os.path.isfile(file_path):
ts_list.append(file_path)
syscap_dict = dict()
ptrn = re.compile(pattern)
for ts in ts_list:
with open(ts, 'r') as f:
content = f.read()
sub_syscap_list = re.findall(ptrn, content)
sub_syscap_set = set()
for syscap in sub_syscap_list:
sub_syscap_set.add(post_handler(syscap))
syscap_dict[ts] = sub_syscap_set
syscap_set = set()
for v in syscap_dict.values():
syscap_set.update(v)
return syscap_set, syscap_dict
def find_files_containes_value(value_set: set, file_values_dict: dict) -> dict:
"""
查看包含指定值的文件
:param value_set: 指定值
:param file_values_dict: 文件和值组成的dict
:return: 值和文件组成的dict
"""
value_files_dict = dict()
for v in value_set:
filename_set = set()
for file in file_values_dict.keys():
if v in file_values_dict[file]:
filename_set.add(file)
if 0 != len(filename_set):
value_files_dict[v] = filename_set
return value_files_dict
def mutual_diff(a_set: set, b_set: set) -> tuple:
return a_set.difference(b_set), b_set.difference(a_set)
def print_inconsistent(diff_set: set, a_name: str, b_name: str, table: PrettyTable,
value_file_dict: dict) -> None:
table.clear()
if len(diff_set) != 0:
table.field_names = ["index", "SysCap only in {}".format(a_name), "Files"]
add_dict_as_table_row(table, value_file_dict)
elif len(diff_set) == 0:
table.field_names = ["All SysCap in {} have been Covered by {}".format(a_name, b_name)]
print(table)
print()
def print_consistent(a_diff_b_set: set, b_diff_a_set: set, table: PrettyTable, a_name: str, b_name: str) -> bool:
if len(a_diff_b_set) == 0 and len(b_diff_a_set) == 0:
table.field_names = ["{} and {} are Consistent".format(a_name, b_name)]
print(table)
print()
return True
return False
def print_check_result(a_diff_b_set: set,
b_diff_a_set: set,
a_name: str,
b_name: str,
a_value_file_dict: dict,
b_value_file_dict: dict,
) -> None:
f_table = PrettyTable()
f_table.hrules = ALL
consistent_flag = print_consistent(a_diff_b_set, b_diff_a_set, f_table, a_name, b_name)
if not consistent_flag:
print_inconsistent(a_diff_b_set, a_name, b_name, f_table, a_value_file_dict)
print_inconsistent(b_diff_a_set, b_name, a_name, f_table, b_value_file_dict)
def check_component_and_codec(project_path, syscap_define_path: str, component_black_dirs: tuple,
bundle_key_heirarchy: tuple, bundles=None):
component_syscap_set, component_syscap_dict = collect_syscap_from_component(
project_path, black_dirs=component_black_dirs, key_heirarchy=bundle_key_heirarchy, bundles=bundles
)
array_syscap_set, array_syscap_dict = collect_syscap_from_codec(syscap_define_path)
component_diff_array, array_diff_component = mutual_diff(component_syscap_set, array_syscap_set)
value_component_dict = find_files_containes_value(
component_diff_array, component_syscap_dict
)
value_h_dict = find_files_containes_value(array_diff_component, array_syscap_dict)
print_check_result(component_diff_array, array_diff_component, a_name="Component", b_name="Codec",
a_value_file_dict=value_component_dict, b_value_file_dict=value_h_dict)
def check_component_and_sdk(project_path, component_black_dirs: tuple, component_key_heirarchy: tuple, sdk_path: str):
component_syscap_set, component_syscap_dict = collect_syscap_from_component(
project_path, black_dirs=component_black_dirs, key_heirarchy=component_key_heirarchy
)
ts_syscap_set, ts_syscap_dict = collect_syscap_from_sdk(ts_path=sdk_path,
post_handler=sdk_syscap_post_handler)
component_diff_ts, ts_diff_component = mutual_diff(component_syscap_set, ts_syscap_set)
value_ts_dict = find_files_containes_value(ts_diff_component, ts_syscap_dict)
value_component_dict = find_files_containes_value(
component_diff_ts, component_syscap_dict
)
print_check_result(component_diff_ts, ts_diff_component, a_name="Component", b_name="SDK",
a_value_file_dict=value_component_dict, b_value_file_dict=value_ts_dict)
def check_sdk_and_codec(syscap_define_path: str, sdk_path: str) -> None:
ts_syscap_set, ts_syscap_dict = collect_syscap_from_sdk(ts_path=sdk_path,
post_handler=sdk_syscap_post_handler)
array_syscap_set, array_syscap_dict = collect_syscap_from_codec(syscap_define_path)
ts_diff_array, array_diff_ts = mutual_diff(ts_syscap_set, array_syscap_set)
value_ts_dict = find_files_containes_value(ts_diff_array, ts_syscap_dict)
value_h_dict = find_files_containes_value(array_diff_ts, array_syscap_dict)
print_check_result(ts_diff_array, array_diff_ts, a_name="SDK", b_name="Codec", a_value_file_dict=value_ts_dict,
b_value_file_dict=value_h_dict)
def main():
args = get_args()
project_path = args.project_path
check_target = args.check_target
bundles = args.bundles
syscap_define_path = os.path.join(project_path, "developtools", "syscap_codec", "include",
"codec_config", "syscap_define.h")
ts_path = os.path.join(project_path, "interface", "sdk-js", "api")
component_black_dirs = ("out",)
bundle_syscap_heirarchy = ("component", "syscap")
if (bundles is not None or (bundles is not None and len(bundles) != 0)) and check_target != "component_codec":
print("error: --bundles could only be used with -t component_codec")
return
if "component_sdk" == check_target:
check_component_and_sdk(project_path, component_black_dirs, bundle_syscap_heirarchy, sdk_path=ts_path)
elif "sdk_codec" == check_target:
check_sdk_and_codec(syscap_define_path=syscap_define_path, sdk_path=ts_path)
elif "component_codec" == check_target:
if bundles is not None and len(bundles) == 0:
print(r"error: '--bundles' parameter is specified, but has no value")
else:
check_component_and_codec(project_path, syscap_define_path, component_black_dirs=component_black_dirs,
bundle_key_heirarchy=bundle_syscap_heirarchy, bundles=bundles)
if __name__ == "__main__":
main()
