pytest-dsl 0.14.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

pytest_dsl/cli.py

@@ -16,10 +16,8 @@ from pytest_dsl.core.yaml_loader import load_yaml_variables_from_args
 from pytest_dsl.core.auto_directory import (
     SETUP_FILE_NAME, TEARDOWN_FILE_NAME, execute_hook_file
 )
-from pytest_dsl.core.plugin_discovery import (
-    load_all_plugins, scan_local_keywords
-)
-from pytest_dsl.core.keyword_manager import keyword_manager
+from pytest_dsl.core.keyword_loader import load_all_keywords
+from pytest_dsl.core.keyword_utils import list_keywords as utils_list_keywords
 
 
 def read_file(filename):
@@ -138,588 +136,25 @@ def parse_args():
         return args
 
 
-def load_all_keywords(include_remote=False):
-    """加载所有可用的关键字
-
-    Args:
-        include_remote: 是否包含远程关键字，默认为False
-    """
-    # 首先导入内置关键字模块，确保内置关键字被注册
-    try:
-        import pytest_dsl.keywords  # noqa: F401
-        print("内置关键字模块加载完成")
-    except ImportError as e:
-        print(f"加载内置关键字模块失败: {e}")
-
-    # 加载已安装的关键字插件
-    load_all_plugins()
-
-    # 扫描本地关键字
-    scan_local_keywords()
-
-    # 自动导入项目中的resources目录
-    try:
-        from pytest_dsl.core.custom_keyword_manager import (
-            custom_keyword_manager)
-
-        # 尝试从多个可能的项目根目录位置导入resources
-        possible_roots = [
-            os.getcwd(),  # 当前工作目录
-            os.path.dirname(os.getcwd()),  # 上级目录
-        ]
-
-        # 尝试每个可能的根目录
-        for project_root in possible_roots:
-            if project_root and os.path.exists(project_root):
-                resources_dir = os.path.join(project_root, "resources")
-                if (os.path.exists(resources_dir) and
-                        os.path.isdir(resources_dir)):
-                    custom_keyword_manager.auto_import_resources_directory(
-                        project_root)
-                    break
-    except Exception as e:
-        print(f"自动导入resources目录时出现警告: {str(e)}")
-
-    # 扫描项目中的自定义关键字（.resource文件中定义的）
-    project_custom_keywords = scan_project_custom_keywords()
-    if project_custom_keywords:
-        print(f"发现 {len(project_custom_keywords)} 个项目自定义关键字")
-
-        # 加载.resource文件中的关键字到关键字管理器
-        from pytest_dsl.core.custom_keyword_manager import (
-            custom_keyword_manager
-        )
-        from pathlib import Path
-
-        project_root = Path(os.getcwd())
-        resource_files = list(project_root.glob('**/*.resource'))
-
-        for resource_file in resource_files:
-            try:
-                custom_keyword_manager.load_resource_file(str(resource_file))
-                print(f"已加载资源文件: {resource_file}")
-            except Exception as e:
-                print(f"加载资源文件失败 {resource_file}: {e}")
-
-    # 根据参数决定是否加载远程关键字
-    if include_remote:
-        print("正在扫描远程关键字...")
-        # 这里可以添加远程关键字的扫描逻辑
-        # 目前远程关键字是通过DSL文件中的@remote导入指令动态加载的
-    else:
-        print("跳过远程关键字扫描")
-
-    return project_custom_keywords
-
-
-def categorize_keyword(keyword_name, keyword_info,
-                       project_custom_keywords=None):
-    """判断关键字的类别"""
-    # 优先使用存储的来源信息
-    source_type = keyword_info.get('source_type')
-    if source_type:
-        if source_type == 'builtin':
-            return 'builtin'
-        elif source_type == 'plugin':
-            return 'plugin'
-        elif source_type in ['external', 'local']:
-            return 'custom'
-        elif source_type == 'project_custom':
-            return 'project_custom'
-
-    # 向后兼容：使用原有的判断逻辑
-    if keyword_info.get('remote', False):
-        return 'remote'
-
-    # 检查是否是项目自定义关键字（DSL文件中定义的）
-    if project_custom_keywords and keyword_name in project_custom_keywords:
-        return 'project_custom'
-
-    # 检查是否是内置关键字（通过检查函数所在模块）
-    func = keyword_info.get('func')
-    if func and hasattr(func, '__module__'):
-        module_name = func.__module__
-        if module_name and module_name.startswith('pytest_dsl.keywords'):
-            return 'builtin'
-
-    return 'custom'
-
-
-def get_keyword_source_info(keyword_info):
-    """获取关键字的详细来源信息"""
-    source_type = keyword_info.get('source_type', 'unknown')
-    source_name = keyword_info.get('source_name', '未知')
-
-    return {
-        'type': source_type,
-        'name': source_name,
-        'display_name': source_name,
-        'module': keyword_info.get('module_name', ''),
-        'plugin_module': keyword_info.get('plugin_module', '')
-    }
-
-
-def group_keywords_by_source(keywords_dict, project_custom_keywords=None):
-    """按来源分组关键字
-
-    Returns:
-        dict: 格式为 {source_group: {source_name: [keywords]}}
-    """
-    groups = {
-        'builtin': {},
-        'plugin': {},
-        'custom': {},
-        'project_custom': {},
-        'remote': {}
-    }
-
-    for keyword_name, keyword_info in keywords_dict.items():
-        category = categorize_keyword(
-            keyword_name, keyword_info, project_custom_keywords
-        )
-        source_info = get_keyword_source_info(keyword_info)
-
-        # 特殊处理项目自定义关键字
-        if category == 'project_custom' and project_custom_keywords:
-            custom_info = project_custom_keywords[keyword_name]
-            source_name = custom_info['file']
-        else:
-            source_name = source_info['name']
-
-        if source_name not in groups[category]:
-            groups[category][source_name] = []
-
-        groups[category][source_name].append({
-            'name': keyword_name,
-            'info': keyword_info,
-            'source_info': source_info
-        })
-
-    return groups
-
-
-def format_keyword_info_text(keyword_name, keyword_info, show_category=True,
-                             project_custom_keywords=None):
-    """格式化关键字信息为文本格式"""
-    lines = []
-
-    # 关键字名称和类别
-    category = categorize_keyword(
-        keyword_name, keyword_info, project_custom_keywords
-    )
-    category_names = {
-        'builtin': '内置',
-        'custom': '自定义',
-        'project_custom': '项目自定义',
-        'remote': '远程'
-    }
-
-    if show_category:
-        category_display = category_names.get(category, '未知')
-        lines.append(f"关键字: {keyword_name} [{category_display}]")
-    else:
-        lines.append(f"关键字: {keyword_name}")
-
-    # 远程关键字特殊标识
-    if keyword_info.get('remote', False):
-        alias = keyword_info.get('alias', '未知')
-        original_name = keyword_info.get('original_name', keyword_name)
-        lines.append(f"  远程服务器: {alias}")
-        lines.append(f"  原始名称: {original_name}")
-
-    # 项目自定义关键字特殊标识
-    if category == 'project_custom' and project_custom_keywords:
-        custom_info = project_custom_keywords[keyword_name]
-        lines.append(f"  文件位置: {custom_info['file']}")
-
-        # 对于项目自定义关键字，使用从AST中提取的参数信息
-        custom_parameters = custom_info.get('parameters', [])
-        if custom_parameters:
-            lines.append("  参数:")
-            for param_info in custom_parameters:
-                param_name = param_info['name']
-                param_mapping = param_info.get('mapping', '')
-                param_desc = param_info.get('description', '')
-                param_default = param_info.get('default', None)
-
-                # 构建参数描述
-                param_parts = []
-                if param_mapping and param_mapping != param_name:
-                    param_parts.append(f"{param_name} ({param_mapping})")
-                else:
-                    param_parts.append(param_name)
-
-                param_parts.append(f": {param_desc}")
-
-                # 添加默认值信息
-                if param_default is not None:
-                    param_parts.append(f" (默认值: {param_default})")
-
-                lines.append(f"    {''.join(param_parts)}")
-        else:
-            lines.append("  参数: 无")
-    else:
-        # 参数信息（对于其他类型的关键字）
-        parameters = keyword_info.get('parameters', [])
-        if parameters:
-            lines.append("  参数:")
-            for param in parameters:
-                param_name = getattr(param, 'name', str(param))
-                param_mapping = getattr(param, 'mapping', '')
-                param_desc = getattr(param, 'description', '')
-                param_default = getattr(param, 'default', None)
-
-                # 构建参数描述
-                param_info = []
-                if param_mapping and param_mapping != param_name:
-                    param_info.append(f"{param_name} ({param_mapping})")
-                else:
-                    param_info.append(param_name)
-
-                param_info.append(f": {param_desc}")
-
-                # 添加默认值信息
-                if param_default is not None:
-                    param_info.append(f" (默认值: {param_default})")
-
-                lines.append(f"    {''.join(param_info)}")
-        else:
-            lines.append("  参数: 无")
-
-    # 函数文档
-    func = keyword_info.get('func')
-    if func and hasattr(func, '__doc__') and func.__doc__:
-        lines.append(f"  说明: {func.__doc__.strip()}")
-
-    return '\n'.join(lines)
-
-
-def format_keyword_info_json(keyword_name, keyword_info,
-                             project_custom_keywords=None):
-    """格式化关键字信息为JSON格式"""
-    category = categorize_keyword(
-        keyword_name, keyword_info, project_custom_keywords
-    )
-    source_info = get_keyword_source_info(keyword_info)
-
-    keyword_data = {
-        'name': keyword_name,
-        'category': category,
-        'source_info': source_info,
-        'parameters': []
-    }
-
-    # 远程关键字特殊信息
-    if keyword_info.get('remote', False):
-        keyword_data['remote'] = {
-            'alias': keyword_info.get('alias', ''),
-            'original_name': keyword_info.get('original_name', keyword_name)
-        }
-
-    # 项目自定义关键字特殊信息
-    if category == 'project_custom' and project_custom_keywords:
-        custom_info = project_custom_keywords[keyword_name]
-        keyword_data['file_location'] = custom_info['file']
-
-        # 对于项目自定义关键字，使用从AST中提取的参数信息
-        for param_info in custom_info.get('parameters', []):
-            keyword_data['parameters'].append(param_info)
-    else:
-        # 参数信息（对于其他类型的关键字）
-        parameters = keyword_info.get('parameters', [])
-        for param in parameters:
-            param_data = {
-                'name': getattr(param, 'name', str(param)),
-                'mapping': getattr(param, 'mapping', ''),
-                'description': getattr(param, 'description', '')
-            }
-
-            # 添加默认值信息
-            param_default = getattr(param, 'default', None)
-            if param_default is not None:
-                param_data['default'] = param_default
-
-            keyword_data['parameters'].append(param_data)
-
-    # 函数文档
-    func = keyword_info.get('func')
-    if func and hasattr(func, '__doc__') and func.__doc__:
-        keyword_data['documentation'] = func.__doc__.strip()
-
-    return keyword_data
-
-
-def generate_html_report(keywords_data, output_file):
-    """生成HTML格式的关键字报告"""
-    from jinja2 import Environment, FileSystemLoader, select_autoescape
-    import os
-
-    # 准备数据
-    summary = keywords_data['summary']
-    keywords = keywords_data['keywords']
-
-    # 按类别分组
-    categories = {}
-    for keyword in keywords:
-        category = keyword['category']
-        if category not in categories:
-            categories[category] = []
-        categories[category].append(keyword)
-
-    # 按来源分组（用于更详细的分组视图）
-    source_groups = {}
-    for keyword in keywords:
-        source_info = keyword.get('source_info', {})
-        category = keyword['category']
-        source_name = source_info.get('name', '未知来源')
-
-        # 构建分组键
-        if category == 'plugin':
-            group_key = f"插件 - {source_name}"
-        elif category == 'builtin':
-            group_key = "内置关键字"
-        elif category == 'project_custom':
-            group_key = f"项目自定义 - {keyword.get('file_location', source_name)}"
-        elif category == 'remote':
-            group_key = f"远程 - {source_name}"
-        else:
-            group_key = f"自定义 - {source_name}"
-
-        if group_key not in source_groups:
-            source_groups[group_key] = []
-        source_groups[group_key].append(keyword)
-
-    # 按位置分组（用于全部关键字视图，保持向后兼容）
-    location_groups = {}
-    for keyword in keywords:
-        # 优先使用file_location，然后使用source_info中的name
-        location = keyword.get('file_location')
-        if not location:
-            source_info = keyword.get('source_info', {})
-            location = source_info.get('name', '内置/插件')
-
-        if location not in location_groups:
-            location_groups[location] = []
-        location_groups[location].append(keyword)
-
-    # 类别名称映射
-    category_names = {
-        'builtin': '内置',
-        'plugin': '插件',
-        'custom': '自定义',
-        'project_custom': '项目自定义',
-        'remote': '远程'
-    }
-
-    # 设置Jinja2环境
-    template_dir = os.path.join(os.path.dirname(__file__), 'templates')
-
-    env = Environment(
-        loader=FileSystemLoader(template_dir),
-        autoescape=select_autoescape(['html', 'xml'])
-    )
-
-    # 加载模板
-    template = env.get_template('keywords_report.html')
-
-    # 渲染模板
-    html_content = template.render(
-        summary=summary,
-        keywords=keywords,
-        categories=categories,
-        source_groups=source_groups,
-        location_groups=location_groups,
-        category_names=category_names
-    )
-
-    # 写入文件
-    with open(output_file, 'w', encoding='utf-8') as f:
-        f.write(html_content)
-
-    print(f"HTML报告已生成: {output_file}")
-
-
 def list_keywords(output_format='json', name_filter=None,
                   category_filter='all', output_file=None,
                   include_remote=False):
