# NG: 1つのメソッドに複数の責任が混在 (50行以上)
class OrderProcessor:
    def process_order(self, order_data: dict) -> OrderResult:
        # ── バリデーション ──
        if not order_data.get('items'):
            raise ValidationError("商品が選択されていません")
        if not order_data.get('customer_id'):
            raise ValidationError("顧客情報がありません")
        for item in order_data['items']:
            if item['quantity'] <= 0:
                raise ValidationError(f"数量が不正: {item['name']}")
            product = self.db.query(
                "SELECT stock FROM products WHERE id = %s", item['id']
            )
            if product.stock < item['quantity']:
                raise ValidationError(f"在庫不足: {item['name']}")
 
        # ── 合計計算 ──
        subtotal = 0
        for item in order_data['items']:
            price = item['unit_price'] * item['quantity']
            if item.get('discount_code'):
                discount = self.db.query(
                    "SELECT rate FROM discounts WHERE code = %s",
                    item['discount_code']
                )
                price *= (1 - discount.rate)
            subtotal += price
        tax = subtotal * Decimal("0.10")
        shipping = Decimal("500") if subtotal < Decimal("5000") else Decimal("0")
        total = subtotal + tax + shipping
 
        # ── DB保存 ──
        order = Order(
            customer_id=order_data['customer_id'],
            items=order_data['items'],
            subtotal=subtotal, tax=tax, shipping=shipping, total=total
        )
        self.db.save(order)
 
        # ── メール送信 ──
        customer = self.db.query(
            "SELECT * FROM customers WHERE id = %s",
            order_data['customer_id']
        )
        self.email_service.send(
            to=customer.email,
            subject="ご注文ありがとうございます",
            body=self._render_confirmation(order)
        )
 
        # ── 分析トラッキング ──
        self.analytics.track('order_completed', {
            'order_id': order.id,
            'total': float(total),
            'item_count': len(order_data['items'])
        })
 
        return OrderResult.success(order)
 
 
# OK: 意図ごとに関数を分離 ── 各メソッドは5-10行
class OrderProcessor:
    def process_order(self, order_data: dict) -> OrderResult:
        """注文処理のオーケストレーション"""
        self._validate_order(order_data)
        pricing = self._calculate_pricing(order_data['items'])
        order = self._save_order(order_data, pricing)
        self._send_confirmation(order)
        self._track_analytics(order)
        return OrderResult.success(order)
 
    def _validate_order(self, order_data: dict) -> None:
        """注文データのバリデーション"""
        validator = OrderValidator(self.db)
        validator.validate(order_data)
 
    def _calculate_pricing(self, items: list[dict]) -> OrderPricing:
        """価格計算"""
        calculator = PricingCalculator(self.db)
        return calculator.calculate(items)
 
    def _save_order(self, data: dict, pricing: OrderPricing) -> Order:
        """注文のDB保存"""
        order = Order.from_data(data, pricing)
        self.db.save(order)
        return order
 
    def _send_confirmation(self, order: Order) -> None:
        """確認メールの送信"""
        customer = self.db.find_customer(order.customer_id)
        self.email_service.send_order_confirmation(customer, order)
 
    def _track_analytics(self, order: Order) -> None:
        """分析トラッキング"""
        self.analytics.track('order_completed', order.to_analytics_dict())

// NG: God Class ── 複数の責任が1つのクラスに集中
public class ApplicationManager {
    private UserRepository userRepo;
    private OrderRepository orderRepo;
    private PaymentGateway paymentGw;
    private EmailService emailSvc;
 
    // 認証の責任
    public User authenticateUser(String email, String password) {
        User user = userRepo.findByEmail(email);
        if (user == null) throw new AuthException("ユーザーが見つかりません");
        if (!BCrypt.checkpw(password, user.getPasswordHash())) {
            throw new AuthException("パスワードが一致しません");
        }
        user.setLastLogin(Instant.now());
        userRepo.save(user);
        return user;
    }
 
    // 注文の責任
    public Order createOrder(User user, List<OrderItem> items) {
        Order order = new Order(user, items);
        order.setTotal(items.stream()
            .mapToDouble(i -> i.getPrice() * i.getQuantity())
            .sum());
        orderRepo.save(order);
        return order;
    }
 
    // 決済の責任
    public PaymentResult processPayment(Order order, CreditCard card) {
        return paymentGw.charge(card, order.getTotal());
    }
 
