class OrderProcessor:
    def __init__(self, validator: OrderValidator, logger: Logger):
        self.validator = validator  # フィールド
        self.logger = logger       # フィールド
 
    def process(self, order: Order) -> ProcessResult:
        # ルール1: 自身のメソッド（self）
        self._log_processing_start(order)
 
        # ルール2: 引数のメソッド（param）
        if not order.is_valid():
            return ProcessResult.invalid()
 
        # ルール3: ローカルで生成したオブジェクトのメソッド（local）
        receipt = Receipt.create(order)
        receipt.finalize()
 
        # ルール4: フィールドのメソッド（field）
        self.validator.validate(order)
        self.logger.info(f"Order {order.id} processed")
 
        return ProcessResult.success(receipt)
 
    def _log_processing_start(self, order: Order):
        self.logger.info(f"Processing order {order.id}")
 
    # 以下は NG（友人の友人のメソッドを呼んでいる）
    # order.customer.address.city.name  ← NG！
    # self.validator.config.timeout      ← NG！

# === LoD違反: 深いドット連鎖 ===
class OrderProcessor:
    def calculate_shipping(self, order):
        # Order → Customer → Address → City → ZipCode と4段掘り下げ
        zip_code = order.customer.address.city.zip_code
        if zip_code.startswith('100'):
            return 500  # 都内は500円
        return 1000
 
 
# === LoD準拠: 各オブジェクトが自分の責任範囲で応答 ===
class Order:
    def __init__(self, customer: Customer):
        self.customer = customer
 
    def get_shipping_zip_code(self) -> str:
        """配送先の郵便番号を返す（内部構造を隠蔽）"""
        return self.customer.get_zip_code()
 
class Customer:
    def __init__(self, address: Address):
        self.address = address
 
    def get_zip_code(self) -> str:
        """顧客の郵便番号を返す"""
        return self.address.get_zip_code()
 
class Address:
    def __init__(self, city: City):
        self.city = city
 
    def get_zip_code(self) -> str:
        """住所の郵便番号を返す"""
        return self.city.zip_code
 
class OrderProcessor:
    def calculate_shipping(self, order):
        zip_code = order.get_shipping_zip_code()  # 1ドットで完結
        if zip_code.startswith('100'):
            return 500
        return 1000

// === LoD違反: 内部コレクションを外部に公開 ===
class Department {
    private List<Employee> employees;
 
    public List<Employee> getEmployees() {
        return employees;  // 内部構造を暴露
    }
}
 
// 呼び出し側が内部構造に依存
int count = department.getEmployees().stream()
    .filter(e -> e.getSalary() > 500000)
    .count();
 
// 問題点:
// 1. Department が内部のデータ構造（List）を公開している
// 2. 呼び出し側が Employee の salary フィールドを知っている
// 3. フィルタリングロジックが呼び出し側に漏れている
 
 
// === LoD準拠: 問い合わせメソッドを提供 ===
class Department {
    private List<Employee> employees;
 
    public int countEmployeesWithSalaryAbove(int threshold) {
        return (int) employees.stream()
            .filter(e -> e.getSalary() > threshold)
            .count();
    }
 
    public List<String> getEmployeeNames() {
        return employees.stream()
            .map(Employee::getName)
            .collect(Collectors.toUnmodifiableList());
    }
 
    public Optional<Employee> findHighestPaid() {
        return employees.stream()
            .max(Comparator.comparingInt(Employee::getSalary));
    }
 
    // 必要に応じて防御的コピーを返す
    public List<Employee> getEmployeesSnapshot() {
        return List.copyOf(employees);
    }
}
 
// 呼び出し側はシンプル
int count = department.countEmployeesWithSalaryAbove(500000);

// === LoD違反: 設定の深い階層に直接アクセス ===
function connectDatabase(config: AppConfig) {
  const host = config.database.connection.primary.host;
  const port = config.database.connection.primary.port;
  const timeout = config.database.connection.primary.timeoutMs;
  return new Database(`${host}:${port}`, { timeout });
}
// → config の内部構造に3段階依存
// → database, connection, primary のいずれかの構造変更で壊れる
 
 
// === LoD準拠: 必要なデータだけを受け取る ===
interface DatabaseConnectionInfo {
  host: string;
  port: number;
  timeoutMs: number;
}
 
