@su-record/vibe 2.4.72 → 2.4.76

package/languages/rust.md

@@ -1,26 +1,27 @@
-# 🦀 Rust 품질 규칙
+# Rust Quality Rules
 
-## 핵심 원칙 (core에서 상속)
+## Core Principles (inherited from core)
 
 ```markdown
-✅ 단일 책임 (SRP)
-✅ 중복 제거 (DRY)
-✅ 재사용성
-✅ 낮은 복잡도
-✅ 함수 ≤ 30줄
-✅ 중첩 ≤ 3단계
-✅ Cyclomatic complexity ≤ 10
+# Core Principles (inherited from core)
+Single Responsibility (SRP)
+No Duplication (DRY)
+Reusability
+Low Complexity
+Function <= 30 lines
+Nesting <= 3 levels
+Cyclomatic complexity <= 10
 ```
 
-## Rust 특화 규칙
+## Rust Specific Rules
 
-### 1. 에러 처리 (Result, Option)
+### 1. Error Handling (Result, Option)
 
 ```rust
-// ❌ unwrap() 남용
+// Bad: Overusing unwrap()
 let content = fs::read_to_string("config.json").unwrap();
 
-// ✅ ? 연산자와 적절한 에러 처리
+// Good: ? operator with proper error handling
 fn read_config(path: &str) -> Result<Config, ConfigError> {
     let content = fs::read_to_string(path)
         .map_err(|e| ConfigError::IoError(e))?;
@@ -31,39 +32,39 @@ fn read_config(path: &str) -> Result<Config, ConfigError> {
     Ok(config)
 }
 
-// ✅ 커스텀 에러 타입 (thiserror)
+// Good: Custom error type (thiserror)
 use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum AppError {
-    #[error("설정 파일을 읽을 수 없습니다: {0}")]
+    #[error("Cannot read config file: {0}")]
     ConfigError(#[from] std::io::Error),
 
-    #[error("잘못된 요청입니다: {0}")]
+    #[error("Invalid request: {0}")]
     BadRequest(String),
 
-    #[error("리소스를 찾을 수 없습니다: {resource} (ID: {id})")]
+    #[error("Resource not found: {resource} (ID: {id})")]
     NotFound { resource: String, id: String },
 
-    #[error("데이터베이스 오류: {0}")]
+    #[error("Database error: {0}")]
     DatabaseError(#[from] sqlx::Error),
 }
 
-// ✅ anyhow로 간편한 에러 처리 (애플리케이션 레벨)
+// Good: Easy error handling with anyhow (application level)
 use anyhow::{Context, Result};
 
 fn process_file(path: &str) -> Result<String> {
     let content = fs::read_to_string(path)
-        .context(format!("파일을 읽을 수 없습니다: {}", path))?;
+        .context(format!("Cannot read file: {}", path))?;
 
     Ok(content)
 }
 ```
 
-### 2. 구조체와 트레이트
+### 2. Structs and Traits
 
 ```rust
-// ✅ 구조체 정의
+// Good: Struct definition
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
@@ -90,7 +91,7 @@ impl User {
     }
 }
 
-// ✅ 트레이트 정의
+// Good: Trait definition
 #[async_trait]
 pub trait UserRepository: Send + Sync {
     async fn find_by_id(&self, id: Uuid) -> Result<Option<User>, AppError>;
@@ -100,7 +101,7 @@ pub trait UserRepository: Send + Sync {
     async fn delete(&self, id: Uuid) -> Result<(), AppError>;
 }
 
-// ✅ 트레이트 구현
+// Good: Trait implementation
 pub struct PostgresUserRepository {
     pool: PgPool,
 }
@@ -119,14 +120,14 @@ impl UserRepository for PostgresUserRepository {
         Ok(user)
     }
 
-    // ... 다른 메서드 구현
+    // ... other method implementations
 }
 ```
 
