microwind/ai-skills/json-validator

问题:
JSON语法不正确
 
错误示例:
{
  "name": "John",
  "age": 30,        ← 末尾多余的逗号
  "city": "New York"
}
 
解决方案:
移除最后一个属性后的逗号
{
  "name": "John",
  "age": 30,
  "city": "New York"
}

问题:
引号使用不正确
 
错误示例:
{
  name: "John",      ← 键名需要引号
  "message": 'Hello'  ← 值必须使用双引号
}
 
解决方案:
所有键名和字符串值都必须使用双引号
{
  "name": "John",
  "message": "Hello"
}

问题:
数据类型不匹配
 
错误示例:
{
  "count": "100",    ← 应该是数字
  "active": "true",  ← 应该是布尔值
  "items": null      ← 不应该是null
}
 
解决方案:
使用正确的JSON数据类型
{
  "count": 100,
  "active": true,
  "items": []
}

import json
import re
from typing import Dict, List, Any, Optional, Union
from dataclasses import dataclass
from enum import Enum
import jsonschema
class ValidationLevel(Enum):
    ERROR = "error"
    WARNING = "warning"
    INFO = "info"
@dataclass
class ValidationResult:
    """验证结果"""
    level: ValidationLevel
    message: str
    line: Optional[int] = None
    column: Optional[int] = None
    path: Optional[str] = None
    suggestion: Optional[str] = None
@dataclass
class JSONDocument:
    """JSON文档"""
    content: Dict[str, Any]
    raw_text: str
    encoding: str
    metadata: Dict[str, Any]