function connectDatabase(connection: DatabaseConnectionInfo) {
  return new Database(`${connection.host}:${connection.port}`, {
    timeout: connection.timeoutMs
  });
}
 
// 呼び出し側で必要な情報を抽出して渡す
// config の構造変更は呼び出し側（1箇所）のみに影響
const db = connectDatabase(config.getDatabaseConnection());

# === LoD違反 + null地獄 ===
def get_manager_email(employee):
    if employee is not None:
        dept = employee.department
        if dept is not None:
            manager = dept.manager
            if manager is not None:
                contact = manager.contact
                if contact is not None:
                    return contact.email
    return "unknown@example.com"
# → 4段のnullチェック = 4つのクラスの内部構造を知っている
# → 追跡が困難、テスト組み合わせが 2^4 = 16パターン
 
 
# === LoD準拠: 各オブジェクトが責任を持つ ===
class Employee:
    def get_manager_email(self) -> str:
        """マネージャーのメールアドレスを取得（部門に委譲）"""
        if self.department is None:
            return "unknown@example.com"
        return self.department.get_manager_email()
 
class Department:
    def get_manager_email(self) -> str:
        """マネージャーのメールを取得（マネージャーに委譲）"""
        if self.manager is None:
            return "unknown@example.com"
        return self.manager.get_email()
 
class Manager:
    def get_email(self) -> str:
        """メールアドレスを取得"""
        return self.contact.email if self.contact else "unknown@example.com"
 
# 呼び出し: シンプルかつnull安全
email = employee.get_manager_email()
# → nullチェックは各クラスが自身の責任範囲で処理
# → テストは各クラスごとに独立して記述可能

# === Ask パターン（LoD違反しやすい） ===
class OrderProcessor:
    def process_discount(self, order: Order):
        # 顧客の情報を「聞いて」自分で判断する
        customer = order.customer
        if customer.membership_level == 'gold':
            if customer.total_purchases > 100000:
                discount = 0.15
            else:
                discount = 0.10
        elif customer.membership_level == 'silver':
            discount = 0.05
        else:
            discount = 0.0
 
        order.apply_discount(discount)
        # → 割引ロジックが OrderProcessor に漏れている
        # → Customer の membership_level の仕様変更で OrderProcessor が壊れる
 
 
# === Tell パターン（LoD準拠） ===
class OrderProcessor:
    def process_discount(self, order: Order):
        # 注文に「割引を計算して適用して」と命令する
        order.apply_membership_discount()
        # → OrderProcessor は割引の詳細を知らない
 
class Order:
    def apply_membership_discount(self):
        discount = self.customer.calculate_discount()
        self.total *= (1 - discount)
 
class Customer:
    def calculate_discount(self) -> float:
        """顧客自身が自分の割引率を知っている"""
        if self.membership_level == 'gold':
            return 0.15 if self.total_purchases > 100000 else 0.10
        elif self.membership_level == 'silver':
            return 0.05
        return 0.0
    # → 割引ロジックが Customer クラスに閉じている
    # → 仕様変更は Customer のみに影響

// === LoD違反: 呼び出し側がすべての判断を行う ===
class ShippingService {
  calculateShippingCost(order: Order): number {
    // 注文の内部構造を深く知りすぎている
    const weight = order.items.reduce(
      (sum, item) => sum + item.product.weight * item.quantity, 0
    );
    const isOversized = order.items.some(
      item => item.product.dimensions.width > 120 ||
              item.product.dimensions.height > 120
    );
    const address = order.customer.shippingAddress;
    const isRemoteArea = address.prefecture === '沖縄' ||
                         address.prefecture === '北海道';
 
    let cost = weight * 10; // 基本運賃
    if (isOversized) cost *= 1.5;
    if (isRemoteArea) cost += 500;
    if (order.customer.membershipLevel === 'premium') cost *= 0.8;
 
    return cost;
  }
}
// → ShippingService が Order, Item, Product, Dimensions,
//   Customer, Address, MembershipLevel を知っている
 
 
// === LoD準拠: 各オブジェクトに判断を委譲 ===
class ShippingService {
  calculateShippingCost(order: Order): number {
    const shippingInfo = order.getShippingInfo();
    return this.calculateBaseCost(shippingInfo)
         * shippingInfo.sizeMultiplier
         + shippingInfo.remoteAreaSurcharge
         * shippingInfo.membershipDiscount;
  }
 
