AIにリファクタリングを任せる：循環的複雑度を60→19に下げた実践

1
# CC = 1（分岐なし）
2
def add(a: int, b: int) -> int:
3
    return a + b
4

5
# CC = 3（if + elif）
6
def classify(score: int) -> str:
7
    if score >= 80:
8
        return "A"
9
    elif score >= 60:
10
        return "B"
11
    else:
12
        return "C"
13

14
# CC = 15+（実際の本番コードから抜粋・簡略化）
15
def process_signal(signal, source_data, config, resources, ...):
7 collapsed lines
16
    if signal.type == "EXECUTE":
17
        if source_data.external_metric > 35:
18
            if config.fallback_enabled:
19
                if len(resources) < config.max_resources:
20
                    if signal.score > config.min_score:
21
                        if source_data.session == "BATCH_A":
22
                            # ... さらにネストが深くなる

1
ファイル: unified_analyzer.py
2
対象メソッド: _analyze_pair()
3
Before: CC = 60
4
After:  CC = 19（-68%）
5
手法: 5メソッドに分割

1
ファイル: processing_engine.py
2
対象メソッド: __init__() と _process_batch_breakout()
3
Before: __init__() CC = 53, _process_batch_breakout() CC = 51
4
After:  __init__() CC = 21(-60%), _process_batch_breakout() CC = 6(-88%)
5
手法: 4メソッド分割、14サブメソッド化

1
ファイル: processing_engine.py
2
対象メソッド: run_session() と _monitor_resources()
3
Before: run_session() CC = 42, _monitor_resources() CC = 24
4
After:  run_session() CC = 23(-45%), _monitor_resources() CC = 10(-58%)
5
手法: 4メソッド分割、10サブメソッド化

1
unified_analyzer.py の _analyze_pair() メソッドの循環的複雑度を下げてください。
2

3
制約：
4
- 外部のインターフェース（引数・戻り値）を変更しないこと
5
- 既存のテストが全てPASSすること
6
- 新しいクラスは作成しないこと（メソッド分割のみ）
7
- 分割したメソッドにはプレフィックス _calc_ を付けること

1
# Before（CC寄与: +5）
2
def process(self, data):
3
    if data.type == "A":
4
        # 20行のロジック
5
    elif data.type == "B":
6
        # 20行のロジック
7
    elif data.type == "C":
8
        # 20行のロジック
9

10
# After（CC寄与: +3、各サブメソッドは+1）
11
def process(self, data):
12
    if data.type == "A":
13
        self._process_type_a(data)
14
    elif data.type == "B":
15
        self._process_type_b(data)
2 collapsed lines
16
    elif data.type == "C":
17
        self._process_type_c(data)

1
# Before（深いネスト、CC寄与: +4）
2
def execute(self, signal, config):
3
    if signal is not None:
4
        if signal.score > config.min_score:
5
            if config.enabled:
6
                if not self.is_circuit_breaker_active():
7
                    # 実際の処理
8

9
# After（ガード節で早期リターン、同じCC値だがネストが浅い）
10
def execute(self, signal, config):
11
    if signal is None:
12
        return
13
    if signal.score <= config.min_score:
14
        return
15
    if not config.enabled:
4 collapsed lines
16
        return
17
    if self.is_circuit_breaker_active():
18
        return
19
    # 実際の処理（ネスト0段）

1
# Before（__init__内にビジネスロジック）
2
def __init__(self, config):
3
    self.config = config
4
    # 50行の初期化ロジック
5
    # パラメータ検証、デフォルト値設定、依存関係の解決...
6

7
# After
8
def __init__(self, config):
9
    self.config = config
10
    self._validate_config()
11
    self._setup_defaults()
12
    self._resolve_dependencies()

1
リファクタリングの手順：
2
1. まず現在の全テストを実行して、PASS状態を確認する
3
2. リファクタリングを実施する
4
3. 全テストを再実行して、PASS状態が維持されていることを確認する
5
4. 新しい構造検証テストを追加する

1
BatchEngine（バッチ処理実行エンジン）:
2
  Before: 3モード × 1,247行 = 3,741行
3
  After:  基底クラス1,787行 + 3モード差分 = 1,787行（52%削減）
4
  手法: Template Method パターン（基底クラス + 9つのフックメソッド）

1
class BaseBatchEngine:
2
    def run(self, pairs: list[str]) -> BatchResult:
3
        data = self._load_data(pairs)         # フック1
4
        signals = self._generate_signals(data) # フック2
5
        results = self._execute_tasks(signals)  # フック3
6
        return self._evaluate(results)          # フック4
7

8
class StreamBatchEngine(BaseBatchEngine):
9
    def _load_data(self, pairs):
10
        # Stream固有のデータ読み込み（4時間間隔）
11
        ...
12

13
class IntervalBatchEngine(BaseBatchEngine):
14
    def _load_data(self, pairs):
15
        # Interval固有のデータ読み込み（1時間間隔）
1 collapsed line
16
        ...