python实现测试脚本的关键字统计程序

通常自动化测试项目到了一定的程序，编写的测试代码自然就会很多，如果很早已经编写的测试脚本现在某些基础函数、业务函数需要修改，那么势必要找出那些引用过这个被修改函数的地方，有些IDE支持全文查找和引用查找，而有些简单的可能就没有，因为日后要用到统计功能、和一些其它的需求，所以写了一个脚本。除了跟目录下全文查找引用过的文件外，还是支持统计查找到的数量，一次可以查找多个关键字，支持按主关键字来归类。

#encoding: utf-8
import os
import sys
import re

reload(sys)
sys.setdefaultencoding("utf-8")

short_exclude = [".svn", "sendbox"]   ##不检查的文件、目录名
long_exclude = []   ##不包含检查的文件、目录的完整路径
extend_name = [".rb"]  ##指定检查的文件后缀
temp_key_words = [ 
    {
        "key" : "#作者：",
        "display" : "作者",
        "times" : -1,
        "match" : "include",
        "primary_key" : True,
    },
    {
        "key" : "#[summary]",
        "display" : "完成用例数",
        "times" : -1,
        "match" : "include",
    },    
    {
        "key" : "File.expand_path",
        "display" : "有状态行数",
        "times" : -1,
        "ignore_case" : True,
    },    
    {
        "key" : "def\s+test_",
        "display" : "有效用例数",
        "times" : -1,
        "match" : "regex",
        "ignore_case" : True,
    },    
    {
        "key" : "#def\s+test_",
        "display" : "注释用例数",
        "times" : -1,
        "match" : "regex",
        "ignore_case" : True,
    },    
]

for kv in temp_key_words:
    if not "key" in kv:
        raise "以下的列表中没有【key】值！\n%s" % kv
    if not "key" in kv:
        raise "以下的列表中没有【display】值！\n%s" % kv    
    kv['times'] = kv.get('times', -1)   ##默认为不限制检查次数     
    if kv.get("ignore_case", True)==False:  ##默认忽略大小写
        flag = 0
    else:
        flag = re.I       
    kv['pattern'] = re.compile(kv['key'], flag)
    if kv.get("primary_key", False):
        kv['times'] = 1
import copy
key_words = []        

def deepcopy(objs):
    t_list = []
    for obj in objs:
        t_list.append(copy.copy(obj))
    return t_list

def loop_case(root_dir):
    t_sum = []
    print root_dir
    sub_gen = os.listdir(root_dir)
    for sub in sub_gen:
        if sub in short_exclude:  ##在不检查文件、目录范围中
            continue
        abs_path = os.path.join(root_dir, sub)
        if long_exclude:
            is_exclude = False
            for exclude in long_exclude:
                if exclude == abs_path[-len(exclude):]:
                    is_exclude = True
                    break
            if is_exclude:
                continue
        print abs_path
        if os.path.isdir(abs_path):
            print "dir"
            t_sum.extend(loop_case(abs_path))
        elif os.path.isfile(abs_path):            
            if not "." + abs_path.rsplit(".", 1)[1] in extend_name:  ##不在后缀名 检查范围中
                continue
            print "file"
            global key_words 
            key_words = deepcopy(temp_key_words)          
            t_sum.append(count_case(abs_path)) 
    return t_sum        
    
def count_case(abs_path):   
    t_dict = {}
    with open(abs_path) as f:
        for l in f:
            l = l.strip()
            match_rule(l)  
    index = 0
    count_result = [0] * len(key_words)     
    for kv in key_words: 
        if 'primary_key' in kv:
            t_dict['primary_key'] = kv.get('display')
            t_dict['primary_key_value'] = kv.get('primary_key_value', "None")
        count_result[index] = -1-kv['times']  
        index += 1 
    t_dict['match_result'] = count_result
    t_dict['file_path'] = abs_path  
    return t_dict

def match_rule(line):
    primary_key = None  
    for kv in key_words:
        match = False                  
        if kv['times']==0:  ##检查次数已满，不再检查
            continue
        if kv.get('match', "") == "regex":  ##指定了匹配方式为:正则
            if kv['pattern'].match(line):   ##匹配正则成功
                match = True
        else:    ##默认匹配方式为： 包含
            if kv['key'] in line:   ##包含了指定字符串
                match = True
        if match:
            if kv.get('primary_key', False):
                kv['primary_key_value'] = line.split(kv['key'])[1].strip()    
#                kv['primary_key'] = False            
            kv['times'] -= 1            ##匹配成功，同理剩余匹配的次数 -1
    return primary_key        
    
def format_info(sum_list):
    tip_list = []    
    p_k_dict = {}
    for d in sum_list:
        p_k = d['primary_key_value']
        if p_k not in p_k_dict:
            p_k_dict[p_k] = [0] * len(key_words) 
        temp_list = []
        m = d['match_result']
        temp_list.append("文件名称：%s\n%s:%s\n" % (d['file_path'], d['primary_key'], d['primary_key_value']))
        for i in range(len(m)):
            if 'primary_key' in key_words[i]:               
                continue 
            else:
                t_s = str(m[i])
            temp_list.append("%s:%s\n" % (key_words[i]["display"], t_s))
            p_k_dict[p_k][i] += m[i]
        tip_list.append("".join(temp_list))
        p_k_dict[p_k][0] += 1
    tip_list.append("===========================主键统计分割线===============================")
    total_dict = {}
    for kv in key_words:
        if 'primary_key' not in kv:
            total_dict[kv['display']] = 0
    total_dict['全部文件数'] = 0
    for k,v in p_k_dict.items():
        temp_list = []
        temp_list.append("主键：%s\n文件总数：%s\n" % (k, v[0]))
        for i in range(1, len(v)):
            temp_list.append("%s:%s\n" % (key_words[i]["display"], str(v[i]))) 
            total_dict[key_words[i]["display"]] += v[i]       
        tip_list.append("".join(temp_list))
        total_dict['全部文件数'] += v[0]
    tip_list.append("===========================全部统计分割线===============================")
    temp_list = []
    for k,v in total_dict.items():
        temp_list.append("全部%s:%s\n" % (k,v))
    tip_list.append("".join(temp_list))
    tip_msg = "\n".join(tip_list)
    print tip_msg
    open(r"sum_case.log", "w").write(tip_msg)
    
if __name__=="__main__":
    if len(sys.argv) > 1:
        root_list = sys.argv[1:]
    else:
        root_list = [os.curdir]
    sum_list = []
    for root_dir in root_list:    
        if os.path.exists(root_dir) and os.path.isdir(root_dir):
            sum_list.extend(loop_case(root_dir))
            format_info(sum_list)
        else:
            print "给定的根目录无效\n%s" % root_dir

可以通过配置开头的设置来确定检查什么关键字，文件类型，过滤哪些文件和目录等