pytest-dsl 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

pytest_dsl/core/dsl_executor.py

@@ -13,6 +13,16 @@ from pytest_dsl.core.yaml_vars import yaml_vars
 from pytest_dsl.core.variable_utils import VariableReplacer
 
 
+class BreakException(Exception):
+    """Break控制流异常"""
+    pass
+
+
+class ContinueException(Exception):
+    """Continue控制流异常"""
+    pass
+
+
 class DSLExecutor:
     """DSL执行器，负责执行解析后的AST
 
@@ -90,6 +100,15 @@ class DSLExecutor:
                 item_value = self.eval_expression(item)
                 result.append(item_value)
             return result
+        elif expr_node.type == 'DictExpr':
+            # 处理字典表达式
+            result = {}
+            for item in expr_node.children:
+                # 每个item是DictItem节点，包含键和值
+                key_value = self.eval_expression(item.children[0])
+                value_value = self.eval_expression(item.children[1])
+                result[key_value] = value_value
+            return result
         elif expr_node.type == 'BooleanExpr':
             # 处理布尔值表达式
             return expr_node.value
@@ -111,13 +130,14 @@ class DSLExecutor:
             if value in self.variable_replacer.local_variables:
                 return self.variable_replacer.local_variables[value]
 
-            # 定义变量引用模式
-            pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)\}'
+            # 定义扩展的变量引用模式，支持数组索引和字典键访问
+            pattern = r'\$\{([a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*(?:(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)|(?:\[[^\]]+\]))*)\}'
             # 检查整个字符串是否完全匹配单一变量引用模式
             match = re.fullmatch(pattern, value)
             if match:
-                var_name = match.group(1)
-                return self.variable_replacer.get_variable(var_name)
+                var_ref = match.group(1)
+                # 使用新的变量路径解析器
+                return self.variable_replacer._parse_variable_path(var_ref)
             else:
                 # 如果不是单一变量，则替换字符串中的所有变量引用
                 return self.variable_replacer.replace_in_string(value)
@@ -165,7 +185,7 @@ class DSLExecutor:
         """
         left_value = self.eval_expression(expr_node.children[0])
         right_value = self.eval_expression(expr_node.children[1])
-        operator = expr_node.value  # 操作符: +, -, *, /
+        operator = expr_node.value  # 操作符: +, -, *, /, %
 
         # 尝试类型转换 - 如果是字符串数字则转为数字
         if isinstance(left_value, str) and str(left_value).replace('.', '', 1).isdigit():
@@ -200,6 +220,11 @@ class DSLExecutor:
             if right_value == 0:
                 raise Exception("除法错误: 除数不能为0")
             return left_value / right_value
+        elif operator == '%':
+            # 模运算时检查除数是否为0
+            if right_value == 0:
+                raise Exception("模运算错误: 除数不能为0")
+            return left_value % right_value
         else:
             raise Exception(f"未知的算术操作符: {operator}")
 
@@ -448,7 +473,24 @@ class DSLExecutor:
             self.variable_replacer.local_variables[var_name] = i
             self.test_context.set(var_name, i)  # 同时添加到测试上下文
             with allure.step(f"循环轮次: {var_name} = {i}"):