-### 3. Actix-web / Axum 핸들러
+### 3. Actix-web / Axum Handlers
 
 ```rust
-// ✅ Axum 핸들러
+// Good: Axum handler
 use axum::{
     extract::{Path, State, Json},
     http::StatusCode,
@@ -141,7 +142,7 @@ pub async fn get_user(
         .find_by_id(id)
         .await?
         .ok_or(AppError::NotFound {
-            resource: "사용자".to_string(),
+            resource: "User".to_string(),
             id: id.to_string(),
         })?;
 
@@ -158,7 +159,7 @@ pub async fn create_user(
     Ok((StatusCode::CREATED, Json(created)))
 }
 
-// ✅ Actix-web 핸들러
+// Good: Actix-web handler
 use actix_web::{web, HttpResponse, Result};
 
 pub async fn get_user(
@@ -170,7 +171,7 @@ pub async fn get_user(
         .find_by_id(id)
         .await?
         .ok_or(AppError::NotFound {
-            resource: "사용자".to_string(),
+            resource: "User".to_string(),
             id: id.to_string(),
         })?;
 
@@ -178,21 +179,21 @@ pub async fn get_user(
 }
 ```
 
-### 4. 소유권과 생명주기
+### 4. Ownership and Lifetimes
 
 ```rust
-// ❌ 불필요한 클론
+// Bad: Unnecessary clone
 fn process(data: &Vec<String>) -> Vec<String> {
-    let cloned = data.clone();  // 불필요
+    let cloned = data.clone();  // Unnecessary
     cloned.iter().map(|s| s.to_uppercase()).collect()
 }
 
-// ✅ 참조 활용
+// Good: Use references
 fn process(data: &[String]) -> Vec<String> {
     data.iter().map(|s| s.to_uppercase()).collect()
 }
 
-// ✅ 생명주기 명시
+// Good: Explicit lifetimes
 pub struct UserService<'a> {
     repo: &'a dyn UserRepository,
     cache: &'a dyn CacheRepository,
@@ -207,16 +208,16 @@ impl<'a> UserService<'a> {
     }
 }
 
-// ✅ 소유권 이전 vs 빌려오기
-fn take_ownership(s: String) { /* s의 소유권을 가짐 */ }
-fn borrow(s: &str) { /* s를 빌려옴 */ }
-fn borrow_mut(s: &mut String) { /* s를 가변 빌려옴 */ }
+// Good: Ownership transfer vs borrowing
+fn take_ownership(s: String) { /* Takes ownership of s */ }
+fn borrow(s: &str) { /* Borrows s */ }
+fn borrow_mut(s: &mut String) { /* Mutably borrows s */ }
 ```
 
-### 5. 비동기 처리 (Tokio)
+### 5. Async Processing (Tokio)
 
 ```rust
-// ✅ 비동기 함수
+// Good: Async function
 use tokio::time::{sleep, Duration};
 
 pub async fn fetch_with_retry<T, F, Fut>(
@@ -242,7 +243,7 @@ where
     }
 }
 
-// ✅ 동시 실행
+// Good: Concurrent execution
 use futures::future::join_all;
 
 pub async fn fetch_users(ids: Vec<Uuid>) -> Vec<Result<User, AppError>> {
@@ -254,7 +255,7 @@ pub async fn fetch_users(ids: Vec<Uuid>) -> Vec<Result<User, AppError>> {
     join_all(futures).await
 }
 
-// ✅ tokio::spawn으로 태스크 생성
+// Good: Task creation with tokio::spawn
 pub async fn background_job() {
     tokio::spawn(async {
         loop {
@@ -265,7 +266,7 @@ pub async fn background_job() {
 }
 ```
 