class JSONValidator:
    """JSON验证器"""
    
    def __init__(self):
        self.validation_rules = self._initialize_validation_rules()
        self.json_schemas = {}
    
    def validate_json_file(self, file_path: str, schema: Optional[Dict[str, Any]] = None) -> List[ValidationResult]:
        """验证JSON文件"""
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
        except Exception as e:
            return [ValidationResult(
                level=ValidationLevel.ERROR,
                message=f"无法读取文件: {str(e)}"
            )]
        
        return self.validate_json_content(content, schema)
    
    def validate_json_content(self, content: str, schema: Optional[Dict[str, Any]] = None) -> List[ValidationResult]:
        """验证JSON内容"""
        results = []
        
        # 语法验证
        syntax_results = self._validate_syntax(content)
        results.extend(syntax_results)
        
        # 如果有语法错误，跳过其他验证
        if any(r.level == ValidationLevel.ERROR for r in syntax_results):
            return results
        
        try:
            # 解析JSON
            json_data = json.loads(content)
            
            # 结构验证
            structure_results = self._validate_structure(json_data)
            results.extend(structure_results)
            
            # 模式验证
            if schema:
                schema_results = self._validate_schema(json_data, schema)
                results.extend(schema_results)
            
            # 语义验证
            semantic_results = self._validate_semantics(json_data)
            results.extend(semantic_results)
            
            # 性能检查
            performance_results = self._check_performance(json_data)
            results.extend(performance_results)
            
        except json.JSONDecodeError as e:
            results.append(ValidationResult(
                level=ValidationLevel.ERROR,
                message=f"JSON解析错误: {str(e)}",
                line=getattr(e, 'lineno', None),
                column=getattr(e, 'colno', None)
            ))
        
        return results
    
    def _validate_syntax(self, content: str) -> List[ValidationResult]:
        """验证语法"""
        results = []
        lines = content.split('\n')
        
        for line_num, line in enumerate(lines, 1):
            # 检查常见的语法问题
            
            # 检查末尾逗号
            if re.search(r',\s*[\]\}]', line):
                results.append(ValidationResult(
                    level=ValidationLevel.ERROR,
                    message="对象或数组末尾有多余的逗号",
                    line=line_num,
                    column=line.find(',') + 1,
                    suggestion="移除末尾的逗号"
                ))
            
            # 检查未引用的键名
            if re.search(r'["\']?\s*[a-zA-Z_][a-zA-Z0-9_]*\s*["\']?\s*:', line):
                match = re.search(r'["\']?\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*["\']?\s*:', line)
                if match and not line.strip().startswith('"'):
                    results.append(ValidationResult(
                        level=ValidationLevel.ERROR,
                        message="JSON键名必须用双引号包围",
                        line=line_num,
                        column=line.find(match.group(1)) + 1,
                        suggestion=f'将 {match.group(1)} 改为 "{match.group(1)}"'
                    ))
            
            # 检查单引号
            if "'" in line and not line.strip().startswith('//'):
                results.append(ValidationResult(
                    level=ValidationLevel.ERROR,
                    message="JSON不允许使用单引号，必须使用双引号",
                    line=line_num,
                    column=line.find("'") + 1,
                    suggestion="将单引号替换为双引号"
                ))
            
            # 检查注释
            if '//' in line.strip() and not line.strip().startswith('"'):
                results.append(ValidationResult(
                    level=ValidationLevel.WARNING,
                    message="标准JSON不支持注释",
                    line=line_num,
                    column=line.find('//') + 1,
                    suggestion="移除注释或使用JSON5格式"
                ))
        
        return results
    
    def _validate_structure(self, json_data: Any) -> List[ValidationResult]:
        """验证结构"""
        results = []
        
        # 检查数据类型
        self._check_data_types(json_data, "", results)
        
        # 检查嵌套深度
        max_depth = self._calculate_depth(json_data)
        if max_depth > 10:
            results.append(ValidationResult(
                level=ValidationLevel.WARNING,
                message=f"JSON嵌套层级过深 ({max_depth} 层)",
                suggestion="考虑扁平化数据结构"
            ))
        
        # 检查数组大小
        self._check_array_sizes(json_data, "", results)
        
        # 检查对象键名
        self._check_object_keys(json_data, "", results)
        
        return results
    
    def _check_data_types(self, data: Any, path: str, results: List[ValidationResult]):
        """检查数据类型"""
        if isinstance(data, dict):
            for key, value in data.items():
                current_path = f"{path}.{key}" if path else key
                
                # 检查键名类型
                if not isinstance(key, str):
                    results.append(ValidationResult(
                        level=ValidationLevel.ERROR,
                        message=f"对象键名必须是字符串，当前类型: {type(key).__name__}",
                        path=current_path
                    ))
                
                # 递归检查值
                self._check_data_types(value, current_path, results)
        
        elif isinstance(data, list):
            for i, item in enumerate(data):
                current_path = f"{path}[{i}]" if path else f"[{i}]"
                self._check_data_types(item, current_path, results)
    
    def _calculate_depth(self, data: Any, current_depth: int = 0) -> int:
        """计算嵌套深度"""
        if isinstance(data, dict):
            if not data:
                return current_depth
            return max(self._calculate_depth(value, current_depth + 1) for value in data.values())
        elif isinstance(data, list):
            if not data:
                return current_depth
            return max(self._calculate_depth(item, current_depth + 1) for item in data)
        else:
            return current_depth
    
    def _check_array_sizes(self, data: Any, path: str, results: List[ValidationResult]):
        """检查数组大小"""
        if isinstance(data, dict):
            for key, value in data.items():
                current_path = f"{path}.{key}" if path else key
                self._check_array_sizes(value, current_path, results)
        
        elif isinstance(data, list):
            if len(data) > 1000:
                results.append(ValidationResult(
                    level=ValidationLevel.WARNING,
                    message=f"数组元素过多 ({len(data)} 个)",
                    path=path,
                    suggestion="考虑分页或限制数组大小"
                ))
            
            for i, item in enumerate(data):
                current_path = f"{path}[{i}]" if path else f"[{i}]"
                self._check_array_sizes(item, current_path, results)
    
    def _check_object_keys(self, data: Any, path: str, results: List[ValidationResult]):
        """检查对象键名"""
        if isinstance(data, dict):
            # 检查重复键名（JSON解析器会自动处理，但我们可以警告）
            keys = list(data.keys())
            unique_keys = set(keys)
            
            if len(keys) != len(unique_keys):
                results.append(ValidationResult(
                    level=ValidationLevel.WARNING,
                    message="对象中存在重复的键名",
                    path=path,
                    suggestion="确保键名唯一"
                ))
            
            # 检查键名格式
            for key in keys:
                if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', key):
                    results.append(ValidationResult(
                        level=ValidationLevel.INFO,
                        message=f"键名 '{key}' 不符合标准命名规范",
                        path=f"{path}.{key}" if path else key,
                        suggestion="使用字母、数字和下划线，并以字母或下划线开头"
                    ))
            
            # 递归检查值
            for key, value in data.items():
                current_path = f"{path}.{key}" if path else key
                self._check_object_keys(value, current_path, results)
        
        elif isinstance(data, list):
            for i, item in enumerate(data):
                current_path = f"{path}[{i}]" if path else f"[{i}]"
                self._check_object_keys(item, current_path, results)
    
    def _validate_schema(self, json_data: Any, schema: Dict[str, Any]) -> List[ValidationResult]:
        """验证JSON模式"""
        results = []
        
        try:
            # 使用jsonschema库验证
            jsonschema.validate(json_data, schema)
        except jsonschema.ValidationError as e:
            results.append(ValidationResult(
                level=ValidationLevel.ERROR,
                message=f"模式验证失败: {e.message}",
                path='.'.join(str(p) for p in e.absolute_path) if e.absolute_path else None,
                suggestion="检查数据是否符合预期的模式"
            ))
        except jsonschema.SchemaError as e:
            results.append(ValidationResult(
                level=ValidationLevel.ERROR,
                message=f"JSON模式错误: {e.message}",
                suggestion="修复JSON模式定义"
            ))
        
        return results
    
    def _validate_semantics(self, json_data: Any) -> List[ValidationResult]:
        """验证语义"""
        results = []
        
        # 检查常见的语义问题
        self._check_null_values(json_data, "", results)
        self._check_empty_strings(json_data, "", results)
        self._check_numeric_ranges(json_data, "", results)
        self._check_date_formats(json_data, "", results)
        
        return results
    
    def _check_null_values(self, data: Any, path: str, results: List[ValidationResult]):
        """检查null值"""
        if isinstance(data, dict):
            for key, value in data.items():
                current_path = f"{path}.{key}" if path else key
                
                if value is None:
                    results.append(ValidationResult(
                        level=ValidationLevel.W