-    """罗列所有关键字信息"""
-    import json
-
+    """罗列所有关键字信息（简化版，调用统一的工具函数）"""
     print("正在加载关键字...")
-    project_custom_keywords = load_all_keywords(include_remote=include_remote)
-
-    # 获取所有注册的关键字
-    all_keywords = keyword_manager._keywords
-
-    if not all_keywords:
-        print("未发现任何关键字")
-        return
-
-    # 过滤关键字
-    filtered_keywords = {}
-
-    for name, info in all_keywords.items():
-        # 名称过滤
-        if name_filter and name_filter.lower() not in name.lower():
-            continue
 
-        # 远程关键字过滤
-        if not include_remote and info.get('remote', False):
-            continue
-
-        # 类别过滤
-        if category_filter != 'all':
-            keyword_category = categorize_keyword(
-                name, info, project_custom_keywords
-            )
-            if keyword_category != category_filter:
-                continue
-
-        filtered_keywords[name] = info
-
-    if not filtered_keywords:
-        if name_filter:
-            print(f"未找到包含 '{name_filter}' 的关键字")
-        else:
-            print(f"未找到 {category_filter} 类别的关键字")
-        return
-
-    # 输出统计信息
-    total_count = len(filtered_keywords)
-    category_counts = {}
-    source_counts = {}
-
-    for name, info in filtered_keywords.items():
-        cat = categorize_keyword(name, info, project_custom_keywords)
-        category_counts[cat] = category_counts.get(cat, 0) + 1
-
-        # 统计各来源的关键字数量
-        source_info = get_keyword_source_info(info)
-        source_name = source_info['name']
-        if cat == 'project_custom' and project_custom_keywords:
-            custom_info = project_custom_keywords[name]
-            source_name = custom_info['file']
-
-        source_key = f"{cat}:{source_name}"
-        source_counts[source_key] = source_counts.get(source_key, 0) + 1
-
-    if output_format == 'text':
-        print(f"\n找到 {total_count} 个关键字:")
-        for cat, count in category_counts.items():
-            cat_names = {
-                'builtin': '内置', 'plugin': '插件', 'custom': '自定义',
-                'project_custom': '项目自定义', 'remote': '远程'
-            }
-            print(f"  {cat_names.get(cat, cat)}: {count} 个")
-        print("-" * 60)
-
-        # 按类别和来源分组显示
-        grouped = group_keywords_by_source(
-            filtered_keywords, project_custom_keywords
+    # 使用统一的工具函数
+    try:
+        utils_list_keywords(
+            output_format=output_format,
+            name_filter=name_filter,
+            category_filter=category_filter,
+            include_remote=include_remote,
+            output_file=output_file,
+            print_summary=True
         )
-
-        for category in [
-            'builtin', 'plugin', 'custom', 'project_custom', 'remote'
-        ]:
-            if category not in grouped or not grouped[category]:
-                continue
-
-            cat_names = {
-                'builtin': '内置关键字',
-                'plugin': '插件关键字',
-                'custom': '自定义关键字',
-                'project_custom': '项目自定义关键字',
-                'remote': '远程关键字'
-            }
-            print(f"\n=== {cat_names[category]} ===")
-
-            for source_name, keyword_list in grouped[category].items():
-                if len(grouped[category]) > 1:  # 如果有多个来源，显示来源名
-                    print(f"\n--- {source_name} ---")
-
-                for keyword_data in keyword_list:
-                    name = keyword_data['name']
-                    info = keyword_data['info']
-                    print()
-                    print(format_keyword_info_text(
-                        name, info, show_category=False,
-                        project_custom_keywords=project_custom_keywords
-                    ))
-
-    elif output_format == 'json':
-        keywords_data = {
-            'summary': {
-                'total_count': total_count,
-                'category_counts': category_counts,
-                'source_counts': source_counts
-            },
-            'keywords': []
-        }
-
-        for name in sorted(filtered_keywords.keys()):
-            info = filtered_keywords[name]
-            keyword_data = format_keyword_info_json(
-                name, info, project_custom_keywords
-            )
-            keywords_data['keywords'].append(keyword_data)
-
-        json_output = json.dumps(keywords_data, ensure_ascii=False, indent=2)
-
-        # 确定输出文件名
-        if output_file is None:
-            output_file = 'keywords.json'
-
-        # 写入到文件
-        try:
-            with open(output_file, 'w', encoding='utf-8') as f:
-                f.write(json_output)
-            print(f"关键字信息已保存到文件: {output_file}")
-            print(f"共 {total_count} 个关键字")
-            for cat, count in category_counts.items():
-                cat_names = {
-                    'builtin': '内置', 'plugin': '插件', 'custom': '自定义',
-                    'project_custom': '项目自定义', 'remote': '远程'
-                }
-                print(f"  {cat_names.get(cat, cat)}: {count} 个")
-        except Exception as e:
-            print(f"保存文件失败: {e}")
-            # 如果写入文件失败，则回退到打印
-            print(json_output)
-
-    elif output_format == 'html':
-        keywords_data = {
-            'summary': {
-                'total_count': total_count,
-                'category_counts': category_counts,
-                'source_counts': source_counts
-            },
-            'keywords': []
-        }
-
-        for name in sorted(filtered_keywords.keys()):
-            info = filtered_keywords[name]
-            keyword_data = format_keyword_info_json(
-                name, info, project_custom_keywords
-            )
-            keywords_data['keywords'].append(keyword_data)
-
-        # 确定输出文件名
-        if output_file is None:
-            output_file = 'keywords.html'
-
-        # 生成HTML报告
-        try:
-            generate_html_report(keywords_data, output_file)
-            print(f"共 {total_count} 个关键字")
-            for cat, count in category_counts.items():
-                cat_names = {
-                    'builtin': '内置', 'plugin': '插件', 'custom': '自定义',
-                    'project_custom': '项目自定义', 'remote': '远程'
-                }
-                print(f"  {cat_names.get(cat, cat)}: {count} 个")
-        except Exception as e:
-            print(f"生成HTML报告失败: {e}")
-            raise
+    except Exception as e:
+        print(f"列出关键字失败: {e}")
+        raise
 
 
 def load_yaml_variables(args):
@@ -932,107 +367,5 @@ def main_list_keywords():
     )
 
 
