@sun-asterisk/sunlint 1.3.16 → 1.3.17

package/rules/common/C002_no_duplicate_code/test-cases/api-handlers.ts

@@ -0,0 +1,64 @@
+// ❌ VIOLATION: Monkey coding - Copy-paste error handling
+
+export class ApiHandlers {
+  // Get user by ID with error handling
+  async getUserById(id: number) {
+    try {
+      const response = await fetch(`/api/users/${id}`);
+
+      if (!response.ok) {
+        const error = await response.json();
+        console.error('Error fetching user:', error);
+        throw new Error(error.message || 'Failed to fetch user');
+      }
+
+      const data = await response.json();
+      return data;
+
+    } catch (error) {
+      console.error('Network error:', error);
+      throw new Error('Network request failed');
+    }
+  }
+
+  // Get product by ID - SAME error handling!
+  async getProductById(id: number) {
+    // DUPLICATE: Same try-catch, error handling pattern (monkey coding!)
+    try {
+      const response = await fetch(`/api/products/${id}`);
+
+      if (!response.ok) {
+        const error = await response.json();
+        console.error('Error fetching product:', error);
+        throw new Error(error.message || 'Failed to fetch product');
+      }
+
+      const data = await response.json();
+      return data;
+
+    } catch (error) {
+      console.error('Network error:', error);
+      throw new Error('Network request failed');
+    }
+  }
+
+  // Get order by ID - same pattern
+  async getOrderById(id: number) {
+    try {
+      const response = await fetch(`/api/orders/${id}`);
+
+      if (!response.ok) {
+        const error = await response.json();
+        console.error('Error fetching order:', error);
+        throw new Error(error.message || 'Failed to fetch order');
+      }
+
+      const data = await response.json();
+      return data;
+
+    } catch (error) {
+      console.error('Network error:', error);
+      throw new Error('Network request failed');
+    }
+  }
+}

package/rules/common/C002_no_duplicate_code/test-cases/data-processor.ts