    // メールの責任
    public void sendConfirmation(Order order) {
        emailSvc.send(order.getUser().getEmail(), "注文確認", "...");
    }
    // ... さらに数十のメソッドが続く
}
 
 
// OK: 責任ごとにクラスを分離
public class AuthenticationService {
    private final UserRepository userRepo;
    private final PasswordEncoder encoder;
 
    public AuthenticationService(UserRepository userRepo, PasswordEncoder encoder) {
        this.userRepo = userRepo;
        this.encoder = encoder;
    }
 
    public User authenticate(String email, String password) {
        User user = userRepo.findByEmail(email)
            .orElseThrow(() -> new AuthException("ユーザーが見つかりません"));
        if (!encoder.matches(password, user.getPasswordHash())) {
            throw new AuthException("パスワードが一致しません");
        }
        user.recordLogin();
        userRepo.save(user);
        return user;
    }
}
 
public class OrderService {
    private final OrderRepository orderRepo;
    private final PricingCalculator calculator;
 
    public Order create(User user, List<OrderItem> items) {
        Order order = Order.create(user, items, calculator);
        orderRepo.save(order);
        return order;
    }
}

// NG: パラメータが8つ ── 順序を間違えやすい
function createUser(
  firstName: string,
  lastName: string,
  email: string,
  phone: string,
  street: string,
  city: string,
  zipCode: string,
  country: string
): User {
  // ...
}
 
// 呼び出し側: どのパラメータが何か分からない
createUser("太郎", "山田", "taro@example.com", "090-1234-5678",
           "丸の内1-1-1", "千代田区", "100-0001", "日本");
 
 
// OK: パラメータオブジェクトに集約
interface PersonalInfo {
  firstName: string;
  lastName: string;
  email: string;
  phone: string;
}
 
interface Address {
  street: string;
  city: string;
  zipCode: string;
  country: string;
 
  // Address 自身がバリデーションを持つ
  validate(): ValidationResult;
  format(): string;
}
 
interface CreateUserRequest {
  personal: PersonalInfo;
  address: Address;
}
 
function createUser(request: CreateUserRequest): User {
  request.address.validate();
  return new User(request);
}
 
// 呼び出し側: 構造が明確
createUser({
  personal: { firstName: "太郎", lastName: "山田",
              email: "taro@example.com", phone: "090-1234-5678" },
  address:  { street: "丸の内1-1-1", city: "千代田区",
              zipCode: "100-0001", country: "日本",
              validate() { /* ... */ }, format() { /* ... */ } },
});

# NG: 同じパラメータ群が繰り返し登場
def create_user(first_name, last_name, street, city, zip_code, country): ...
def update_address(user_id, street, city, zip_code, country): ...
def validate_address(street, city, zip_code, country): ...
def format_address(street, city, zip_code, country): ...
def calculate_shipping(street, city, zip_code, country, weight): ...
 
# テスト: パラメータの組み合わせが多すぎてテストしづらい
 
 
# OK: データクラスに抽出
@dataclass(frozen=True)
class Address:
    """住所値オブジェクト ── 不変・バリデーション付き"""
    street: str
    city: str
    zip_code: str
    country: str
 
    def __post_init__(self):
        if not self.zip_code:
            raise ValueError("郵便番号は必須です")
        if not self.country:
            raise ValueError("国名は必須です")
 
    def validate(self) -> bool:
        """住所の妥当性を検証"""
        return bool(self.street and self.city and
                    self.zip_code and self.country)
 
    def format(self, style: str = "japanese") -> str:
        """住所をフォーマット"""
        if style == "japanese":
            return f"〒{self.zip_code} {self.city}{self.street}"
        return f"{self.street}, {self.city} {self.zip_code}, {self.country}"
 
    def is_domestic(self) -> bool:
        return self.country == "日本"
 
 
def create_user(first_name: str, last_name: str, address: Address): ...
def update_address(user_id: str, address: Address): ...
def calculate_shipping(address: Address, weight: float) -> Decimal: ...
 
# テスト: Address を1つ作れば全関数で再利用可能

// NG: ドメイン概念をプリミティブ型で表現
function processPayment(
  amount: number,       // 円？ドル？ マイナスは？
  currency: string,     // "JPY"? "jpy"? "円"?
  email: string,        // バリデーション済み？
  cardNumber: string    // マスク済み？ 有効期限は？
): boolean { /* ... */ }
 
