| import re |
| import ast |
| import difflib |
| from typing import Dict, Any, List, Optional, Set, Tuple |
|
|
| from validators.base import BaseValidator, Validator |
|
|
| class DesignImplementationValidator(BaseValidator, Validator): |
| """設計書と実装コードの整合性を検証するクラス""" |
| |
| def __init__(self, client=None): |
| """設計・実装検証クラスの初期化""" |
| super().__init__(client) |
| self.validation_results = {} |
| |
| async def validate(self, content, context=None): |
| """設計書と実装コードの整合性を検証する（インターフェース実装）""" |
| |
| if context and isinstance(content, str) and isinstance(context, str): |
| design_doc = content |
| implementation_code = context |
| else: |
| |
| design_code_parts = self._separate_design_and_code(content) |
| if design_code_parts: |
| design_doc, implementation_code = design_code_parts |
| else: |
| |
| return content |
| |
| |
| validation_result = self.validate_design_implementation(design_doc, implementation_code) |
| self.validation_results = validation_result |
| |
| |
| if not validation_result.get("is_compliant", True): |
| implementation_code = self._add_compliance_notes(implementation_code, validation_result) |
| |
| return implementation_code |
| |
| def get_result_summary(self): |
| """検証結果の要約を返す（インターフェース実装）""" |
| if not self.validation_results: |
| return "設計書と実装コードの整合性はまだ検証されていません。" |
| |
| is_compliant = self.validation_results.get("is_compliant", True) |
| compliance_score = self.validation_results.get("compliance_score", 0.0) |
| |
| if is_compliant: |
| return f"設計書と実装コードは整合しています（整合性スコア: {compliance_score}/10.0）" |
| |
| missing_components = self.validation_results.get("missing_components", []) |
| missing_methods = self.validation_results.get("missing_methods", []) |
| missing_requirements = self.validation_results.get("missing_requirements", []) |
| |
| summary = f"設計書と実装コードに不整合があります（整合性スコア: {compliance_score}/10.0）\n\n" |
| |
| if missing_components: |
| summary += "不足しているコンポーネント:\n" |
| summary += "\n".join([f"- {component}" for component in missing_components[:3]]) |
| if len(missing_components) > 3: |
| summary += f"\n...他{len(missing_components) - 3}個" |
| summary += "\n\n" |
| |
| if missing_methods: |
| summary += "不足しているメソッド:\n" |
| summary += "\n".join([f"- {method}" for method in missing_methods[:3]]) |
| if len(missing_methods) > 3: |
| summary += f"\n...他{len(missing_methods) - 3}個" |
| summary += "\n\n" |
| |
| if missing_requirements: |
| summary += "未実装の要件:\n" |
| summary += "\n".join([f"- {req}" for req in missing_requirements[:3]]) |
| if len(missing_requirements) > 3: |
| summary += f"\n...他{len(missing_requirements) - 3}個" |
| |
| return summary |
| |
| def _separate_design_and_code(self, content: str) -> Optional[Tuple[str, str]]: |
| """コンテンツから設計書部分と実装コード部分を分離する""" |
| |
| design_markers = [ |
| "# 設計書", "## 設計書", "# 設計", "## 設計", |
| "# アーキテクチャ設計", "# 詳細設計", |
| "# Design Document", "## Design Document", |
| "# Architecture", "## Architecture" |
| ] |
| |
| |
| code_markers = [ |
| "# 実装", "## 実装", "# 実装コード", "## 実装コード", |
| "# Implementation", "## Implementation", |
| "# Code", "## Code", |
| "```python", "```java", "```javascript", "```cpp" |
| ] |
| |
| |
| design_start = -1 |
| code_start = -1 |
| |
| for marker in design_markers: |
| if marker in content: |
| design_start = content.find(marker) |
| break |
| |
| for marker in code_markers: |
| if marker in content: |
| marker_pos = content.find(marker) |
| if marker_pos > design_start: |
| code_start = marker_pos |
| break |
| |
| |
| if design_start >= 0 and code_start > design_start: |
| design_doc = content[design_start:code_start].strip() |
| implementation_code = content[code_start:].strip() |
| return design_doc, implementation_code |
| |
| |
| return None |
| |
| def _add_compliance_notes(self, implementation_code: str, validation_result: Dict[str, Any]) -> str: |
| """検証結果に基づいて実装コードに注釈を追加する""" |
| notes = ["# 設計書との整合性の問題点:"] |
| |
| |
| missing_components = validation_result.get("missing_components", []) |
| if missing_components: |
| notes.append("# 不足しているコンポーネント:") |
| for component in missing_components: |
| notes.append(f"# - {component}") |
| |
| missing_methods = validation_result.get("missing_methods", []) |
| if missing_methods: |
| notes.append("# 不足しているメソッド:") |
| for method in missing_methods: |
| notes.append(f"# - {method}") |
| |
| missing_requirements = validation_result.get("missing_requirements", []) |
| if missing_requirements: |
| notes.append("# 未実装の要件:") |
| for req in missing_requirements: |
| notes.append(f"# - {req}") |
| |
| |
| suggestion = validation_result.get("suggestion") |
| if suggestion: |
| notes.append("# 提案:") |
| for line in suggestion.split("\n"): |
| notes.append(f"# {line}") |
| |
| |
| notes_str = "\n".join(notes) |
| return f"{notes_str}\n\n{implementation_code}" |
| |
| def validate_design_implementation(self, design_doc: str, implementation_code: str) -> Dict[str, Any]: |
| """設計書と実装コードの整合性を検証する""" |
| result = { |
| "is_compliant": True, |
| "issues": [], |
| "missing_components": [], |
| "missing_methods": [], |
| "missing_requirements": [], |
| "extra_components": [], |
| "compliance_score": 0.0, |
| "suggestion": None |
| } |
| |
| |
| design_components = self._extract_design_components(design_doc) |
| |
| |
| implementation_components = self._extract_implementation_components(implementation_code) |
| |
| |
| self._validate_consistency(design_components, implementation_components, result) |
| |
| |
| self._calculate_compliance_score(result) |
| |
| |
| self._generate_suggestions(result) |
| |
| return result |
| |
| def _extract_design_components(self, design_doc: str) -> Dict[str, Any]: |
| """設計書からコンポーネント、クラス、メソッド、要件などを抽出する""" |
| components = { |
| "classes": [], |
| "interfaces": [], |
| "methods": {}, |
| "attributes": {}, |
| "requirements": [], |
| "dependencies": [], |
| "data_structures": [] |
| } |
| |
| |
| class_pattern = r'(class\s+(\w+)(?:\s*\(\s*\w+\s*\))?\s*:)' |
| for match in re.finditer(class_pattern, design_doc): |
| class_name = match.group(2) |
| components["classes"].append(class_name) |
| components["methods"][class_name] = [] |
| components["attributes"][class_name] = [] |
| |
| |
| class_start = match.end() |
| next_class_match = re.search(class_pattern, design_doc[class_start:]) |
| class_end = class_start + next_class_match.start() if next_class_match else len(design_doc) |
| class_body = design_doc[class_start:class_end] |
| |
| |
| method_pattern = r'def\s+(\w+)\s*\((.*?)\)' |
| for method_match in re.finditer(method_pattern, class_body): |
| method_name = method_match.group(1) |
| components["methods"][class_name].append(method_name) |
| |
| |
| attribute_pattern = r'self\.(\w+)\s*=' |
| for attr_match in re.finditer(attribute_pattern, class_body): |
| attr_name = attr_match.group(1) |
| if attr_name not in components["attributes"][class_name]: |
| components["attributes"][class_name].append(attr_name) |
| |
| |
| interface_pattern = r'(class\s+(\w+)(?:\s*\(\s*(?:ABC|Protocol)\s*\))?\s*:)' |
| for match in re.finditer(interface_pattern, design_doc): |
| interface_name = match.group(2) |
| if interface_name not in components["classes"]: |
| components["interfaces"].append(interface_name) |
| components["methods"][interface_name] = [] |
| |
| |
| interface_start = match.end() |
| next_interface_match = re.search(interface_pattern, design_doc[interface_start:]) |
| interface_end = interface_start + next_interface_match.start() if next_interface_match else len(design_doc) |
| interface_body = design_doc[interface_start:interface_end] |
| |
| |
| method_pattern = r'def\s+(\w+)\s*\((.*?)\)' |
| for method_match in re.finditer(method_pattern, interface_body): |
| method_name = method_match.group(1) |
| components["methods"][interface_name].append(method_name) |
| |
| |
| requirement_sections = [ |
| "要件", "機能要件", "非機能要件", "制約", "前提条件", |
| "Requirements", "Functional Requirements", "Non-functional Requirements" |
| ] |
| |
| for section in requirement_sections: |
| section_match = re.search(rf'{section}[：:]\s*(.*?)(?=\n\n|\n#|\Z)', design_doc, re.DOTALL) |
| if section_match: |
| section_text = section_match.group(1).strip() |
| |
| |
| bullet_patterns = [ |
| r'[-*•]\s*(.*?)(?=\n[-*•]|\n\n|\Z)', |
| r'\d+\.\s*(.*?)(?=\n\d+\.|\n\n|\Z)' |
| ] |
| |
| for pattern in bullet_patterns: |
| for req_match in re.finditer(pattern, section_text, re.DOTALL): |
| requirement = req_match.group(1).strip() |
| if requirement and requirement not in components["requirements"]: |
| components["requirements"].append(requirement) |
| |
| |
| data_structure_patterns = [ |
| r'(class|struct)\s+(\w+)', |
| r'(enum)\s+(\w+)', |
| r'(type|typedef)\s+(\w+)' |
| ] |
| |
| for pattern in data_structure_patterns: |
| for match in re.finditer(pattern, design_doc): |
| structure_type = match.group(1) |
| structure_name = match.group(2) |
| if structure_name not in components["classes"] and structure_name not in components["interfaces"]: |
| components["data_structures"].append(structure_name) |
| |
| |
| dependency_patterns = [ |
| r'依存[：:]\s*(.*?)(?=\n\n|\Z)', |
| r'Dependencies[：:]\s*(.*?)(?=\n\n|\Z)', |
| r'利用[：:]\s*(.*?)(?=\n\n|\Z)', |
| r'Uses[：:]\s*(.*?)(?=\n\n|\Z)', |
| r'import\s+(\w+)', |
| r'from\s+(\w+)\s+import' |
| ] |
| |
| for pattern in dependency_patterns: |
| for match in re.finditer(pattern, design_doc): |
| dependency = match.group(1).strip() |
| if dependency and dependency not in components["dependencies"]: |
| components["dependencies"].append(dependency) |
| |
| return components |
| |
| def _extract_implementation_components(self, implementation_code: str) -> Dict[str, Any]: |
| """実装コードからコンポーネント、クラス、メソッド、属性などを抽出する""" |
| components = { |
| "classes": [], |
| "interfaces": [], |
| "methods": {}, |
| "attributes": {}, |
| "imports": [], |
| "functions": [] |
| } |
| |
| try: |
| |
| tree = ast.parse(implementation_code) |
| |
| |
| for node in ast.walk(tree): |
| if isinstance(node, ast.Import): |
| for name in node.names: |
| components["imports"].append(name.name) |
| elif isinstance(node, ast.ImportFrom): |
| if node.module: |
| components["imports"].append(node.module) |
| |
| |
| for node in ast.walk(tree): |
| if isinstance(node, ast.ClassDef): |
| class_name = node.name |
| |
| |
| is_interface = False |
| for base in node.bases: |
| if isinstance(base, ast.Name) and base.id in ["ABC", "Protocol"]: |
| is_interface = True |
| break |
| |
| if is_interface: |
| components["interfaces"].append(class_name) |
| else: |
| components["classes"].append(class_name) |
| |
| components["methods"][class_name] = [] |
| components["attributes"][class_name] = [] |
| |
| |
| for item in node.body: |
| if isinstance(item, ast.FunctionDef): |
| components["methods"][class_name].append(item.name) |
| elif isinstance(item, ast.Assign): |
| for target in item.targets: |
| if isinstance(target, ast.Name): |
| components["attributes"][class_name].append(target.id) |
| |
| |
| for node in ast.walk(tree): |
| if isinstance(node, ast.FunctionDef) and node.name not in [m for methods in components["methods"].values() for m in methods]: |
| if not any(isinstance(parent, ast.ClassDef) for parent in ast.iter_child_nodes(tree)): |
| components["functions"].append(node.name) |
| |
| except SyntaxError as e: |
| print(f"[Warning] Syntax error during code analysis: {e}") |
| |
| self._fallback_extract_implementation_components(implementation_code, components) |
| |
| return components |
| |
| def _fallback_extract_implementation_components(self, code: str, components: Dict[str, Any]) -> None: |
| """構文エラーがある場合のフォールバック抽出メソッド（正規表現ベース）""" |
| |
| class_pattern = r'class\s+(\w+)(?:\s*\(.*?\))?\s*:' |
| for match in re.finditer(class_pattern, code): |
| class_name = match.group(1) |
| if class_name not in components["classes"]: |
| components["classes"].append(class_name) |
| components["methods"][class_name] = [] |
| components["attributes"][class_name] = [] |
| |
| |
| class_start = match.end() |
| |
| class_body = "" |
| in_class = True |
| indent_level = None |
| |
| for line in code[class_start:].split('\n'): |
| if not line.strip(): |
| class_body += line + '\n' |
| continue |
| |
| current_indent = len(line) - len(line.lstrip()) |
| |
| if indent_level is None: |
| if current_indent > 0: |
| indent_level = current_indent |
| class_body += line + '\n' |
| continue |
| |
| if current_indent >= indent_level: |
| class_body += line + '\n' |
| else: |
| break |
| |
| |
| method_pattern = r'def\s+(\w+)\s*\(' |
| for method_match in re.finditer(method_pattern, class_body): |
| method_name = method_match.group(1) |
| if method_name not in components["methods"][class_name]: |
| components["methods"][class_name].append(method_name) |
| |
| |
| attribute_pattern = r'self\.(\w+)\s*=' |
| for attr_match in re.finditer(attribute_pattern, class_body): |
| attr_name = attr_match.group(1) |
| if attr_name not in components["attributes"][class_name]: |
| components["attributes"][class_name].append(attr_name) |
| |
| |
| import_pattern = r'import\s+(\w+)' |
| for match in re.finditer(import_pattern, code): |
| import_name = match.group(1) |
| if import_name not in components["imports"]: |
| components["imports"].append(import_name) |
| |
| from_import_pattern = r'from\s+(\w+)\s+import' |
| for match in re.finditer(from_import_pattern, code): |
| import_name = match.group(1) |
| if import_name not in components["imports"]: |
| components["imports"].append(import_name) |
| |
| |
| function_pattern = r'^def\s+(\w+)\s*\(' |
| for match in re.finditer(function_pattern, code, re.MULTILINE): |
| func_name = match.group(1) |
| if func_name not in components["functions"]: |
| components["functions"].append(func_name) |
| |
| def _validate_consistency(self, design: Dict[str, Any], implementation: Dict[str, Any], result: Dict[str, Any]) -> None: |
| """設計と実装の整合性を検証する""" |
| |
| for class_name in design["classes"]: |
| if class_name not in implementation["classes"] and class_name not in implementation["interfaces"]: |
| result["is_compliant"] = False |
| result["missing_components"].append(f"Class: {class_name}") |
| result["issues"].append(f"設計書で定義されているクラス '{class_name}' が実装に存在しません。") |
| |
| |
| for interface_name in design["interfaces"]: |
| if interface_name not in implementation["interfaces"] and interface_name not in implementation["classes"]: |
| result["is_compliant"] = False |
| result["missing_components"].append(f"Interface: {interface_name}") |
| result["issues"].append(f"設計書で定義されているインターフェース '{interface_name}' が実装に存在しません。") |
| |
| |
| for class_name, methods in design["methods"].items(): |
| if class_name in implementation["methods"]: |
| for method_name in methods: |
| if method_name not in implementation["methods"][class_name]: |
| result["is_compliant"] = False |
| result["missing_methods"].append(f"{class_name}.{method_name}") |
| result["issues"].append(f"設計書で定義されているメソッド '{class_name}.{method_name}' が実装に存在しません。") |
| |
| |
| for class_name, attrs in design["attributes"].items(): |
| if class_name in implementation["attributes"]: |
| for attr_name in attrs: |
| if attr_name not in implementation["attributes"][class_name]: |
| |
| result["issues"].append(f"設計書で定義されている属性 '{class_name}.{attr_name}' が実装に存在しません（警告）。") |
| |
| |
| code_text = implementation_code if hasattr(self, 'implementation_code') else "" |
| for req in design["requirements"]: |
| |
| keywords = self._extract_keywords(req) |
| |
| |
| if keywords and not all(keyword.lower() in code_text.lower() for keyword in keywords if len(keyword) > 3): |
| result["is_compliant"] = False |
| result["missing_requirements"].append(req) |
| result["issues"].append(f"要件 '{req}' が実装に反映されていない可能性があります。") |
| |
| |
| for class_name in implementation["classes"]: |
| if class_name not in design["classes"] and class_name not in design["interfaces"]: |
| result["extra_components"].append(f"Class: {class_name}") |
| |
| result["issues"].append(f"実装に存在するクラス '{class_name}' が設計書に定義されていません（警告）。") |
| |
| def _extract_keywords(self, text: str) -> List[str]: |
| """テキストから重要なキーワードを抽出する""" |
| |
| stop_words = { |
| "a", "an", "the", "this", "that", "these", "those", |
| "is", "are", "was", "were", "be", "been", "being", |
| "have", "has", "had", "do", "does", "did", "will", "would", "shall", "should", |
| "can", "could", "may", "might", "must", "and", "or", "but", "if", "then", "else", |
| "when", "where", "why", "how", "all", "any", "both", "each", "few", "more", "most", |
| "other", "some", "such", "no", "nor", "not", "only", "own", "same", "so", "than", |
| "too", "very", "を", "に", "は", "が", "で", "と", "から", "まで", "より", "して", "する", "ます", "です" |
| } |
| |
| |
| words = [] |
| |
| english_words = re.findall(r'\b[a-zA-Z]+\b', text.lower()) |
| words.extend(english_words) |
| |
| |
| japanese_text = re.sub(r'[a-zA-Z0-9\s]', '', text) |
| for char in japanese_text: |
| if char not in "、。！？「」『』（）［］【】…：；": |
| words.append(char) |
| |
| |
| keywords = [w for w in words if w not in stop_words and len(w) > 1] |
| |
| |
| unique_keywords = list(set(keywords)) |
| |
| return unique_keywords |
| |
| def _calculate_compliance_score(self, result: Dict[str, Any]) -> None: |
| """コンプライアンススコアを計算する（0.0〜10.0の範囲）""" |
| |
| score = 10.0 |
| |
| |
| score -= len(result["missing_components"]) * 2.0 |
| |
| |
| score -= len(result["missing_methods"]) * 1.0 |
| |
| |
| score -= len(result["missing_requirements"]) * 1.5 |
| |
| |
| score -= len(result["extra_components"]) * 0.5 |
| |
| |
| result["compliance_score"] = max(0.0, min(10.0, score)) |
| |
| |
| result["is_compliant"] = result["compliance_score"] >= 7.0 |
| |
| def _generate_suggestions(self, result: Dict[str, Any]) -> None: |
| """検証結果に基づいて改善提案を生成する""" |
| if result["is_compliant"]: |
| if result["compliance_score"] == 10.0: |
| result["suggestion"] = "設計書と実装は完全に一致しています。素晴らしい実装です。" |
| else: |
| result["suggestion"] = "設計書と実装は概ね一致していますが、いくつかの軽微な問題があります。詳細は issues リストを確認してください。" |
| else: |
| |
| if result["missing_components"]: |
| result["suggestion"] = f"設計書で定義されている以下のコンポーネントを実装してください: {', '.join(result['missing_components'][:3])}" |
| if len(result["missing_components"]) > 3: |
| result["suggestion"] += f" ... 他 {len(result['missing_components']) - 3} 件" |
| |
| |
| elif result["missing_methods"]: |
| result["suggestion"] = f"設計書で定義されている以下のメソッドを実装してください: {', '.join(result['missing_methods'][:3])}" |
| if len(result["missing_methods"]) > 3: |
| result["suggestion"] += f" ... 他 {len(result['missing_methods']) - 3} 件" |
| |
| |
| elif result["missing_requirements"]: |
| result["suggestion"] = "以下の要件が実装に反映されていない可能性があります。要件を満たす機能を実装してください。" |
| for i, req in enumerate(result["missing_requirements"][:3]): |
| result["suggestion"] += f"\n{i+1}. {req}" |
| if len(result["missing_requirements"]) > 3: |
| result["suggestion"] += f"\n... 他 {len(result['missing_requirements']) - 3} 件" |
| |
| |
| else: |
| result["suggestion"] = "設計書と実装の間にいくつかの不一致があります。issues リストを確認して修正してください。" |