@@ -0,0 +1,46 @@
+// ❌ VIOLATION: Monkey coding - Copy-paste data transformation
+
+export class DataProcessor {
+  // Process user data from API
+  processUserData(rawData: any[]) {
+    return rawData
+      .filter(item => item !== null && item !== undefined)
+      .map(item => ({
+        id: item.id,
+        name: item.name?.trim() || 'Unknown',
+        email: item.email?.toLowerCase() || '',
+        status: item.active ? 'active' : 'inactive',
+        createdAt: new Date(item.created_at)
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  // Process product data from API - SAME transformation logic!
+  processProductData(rawData: any[]) {
+    // DUPLICATE: Same filtering, mapping, sorting pattern (monkey coding!)
+    return rawData
+      .filter(item => item !== null && item !== undefined)
+      .map(item => ({
+        id: item.id,
+        name: item.name?.trim() || 'Unknown',
+        price: item.price || 0,
+        status: item.available ? 'active' : 'inactive',
+        createdAt: new Date(item.created_at)
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  // Process order data - same pattern again
+  processOrderData(rawData: any[]) {
+    return rawData
+      .filter(item => item !== null && item !== undefined)
+      .map(item => ({
+        id: item.id,
+        customer: item.customer_name?.trim() || 'Unknown',
+        total: item.total_amount || 0,
+        status: item.paid ? 'active' : 'inactive',
+        createdAt: new Date(item.order_date)
+      }))
+      .sort((a, b) => a.customer.localeCompare(b.customer));
+  }
+}

package/rules/common/C002_no_duplicate_code/test-cases/good-example.tsx

@@ -0,0 +1,40 @@
+// ✅ GOOD: No violation - These are intentional patterns (different names, simple wrappers)
+
+import React from 'react';
+
+// Different button variants - intentional pattern, not duplicate
+export function PrimaryButton({ className, ...props }: React.ComponentProps<'button'>) {
+  return (
+    <button
+      className={`btn-primary ${className}`}
+      {...props}
+    />
+  );
+}
+
+export function SecondaryButton({ className, ...props }: React.ComponentProps<'button'>) {
+  return (
+    <button
+      className={`btn-secondary ${className}`}
+      {...props}
+    />
+  );
+}
+
+export function DangerButton({ className, ...props }: React.ComponentProps<'button'>) {
+  return (
+    <button
+      className={`btn-danger ${className}`}
+      {...props}
+    />
+  );
+}
+
+// Short functions - below minimum lines
+export function add(a: number, b: number) {
+  return a + b;
+}
+
+export function subtract(a: number, b: number) {
+  return a - b;
+}

package/rules/common/C002_no_duplicate_code/test-cases/product-service.ts

@@ -0,0 +1,57 @@
+// ❌ VIOLATION: Monkey coding - Copy-paste calculation logic
+
+export class ProductService {
+  // Calculate price with tax for online orders
+  calculateOnlinePrice(price: number, quantity: number) {
+    const subtotal = price * quantity;
+    const tax = subtotal * 0.1; // 10% tax
+    const shipping = subtotal > 100 ? 0 : 10; // Free shipping over $100
+    const discount = subtotal > 200 ? subtotal * 0.05 : 0; // 5% discount over $200
+    const total = subtotal + tax + shipping - discount;
+
+    return {
+      subtotal,
+      tax,
+      shipping,
+      discount,
+      total
+    };
+  }
+
+  // Calculate price with tax for store orders - SAME calculation!
+  calculateStorePrice(price: number, quantity: number) {
+    // DUPLICATE: Exactly same calculation logic (monkey coding!)
+    const subtotal = price * quantity;
+    const tax = subtotal * 0.1; // 10% tax
+    const shipping = subtotal > 100 ? 0 : 10; // Free shipping over $100
+    const discount = subtotal > 200 ? subtotal * 0.05 : 0; // 5% discount over $200
+    const total = subtotal + tax + shipping - discount;
+
+    return {
+      subtotal,
+      tax,
+      shipping,
+      discount,
+      total
+    };
+  }
+
+  // Wholesale pricing - slightly different but still copy-paste
+  calculateWholesalePrice(price: number, quantity: number) {
+    const subtotal = price * quantity;
+    const tax = subtotal * 0.1; // 10% tax
+    const shipping = subtotal > 100 ? 0 : 10; // Free shipping over $100
+    const discount = subtotal > 200 ? subtotal * 0.05 : 0; // 5% discount over $200
+    const wholesaleDiscount = quantity > 50 ? subtotal * 0.1 : 0; // Extra 10% for bulk
+    const total = subtotal + tax + shipping - discount - wholesaleDiscount;
+
+    return {
+      subtotal,
+      tax,
+      shipping,
+      discount,
+      wholesaleDiscount,
+      total
+    };
+  }
+}

package/rules/common/C002_no_duplicate_code/test-cases/user-service.ts

@@ -0,0 +1,49 @@
+// ❌ VIOLATION: Monkey coding - Copy-paste entire functions
+
+export class UserService {
+  // Function 1: Process user payment
+  async processUserPayment(userId: number, amount: number) {
+    const user = await this.getUserData(userId);
+
+    if (amount <= 0) {
+      throw new Error('Invalid payment amount');
+    }
+
+    const fee = amount * 0.029 + 0.30; // Stripe fee
+    const total = amount + fee;
+
+    const result = await this.chargeCard(user.cardId, total);
+
+    if (!result.success) {
+      throw new Error('Payment failed');
+    }
+
+    await this.recordTransaction(userId, total, 'payment');
+    return { success: true, transactionId: result.id };
+  }
+
+  // Function 2: Process user refund - EXACT COPY-PASTE!
+  async processUserRefund(userId: number, amount: number) {
+    const user = await this.getUserData(userId);
+
+    if (amount <= 0) {
+      throw new Error('Invalid payment amount');
+    }
+
+    const fee = amount * 0.029 + 0.30; // Stripe fee
+    const total = amount + fee;
+
+    const result = await this.chargeCard(user.cardId, total);
+
+    if (!result.success) {
+      throw new Error('Payment failed');
+    }
+
+    await this.recordTransaction(userId, total, 'payment');
+    return { success: true, transactionId: result.id };
+  }
+
+  private async getUserData(userId: number) { return {}; }
+  private async chargeCard(cardId: string, amount: number) { return { success: true, id: '123' }; }
+  private async recordTransaction(userId: number, amount: number, type: string) { }
+}

package/rules/common/C008/analyzer.js

@@ -0,0 +1,40 @@
+/**
+ * C008 Analyzer - Minimize Variable Scope (Declare Near Usage)
+ * 
+ * Uses ts-morph (AST-based) for 100% accurate analysis with intelligent filtering:
+ * - Module-level constants (UPPER_CASE = value)
+ * - Redux Toolkit patterns (createAsyncThunk, createSlice)
+ * - Storybook meta exports
+ * - React hooks (useState, useEffect, etc.)
+ * - CSS-in-JS (keyframes, styled, css)
+ * 
+ * Following Rule C005: Single responsibility - variable scope detection
+ * Following Rule C006: Verb-noun naming
+ */
+
+const C008TsMorphAnalyzer = require('./ts-morph-analyzer');
+
+class C008Analyzer {
+  constructor(semanticEngine = null, options = {}) {
+    this.analyzer = new C008TsMorphAnalyzer(semanticEngine, options);
+    this.initialized = false;
+  }
+
+  async initialize(semanticEngine = null) {
+    if (!this.initialized) {
+      await this.analyzer.initialize(semanticEngine);
+      this.initialized = true;
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    // Ensure initialized before analysis
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.analyzer.analyze(files, language, options);
+  }
+}
+
+module.exports = C008Analyzer;
+

package/rules/common/C008/config.json

@@ -0,0 +1,20 @@
+{
+  "ruleId": "C008",
+  "name": "Minimize Variable Scope - Declare Near Usage",
+  "description": "Variables should be declared as close as possible to where they are first used to improve code locality and reduce cognitive load",
+  "category": "code-quality",
+  "severity": "warning",
+  "languages": ["typescript", "javascript"],
+  "enabled": true,
+  "metadata": {
+    "tags": ["readability", "maintainability", "best-practice"],
+    "principleId": "CODE_QUALITY",
+    "version": "1.0.0",
+    "status": "active"
+  },
+  "options": {
+    "maxLineDistance": 10,
+    "allowTopOfBlock": true,
+    "ignoreConst": false
+  }
+}