// 呼び出し側: 負の金額や不正なメールを渡せてしまう
processPayment(-1000, "yen", "not-an-email", "1234");
 
 
// OK: 値オブジェクトで型安全性を確保
class Money {
  readonly amount: number;
  readonly currency: Currency;
 
  constructor(amount: number, currency: Currency) {
    if (amount < 0) throw new Error("金額は0以上でなければなりません");
    if (!Number.isFinite(amount)) throw new Error("金額は有限の数値です");
    this.amount = amount;
    this.currency = currency;
  }
 
  add(other: Money): Money {
    if (this.currency !== other.currency) {
      throw new CurrencyMismatchError(this.currency, other.currency);
    }
    return new Money(this.amount + other.amount, this.currency);
  }
 
  multiply(factor: number): Money {
    return new Money(Math.round(this.amount * factor), this.currency);
  }
 
  format(): string {
    return new Intl.NumberFormat('ja-JP', {
      style: 'currency', currency: this.currency
    }).format(this.amount);
  }
}
 
class Email {
  private static readonly PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  readonly value: string;
 
  constructor(value: string) {
    const normalized = value.trim().toLowerCase();
    if (!Email.PATTERN.test(normalized)) {
      throw new InvalidEmailError(value);
    }
    this.value = normalized;
  }
}
 
class CreditCard {
  readonly maskedNumber: string;
  readonly last4: string;
 
  constructor(number: string, expiry: Date) {
    if (!CreditCard.isValidLuhn(number)) {
      throw new InvalidCardError("カード番号が不正です");
    }
    if (expiry < new Date()) {
      throw new ExpiredCardError("有効期限切れです");
    }
    this.last4 = number.slice(-4);
    this.maskedNumber = `****-****-****-${this.last4}`;
  }
 
  private static isValidLuhn(number: string): boolean {
    // Luhn アルゴリズムによる検証
    let sum = 0;
    let isEven = false;
    for (let i = number.length - 1; i >= 0; i--) {
      let digit = parseInt(number[i], 10);
      if (isEven) { digit *= 2; if (digit > 9) digit -= 9; }
      sum += digit;
      isEven = !isEven;
    }
    return sum % 10 === 0;
  }
}
 
// 型安全な関数シグネチャ
function processPayment(
  amount: Money,
  email: Email,
  card: CreditCard
): PaymentResult { /* ... */ }

# NG: 型による分岐が複数箇所に散在
# 新しい Shape を追加するたびに全関数を修正する必要がある
def calculate_area(shape):
    if shape.type == 'circle':
        return math.pi * shape.radius ** 2
    elif shape.type == 'rectangle':
        return shape.width * shape.height
    elif shape.type == 'triangle':
        return shape.base * shape.height / 2
    else:
        raise ValueError(f"未知の図形: {shape.type}")
 
def calculate_perimeter(shape):
    if shape.type == 'circle':
        return 2 * math.pi * shape.radius
    elif shape.type == 'rectangle':
        return 2 * (shape.width + shape.height)
    elif shape.type == 'triangle':
        return shape.side_a + shape.side_b + shape.side_c
    else:
        raise ValueError(f"未知の図形: {shape.type}")
 
def draw(shape, canvas):
    if shape.type == 'circle':
        canvas.draw_circle(shape.center, shape.radius)
    elif shape.type == 'rectangle':
        canvas.draw_rect(shape.origin, shape.width, shape.height)
    elif shape.type == 'triangle':
        canvas.draw_polygon(shape.vertices)
 
 
# OK: ポリモーフィズムで置換 ── 新しい図形はクラスを追加するだけ
from abc import ABC, abstractmethod
import math
 
class Shape(ABC):
    """図形の基底クラス"""
 
    @abstractmethod
    def area(self) -> float:
        """面積を計算"""
 
    @abstractmethod
    def perimeter(self) -> float:
        """外周を計算"""
 
    @abstractmethod
    def draw(self, canvas: Canvas) -> None:
        """キャンバスに描画"""
 