-                self.execute(node.children[2])
+                try:
+                    self.execute(node.children[2])
+                except BreakException:
+                    # 遇到break语句，退出循环
+                    allure.attach(
+                        f"在 {var_name} = {i} 时遇到break语句，退出循环",
+                        name="循环Break",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    break
+                except ContinueException:
+                    # 遇到continue语句，跳过本次循环
+                    allure.attach(
+                        f"在 {var_name} = {i} 时遇到continue语句，跳过本次循环",
+                        name="循环Continue",
+                        attachment_type=allure.attachment_type.TEXT
+                    )
+                    continue
 
     def _execute_keyword_call(self, node):
         """执行关键字调用"""
@@ -501,26 +543,63 @@ class DSLExecutor:
         expr_node = node.children[0]
         return self.eval_expression(expr_node)
 
+    @allure.step("执行break语句")
+    def _handle_break(self, node):
+        """处理break语句
+
+        Args:
+            node: Break节点
+
+        Raises:
+            BreakException: 抛出异常来实现break控制流
+        """
+        raise BreakException()
+
+    @allure.step("执行continue语句")
+    def _handle_continue(self, node):
+        """处理continue语句
+
+        Args:
+            node: Continue节点
+
+        Raises:
+            ContinueException: 抛出异常来实现continue控制流
+        """
+        raise ContinueException()
+
     @allure.step("执行条件语句")
     def _handle_if_statement(self, node):
-        """处理if-else语句
+        """处理if-elif-else语句
 
         Args:
-            node: IfStatement节点，包含条件表达式、if分支和可选的else分支
+            node: IfStatement节点，包含条件表达式、if分支、可选的elif分支和可选的else分支
         """
+        # 首先检查if条件
         condition = self.eval_expression(node.children[0])
 
-        # 将条件转换为布尔值进行评估
         if condition:
             # 执行if分支
             with allure.step("执行if分支"):
                 return self.execute(node.children[1])
-        elif len(node.children) > 2:
-            # 如果存在else分支且条件为假，则执行else分支
-            with allure.step("执行else分支"):
-                return self.execute(node.children[2])
 
-        # 如果条件为假且没有else分支，则不执行任何操作
+        # 如果if条件为假，检查elif分支
+        for i in range(2, len(node.children)):
+            child = node.children[i]
+
+            # 如果是ElifClause节点
+            if hasattr(child, 'type') and child.type == 'ElifClause':
+                elif_condition = self.eval_expression(child.children[0])
+                if elif_condition:
+                    with allure.step(f"执行elif分支 {i-1}"):
+                        return self.execute(child.children[1])
+
+            # 如果是普通的statements节点（else分支）
+            elif not hasattr(child, 'type') or child.type == 'Statements':
+                # 这是else分支，只有在所有前面的条件都为假时才执行
+                with allure.step("执行else分支"):
+                    return self.execute(child)
+
+        # 如果所有条件都为假且没有else分支，则不执行任何操作
         return None
 
     def _execute_remote_keyword_call(self, node):
@@ -641,7 +720,9 @@ class DSLExecutor:
             'CustomKeyword': lambda _: None,  # 添加对CustomKeyword节点的处理，只需注册不需执行
             'RemoteImport': self._handle_remote_import,
             'RemoteKeywordCall': self._execute_remote_keyword_call,
-            'AssignmentRemoteKeywordCall': self._handle_assignment_remote_keyword_call
+            'AssignmentRemoteKeywordCall': self._handle_assignment_remote_keyword_call,
+            'Break': self._handle_break,
+            'Continue': self._handle_continue
         }
 
         handler = handlers.get(node.type)

pytest_dsl/core/lexer.py

@@ -12,10 +12,13 @@ reserved = {
     'False': 'FALSE',   # 添加布尔值支持
     'return': 'RETURN',  # 添加return关键字支持
     'else': 'ELSE',   # 添加else关键字支持
+    'elif': 'ELIF',   # 添加elif关键字支持
     'if': 'IF',  # 添加if关键字支持
     'as': 'AS',   # 添加as关键字支持，用于远程关键字别名
     'function': 'FUNCTION',  # 添加function关键字支持，用于自定义关键字定义
-    'teardown': 'TEARDOWN'   # 添加teardown关键字支持，用于清理操作
+    'teardown': 'TEARDOWN',   # 添加teardown关键字支持，用于清理操作
+    'break': 'BREAK',  # 添加break关键字支持，用于循环控制
+    'continue': 'CONTINUE'  # 添加continue关键字支持，用于循环控制
 }
 
 # token 名称列表
@@ -29,6 +32,8 @@ tokens = [
     'RPAREN',
     'LBRACKET',
     'RBRACKET',
+    'LBRACE',    # 左大括号 {，用于字典字面量
+    'RBRACE',    # 右大括号 }，用于字典字面量
     'COLON',
     'COMMA',
     'PLACEHOLDER',
@@ -50,6 +55,7 @@ tokens = [
     'MINUS',     # 减法 -
     'TIMES',     # 乘法 *
     'DIVIDE',    # 除法 /
+    'MODULO',    # 模运算 %
     'PIPE',      # 管道符 |，用于远程关键字调用
 ] + list(reserved.values())
 
@@ -58,6 +64,8 @@ t_LPAREN = r'\('
 t_RPAREN = r'\)'
 t_LBRACKET = r'\['
 t_RBRACKET = r'\]'
+t_LBRACE = r'\{'
+t_RBRACE = r'\}'
 t_COLON = r':'
 t_COMMA = r','
 t_EQUALS = r'='
@@ -71,9 +79,13 @@ t_PLUS = r'\+'
 t_MINUS = r'-'
 t_TIMES = r'\*'
 t_DIVIDE = r'/'
+t_MODULO = r'%'
 
-# 增加PLACEHOLDER规则，匹配 ${变量名} 格式
-t_PLACEHOLDER = r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*\}'
+# 增加PLACEHOLDER规则，匹配 ${变量名} 格式，支持点号、数组索引和字典键访问
+# 匹配: ${variable}, ${obj.prop}, ${arr[0]}, ${dict["key"]}, ${obj[0].prop} 等
+t_PLACEHOLDER = (r'\$\{[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*'
+                 r'(?:(?:\.[a-zA-Z_\u4e00-\u9fa5][a-zA-Z0-9_\u4e00-\u9fa5]*)'
+                 r'|(?:\[[^\]]+\]))*\}')
 
 # 添加管道符的正则表达式定义
 t_PIPE = r'\|'
@@ -143,8 +155,12 @@ def t_IMPORT_KEYWORD(t):
 
 
 def t_NUMBER(t):
-    r'\d+'
-    t.value = int(t.value)
+    r'\d+(\.\d+)?'
+    # 如果包含小数点，转换为浮点数；否则转换为整数
+    if '.' in t.value:
+        t.value = float(t.value)
+    else:
+        t.value = int(t.value)
     return t
 
 

pytest_dsl/core/parser.py

@@ -14,7 +14,7 @@ precedence = (
     ('left', 'COMMA'),
     ('left', 'GT', 'LT', 'GE', 'LE', 'EQ', 'NE'),  # 比较运算符优先级
     ('left', 'PLUS', 'MINUS'),  # 加减运算符优先级
-    ('left', 'TIMES', 'DIVIDE'),  # 乘除运算符优先级
+    ('left', 'TIMES', 'DIVIDE', 'MODULO'),  # 乘除模运算符优先级
     ('right', 'EQUALS'),
 )
 
@@ -124,7 +124,9 @@ def p_statement(p):
                 | loop
                 | custom_keyword
                 | return_statement
-                | if_statement'''
+                | if_statement
+                | break_statement
+                | continue_statement'''
     p[0] = p[1]
 
 
@@ -158,6 +160,7 @@ def p_expr_atom(p):
                  | ID
                  | boolean_expr
                  | list_expr
+                 | dict_expr
                  | LPAREN expression RPAREN'''
     if p[1] == '(':
         # 处理括号表达式，直接返回括号内的表达式节点
@@ -197,6 +200,29 @@ def p_list_item(p):
     p[0] = p[1]
 
 
+def p_dict_expr(p):
+    '''dict_expr : LBRACE dict_items RBRACE
+                 | LBRACE RBRACE'''
+    if len(p) == 4:
+        p[0] = Node('DictExpr', children=p[2])
+    else:
+        p[0] = Node('DictExpr', children=[])  # 空字典
+
+
+def p_dict_items(p):
+    '''dict_items : dict_item
+                  | dict_item COMMA dict_items'''
+    if len(p) == 2:
+        p[0] = [p[1]]
+    else:
+        p[0] = [p[1]] + p[3]
+
+
+def p_dict_item(p):
+    '''dict_item : expression COLON expression'''
+    p[0] = Node('DictItem', children=[p[1], p[3]])
+
+
 def p_loop(p):
     '''loop : FOR ID IN RANGE LPAREN expression COMMA expression RPAREN DO statements END'''
     p[0] = Node('ForLoop', [p[6], p[8], p[11]], p[2])
@@ -278,13 +304,47 @@ def p_return_statement(p):
     p[0] = Node('Return', [p[2]])
 
 
+def p_break_statement(p):
+    '''break_statement : BREAK'''
+    p[0] = Node('Break', [])
+
+
+def p_continue_statement(p):
+    '''continue_statement : CONTINUE'''
+    p[0] = Node('Continue', [])
+
+
 def p_if_statement(p):
     '''if_statement : IF expression DO statements END
-                   | IF expression DO statements ELSE statements END'''
+                   | IF expression DO statements elif_clauses END
+                   | IF expression DO statements ELSE statements END
+                   | IF expression DO statements elif_clauses ELSE statements END'''
     if len(p) == 6:
+        # if condition do statements end
         p[0] = Node('IfStatement', [p[2], p[4]], None)
-    else:
+    elif len(p) == 7:
+        # if condition do statements elif_clauses end
+        p[0] = Node('IfStatement', [p[2], p[4]] + p[5], None)
+    elif len(p) == 8:
+        # if condition do statements else statements end
         p[0] = Node('IfStatement', [p[2], p[4], p[6]], None)
+    else:
+        # if condition do statements elif_clauses else statements end
+        p[0] = Node('IfStatement', [p[2], p[4]] + p[5] + [p[7]], None)
+
+
+def p_elif_clauses(p):
+    '''elif_clauses : elif_clause
+                    | elif_clause elif_clauses'''
+    if len(p) == 2:
+        p[0] = [p[1]]
+    else:
+        p[0] = [p[1]] + p[2]
+
+
+def p_elif_clause(p):
+    '''elif_clause : ELIF expression DO statements'''
+    p[0] = Node('ElifClause', [p[2], p[4]], None)
 
 
 def p_comparison_expr(p):
@@ -319,7 +379,8 @@ def p_arithmetic_expr(p):
     '''arithmetic_expr : expression PLUS expression
                        | expression MINUS expression
                        | expression TIMES expression
-                       | expression DIVIDE expression'''
+                       | expression DIVIDE expression
+                       | expression MODULO expression'''
 
     # 根据规则索引判断使用的是哪个操作符
     if p.slice[2].type == 'PLUS':
@@ -330,6 +391,8 @@ def p_arithmetic_expr(p):
         operator = '*'
     elif p.slice[2].type == 'DIVIDE':
         operator = '/'
+    elif p.slice[2].type == 'MODULO':
+        operator = '%'
     else:
         print(f"警告: 无法识别的操作符类型 {p.slice[2].type}")
         operator = None