@sun-asterisk/sunlint 1.3.16 → 1.3.17

package/rules/docs/C002_no_duplicate_code.md

@@ -1,3 +1,4 @@
+````markdown
 # C002_no_duplicate_code - CODING Rule
 
 ## 📋 Overview
@@ -5,42 +6,289 @@
 **Rule ID**: `C002_no_duplicate_code`  
 **Category**: coding  
 **Severity**: Error  
-**Status**: pending
+**Status**: active
 
 ## 🎯 Description
 
-TODO: Add rule description after migration from ESLint.
+Detects and warns about duplicate code blocks of 10 or more lines across functions and classes. This rule enforces the **DRY (Don't Repeat Yourself)** principle to maintain clean, refactorable code and reduce maintenance burden.
 
+**Key Objectives:**
+- 🎯 Avoid messy, hard-to-refactor code
+- ♻️ Apply DRY principle consistently
+- 🔧 Improve code maintainability
+- 🧪 Enhance testability
+
+**Detection Criteria:**
+- Warns when duplicate code ≥ 10 lines found in functions/classes
+- Ignores comments and whitespace variations
+- Uses similarity threshold (85%) to detect near-duplicates
+- Cross-file duplicate detection
 
 ## 🔄 Migration Info
 
 **ESLint Rule**: `c002-no-duplicate-code`  
-**Compatibility**: partial  
-**Priority**: medium
+**Compatibility**: Full  
+**Priority**: High
 
 
 ## ✅ Valid Code Examples
 
-```javascript
-// TODO: Add valid code examples
+### Example 1: Extract Common Logic into Utility Functions
+
+```typescript
+// ✅ GOOD: Extracted validation logic into reusable functions
+function validateEmail(email: string): void {
+  if (!email || !email.includes('@')) {
+    throw new ValidationError('Invalid email format');
+  }
+}
+
+function validatePassword(password: string): void {
+  if (!password || password.length < 8) {
+    throw new ValidationError('Password must be at least 8 characters');
+  }
+}
+
+function registerUser(userData: UserData): void {
+  validateEmail(userData.email);
+  validatePassword(userData.password);
+  // Registration logic
+}
+
+function updateUserProfile(userId: string, profileData: ProfileData): void {
+  if (profileData.email) {
+    validateEmail(profileData.email);
+  }
+  if (profileData.password) {
+    validatePassword(profileData.password);
+  }
+  // Update logic
+}
+```
+
+### Example 2: Using Inheritance for Shared Behavior
+
+```typescript
+// ✅ GOOD: Base class with common logic
+abstract class BaseRepository<T> {
+  protected async findById(id: string): Promise<T | null> {
+    const result = await this.db.query(
+      `SELECT * FROM ${this.tableName} WHERE id = ?`,
+      [id]
+    );
+    return result.length > 0 ? this.mapToEntity(result[0]) : null;
+  }
+  
+  protected async save(entity: T): Promise<void> {
+    const data = this.mapToData(entity);
+    await this.db.query(
+      `INSERT INTO ${this.tableName} VALUES (?, ?, ?)`,
+      Object.values(data)
+    );
+  }
+  
+  protected abstract mapToEntity(row: any): T;
+  protected abstract mapToData(entity: T): any;
+  protected abstract tableName: string;
+}
+
+class UserRepository extends BaseRepository<User> {
+  protected tableName = 'users';
+  protected mapToEntity(row: any): User { /* ... */ }
+  protected mapToData(entity: User): any { /* ... */ }
+}
+
+class ProductRepository extends BaseRepository<Product> {
+  protected tableName = 'products';
+  protected mapToEntity(row: any): Product { /* ... */ }
+  protected mapToData(entity: Product): any { /* ... */ }
+}
+```
+
+### Example 3: Composition for Shared Logic
+
+```typescript
+// ✅ GOOD: Shared service for common operations
+class ErrorLogger {
+  logError(context: string, error: Error): void {
+    console.error(`[${context}] ${error.message}`);
+    this.sendToMonitoring(error);
+  }
+  
+  private sendToMonitoring(error: Error): void {
+    // Send to monitoring service
+  }
+}
+
+class UserService {
+  constructor(private errorLogger: ErrorLogger) {}
+  
+  async getUser(id: string): Promise<User> {
+    try {
+      return await this.userRepo.findById(id);
+    } catch (error) {
+      this.errorLogger.logError('UserService.getUser', error);
+      throw error;
+    }
+  }
+}
+
+class OrderService {
+  constructor(private errorLogger: ErrorLogger) {}
+  
+  async getOrder(id: string): Promise<Order> {
+    try {
+      return await this.orderRepo.findById(id);
+    } catch (error) {
+      this.errorLogger.logError('OrderService.getOrder', error);
+      throw error;
+    }
+  }
+}
 ```
 
 ## ❌ Invalid Code Examples
 
-```javascript  
-// TODO: Add invalid code examples that should trigger violations
+### Example 1: Duplicated Validation Logic
+
+```typescript
+// ❌ BAD: Duplicated validation in multiple functions
+function registerUser(userData: UserData): void {
+  // Duplicated validation logic
+  if (!userData.email || !userData.email.includes('@')) {
+    throw new ValidationError('Invalid email format');
+  }
+  if (!userData.password || userData.password.length < 8) {
+    throw new ValidationError('Password must be at least 8 characters');
+  }
+  // Registration logic
+}
+
+function updateUserProfile(userId: string, profileData: ProfileData): void {
+  // Same validation logic duplicated here
+  if (profileData.email && (!profileData.email || !profileData.email.includes('@'))) {
+    throw new ValidationError('Invalid email format');
+  }
+  if (profileData.password && (!profileData.password || profileData.password.length < 8)) {
+    throw new ValidationError('Password must be at least 8 characters');
+  }
+  // Update logic
+}
+```
+
+**Violation Message:**
 ```
+Duplicate function detected (12 non-comment lines). Extract into a shared utility 
+module or helper file. Found in 2 locations: registerUser.ts:5-16, updateUserProfile.ts:10-21
+```
+
+### Example 2: Duplicated Repository Logic
+
+```typescript
+// ❌ BAD: Same database logic repeated in multiple repositories
+class UserRepository {
+  async findById(id: string): Promise<User | null> {
+    const result = await this.db.query(
+      'SELECT * FROM users WHERE id = ?',
+      [id]
+    );
+    if (result.length === 0) return null;
+    return {
+      id: result[0].id,
+      name: result[0].name,
+      email: result[0].email
+    };
+  }
+}
+
+class ProductRepository {
+  async findById(id: string): Promise<Product | null> {
+    const result = await this.db.query(
+      'SELECT * FROM products WHERE id = ?',
+      [id]
+    );
+    if (result.length === 0) return null;
+    return {
+      id: result[0].id,
+      name: result[0].name,
+      price: result[0].price
+    };
+  }
+}
+```
+
+**Suggested Fix:**
+- Use inheritance to share common behavior
+- Extract shared logic into a base class or mixin
 
 ## ⚙️ Configuration
 
 ```json
 {
   "rules": {
-    "C002_no_duplicate_code": "error"
+    "C002_no_duplicate_code": ["error", {
+      "minLines": 10,
+      "similarityThreshold": 0.85,
+      "ignoreComments": true,
+      "ignoreWhitespace": true,
+      "ignoreEmptyLines": true
+    }]
   }
 }
 ```
 
+**Configuration Options:**
+- `minLines` (default: 10): Minimum number of lines to consider as duplicate
+- `similarityThreshold` (default: 0.85): Similarity percentage (0-1) to detect near-duplicates
+- `ignoreComments` (default: true): Ignore comments when comparing code
+- `ignoreWhitespace` (default: true): Ignore whitespace differences
+- `ignoreEmptyLines` (default: true): Ignore empty lines
+
+## 🔧 Refactoring Strategies
+
+### 1. Extract Functions/Utilities
+When you have duplicated logic in multiple functions:
+```typescript
+// Extract common logic into a utility function
+const validateUserInput = (email: string, password: string) => {
+  validateEmail(email);
+  validatePassword(password);
+};
+```
+
+### 2. Use Inheritance
+When you have duplicated logic in multiple classes with similar responsibilities:
+```typescript
+// Create a base class with common behavior
+abstract class BaseService {
+  protected abstract entityName: string;
+  
+  protected async findById(id: string) {
+    // Common implementation
+  }
+}
+```
+
+### 3. Use Composition
+When inheritance doesn't fit or you need more flexibility:
+```typescript
+// Create a shared service that can be injected
+class CommonOperations {
+  logError(context: string, error: Error) { /* ... */ }
+  validateInput(data: any) { /* ... */ }
+}
+```
+
+### 4. Create Shared Libraries
+For cross-cutting concerns used across multiple modules:
+```typescript
+// utils/validation.ts
+export const validators = {
+  email: (email: string) => { /* ... */ },
+  password: (password: string) => { /* ... */ }
+};
+```
+
 ## 🧪 Testing
 
 ```bash
@@ -49,9 +297,26 @@ npm test -- c002_no_duplicate_code
 
 # Test with SunLint CLI
 sunlint --rules=C002_no_duplicate_code --input=examples/
+
+# Analyze specific files
+sunlint analyze --rules=C002 src/**/*.ts
 ```
 
+## 📚 Related Rules
+
+- **C005**: Each function should do one thing (Single Responsibility)
+- **C047**: Retry logic must not be duplicated
+- **C014**: Use Dependency Injection instead of direct instantiation
+
+## 🔗 References
+
+- [DRY Principle](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)
+- [Code Duplication (Martin Fowler)](https://refactoring.guru/smells/duplicate-code)
+- [SonarQube: Duplicated Blocks](https://rules.sonarsource.com/java/RSPEC-1192)
+
 ---
 
-**Migration Status**: pending  
-**Last Updated**: 2025-07-21
+**Migration Status**: active  
+**Last Updated**: 2025-10-16
+
+````

package/rules/index.js

@@ -48,6 +48,7 @@ function loadRuleConfig(category, ruleId) {
 
 // 🔹 Common Rules (C-series) - General coding standards
 const commonRules = {
+    C002: loadRule('common', 'C002_no_duplicate_code'),
     C006: loadRule('common', 'C006_function_naming'),
     C012: loadRule('common', 'C012_command_query_separation'),
     C013: loadRule('common', 'C013_no_dead_code'),
@@ -59,17 +60,20 @@ const commonRules = {
     C024: loadRule('common', 'C024_no_scatter_hardcoded_constants'),
     C029: loadRule('common', 'C029_catch_block_logging'),
     C031: loadRule('common', 'C031_validation_separation'),
+    C033: loadRule('common', 'C033_separate_service_repository'),
     C041: loadRule('common', 'C041_no_sensitive_hardcode'),
     C042: loadRule('common', 'C042_boolean_name_prefix'),
+    // C047: loadRule('common', 'C047_no_duplicate_retry_logic'),
     C048: loadRule('common', 'C048_no_bypass_architectural_layers'),
     C052: loadRule('common', 'C052_parsing_or_data_transformation'),
-    C047: loadRule('common', 'C047_no_duplicate_retry_logic'),
     C060: loadRule('common', 'C060_no_override_superclass'),
+    C067: loadRule('common', 'C067_no_hardcoded_config'),
 };
 
 // 🔒 Security Rules (S-series) - Ready for migration
 const securityRules = {
     S006: loadRule('security', 'S006_no_plaintext_recovery_codes'),
+    S010: loadRule('security', 'S010_no_insecure_encryption'),
     S015: loadRule('security', 'S015_insecure_tls_certificate'),
     S023: loadRule('security', 'S023_no_json_injection'),
     S026: loadRule('security', 'S026_json_schema_validation'),