class Circle(Shape):
    def __init__(self, center: Point, radius: float):
        if radius <= 0:
            raise ValueError("半径は正の数でなければなりません")
        self.center = center
        self.radius = radius
 
    def area(self) -> float:
        return math.pi * self.radius ** 2
 
    def perimeter(self) -> float:
        return 2 * math.pi * self.radius
 
    def draw(self, canvas: Canvas) -> None:
        canvas.draw_circle(self.center, self.radius)
 
class Rectangle(Shape):
    def __init__(self, origin: Point, width: float, height: float):
        self.origin = origin
        self.width = width
        self.height = height
 
    def area(self) -> float:
        return self.width * self.height
 
    def perimeter(self) -> float:
        return 2 * (self.width + self.height)
 
    def draw(self, canvas: Canvas) -> None:
        canvas.draw_rect(self.origin, self.width, self.height)
 
# 新しい図形を追加: 既存コードの修正は不要
class Pentagon(Shape):
    def __init__(self, center: Point, side_length: float):
        self.center = center
        self.side_length = side_length
 
    def area(self) -> float:
        return (math.sqrt(5 * (5 + 2 * math.sqrt(5))) / 4) * self.side_length ** 2
 
    def perimeter(self) -> float:
        return 5 * self.side_length
 
    def draw(self, canvas: Canvas) -> None:
        canvas.draw_polygon(self._calculate_vertices())

# NG: Stack は List のメソッドの大部分を使わない/使わせたくない
class Stack(list):
    """スタック ── だが list の insert, sort, reverse が使えてしまう"""
    def push(self, item):
        self.append(item)
 
    def peek(self):
        return self[-1] if self else None
 
# stack.insert(0, "割り込み")  ← スタックの不変条件を破壊！
# stack.sort()                  ← 意味がない操作が可能
 
 
# OK: 委譲（コンポジション）で必要なインターフェースだけを公開
class Stack:
    """スタック ── LIFO のみを公開"""
    def __init__(self):
        self._items: list = []
 
    def push(self, item) -> None:
        self._items.append(item)
 
    def pop(self):
        if not self._items:
            raise EmptyStackError("スタックが空です")
        return self._items.pop()
 
    def peek(self):
        if not self._items:
            raise EmptyStackError("スタックが空です")
        return self._items[-1]
 
    def is_empty(self) -> bool:
        return len(self._items) == 0
 
    def __len__(self) -> int:
        return len(self._items)

// NG: totalSales と averagePrice は generateReport() でしか使わない
public class SalesAnalyzer {
    private List<Sale> sales;
    private double totalSales;     // ← 一時フィールド
    private double averagePrice;   // ← 一時フィールド
 
    public Report generateReport() {
        this.totalSales = sales.stream().mapToDouble(Sale::getAmount).sum();
        this.averagePrice = this.totalSales / sales.size();
        return new Report(this.totalSales, this.averagePrice);
    }
}
 
 
// OK: メソッドローカル変数またはデータクラスに移動
public class SalesAnalyzer {
    private final List<Sale> sales;
 
    public Report generateReport() {
        SalesStatistics stats = calculateStatistics();
        return new Report(stats);
    }
 
    private SalesStatistics calculateStatistics() {
        double total = sales.stream().mapToDouble(Sale::getAmount).sum();
        double average = total / sales.size();
        return new SalesStatistics(total, average);
    }
}
 
record SalesStatistics(double totalSales, double averagePrice) {}

# NG: 「税率の変更」で6箇所のファイルを修正する必要がある
# order_service.py
class OrderService:
    def calculate_total(self, order):
        return order.subtotal * 1.10  # ← 税率ハードコード
 
# invoice_service.py
class InvoiceService:
    def generate(self, order):
        tax = order.subtotal * 0.10   # ← 同じ税率
        return f"税額: {tax}"
 
# report_service.py
class ReportService:
    def monthly_tax(self, orders):
        return sum(o.subtotal * 0.10 for o in orders)  # ← また同じ
 
# receipt_printer.py, api_controller.py, test_helper.py ... 全て修正
 
 
# OK: 税率計算を1箇所に集約
class TaxCalculator:
    """税金計算の唯一の真実の源 (Single Source of Truth)"""
    STANDARD_RATE = Decimal("0.10")
    REDUCED_RATE = Decimal("0.08")
 
    @classmethod
    def calculate(cls, amount: Decimal,
                  rate_type: str = "standard") -> Decimal:
        rate = cls.REDUCED_RATE if rate_type == "reduced" else cls.STANDARD_RATE
        return (amount * rate).quantize(Decimal("1"))
 
    @classmethod
    def add_tax(cls, amount: Decimal,
                rate_type: str = "standard") -> Decimal:
        return amount + cls.calculate(amount, rate_type)
 
 