-def scan_project_custom_keywords(project_root=None):
-    """扫描项目中.resource文件中的自定义关键字
-
-    Args:
-        project_root: 项目根目录，默认为当前工作目录
-
-    Returns:
-        dict: 自定义关键字信息，格式为 
-              {keyword_name: {'file': file_path, 'node': ast_node}}
-    """
-    if project_root is None:
-        project_root = os.getcwd()
-
-    project_root = Path(project_root)
-    custom_keywords = {}
-
-    # 查找所有.resource文件
-    resource_files = list(project_root.glob('**/*.resource'))
-
-    if not resource_files:
-        return custom_keywords
-
-    lexer = get_lexer()
-    parser = get_parser()
-
-    for file_path in resource_files:
-        try:
-            # 读取并解析文件
-            content = read_file(str(file_path))
-            ast = parser.parse(content, lexer=lexer)
-
-            # 查找自定义关键字定义
-            keywords_in_file = extract_custom_keywords_from_ast(
-                ast, str(file_path)
-            )
-            custom_keywords.update(keywords_in_file)
-
-        except Exception as e:
-            print(f"解析资源文件 {file_path} 时出错: {e}")
-
-    return custom_keywords
-
-
-def extract_custom_keywords_from_ast(ast, file_path):
-    """从AST中提取自定义关键字定义
-
-    Args:
-        ast: 抽象语法树
-        file_path: 文件路径
-
-    Returns:
-        dict: 自定义关键字信息
-    """
-    custom_keywords = {}
-
-    if ast.type != 'Start' or len(ast.children) < 2:
-        return custom_keywords
-
-    # 遍历语句节点
-    statements_node = ast.children[1]
-    if statements_node.type != 'Statements':
-        return custom_keywords
-
-    for node in statements_node.children:
-        # 支持两种格式：CustomKeyword（旧格式）和Function（新格式）
-        if node.type in ['CustomKeyword', 'Function']:
-            keyword_name = node.value
-
-            # 提取参数信息
-            params_node = node.children[0] if node.children else None
-            parameters = []
-
-            if params_node:
-                for param in params_node:
-                    param_name = param.value
-                    param_default = None
-
-                    # 检查是否有默认值
-                    if param.children and param.children[0]:
-                        param_default = param.children[0].value
-
-                    param_info = {
-                        'name': param_name,
-                        'mapping': param_name,
-                        'description': f'自定义关键字参数 {param_name}'
-                    }
-
-                    if param_default is not None:
-                        param_info['default'] = param_default
-
-                    parameters.append(param_info)
-
-            custom_keywords[keyword_name] = {
-                'file': file_path,
-                'node': node,
-                'type': 'project_custom',
-                'parameters': parameters
-            }
-
-    return custom_keywords
-
-
 if __name__ == '__main__':
     main()