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

pytest_dsl/__init__.py

@@ -54,6 +54,13 @@ from pytest_dsl.core.keyword_loader import (
     group_keywords_by_source, scan_project_custom_keywords
 )
 
+# 关键字工具
+from pytest_dsl.core.keyword_utils import (
+    KeywordInfo, KeywordListOptions, KeywordFormatter, KeywordLister,
+    keyword_lister, list_keywords, get_keyword_info, search_keywords,
+    generate_html_report
+)
+
 # 便捷导入的别名
 Executor = DSLExecutor
 Validator = DSLValidator
@@ -77,6 +84,11 @@ __all__ = [
     'load_all_keywords', 'categorize_keyword', 'get_keyword_source_info',
     'group_keywords_by_source', 'scan_project_custom_keywords',
 
+    # 关键字工具
+    'KeywordInfo', 'KeywordListOptions', 'KeywordFormatter', 'KeywordLister',
+    'keyword_lister', 'list_keywords', 'get_keyword_info', 'search_keywords',
+    'generate_html_report',
+
     # Hook系统
     'hookimpl', 'hookspec', 'DSLHookSpecs',
     'hook_manager', 'DSLHookManager', 'HookManager',

pytest_dsl/cli.py

@@ -16,11 +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.keyword_loader import (
-    load_all_keywords, categorize_keyword, get_keyword_source_info,
-    group_keywords_by_source, scan_project_custom_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):
@@ -139,431 +136,25 @@ def parse_args():
         return args
 
 
-
-
-
-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):
@@ -776,8 +367,5 @@ def main_list_keywords():
     )
 
 
-
-
-
 if __name__ == '__main__':
     main()

pytest_dsl/core/dsl_executor.py

@@ -321,8 +321,6 @@ class DSLExecutor:
     def _handle_start(self, node):
         """处理开始节点"""
         try:
-            # 清空上下文，确保每个测试用例都有一个新的上下文
-            self.test_context.clear()
             metadata = {}
             teardown_node = None
 
@@ -722,6 +720,7 @@ class DSLExecutor:
                 kwargs['step_name'] = keyword_name  # 内层步骤只显示关键字名称
                 # 避免KeywordManager重复记录，由DSL执行器统一记录
                 kwargs['skip_logging'] = True
+
                 result = keyword_manager.execute(keyword_name, **kwargs)
 
                 # 执行成功后记录关键字信息，包含行号
@@ -733,9 +732,26 @@ class DSLExecutor:
 
                 return result
             except Exception as e:
-                # 记录关键字执行失败，包含行号信息
+                # 记录关键字执行失败，包含行号信息和更详细的错误信息
+                error_details = (
+                    f"关键字: {keyword_name}\n"
+                    f"错误: {str(e)}\n"
+                    f"错误类型: {type(e).__name__}"
+                    f"{line_info}"
+                )
+                
+                # 如果异常中包含了内部行号信息，提取并显示
+                if hasattr(e, 'args') and e.args:
+                    error_msg = str(e.args[0])
+                    # 尝试从错误消息中提取行号信息
+                    import re
+                    line_match = re.search(r'行(\d+)', error_msg)
+                    if line_match:
+                        inner_line = int(line_match.group(1))
+                        error_details += f"\n内部错误行号: {inner_line}"
+                
                 allure.attach(
-                    f"关键字: {keyword_name}\n错误: {str(e)}{line_info}",
+                    error_details,
                     name="关键字调用失败",
                     attachment_type=allure.attachment_type.TEXT
                 )

pytest_dsl/core/keyword_utils.py