# 全てのサービスが TaxCalculator を使う
class OrderService:
    def calculate_total(self, order):
        return TaxCalculator.add_tax(order.subtotal)
 
class InvoiceService:
    def generate(self, order):
        tax = TaxCalculator.calculate(order.subtotal)
        return f"税額: {tax}"

# NG: デッドコードが散在
import os                     # ← 未使用インポート
import json                   # ← 未使用インポート
from datetime import datetime
 
class UserManager:
    def __init__(self, db):
        self.db = db
        self.cache = {}        # ← 一度も読み書きされない
 
    def get_user(self, user_id: str) -> User:
        return self.db.find(user_id)
 
    def _old_get_user(self, user_id: str) -> User:
        """旧実装 ── いつか必要になるかもしれないので残す"""  # ← デッドコード
        result = self.db.execute(f"SELECT * FROM users WHERE id = '{user_id}'")
        return User.from_row(result)
 
    def update_user(self, user_id: str, data: dict) -> User:
        user = self.get_user(user_id)
        # if False:                              # ← 到達不能コード
        #     self._send_update_notification(user)
        user.update(data)
        self.db.save(user)
        return user
 
    def _send_update_notification(self, user):   # ← 呼び出されない
        pass
 
 
# OK: デッドコードを完全に除去
from datetime import datetime
 
class UserManager:
    def __init__(self, db):
        self.db = db
 
    def get_user(self, user_id: str) -> User:
        return self.db.find(user_id)
 
    def update_user(self, user_id: str, data: dict) -> User:
        user = self.get_user(user_id)
        user.update(data)
        self.db.save(user)
        return user
 
# 旧実装が必要なら Git の履歴から復元可能
# → デッドコードを「念のため」残す必要はない

# NG: 現在 JSON しか使わないのに過度に抽象化
class SerializerFactory:
    def create(self, format_type: str) -> Serializer:
        if format_type == "json":
            return JsonSerializer()
        elif format_type == "xml":          # ← 使われていない
            return XmlSerializer()
        elif format_type == "yaml":         # ← 使われていない
            return YamlSerializer()
        elif format_type == "msgpack":      # ← 使われていない
            return MsgpackSerializer()
        elif format_type == "protobuf":     # ← 使われていない
            return ProtobufSerializer()
 
class Serializer(ABC): ...
class JsonSerializer(Serializer): ...
class XmlSerializer(Serializer): ...        # ← 使われていない
class YamlSerializer(Serializer): ...       # ← 使われていない
class MsgpackSerializer(Serializer): ...    # ← 使われていない
class ProtobufSerializer(Serializer): ...   # ← 使われていない
 
 
# OK: 必要なものだけを実装
class JsonSerializer:
    """JSON シリアライゼーション ── 現在必要な唯一のフォーマット"""
    def serialize(self, data: dict) -> str:
        return json.dumps(data, ensure_ascii=False, default=str)
 
    def deserialize(self, text: str) -> dict:
        return json.loads(text)
 
# 将来 XML が必要になったら、そのときに抽象化を導入する
# → "Rule of Three": 3回目のパターン出現まで抽象化を待つ

# NG: ほぼ同じ検証ロジックが3箇所に重複
class UserRegistration:
    def register(self, data: dict):
        # メールバリデーション (重複1)
        if not data.get('email'):
            raise ValueError("メールは必須です")
        if '@' not in data['email']:
            raise ValueError("メール形式が不正です")
        if len(data['email']) > 254:
            raise ValueError("メールが長すぎます")
        # ...
 
class ProfileUpdate:
    def update_email(self, data: dict):
        # メールバリデーション (重複2 ── ほぼ同一)
        if not data.get('new_email'):
            raise ValueError("メールは必須です")
        if '@' not in data['new_email']:
            raise ValueError("メール形式が不正です")
        if len(data['new_email']) > 254:
            raise ValueError("メールが長すぎます")
        # ...
 
class InviteService:
    def send_invite(self, email: str):
        # メールバリデーション (重複3 ── 微妙に異なる)
        if not email or '@' not in email:
            raise ValueError("不正なメール")
        # ...
 
 