  private calculateBaseCost(info: ShippingInfo): number {
    return info.totalWeight * 10;
  }
}
 
// Order が必要な情報をまとめて提供
class Order {
  getShippingInfo(): ShippingInfo {
    return {
      totalWeight: this.calculateTotalWeight(),
      sizeMultiplier: this.hasOversizedItems() ? 1.5 : 1.0,
      remoteAreaSurcharge: this.customer.getRemoteAreaSurcharge(),
      membershipDiscount: this.customer.getMembershipDiscount(),
    };
  }
 
  private calculateTotalWeight(): number {
    return this.items.reduce(
      (sum, item) => sum + item.getWeight(), 0
    );
  }
 
  private hasOversizedItems(): boolean {
    return this.items.some(item => item.isOversized());
  }
}
 
// 各オブジェクトが自身の判断を担当
class OrderItem {
  getWeight(): number { return this.product.weight * this.quantity; }
  isOversized(): boolean { return this.product.isOversized(); }
}
 
class Product {
  isOversized(): boolean {
    return this.dimensions.width > 120 || this.dimensions.height > 120;
  }
}

# これはLoD違反ではない！（Fluent Interface / メソッドチェーン）
query = (
    QueryBuilder()
    .select("name", "email")
    .from_table("users")
    .where("age > 18")
    .order_by("name")
    .limit(10)
    .build()
)
# 各メソッドは同じオブジェクト（または同じ型）を返す
# → 「友人の友人」ではなく「友人自身」に繰り返し話しかけている
 
# これもLoD違反ではない（Stream パイプライン）
result = (
    users
    .stream()
    .filter(lambda u: u.is_active())
    .map(lambda u: u.name)
    .sorted()
    .collect(to_list())
)
# データ変換のパイプラインであり、内部構造の探索ではない

# === LoD違反: サードパーティAPIの内部構造に依存 ===
class PaymentProcessor:
    def __init__(self):
        self.stripe = stripe
 
    def charge(self, customer_id: str, amount: int):
        # Stripe APIの内部構造に直接依存
        customer = self.stripe.Customer.retrieve(customer_id)
        default_source = customer.sources.data[0]  # 内部構造の探索
        charge = self.stripe.Charge.create(
            amount=amount,
            currency='jpy',
            source=default_source.id,
            customer=customer.id,
        )
        return charge.status == 'succeeded'
        # → Stripe API の構造変更で壊れる
 
 
# === LoD準拠: Adapterでラッピング ===
class StripePaymentAdapter:
    """Stripe APIとの結合をこのクラスに閉じ込める"""
    def __init__(self, api_key: str):
        stripe.api_key = api_key
 
    def charge_default_method(self, customer_id: str, amount: int) -> PaymentResult:
        """顧客のデフォルト決済方法で課金する"""
        try:
            intent = stripe.PaymentIntent.create(
                amount=amount,
                currency='jpy',
                customer=customer_id,
                confirm=True,
            )
            return PaymentResult(
                success=intent.status == 'succeeded',
                transaction_id=intent.id,
            )
        except stripe.error.CardError as e:
            return PaymentResult(success=False, error=str(e))
 
 
class PaymentProcessor:
    """決済処理 - Stripeの内部構造を知らない"""
    def __init__(self, payment_gateway: PaymentGateway):
        self.gateway = payment_gateway  # インターフェースに依存
 
    def charge(self, customer_id: str, amount: int) -> PaymentResult:
        return self.gateway.charge_default_method(customer_id, amount)

// === LoD違反: 長いチェーンで情報を収集 ===
function generateInvoice(order: Order): Invoice {
  const customerName = order.customer.profile.displayName;
  const billingAddress = order.customer.addresses.find(a => a.type === 'billing');
  const taxId = order.customer.taxInfo.registrationNumber;
  const items = order.items.map(i => ({
    name: i.product.name,
    price: i.product.price * i.quantity,
    taxRate: i.product.category.taxRate,
  }));
  // → order, customer, profile, addresses, taxInfo, items,
  //   product, category すべてを知っている
}
 
 
// === LoD準拠: コンテキストオブジェクトで必要情報をまとめる ===
 