@@ -0,0 +1,609 @@
+"""
+pytest-dsl关键字工具
+
+提供统一的关键字列表查看、格式化和导出功能，供CLI和其他程序使用。
+"""
+
+import json
+import os
+from typing import Dict, Any, Optional, Union, List
+
+from pytest_dsl.core.keyword_loader import (
+    load_all_keywords, categorize_keyword, get_keyword_source_info,
+    group_keywords_by_source
+)
+from pytest_dsl.core.keyword_manager import keyword_manager
+
+
+class KeywordInfo:
+    """关键字信息类"""
+
+    def __init__(self, name: str, info: Dict[str, Any],
+                 project_custom_keywords: Optional[Dict[str, Any]] = None):
+        self.name = name
+        self.info = info
+        self.project_custom_keywords = project_custom_keywords
+        self._category = None
+        self._source_info = None
+
+    @property
+    def category(self) -> str:
+        """获取关键字类别"""
+        if self._category is None:
+            self._category = categorize_keyword(
+                self.name, self.info, self.project_custom_keywords
+            )
+        return self._category
+
+    @property
+    def source_info(self) -> Dict[str, Any]:
+        """获取来源信息"""
+        if self._source_info is None:
+            self._source_info = get_keyword_source_info(self.info)
+        return self._source_info
+
+    @property
+    def parameters(self) -> List[Dict[str, Any]]:
+        """获取参数信息"""
+        if (self.category == 'project_custom' and
+            self.project_custom_keywords and
+                self.name in self.project_custom_keywords):
+            return self.project_custom_keywords[self.name].get('parameters', [])
+
+        # 对于其他类型的关键字
+        parameters = self.info.get('parameters', [])
+        param_list = []
+        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
+
+            param_list.append(param_data)
+
+        return param_list
+
+    @property
+    def documentation(self) -> str:
+        """获取文档信息"""
+        func = self.info.get('func')
+        if func and hasattr(func, '__doc__') and func.__doc__:
+            return func.__doc__.strip()
+        return ""
+
+    @property
+    def file_location(self) -> Optional[str]:
+        """获取文件位置（仅适用于项目自定义关键字）"""
+        if (self.category == 'project_custom' and
+            self.project_custom_keywords and
+                self.name in self.project_custom_keywords):
+            return self.project_custom_keywords[self.name]['file']
+        return None
+
+    @property
+    def remote_info(self) -> Optional[Dict[str, str]]:
+        """获取远程关键字信息"""
+        if self.info.get('remote', False):
+            return {
+                'alias': self.info.get('alias', ''),
+                'original_name': self.info.get('original_name', self.name)
+            }
+        return None
+
+
+class KeywordListOptions:
+    """关键字列表选项"""
+
+    def __init__(self,
+                 output_format: str = 'json',
+                 name_filter: Optional[str] = None,
+                 category_filter: str = 'all',
+                 include_remote: bool = False,
+                 output_file: Optional[str] = None):
+        self.output_format = output_format
+        self.name_filter = name_filter
+        self.category_filter = category_filter
+        self.include_remote = include_remote
+        self.output_file = output_file
+
+    def should_include_keyword(self, keyword_info: KeywordInfo) -> bool:
+        """判断是否应该包含此关键字"""
+        # 名称过滤
+        if (self.name_filter and
+                self.name_filter.lower() not in keyword_info.name.lower()):
+            return False
+
+        # 远程关键字过滤
+        if (not self.include_remote and
+                keyword_info.info.get('remote', False)):
+            return False
+
+        # 类别过滤
+        if (self.category_filter != 'all' and
+                keyword_info.category != self.category_filter):
+            return False
+
+        return True
+
+
+class KeywordFormatter:
+    """关键字格式化器"""
+
+    def __init__(self):
+        self.category_names = {
+            'builtin': '内置',
+            'plugin': '插件',
+            'custom': '自定义',
+            'project_custom': '项目自定义',
+            'remote': '远程'
+        }
+
+    def format_text(self, keyword_info: KeywordInfo,
+                    show_category: bool = True) -> str:
+        """格式化为文本格式"""
+        lines = []
+
+        # 关键字名称和类别
+        if show_category:
+            category_display = self.category_names.get(
+                keyword_info.category, '未知'
+            )
+            lines.append(f"关键字: {keyword_info.name} [{category_display}]")
+        else:
+            lines.append(f"关键字: {keyword_info.name}")
+
+        # 远程关键字特殊信息
+        if keyword_info.remote_info:
+            remote = keyword_info.remote_info
+            lines.append(f"  远程服务器: {remote['alias']}")
+            lines.append(f"  原始名称: {remote['original_name']}")
+
+        # 项目自定义关键字文件位置
+        if keyword_info.file_location:
+            lines.append(f"  文件位置: {keyword_info.file_location}")
+
+        # 参数信息
+        parameters = keyword_info.parameters
+        if parameters:
+            lines.append("  参数:")
+            for param_info in 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("  参数: 无")
+
+        # 函数文档
+        if keyword_info.documentation:
+            lines.append(f"  说明: {keyword_info.documentation}")
+
+        return '\n'.join(lines)
+
+    def format_json(self, keyword_info: KeywordInfo) -> Dict[str, Any]:
+        """格式化为JSON格式"""
+        keyword_data = {
+            'name': keyword_info.name,
+            'category': keyword_info.category,
+            'source_info': keyword_info.source_info,
+            'parameters': keyword_info.parameters
+        }
+
+        # 远程关键字特殊信息
+        if keyword_info.remote_info:
+            keyword_data['remote'] = keyword_info.remote_info
+
+        # 项目自定义关键字文件位置
+        if keyword_info.file_location:
+            keyword_data['file_location'] = keyword_info.file_location
+
+        # 函数文档
+        if keyword_info.documentation:
+            keyword_data['documentation'] = keyword_info.documentation
+
+        return keyword_data
+
+
+class KeywordLister:
+    """关键字列表器"""
+
+    def __init__(self):
+        self.formatter = KeywordFormatter()
+        self._project_custom_keywords = None
+
+    def get_keywords(self, options: KeywordListOptions) -> List[KeywordInfo]:
+        """获取关键字列表
+
+        Args:
+            options: 列表选项
+
+        Returns:
+            符合条件的关键字信息列表
+        """
+        # 加载关键字
+        if self._project_custom_keywords is None:
+            self._project_custom_keywords = load_all_keywords(
+                include_remote=options.include_remote
+            )
+
+        # 获取所有注册的关键字
+        all_keywords = keyword_manager._keywords
+
+        if not all_keywords:
+            return []
+
+        # 过滤关键字
+        filtered_keywords = []
+        for name, info in all_keywords.items():
+            keyword_info = KeywordInfo(
+                name, info, self._project_custom_keywords
+            )
+
+            if options.should_include_keyword(keyword_info):
+                filtered_keywords.append(keyword_info)
+
+        return filtered_keywords
+
+    def get_keywords_summary(self, keywords: List[KeywordInfo]) -> Dict[str, Any]:
+        """获取关键字统计摘要
+
+        Args:
+            keywords: 关键字列表
+
+        Returns:
+            统计摘要信息
+        """
+        total_count = len(keywords)
+        category_counts = {}
+        source_counts = {}
+
+        for keyword_info in keywords:
+            # 类别统计
+            cat = keyword_info.category
+            category_counts[cat] = category_counts.get(cat, 0) + 1
+
+            # 来源统计
+            source_name = keyword_info.source_info['name']
+            if keyword_info.file_location:
+                source_name = keyword_info.file_location
+
+            source_key = f"{cat}:{source_name}"
+            source_counts[source_key] = source_counts.get(source_key, 0) + 1
+
+        return {
+            'total_count': total_count,
+            'category_counts': category_counts,
+            'source_counts': source_counts
+        }
+
+    def list_keywords_text(self, options: KeywordListOptions) -> str:
+        """以文本格式列出关键字"""
+        keywords = self.get_keywords(options)
+        summary = self.get_keywords_summary(keywords)
+
+        if not keywords:
+            if options.name_filter:
+                return f"未找到包含 '{options.name_filter}' 的关键字"
+            else:
+                return f"未找到 {options.category_filter} 类别的关键字"
+
+        lines = []
+
+        # 统计信息
+        lines.append(f"找到 {summary['total_count']} 个关键字:")
+        for cat, count in summary['category_counts'].items():
+            cat_display = self.formatter.category_names.get(cat, cat)
+            lines.append(f"  {cat_display}: {count} 个")
+        lines.append("-" * 60)
+
+        # 按类别和来源分组显示
+        all_keywords_dict = {kw.name: kw.info for kw in keywords}
+        grouped = group_keywords_by_source(
+            all_keywords_dict, self._project_custom_keywords
+        )
+
+        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': '远程关键字'
+            }
+            lines.append(f"\n=== {cat_names[category]} ===")
+
+            for source_name, keyword_list in grouped[category].items():
+                if len(grouped[category]) > 1:  # 如果有多个来源，显示来源名
+                    lines.append(f"\n--- {source_name} ---")
+
+                for keyword_data in keyword_list:
+                    name = keyword_data['name']
+                    keyword_info = next(
+                        kw for kw in keywords if kw.name == name)
+                    lines.append("")
+                    lines.append(self.formatter.format_text(
+                        keyword_info, show_category=False
+                    ))
+
+        return '\n'.join(lines)
+
+    def list_keywords_json(self, options: KeywordListOptions) -> Dict[str, Any]:
+        """以JSON格式列出关键字"""
+        keywords = self.get_keywords(options)
+        summary = self.get_keywords_summary(keywords)
+
+        keywords_data = {
+            'summary': summary,
+            'keywords': []
+        }
+
+        # 按名称排序
+        keywords.sort(key=lambda x: x.name)
+
+        for keyword_info in keywords:
+            keyword_data = self.formatter.format_json(keyword_info)
+            keywords_data['keywords'].append(keyword_data)
+
+        return keywords_data
+
+    def list_keywords(self, options: KeywordListOptions) -> Union[str, Dict[str, Any]]:
+        """列出关键字（根据格式返回不同类型）
+
+        Args:
+            options: 列表选项
+
+        Returns:
+            文本格式返回str，JSON格式返回dict，HTML格式返回dict
+        """
+        if options.output_format == 'text':
+            return self.list_keywords_text(options)
+        elif options.output_format in ['json', 'html']:
+            return self.list_keywords_json(options)
+        else:
+            raise ValueError(f"不支持的输出格式: {options.output_format}")
+
+
+def generate_html_report(keywords_data: Dict[str, Any], output_file: str):
+    """生成HTML格式的关键字报告
+
+    Args:
+        keywords_data: 关键字数据（JSON格式）
+        output_file: 输出文件路径
+    """
+    from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+    # 准备数据
+    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)
+
+    # 类别名称映射
+    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,
+        category_names=category_names
+    )
+
+    # 写入文件
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+
+
+# 创建全局实例
+keyword_lister = KeywordLister()
+
+
+# 便捷函数
+def list_keywords(output_format: str = 'json',
+                  name_filter: Optional[str] = None,
+                  category_filter: str = 'all',
+                  include_remote: bool = False,
+                  output_file: Optional[str] = None,
+                  print_summary: bool = True) -> Union[str, Dict[str, Any], None]:
+    """列出关键字的便捷函数
+
+    Args:
+        output_format: 输出格式 ('text', 'json', 'html')
+        name_filter: 名称过滤器（支持部分匹配）
+        category_filter: 类别过滤器
+        include_remote: 是否包含远程关键字
+        output_file: 输出文件路径（可选）
+        print_summary: 是否打印摘要信息
+
+    Returns:
+        根据输出格式返回相应的数据，如果输出到文件则返回None
+    """
+    options = KeywordListOptions(
+        output_format=output_format,
+        name_filter=name_filter,
+        category_filter=category_filter,
+        include_remote=include_remote,
+        output_file=output_file
+    )
+
+    # 获取数据
+    result = keyword_lister.list_keywords(options)
+
+    if isinstance(result, str):
+        # 文本格式
+        if output_file:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(result)
+            if print_summary:
+                print(f"关键字信息已保存到文件: {output_file}")
+            return None
+        else:
+            return result
+
+    elif isinstance(result, dict):
+        # JSON或HTML格式
+        if output_format == 'json':
+            json_output = json.dumps(result, ensure_ascii=False, indent=2)
+
+            if output_file:
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write(json_output)
+                if print_summary:
+                    _print_json_summary(result, output_file)
+                return None
+            else:
+                return result
+
+        elif output_format == 'html':
+            if not output_file:
+                output_file = 'keywords.html'
+
+            try:
+                generate_html_report(result, output_file)
+                if print_summary:
+                    _print_json_summary(result, output_file, is_html=True)
+                return None
+            except Exception as e:
+                if print_summary:
+                    print(f"生成HTML报告失败: {e}")
+                raise
+
+    return result
+
+
+def _print_json_summary(keywords_data: Dict[str, Any],
+                        output_file: str, is_html: bool = False):
+    """打印JSON数据的摘要信息"""
+    summary = keywords_data['summary']
+    total_count = summary['total_count']
+    category_counts = summary['category_counts']
+
+    if is_html:
+        print(f"HTML报告已生成: {output_file}")
+    else:
+        print(f"关键字信息已保存到文件: {output_file}")
+
+    print(f"共 {total_count} 个关键字")
+
+    category_names = {
+        'builtin': '内置',
+        'plugin': '插件',
+        'custom': '自定义',
+        'project_custom': '项目自定义',
+        'remote': '远程'
+    }
+
+    for cat, count in category_counts.items():
+        cat_display = category_names.get(cat, cat)
+        print(f"  {cat_display}: {count} 个")
+
+
+def get_keyword_info(keyword_name: str,
+                     include_remote: bool = False) -> Optional[KeywordInfo]:
+    """获取单个关键字的详细信息
+
+    Args:
+        keyword_name: 关键字名称
+        include_remote: 是否包含远程关键字
+
+    Returns:
+        关键字信息对象，如果未找到则返回None
+    """
+    # 加载关键字
+    project_custom_keywords = load_all_keywords(include_remote=include_remote)
+
+    # 获取关键字信息
+    keyword_info = keyword_manager.get_keyword_info(keyword_name)
+    if not keyword_info:
+        return None
+
+    return KeywordInfo(keyword_name, keyword_info, project_custom_keywords)
+
+
+def search_keywords(pattern: str,
+                    include_remote: bool = False) -> List[KeywordInfo]:
+    """搜索匹配模式的关键字
+
+    Args:
+        pattern: 搜索模式（支持部分匹配）
+        include_remote: 是否包含远程关键字
+
+    Returns:
+        匹配的关键字信息列表
+    """
+    options = KeywordListOptions(
+        name_filter=pattern,
+        include_remote=include_remote
+    )
+    return keyword_lister.get_keywords(options)