# OK: バリデーションロジックを値オブジェクトに統合
import re
from dataclasses import dataclass
 
@dataclass(frozen=True)
class Email:
    """メールアドレス値オブジェクト ── バリデーションは1箇所のみ"""
    value: str
 
    _PATTERN = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
    _MAX_LENGTH = 254
 
    def __post_init__(self):
        if not self.value:
            raise ValueError("メールアドレスは必須です")
        if len(self.value) > self._MAX_LENGTH:
            raise ValueError(f"メールアドレスは{self._MAX_LENGTH}文字以下です")
        if not self._PATTERN.match(self.value):
            raise ValueError(f"メール形式が不正です: {self.value}")
        # frozen=True なので object.__setattr__ で正規化
        object.__setattr__(self, 'value', self.value.strip().lower())
 
class UserRegistration:
    def register(self, data: dict):
        email = Email(data.get('email', ''))  # バリデーションは Email 内で実行
        # ...
 
class ProfileUpdate:
    def update_email(self, data: dict):
        new_email = Email(data.get('new_email', ''))
        # ...

// NG: OrderPrinter が Order の内部データを過度に使用
class OrderPrinter {
    String formatOrder(Order order) {
        StringBuilder sb = new StringBuilder();
        sb.append("注文番号: ").append(order.getId()).append("\n");
        sb.append("顧客名: ").append(order.getCustomer().getName()).append("\n");
        sb.append("日付: ").append(order.getDate()
            .format(DateTimeFormatter.ISO_DATE)).append("\n");
 
        double subtotal = 0;
        for (OrderItem item : order.getItems()) {
            double lineTotal = item.getPrice() * item.getQuantity();
            subtotal += lineTotal;
            sb.append(String.format("  %s x%d = %.0f円\n",
                item.getName(), item.getQuantity(), lineTotal));
        }
        double tax = subtotal * 0.10;
        sb.append(String.format("小計: %.0f円\n税: %.0f円\n合計: %.0f円\n",
            subtotal, tax, subtotal + tax));
        return sb.toString();
    }
}
 
 
// OK: フォーマットロジックを Order に移動
class Order {
    public String format() {
        StringBuilder sb = new StringBuilder();
        sb.append("注文番号: ").append(this.id).append("\n");
        sb.append("顧客名: ").append(this.customer.getName()).append("\n");
        sb.append("日付: ").append(this.date
            .format(DateTimeFormatter.ISO_DATE)).append("\n");
        this.items.forEach(item -> sb.append(item.formatLine()));
        sb.append(formatTotals());
        return sb.toString();
    }
 
    private String formatTotals() {
        double subtotal = calculateSubtotal();
        double tax = subtotal * 0.10;
        return String.format("小計: %.0f円\n税: %.0f円\n合計: %.0f円\n",
            subtotal, tax, subtotal + tax);
    }
 
    public double calculateSubtotal() {
        return items.stream()
            .mapToDouble(item -> item.getPrice() * item.getQuantity())
            .sum();
    }
}
 
class OrderItem {
    public String formatLine() {
        double lineTotal = this.price * this.quantity;
        return String.format("  %s x%d = %.0f円\n",
            this.name, this.quantity, lineTotal);
    }
}

# NG: Demeter の法則に違反
class OrderReport:
    def get_customer_city(self, order):
        # order → customer → address → city の4段階チェーン
        return order.get_customer().get_address().get_city()
 
    def get_payment_bank(self, order):
        # order → payment → method → bank の4段階チェーン
        return order.get_payment().get_method().get_bank_name()
 
 
# OK: 必要な情報を直接取得できるメソッドを提供
class Order:
    def get_customer_city(self) -> str:
        """顧客の都市名を返す（内部構造を隠蔽）"""
        return self._customer.get_city()
 
    def get_payment_bank(self) -> str:
        """決済銀行名を返す"""
        return self._payment.get_bank_name()
 
class Customer:
    def get_city(self) -> str:
        """住所の都市名を返す（内部構造を隠蔽）"""
        return self._address.city
 
class Payment:
    def get_bank_name(self) -> str:
        return self._method.bank_name
 
# 呼び出し側は1段階のみ
class OrderReport:
    def get_customer_city(self, order):
        return order.get_customer_city()