// 請求書生成に必要な情報のみを集めた型
interface InvoiceContext {
  customerName: string;
  billingAddress: Address;
  taxRegistrationNumber: string;
  lineItems: InvoiceLineItem[];
}
 
interface InvoiceLineItem {
  productName: string;
  totalPrice: number;
  taxRate: number;
}
 
// Order がコンテキストを構築する責任を持つ
class Order {
  toInvoiceContext(): InvoiceContext {
    return {
      customerName: this.customer.getDisplayName(),
      billingAddress: this.customer.getBillingAddress(),
      taxRegistrationNumber: this.customer.getTaxRegistrationNumber(),
      lineItems: this.items.map(item => item.toInvoiceLineItem()),
    };
  }
}
 
class OrderItem {
  toInvoiceLineItem(): InvoiceLineItem {
    return {
      productName: this.product.getName(),
      totalPrice: this.product.getPrice() * this.quantity,
      taxRate: this.product.getTaxRate(),
    };
  }
}
 
// 請求書生成関数は InvoiceContext だけを知る
function generateInvoice(context: InvoiceContext): Invoice {
  // Order の内部構造を一切知らない
  return new Invoice(context);
}
 
// 使用
const invoice = generateInvoice(order.toInvoiceContext());

// NG: LoD を過度に適用するとラッパーメソッドだらけになる
class Customer {
    private Address address;
 
    // 委譲メソッドが爆発的に増える
    public String getStreet() { return address.getStreet(); }
    public String getCity() { return address.getCity(); }
    public String getState() { return address.getState(); }
    public String getZipCode() { return address.getZipCode(); }
    public String getCountry() { return address.getCountry(); }
    public void setStreet(String s) { address.setStreet(s); }
    public void setCity(String c) { address.setCity(c); }
    // ... 延々と続く → Middle Man コードスメル
 
// OK: 意味のある抽象レベルで委譲する
class Customer {
    private Address address;
 
    // 全フィールドを個別に委譲するのではなく、
    // 意味のある操作を提供する
    public String getFormattedAddress() {
        return address.format();
    }
 
    public boolean isInDeliveryArea(DeliveryZone zone) {
        return zone.includes(address);
    }
 
    // Address 自体が必要な場合は、防御的コピーを返す
    public Address getAddressCopy() {
        return new Address(address); // 不変コピー
    }
}

# NG: LoD に従おうとして、無関係な責任を押し付ける
class Order:
    def format_customer_address_for_shipping_label(self) -> str:
        # これは Order の責任ではない！
        return f"{self.customer.name}\n{self.customer.address.full_address()}"
 
# OK: 適切なオブジェクトに責任を持たせる
class ShippingLabel:
    """配送ラベルの生成を担当するクラス"""
    def format(self, customer: Customer) -> str:
        return f"{customer.name}\n{customer.get_formatted_address()}"
 
# 使用
label = ShippingLabel()
formatted = label.format(order.customer)
# → Order は配送ラベルの知識を持たず、Customer へのアクセスのみ提供

# NG: 不必要な委譲レイヤーが多すぎる
class WidgetA:
    def get_value(self):
        return self.widget_b.get_value()
 
class WidgetB:
    def get_value(self):
        return self.widget_c.get_value()
 
class WidgetC:
    def get_value(self):
        return self.widget_d.get_value()
 
class WidgetD:
    def get_value(self):
        return self._actual_value
# → 4段の委譲。LoD準拠だが設計が歪んでいる
 
# OK: 設計を見直し、適切な粒度にする
# 過度な委譲は「設計の歪み」のサイン
# 本来の責任の所在を再考する

# === Python: pylint でのLoD違反検出 ===
# .pylintrc
# [DESIGN]
# max-args=5              # 引数が多いとLoD違反の可能性
# max-attributes=7        # フィールドが多いとLoD違反の可能性
 
# === カスタムルール: ドット連鎖の検出 ===
import ast
 
class LoDChecker(ast.NodeVisitor):
    """LoD違反の候補を検出するAST解析"""
    MAX_CHAIN_LENGTH = 2
 