pytest_dsl/core/lexer.py

@@ -90,6 +90,7 @@ t_PLACEHOLDER = (r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*'
 # 添加管道符的正则表达式定义
 t_PIPE = r'\|'
 
+
 # 添加@remote关键字的token规则
 def t_REMOTE_KEYWORD(t):
     r'@remote'
@@ -111,7 +112,14 @@ def t_STRING(t):
     r"""(\'\'\'[\s\S]*?\'\'\'|\"\"\"[\s\S]*?\"\"\"|'[^']*'|\"[^\"]*\")"""
     # 处理单引号和双引号的多行/单行字符串
     if t.value.startswith("'''") or t.value.startswith('"""'):
+        # 对于多行字符串，需要正确更新行号
+        original_value = t.value
         t.value = t.value[3:-3]  # 去掉三引号
+        
+        # 计算多行字符串包含的换行符数量，更新词法分析器的行号
+        newlines = original_value.count('\n')
+        if newlines > 0:
+            t.lexer.lineno += newlines
     else:
         t.value = t.value[1:-1]  # 去掉单引号或双引号
     return t

pytest_dsl/core/parser.py

@@ -198,7 +198,12 @@ def p_expr_atom(p):
     elif isinstance(p[1], Node):
         p[0] = p[1]
     else:
-        p[0] = Node('Expression', value=p[1])
+        # 为基本表达式设置行号信息
+        expr_line = getattr(p.slice[1], 'lineno', None)
+        expr_node = Node('Expression', value=p[1])
+        if expr_line is not None:
+            expr_node.set_position(expr_line)
+        p[0] = expr_node
 
 
 def p_boolean_expr(p):
@@ -265,8 +270,29 @@ def p_keyword_call(p):
     line_number = getattr(p.slice[1], 'lineno', None)
 
     if len(p) == 6:
-        p[0] = Node('KeywordCall', [p[5]], p[2], line_number=line_number)
+        # 对于有参数的关键字调用，尝试获取更精确的行号
+        # 优先使用关键字名称的行号，其次是左括号的行号
+        keyword_line = getattr(p.slice[2], 'lineno', None)
+        if keyword_line is not None:
+            line_number = keyword_line
+
+        keyword_node = Node('KeywordCall', [p[5]], p[2],
+                            line_number=line_number)
+
+        # 为参数列表中的每个参数也设置行号信息（如果可用）
+        if p[5] and isinstance(p[5], list):
+            for param in p[5]:
+                if (hasattr(param, 'set_position') and
+                        not hasattr(param, 'line_number')):
+                    # 如果参数没有行号，使用关键字的行号作为默认值
+                    param.set_position(line_number)
+
+        p[0] = keyword_node
     else:
+        # 对于无参数的关键字调用，也优先使用关键字名称的行号
+        keyword_line = getattr(p.slice[2], 'lineno', None)
+        if keyword_line is not None:
+            line_number = keyword_line
         p[0] = Node('KeywordCall', [[]], p[2], line_number=line_number)
 
 
@@ -286,7 +312,15 @@ def p_parameter_items(p):
 
 def p_parameter_item(p):
     '''parameter_item : ID COLON expression'''
-    p[0] = Node('ParameterItem', value=p[1], children=[p[3]])
+    # 获取参数名的行号
+    param_line = getattr(p.slice[1], 'lineno', None)
+    param_node = Node('ParameterItem', value=p[1], children=[p[3]])
+
+    # 设置参数节点的行号
+    if param_line is not None:
+        param_node.set_position(param_line)
+
+    p[0] = param_node
 
 
 def p_teardown(p):

{pytest_dsl-0.15.0.dist-info → pytest_dsl-0.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-dsl
-Version: 0.15.0
+Version: 0.15.1
 Summary: A DSL testing framework based on pytest
 Author: Chen Shuanglin
 License: MIT

{pytest_dsl-0.15.0.dist-info → pytest_dsl-0.15.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pytest_dsl/__init__.py,sha256=VZz4wtSOB6NkY8jkO69YM8xVfD0y0v6xwob-ljkATnE,4817
-pytest_dsl/cli.py,sha256=pkom2w-7AWEDVH-khQGfUDs3NTeiG9pmWLk04gKD-gM,27289
+pytest_dsl/__init__.py,sha256=QAn8612I9Fn7SnnuaU34ZiAImZ2sHnuVaLuHi3S_3p4,5254
+pytest_dsl/cli.py,sha256=bH2z5-Onqpir1ymB-DB-tu-fuI1nWHcwVo_3ve9Hgco,12845
 pytest_dsl/conftest_adapter.py,sha256=cevEb0oEZKTZfUrGe1-CmkFByxKhUtjuurBJP7kpLc0,149
 pytest_dsl/main_adapter.py,sha256=pUIPN_EzY3JCDlYK7yF_OeLDVqni8vtG15G7gVzPJXg,181
 pytest_dsl/plugin.py,sha256=CEwi-ci2rMevaAl9PwBw2WKXWRbXuHI1IkkDV0I0VIo,2224
@@ -9,7 +9,7 @@ pytest_dsl/core/auto_decorator.py,sha256=9Mga-GB4AzV5nkB6zpfaq8IuHa0KOH8LlFvnWyH
 pytest_dsl/core/auto_directory.py,sha256=egyTnVxtGs4P75EIivRauLRPJfN9aZpoGVvp_Ma72AM,2714
 pytest_dsl/core/context.py,sha256=fXpVQon666Lz_PCexjkWMBBr-Xcd1SkDMp2vHar6eIs,664
 pytest_dsl/core/custom_keyword_manager.py,sha256=F9aSbth4x4-5nHb0N5uG04CpgwGnQv4RDGeRKR2WuIk,16001
-pytest_dsl/core/dsl_executor.py,sha256=DQVPLCh0_Z1PQtMdU_We5Pv1im_CDEwLI0q-9DkzmIQ,47992
+pytest_dsl/core/dsl_executor.py,sha256=aDK7rXbE5xLg4DcQ5VMbexSBuh4YGMDrVqtXENFCbsw,48638
 pytest_dsl/core/dsl_executor_utils.py,sha256=ZJLSYSsiKHqg53d3Bl--ZF8m9abd5kpqdevWl31KEZg,2276
 pytest_dsl/core/execution_tracker.py,sha256=Pwcxraxt_xkOouq32KBqola-OVfnbaomCoMTyUIqoN4,9476
 pytest_dsl/core/global_context.py,sha256=NcEcS2V61MT70tgAsGsFWQq0P3mKjtHQr1rgT3yTcyY,3535
@@ -21,8 +21,9 @@ pytest_dsl/core/http_client.py,sha256=hdx8gI4JCmq1-96pbiKeyKzSQUzPAi08cRNmljiPQm
 pytest_dsl/core/http_request.py,sha256=6e-gTztH3wu2eSW27Nc0uPmyWjB6oBwndx8Vqnu5uyg,60030
 pytest_dsl/core/keyword_loader.py,sha256=3GQ4w5Zf2XdkoJ85uYXh9YB93_8L8OAb7vvuKE3-gVA,13864
 pytest_dsl/core/keyword_manager.py,sha256=5WZWwlYk74kGHh1T6WjCuVd8eelq2-UEXvDIe4U7rEI,7730
-pytest_dsl/core/lexer.py,sha256=WaLzt9IhtHiA90Fg2WGgfVztveCUhtgxzANBaEiy-F8,4347
-pytest_dsl/core/parser.py,sha256=iDxZ6MHa6EtDUieWDBYP36f2QYPBxKnIdoWgTrpulkI,14471
+pytest_dsl/core/keyword_utils.py,sha256=1zIKzbA8Lhifc97skzN4oJV-2Cljzf9aVSutwjU7LaA,19847
+pytest_dsl/core/lexer.py,sha256=o_EJIadfhgyCImI73Y9ybqlBE9AisgA6nOhxpXNlaMw,4648
+pytest_dsl/core/parser.py,sha256=LCyFNwrIO0dEup7HubnCkceAPqY7Qt5aoSKQddqG7Os,15898
 pytest_dsl/core/parsetab.py,sha256=o4XbFKwpsi3fYmfI_F6u5NSM61Qp6gTx-Sfh1jDINxI,31767
 pytest_dsl/core/plugin_discovery.py,sha256=3pt3EXJ7EPF0rkUlyDZMVHkIiTy2vicdIIQJkrHXZjY,8305
 pytest_dsl/core/utils.py,sha256=q0AMdw5HO33JvlA3UJeQ7IXh1Z_8K1QlwiM1_yiITrU,5350
@@ -72,9 +73,9 @@ pytest_dsl/remote/keyword_client.py,sha256=BL80MOaLroUi0v-9sLtkJ55g1R0Iw9SE1k11I
 pytest_dsl/remote/keyword_server.py,sha256=vGIE3Bhh461xX_u1U-Cf5nrWL2GQFYdtQdcMWfFIYgE,22320
 pytest_dsl/remote/variable_bridge.py,sha256=dv-d3Gq9ttvvrXM1fdlLtoSOPB6vRp0_GBOwX4wvcy8,7121
 pytest_dsl/templates/keywords_report.html,sha256=7x84iq6hi08nf1iQ95jZ3izcAUPx6JFm0_8xS85CYws,31241
-pytest_dsl-0.15.0.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
-pytest_dsl-0.15.0.dist-info/METADATA,sha256=C0m-LwNfCj8xXE_CzU1rIUVCuUsxQkeodkC7IQxxDSk,29655
-pytest_dsl-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytest_dsl-0.15.0.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
-pytest_dsl-0.15.0.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
-pytest_dsl-0.15.0.dist-info/RECORD,,
+pytest_dsl-0.15.1.dist-info/licenses/LICENSE,sha256=Rguy8cb9sYhK6cmrBdXvwh94rKVDh2tVZEWptsHIsVM,1071
+pytest_dsl-0.15.1.dist-info/METADATA,sha256=tBZyIhox0tvZCCVK2aaP2EIUNyawij9coLH0NFn8PUo,29655
+pytest_dsl-0.15.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytest_dsl-0.15.1.dist-info/entry_points.txt,sha256=PLOBbH02OGY1XR1JDKIZB1Em87loUvbgMRWaag-5FhY,204
+pytest_dsl-0.15.1.dist-info/top_level.txt,sha256=4CrSx4uNqxj7NvK6k1y2JZrSrJSzi-UvPZdqpUhumWM,11
+pytest_dsl-0.15.1.dist-info/RECORD,,