// NG: User と Profile が互いの内部を直接操作
class User {
  public name: string;
  public email: string;
  public profile: Profile;
 
  updateProfile(bio: string): void {
    // User が Profile の内部を直接操作
    this.profile._bio = bio;               // private を迂回
    this.profile._updatedAt = new Date();  // Profile の責任を侵害
  }
}
 
class Profile {
  _bio: string;          // 本来は private にすべき
  _updatedAt: Date;      // 本来は private にすべき
 
  getDisplayName(): string {
    // Profile が User の内部を直接参照
    return `${this.user.name} (${this.user.email})`;
  }
}
 
 
// OK: 明確なインターフェースを通じてのみ通信
class User {
  private readonly name: string;
  private readonly email: string;
  private readonly profile: Profile;
 
  updateProfile(bio: string): void {
    this.profile.updateBio(bio);  // Profile のメソッドを呼ぶ
  }
 
  getDisplayInfo(): UserDisplayInfo {
    return { name: this.name, email: this.email };
  }
}
 
class Profile {
  private bio: string;
  private updatedAt: Date;
 
  updateBio(bio: string): void {
    if (bio.length > 500) throw new Error("プロフィールは500文字以内");
    this.bio = bio;
    this.updatedAt = new Date();
  }
 
  formatDisplay(userInfo: UserDisplayInfo): string {
    return `${userInfo.name} - ${this.bio}`;
  }
}

# .github/workflows/code-smell-detection.yml
name: Code Smell Detection
 
on:
  pull_request:
    branches: [main, develop]
 