    def visit_Attribute(self, node):
        chain_length = self._count_chain(node)
        if chain_length > self.MAX_CHAIN_LENGTH:
            print(
                f"Line {node.lineno}: "
                f"ドット連鎖が{chain_length}段 "
                f"(しきい値: {self.MAX_CHAIN_LENGTH}段)"
            )
        self.generic_visit(node)
 
    def _count_chain(self, node, depth=1):
        if isinstance(node.value, ast.Attribute):
            return self._count_chain(node.value, depth + 1)
        return depth

// === TypeScript: ESLint カスタムルール ===
// eslint-plugin-demeter
module.exports = {
  rules: {
    'no-deep-chain': {
      create(context) {
        return {
          MemberExpression(node) {
            let depth = 0;
            let current = node;
            while (current.type === 'MemberExpression') {
              depth++;
              current = current.object;
            }
            if (depth > 2) {
              context.report({
                node,
                message: `ドット連鎖が${depth}段です。デメテルの法則に違反する可能性があります。`,
              });
            }
          },
        };
      },
    },
  },
};

class ReportGenerator:
    def generate(self, company):
        # (1)
        ceo_name = company.board.ceo.personal_info.full_name
 
        # (2)
        total = sum(d.budget for d in company.departments)
 
        # (3)
        report = Report()
        report.set_title(f"Annual Report for {company.name}")
 
        # (4)
        formatted = (
            ReportFormatter()
            .set_font("Arial")
            .set_size(12)
            .format(report)
        )
 
        # (5)
        company.departments[0].employees[0].salary
 
        return formatted

class NotificationSender {
  sendReminder(user: User) {
    if (user.preferences.notifications.email.enabled) {
      const email = user.contactInfo.primaryEmail;
      if (user.subscription.plan === 'premium') {
        this.emailService.sendPriority(email, 'Reminder', '...');
      } else {
        this.emailService.send(email, 'Reminder', '...');
      }
    }
 
    if (user.preferences.notifications.push.enabled) {
      const deviceToken = user.devices[0].pushToken;
      this.pushService.send(deviceToken, 'Reminder', '...');
    }
  }
}

// Tell パターン: 各オブジェクトに判断を委譲
class NotificationSender {
  sendReminder(user: User) {
    user.sendNotification({
      type: 'reminder',
      subject: 'Reminder',
      body: '...',
      emailService: this.emailService,
      pushService: this.pushService,
    });
  }
}
 
class User {
  sendNotification(params: NotificationParams) {
    if (this.shouldSendEmail()) {
      this.sendEmailNotification(params);
    }
    if (this.shouldSendPush()) {
      this.sendPushNotification(params);
    }
  }
 
  private shouldSendEmail(): boolean {
    return this.preferences.isEmailEnabled();
  }
 
  private sendEmailNotification(params: NotificationParams) {
    const email = this.contactInfo.getPrimaryEmail();
    if (this.subscription.isPremium()) {
      params.emailService.sendPriority(email, params.subject, params.body);
    } else {
      params.emailService.send(email, params.subject, params.body);
    }
  }
 
  private shouldSendPush(): boolean {
    return this.preferences.isPushEnabled();
  }
 
  private sendPushNotification(params: NotificationParams) {
    const token = this.getPreferredPushToken();
    params.pushService.send(token, params.subject, params.body);
  }
}

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]

# DTOのアクセスはOK
user_dto = api_response.data.user
name = user_dto.profile.display_name  # DTOなのでOK
 
# ドメインロジックではDTOの構造に依存しない
def greet_user(display_name: str) -> str:  # プリミティブ値で受け取る
    return f"Hello, {display_name}!"
 
greet_user(user_dto.profile.display_name)  # 呼び出し側でDTOを展開

-- 関数型: パイプラインはLoD違反ではない
result = users
  |> filter isActive
  |> map getName
  |> sort
  |> take 10
-- 各関数はデータを変換するだけで、内部構造を探索していない
 
-- LoD違反に相当するもの
getUserCity :: User -> String
getUserCity user = city (address (profile user))
-- → User の内部構造（profile → address → city）を知りすぎている
 
-- LoD準拠
getUserCity :: User -> String
getUserCity = getCity . getAddress . getProfile
-- → ただし、これは関数合成として許容される場合が多い
-- → 重要なのは、getUserCity が User モジュールから公開されること