-### 6. 테스트
+### 6. Testing
 
 ```rust
 #[cfg(test)]
@@ -274,7 +275,7 @@ mod tests {
     use mockall::predicate::*;
     use mockall::mock;
 
-    // ✅ Mock 생성
+    // Good: Mock creation
     mock! {
         pub UserRepo {}
 
@@ -285,12 +286,12 @@ mod tests {
         }
     }
 
-    // ✅ 단위 테스트
+    // Good: Unit test
     #[tokio::test]
     async fn test_get_user_success() {
         let mut mock_repo = MockUserRepo::new();
         let user_id = Uuid::new_v4();
-        let expected_user = User::new("test@example.com".into(), "테스트".into());
+        let expected_user = User::new("test@example.com".into(), "Test".into());
 
         mock_repo
             .expect_find_by_id()
@@ -304,7 +305,7 @@ mod tests {
         assert_eq!(result.unwrap().email, "test@example.com");
     }
 
-    // ✅ 에러 케이스 테스트
+    // Good: Error case test
     #[tokio::test]
     async fn test_get_user_not_found() {
         let mut mock_repo = MockUserRepo::new();
@@ -322,10 +323,10 @@ mod tests {
 }
 ```
 
-### 7. 의존성 주입
+### 7. Dependency Injection
 
 ```rust
-// ✅ 생성자 주입
+// Good: Constructor injection
 pub struct UserService {
     repo: Arc<dyn UserRepository>,
     cache: Arc<dyn CacheRepository>,
@@ -340,7 +341,7 @@ impl UserService {
     }
 }
 
-// ✅ Builder 패턴
+// Good: Builder pattern
 #[derive(Default)]
 pub struct ServerBuilder {
     port: Option<u16>,
@@ -377,7 +378,7 @@ impl ServerBuilder {
     }
 }
 
-// 사용
+// Usage
 let server = ServerBuilder::new()
     .port(3000)
     .host("0.0.0.0")
@@ -385,41 +386,41 @@ let server = ServerBuilder::new()
     .build();
 ```
 
-## 파일 구조
+## File Structure
 
-```
+```text
 project/
 ├── src/
-│   ├── main.rs              # 엔트리포인트
-│   ├── lib.rs               # 라이브러리 루트
-│   ├── config.rs            # 설정
-│   ├── error.rs             # 에러 정의
-│   ├── domain/              # 도메인 모델
+│   ├── main.rs              # Entry point
+│   ├── lib.rs               # Library root
+│   ├── config.rs            # Configuration
+│   ├── error.rs             # Error definitions
+│   ├── domain/              # Domain models
 │   │   ├── mod.rs
 │   │   └── user.rs
-│   ├── handlers/            # HTTP 핸들러
+│   ├── handlers/            # HTTP handlers
 │   │   ├── mod.rs
 │   │   └── user.rs
-│   ├── services/            # 비즈니스 로직
+│   ├── services/            # Business logic
 │   │   ├── mod.rs
 │   │   └── user.rs
-│   ├── repositories/        # 데이터 액세스
+│   ├── repositories/        # Data access
 │   │   ├── mod.rs
 │   │   └── user.rs
-│   └── middleware/          # 미들웨어
-├── tests/                   # 통합 테스트
-├── migrations/              # DB 마이그레이션
+│   └── middleware/          # Middleware
+├── tests/                   # Integration tests
+├── migrations/              # DB migrations
 ├── Cargo.toml
 └── Cargo.lock
 ```
 
-## 체크리스트
+## Checklist
 
-- [ ] unwrap()/expect() 최소화, ? 연산자 활용
-- [ ] thiserror/anyhow로 에러 처리
-- [ ] 트레이트로 추상화, 의존성 주입
-- [ ] Clone 최소화, 참조 활용
-- [ ] async/await 적절히 사용
-- [ ] clippy 경고 해결
-- [ ] cargo fmt 적용
-- [ ] #[cfg(test)] 모듈로 테스트 작성
+- [ ] Minimize unwrap()/expect(), use ? operator
+- [ ] Handle errors with thiserror/anyhow
+- [ ] Abstract with traits, use dependency injection
+- [ ] Minimize Clone, use references
+- [ ] Use async/await appropriately
+- [ ] Resolve clippy warnings
+- [ ] Apply cargo fmt
+- [ ] Write tests in #[cfg(test)] module