jobs:
  detect-smells:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
 
      - name: Install analysis tools
        run: |
          pip install ruff radon jscpd
 
      # 1. Lint チェック (スタイル + 基本的なスメル)
      - name: Ruff Lint
        run: ruff check src/ --output-format=github
 
      # 2. サイクロマティック複雑度チェック
      - name: Complexity Check
        run: |
          echo "## 複雑度レポート" >> $GITHUB_STEP_SUMMARY
          radon cc src/ -a -nc --min C
          # C以上 (複雑度11+) がある場合に警告
          COMPLEX=$(radon cc src/ -nc --min C -j | python3 -c "
          import json, sys
          data = json.load(sys.stdin)
          count = sum(len(funcs) for funcs in data.values())
          print(count)
          ")
          if [ "$COMPLEX" -gt 0 ]; then
            echo "::warning::高複雑度の関数が${COMPLEX}個あります"
          fi
 
      # 3. コード重複チェック
      - name: Duplication Check
        run: |
          jscpd src/ --min-lines 6 --min-tokens 50 \
                --reporters "consoleFull" --threshold 3
 
      # 4. デッドコード検出
      - name: Dead Code Detection
        run: |
          pip install vulture
          vulture src/ --min-confidence 80
 
      # 5. 保守性指数
      - name: Maintainability Index
        run: |
          radon mi src/ -s --min B

#!/usr/bin/env python3
"""
ホットスポット分析: 変更頻度と複雑度を組み合わせて
リファクタリングの優先度を科学的に判断する。
 
使用法:
  python hotspot_analysis.py /path/to/repo --days 90
"""
import subprocess
import json
from dataclasses import dataclass
from pathlib import Path
 
 
@dataclass
class FileMetrics:
    """ファイルのスメル指標"""
    path: str
    change_count: int       # Git の変更回数
    complexity: float       # 平均サイクロマティック複雑度
    lines: int              # 行数
    hotspot_score: float    # 変更頻度 x 複雑度
 
    @property
    def priority(self) -> str:
        if self.hotspot_score > 100:
            return "最優先"
        elif self.hotspot_score > 50:
            return "高"
        elif self.hotspot_score > 20:
            return "中"
        return "低"
 
 
def analyze_hotspots(repo_path: str, days: int = 90) -> list[FileMetrics]:
    """変更頻度 x 複雑度のホットスポットを分析"""
 
    # 1. Git log から変更頻度を取得
    result = subprocess.run(
        ['git', 'log', '--format=format:', '--name-only',
         f'--since={days} days ago', '--diff-filter=M'],
        capture_output=True, text=True, cwd=repo_path
    )
    file_changes: dict[str, int] = {}
    for line in result.stdout.strip().split('\n'):
        line = line.strip()
        if line and line.endswith('.py'):
            file_changes[line] = file_changes.get(line, 0) + 1
 
    # 2. radon で複雑度を取得
    result = subprocess.run(
        ['radon', 'cc', repo_path, '-a', '-j'],
        capture_output=True, text=True
    )
    complexity_data = json.loads(result.stdout)
 
    # 3. ホットスポットスコアを計算
    metrics = []
    for filepath, change_count in file_changes.items():
        cc = get_file_complexity(complexity_data, filepath)
        score = change_count * cc
        metrics.append(FileMetrics(
            path=filepath,
            change_count=change_count,
            complexity=cc,
            lines=count_lines(Path(repo_path) / filepath),
            hotspot_score=score
        ))
 
    return sorted(metrics, key=lambda m: m.hotspot_score, reverse=True)
 
 
def print_hotspot_report(metrics: list[FileMetrics]) -> None:
    """ホットスポットレポートを出力"""
    print("=" * 75)
    print("  ホットスポット分析レポート")
    print("=" * 75)
    print(f"{'優先度':<8} {'スコア':<8} {'変更':>4} {'CC':>5} {'行数':>6}  {'ファイル'}")
    print("-" * 75)
    for m in metrics[:20]:
        print(f"{m.priority:<8} {m.hotspot_score:>6.1f} {m.change_count:>4} "
              f"{m.complexity:>5.1f} {m.lines:>6}  {m.path}")

# 問題コード: 以下のスメルを全て特定せよ
import os, sys, json, csv, re  # 使われていないインポートあり
 
class AppManager:
    """アプリケーション全体を管理するクラス"""
    def __init__(self):
        self.db = Database()
        self.mailer = Mailer()
        self.cache = {}
        self.temp_result = None   # 特定のメソッドでのみ使用
 
    def process(self, t, n, e, a, c, z, co):
        """ユーザー登録処理"""
        # バリデーション
        if not n:
            raise ValueError("名前が必要")
        if '@' not in e:
            raise ValueError("メールが不正")
 
        # ユーザー作成
        user = {"type": t, "name": n, "email": e,
                "address": a, "city": c, "zip": z, "country": co}
 
        # 料金計算
        if t == "premium":
            price = 9800
        elif t == "standard":
            price = 4980
        elif t == "free":
            price = 0
 
        # DB保存
        self.db.execute(f"INSERT INTO users VALUES ('{n}', '{e}')")
 
        # メール送信
        self.mailer.send(e, "登録完了", f"ようこそ {n} さん")
 
        # キャッシュクリア
        self.cache = {}
 
        self.temp_result = price
        return price

# 1. 必要なインポートのみ
from dataclasses import dataclass
from abc import ABC, abstractmethod
from decimal import Decimal
 
# 2. 値オブジェクト
@dataclass(frozen=True)
class Email:
    value: str
    def __post_init__(self):
        if '@' not in self.value:
            raise ValueError(f"不正なメール: {self.value}")
 
@dataclass(frozen=True)
class Address:
    street: str
    city: str
    zip_code: str
    country: str
 
# 3. ポリモーフィズムで料金計算
class UserPlan(ABC):
    @abstractmethod
    def monthly_price(self) -> Decimal: ...
 
class PremiumPlan(UserPlan):
    def monthly_price(self) -> Decimal:
        return Decimal("9800")
 
class StandardPlan(UserPlan):
    def monthly_price(self) -> Decimal:
        return Decimal("4980")
 
class FreePlan(UserPlan):
    def monthly_price(self) -> Decimal:
        return Decimal("0")
 
# 4. パラメータオブジェクト
@dataclass
class RegistrationRequest:
    name: str
    email: Email
    address: Address
    plan: UserPlan
 
# 5. 責任の分離
class UserRegistrationService:
    def __init__(self, repository, notifier):
        self.repository = repository
        self.notifier = notifier
 
    def register(self, request: RegistrationRequest) -> Decimal:
        user = User(request.name, request.email, request.address, request.plan)
        self.repository.save(user)
        self.notifier.send_welcome(user)
        return request.plan.monthly_price()

# Step 1: 変更頻度の高いファイルを特定
git log --format=format: --name-only --since="6 months ago" \
  | sort | uniq -c | sort -rn | head -20
 
# Step 2: 複雑度が高いファイルを特定
radon cc src/ -a -nc --min C
 
# Step 3: 両方に含まれるファイルがホットスポット