@sun-asterisk/sunlint 1.3.41 → 1.3.43

package/skill-assets/sunlint-code-quality/rules/ruby/RB039-solid-adapters.md

@@ -0,0 +1,29 @@
+---
+title: Prefer Solid Adapters for Infrastructure (Rails 8+)
+impact: MEDIUM
+impactDescription: Simplify deployment and reduce external dependencies.
+tags: rails, rails8, architecture, infrastructure
+---
+
+## Prefer Solid Adapters for Infrastructure (Rails 8+)
+
+Simplify deployment and reduce external dependencies. For Rails 8 projects, prefer `Solid Queue`, `Solid Cache`, and `Solid Cable` over Redis-based solutions for standard workloads to keep the infrastructure "lean".
+
+**Incorrect:**
+
+```ruby
+# config/environments/production.rb
+config.cache_store = :redis_cache_store
+config.active_job.queue_adapter = :sidekiq
+```
+
+**Correct:**
+
+```ruby
+# Rails 8 lean stack
+config.cache_store = :solid_cache_store
+config.active_job.queue_adapter = :solid_queue
+```
+
+**Tools:** Manual Review
+---

package/skill-assets/sunlint-code-quality/rules/ruby/RB040-rails-authentication.md

@@ -0,0 +1,26 @@
+---
+title: Use built-in Rails 8 Authentication for greenfield projects
+impact: MEDIUM
+impactDescription: Use the native, lightweight authentication system to reduce dependency on Devise.
+tags: rails, rails8, authentication, security
+---
+
+## Use built-in Rails 8 Authentication for greenfield projects
+
+Use the native, lightweight authentication system to reduce dependency on Devise. Use `bin/rails generate authentication` for new projects unless complex features mandate a library.
+
+**Incorrect:**
+
+```ruby
+# Adding Devise by default without evaluating built-in needs
+bundle add devise
+```
+
+**Correct:**
+
+```bash
+# Using Rails 8 built-in generator
+bin/rails generate authentication
+```
+
+**Tools:** Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB041-async-query-loading.md

@@ -0,0 +1,29 @@
+---
+title: Use Async Query Loading for slow interactions
+impact: MEDIUM
+impactDescription: Improve web performance by loading database data concurrently with view rendering.
+tags: rails, performance, active-record, async
+---
+
+## Use Async Query Loading for slow interactions
+
+Improve web performance by loading database data concurrently with view rendering. Use `.load_async` on ActiveRecord relations when multiple independent queries can be executed in the background while the controller or view processes.
+
+**Incorrect:**
+
+```ruby
+# Sequential execution (Sync)
+@posts = Post.all.load
+@users = User.all.load
+```
+
+**Correct:**
+
+```ruby
+# Parallel execution (Async)
+@posts = Post.all.load_async
+@users = User.all.load_async
+```
+
+**Tools:** Manual Review
+---

package/skill-assets/sunlint-code-quality/rules/ruby/RB042-hotwire-turbo.md

@@ -0,0 +1,30 @@
+---
+title: Minimize custom JavaScript with Hotwire/Turbo 2.0
+impact: MEDIUM
+impactDescription: Focus on the Rails "Majestic Monolith" approach for better maintainability.
+tags: rails, hotwire, turbo, stimulus, architecture
+---
+
+## Minimize custom JavaScript with Hotwire/Turbo 2.0
+
+Focus on the Rails "Majestic Monolith" approach for better maintainability. Prefer `Turbo Frames` and `Turbo Streams` for interaction. Use `Stimulus` for small client-side behaviors.
+
+**Incorrect:**
+
+```javascript
+// Complex React/Vue component for a simple list update
+```
+
+**Correct:**
+
+```erb
+<%# Rails Turbo Stream response %>
+<turbo-stream action="append" target="messages">
+  <template>
+    <%= render @message %>
+  </template>
+</turbo-stream>
+```
+
+**Tools:** Manual Review
+---

package/skill-assets/sunlint-code-quality/rules/ruby/RB043-use-propshaft.md

@@ -0,0 +1,27 @@
+---
+title: Use Propshaft as the default asset pipeline
+impact: LOW
+impactDescription: Use the modern, simplified asset pipeline instead of Sprockets.
+tags: rails, assets, propshaft, performance
+---
+
+## Use Propshaft as the default asset pipeline
+
+Use the modern, simplified asset pipeline instead of Sprockets. For new Rails 7+ projects, use `Propshaft` to handle asset digests and paths without the complexity of transpilation.
+
+**Incorrect:**
+
+```ruby
+# Gemfile
+gem 'sprockets-rails'
+```
+
+**Correct:**
+
+```ruby
+# Gemfile
+gem 'propshaft'
+```
+
+**Tools:** Manual Review
+---

package/skill-assets/sunlint-code-quality/rules/ruby/RB044-structured-logging.md

@@ -0,0 +1,35 @@
+---
+title: Use Structured Logging for Observability
+impact: MEDIUM
+impactDescription: Improve log parsing and searching in production environments.
+tags: ruby, rails, logs, observability, json
+---
+
+## Use Structured Logging for Observability
+
+Improve log parsing and searching in production environments. Configure structured (JSON) logging in production to facilitate tracing and automated analysis.
+
+**Incorrect:**
+
+```text
+Processing by UsersController#show as HTML
+  Parameters: {"id"=>"1"}
+Completed 200 OK in 10ms
+```
+
+**Correct:**
+
+```json
+{
+  "timestamp": "2025-02-05T12:00:00Z",
+  "level": "INFO",
+  "controller": "UsersController",
+  "action": "show",
+  "params": {"id": "1"},
+  "status": 200,
+  "duration_ms": 10
+}
+```
+
+**Tools:** Lograge gem
+---

package/skill-assets/sunlint-code-quality/rules/ruby/RB045-prism-parser.md

@@ -0,0 +1,29 @@
+---
+title: Use Prism as the default parser for tooling
+impact: LOW
+impactDescription: Leverage the faster, more accurate Ruby parser.
+tags: ruby, tooling, prism, performance
+---
+
+## Use Prism as the default parser for tooling
+
+Leverage the faster, more accurate Ruby parser. Configure tools like `RuboCop` or `SyntaxTree` to use `Prism` for parsing where supported in Ruby 3.4+.
+
+**Incorrect:**
+
+```yaml
+# .rubocop.yml
+AllCops:
+  ParserEngine: parser # Default
+```
+
+**Correct:**
+
+```yaml
+# .rubocop.yml
+AllCops:
+  ParserEngine: prism
+```
+
+**Tools:** RuboCop (`ParserEngine: prism`)
+---

package/skill-assets/sunlint-code-quality/rules/swift/SW001-block-based-kvo.md

@@ -0,0 +1,40 @@
+---
+title: Sử dụng observe property của Swift thay vì KVO cũ
+impact: MEDIUM
+impactDescription: Tránh sử dụng cơ chế KVO lỗi thời, giảm thiểu độ phức tạp và lỗi khi override observeValue.
+tags: swift, ios, kvo, observation, code-quality
+---
+
+## Sử dụng observe property của Swift thay vì KVO cũ
+
+Ưu tiên dùng block-based KVO API với `keypaths` khi dùng Swift 3.2 trở lên. Loại bỏ việc override `observeValue` truyền thống vốn phức tạp và dễ sai.
+
+**Incorrect (KVO cũ):**
+
+```swift
+class MyObserver: NSObject {
+    @objc var objectToObserve: MyObject
+    
+    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+        if keyPath == "someProperty" {
+            // Xử lý thay đổi
+        }
+    }
+}
+```
+
+**Correct (Block-based KVO):**
+
+```swift
+class MyObserver {
+    var observation: NSKeyValueObservation?
+    
+    init(object: MyObject) {
+        observation = object.observe(\.someProperty, options: [.new]) { object, change in
+            // Xử lý thay đổi qua block
+        }
+    }
+}
+```
+
+**Tools:** SwiftLint (block_based_kvo)

package/skill-assets/sunlint-code-quality/rules/swift/SW002-class-delegate-protocol.md

@@ -0,0 +1,36 @@
+---
+title: Delegate Protocol phải là class-only
+impact: HIGH
+impactDescription: Cho phép dùng weak để tránh retain cycles (memory leak) giữa các đối tượng.
+tags: swift, ios, delegate, memory-leak, AnyObject
+---
+
+## Delegate Protocol phải là class-only
+
+`weak` chỉ hỗ trợ class types, do đó các delegate protocol phải được khai báo là `class`-based (`AnyObject`). Điều này giúp ngăn chặn retain cycles khi delegate trỏ ngược lại đối tượng sở hữu nó.
+
+**Incorrect (không giới hạn class):**
+
+```swift
+protocol MyDelegate {
+    func didUpdateData()
+}
+
+class MyView {
+    var delegate: MyDelegate? // Lỗi: Không thể dùng weak ở đây nếu protocol không là AnyObject
+}
+```
+
+**Correct (class-only protocol):**
+
+```swift
+protocol MyDelegate: AnyObject {
+    func didUpdateData()
+}
+
+class MyView {
+    weak var delegate: MyDelegate? // Đúng: Có thể dùng weak để tránh memory leak
+}
+```
+
+**Tools:** SwiftLint (class_delegate_protocol)

package/skill-assets/sunlint-code-quality/rules/swift/SW003-compiler-protocol-init.md

@@ -0,0 +1,28 @@
+---
+title: Không khởi tạo trực tiếp các protocol hệ thống
+impact: MEDIUM
+impactDescription: Tránh misuse các compiler protocol như ExpressibleByArrayLiteral, khuyến khích sử dụng literal syntax.
+tags: swift, ios, compiler, literals, code-quality
+---
+
+## Không khởi tạo trực tiếp các protocol hệ thống
+
+Các protocol của compiler (như `ExpressibleByArrayLiteral`) không nên được gọi `init` trực tiếp. Hãy sử dụng cú pháp gọn gàng (literals) để khởi tạo giá trị.
+
+**Incorrect (Gọi init trực tiếp):**
+
+```swift
+let array = Array(arrayLiteral: 1, 2, 3)
+let dict = Dictionary(dictionaryLiteral: ("key", "value"))
+let string = String(stringLiteral: "Hello")
+```
+
+**Correct (Sử dụng literal syntax):**
+
+```swift
+let array = [1, 2, 3]
+let dict = ["key": "value"]
+let string = "Hello"
+```
+
+**Tools:** SwiftLint (compiler_protocol_init)

package/skill-assets/sunlint-code-quality/rules/swift/SW004-contains-over-filter-count.md

@@ -0,0 +1,28 @@
+---
+title: Ưu tiên sử dụng .contains trong một số phép lọc
+impact: LOW
+impactDescription: Cải thiện hiệu năng và độ rõ ràng của code bằng cách dùng phương thức chuyên dụng thay vì lọc rồi đếm.
+tags: swift, ios, performance, collections, readability
+---
+
+## Ưu tiên sử dụng .contains trong một số phép lọc
+
+Thay vì `.filter { ... }.count > 0` hoặc `.first != nil`, hãy dùng `.contains`. `.contains` thường ngắn hơn, dễ hiểu hơn và hiệu quả hơn vì nó dừng ngay khi tìm thấy phần tử khớp.
+
+**Incorrect (Lọc rồi đếm):**
+
+```swift
+let numbers = [1, 2, 3, 4, 5]
+let hasEven = numbers.filter { $0 % 2 == 0 }.count > 0
+let hasFive = numbers.first { $0 == 5 } != nil
+```
+
+**Correct (Sử dụng .contains):**
+
+```swift
+let numbers = [1, 2, 3, 4, 5]
+let hasEven = numbers.contains { $0 % 2 == 0 }
+let hasFive = numbers.contains(5)
+```
+
+**Tools:** SwiftLint (contains_over_*)

package/skill-assets/sunlint-code-quality/rules/swift/SW005-convenience-type.md

@@ -0,0 +1,34 @@
+---
+title: Dùng enum cho type chỉ gồm static members
+impact: LOW
+impactDescription: Ngăn chặn việc khởi tạo các type không cần thiết khi chúng chỉ đóng vai trò là container cho hằng số hoặc tiện ích.
+tags: swift, ios, architecture, enum, static-members
+---
+
+## Dùng enum cho type chỉ gồm static members
+
+Nếu một type chỉ chứa static members (như hằng số, helper methods), nên dùng `enum` không có case để không cho phép khởi tạo. `enum` không thể được khởi tạo trực tiếp, giúp tránh việc lạm dụng hoặc tạo ra các instance vô nghĩa.
+
+**Incorrect (Sử dụng struct/class):**
+
+```swift
+struct Config {
+    static let apiKey = "SECRET"
+    static let baseUrl = "https://api.example.com"
+}
+
+let config = Config() // Vẫn có thể tạo instance
+```
+
+**Correct (Sử dụng enum):**
+
+```swift
+enum Config {
+    static let apiKey = "SECRET"
+    static let baseUrl = "https://api.example.com"
+}
+
+// let config = Config() // Lỗi: Enum không có case không thể khởi tạo
+```
+
+**Tools:** SwiftLint (convenience_type)

package/skill-assets/sunlint-code-quality/rules/swift/SW006-discarded-notification-center-observer.md

@@ -0,0 +1,41 @@
+---
+title: Luôn dispose observer của NotificationCenter
+impact: HIGH
+impactDescription: Tránh memory leak và các hành vi không mong muốn khi observer vẫn tồn tại dù đối tượng đã bị giải phóng.
+tags: swift, ios, notification-center, memory-leak, observer
+---
+
+## Luôn dispose observer của NotificationCenter
+
+Luôn lưu lại token khi `addObserver` với NotificationCenter bằng block-based API. Gọi `removeObserver()` khi observer không còn cần thiết hoặc trong `deinit` để giải phóng bộ nhớ.
+
+**Incorrect (không lưu token hoặc không remove):**
+
+```swift
+NotificationCenter.default.addObserver(forName: .myNotification, object: nil, queue: .main) { _ in
+    print("Notification received")
+}
+// Không có cách nào để remove observer này sau đó
+```
+
+**Correct (lưu token và remove trong deinit):**
+
+```swift
+class MyManager {
+    private var observer: NSObjectProtocol?
+
+    init() {
+        observer = NotificationCenter.default.addObserver(forName: .myNotification, object: nil, queue: .main) { _ in
+            print("Notification received")
+        }
+    }
+
+    deinit {
+        if let observer = observer {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+}
+```
+
+**Tools:** SwiftLint (discarded_notification_center_observer)

package/skill-assets/sunlint-code-quality/rules/swift/SW007-discouraged-direct-init.md

@@ -0,0 +1,28 @@
+---
+title: Tránh khởi tạo trực tiếp các system types
+impact: MEDIUM
+impactDescription: Tránh việc tạo các instance không hợp lệ hoặc không cần thiết của các system types có sẵn cơ chế factory/singleton.
+tags: swift, ios, bundle, uidevice, initialization
+---
+
+## Tránh khởi tạo trực tiếp các system types
+
+Tránh khởi tạo trực tiếp các kiểu như: `Bundle`, `NSError`, `UIDevice`. Sử dụng các factory method hoặc properties sẵn có (như `.main`, `.current`) thay vì gọi `init()` trực tiếp để đảm bảo tính nhất quán và hiệu năng.
+
+**Incorrect (khởi tạo trực tiếp):**
+
+```swift
+let bundle = Bundle()
+let device = UIDevice()
+let error = NSError()
+```
+
+**Correct (sử dụng instance có sẵn):**
+
+```swift
+let mainBundle = Bundle.main
+let currentDevice = UIDevice.current
+let designError = NSError(domain: "com.example", code: 404, userInfo: nil) // Cần truyền tham số nếu tạo mới hợp lệ
+```
+
+**Tools:** SwiftLint (discouraged_direct_init)

package/skill-assets/sunlint-code-quality/rules/swift/SW008-discouraged-optional-boolean.md

@@ -0,0 +1,32 @@
+---
+title: Không dùng optional cho Boolean
+impact: HIGH
+impactDescription: Tránh ambiguity logic (3 trạng thái: true, false, nil) khi chỉ cần 2 trạng thái logic nhị phân.
+tags: swift, ios, boolean, optional, logic
+---
+
+## Không dùng optional cho Boolean
+
+Không khai báo kiểu `Bool?` nếu có thể tránh được. Việc có 3 trạng thái (`true`, `false`, `nil`) cho một biến logic thường gây khó khăn trong việc kiểm soát luồng điều kiện và dễ dẫn đến lỗi logic. Hãy sử dụng giá trị mặc định rõ ràng.
+
+**Incorrect (dùng optional bool):**
+
+```swift
+var isExpanded: Bool?
+
+if isExpanded == true {
+    // ...
+}
+```
+
+**Correct (dùng bool với giá trị mặc định):**
+
+```swift
+var isExpanded: Bool = false
+
+if isExpanded {
+    // ...
+}
+```
+
+**Tools:** SwiftLint (discouraged_optional_boolean)

package/skill-assets/sunlint-code-quality/rules/swift/SW009-empty-count.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên .isEmpty thay vì .count == 0
+impact: LOW
+impactDescription: Code rõ ràng hơn và hiệu năng tốt hơn (một số collection cần duyệt để đếm nhưng chỉ cần check phần tử đầu để biết có trống không).
+tags: swift, ios, performance, collection, isEmpty
+---
+
+## Ưu tiên .isEmpty thay vì .count == 0
+
+Dùng `.isEmpty` giúp code dễ đọc hơn và mang ý nghĩa rõ ràng hơn về mục đích kiểm tra tập hợp trống. Ngoài ra, `.count == 0` có thể chậm hơn trên một số loại collection so với `.isEmpty`.
+
+**Incorrect (kiểm tra count):**
+
+```swift
+let items = [String]()
+if items.count == 0 {
+    print("Danh sách trống")
+}
+```
+
+**Correct (dùng isEmpty):**
+
+```swift
+let items = [String]()
+if items.isEmpty {
+    print("Danh sách trống")
+}
+```
+
+**Tools:** SwiftLint (empty_count)

package/skill-assets/sunlint-code-quality/rules/swift/SW010-empty-string.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên isEmpty thay vì so sánh == ""
+impact: LOW
+impactDescription: Tăng độ rõ ràng và tránh lỗi tiềm ẩn khi xử lý chuỗi rỗng.
+tags: swift, ios, string, isEmpty, readability
+---
+
+## Ưu tiên isEmpty thay vì so sánh == ""
+
+Dùng `.isEmpty` thay cho so sánh bằng chuỗi rỗng `""`. Điều này giúp code đồng bộ, chuyên nghiệp và rõ ràng hơn về mặt ngữ nghĩa trong Swift.
+
+**Incorrect (so sánh chuỗi rỗng):**
+
+```swift
+let name = ""
+if name == "" {
+    print("Tên không được để trống")
+}
+```
+
+**Correct (dùng isEmpty):**
+
+```swift
+let name = ""
+if name.isEmpty {
+    print("Tên không được để trống")
+}
+```
+
+**Tools:** SwiftLint (empty_string)

package/skill-assets/sunlint-code-quality/rules/swift/SW011-explicit-init.md

@@ -0,0 +1,26 @@
+---
+title: Không sử dụng .init() khi không cần thiết
+impact: LOW
+impactDescription: Giảm bớt sự rườm rà trong code, tuân thủ phong cách viết Swift ngắn gọn và hiện đại.
+tags: swift, ios, initialization, init, readability
+---
+
+## Không sử dụng .init() khi không cần thiết
+
+Tránh gọi `.init()` một cách tường minh nếu không bắt buộc. Trong Swift, việc khởi tạo đối tượng bằng cách gọi trực tiếp tên kiểu dữ liệu kèm tham số được ưu tiên hơn vì tính ngắn gọn và dễ đọc.
+
+**Incorrect (gọi .init tường minh):**
+
+```swift
+let point = CGPoint.init(x: 10, y: 20)
+let user = User.init(name: "John")
+```
+
+**Correct (khởi tạo trực tiếp):**
+
+```swift
+let point = CGPoint(x: 10, y: 20)
+let user = User(name: "John")
+```
+
+**Tools:** SwiftLint (explicit_init)

package/skill-assets/sunlint-code-quality/rules/swift/SW012-fatal-error-message.md

@@ -0,0 +1,28 @@
+---
+title: Luôn phải có message rõ ràng khi sử dụng fatalError
+impact: MEDIUM
+impactDescription: Giúp xác định nguyên nhân lỗi nhanh chóng khi ứng dụng bị crash trong quá trình phát triển hoặc test.
+tags: swift, ios, error-handling, fatalError, debugging
+---
+
+## Luôn phải có message rõ ràng khi sử dụng fatalError
+
+Bắt buộc thêm mô tả khi gọi `fatalError(...)`. Message này rất quan trọng để cung cấp ngữ cảnh về lý do tại sao code rơi vào trạng thái không thể hồi phục, giúp trace lỗi dễ dàng hơn trong log hoặc khi debug.
+
+**Incorrect (không có message):**
+
+```swift
+func test() {
+    fatalError()
+}
+```
+
+**Correct (có message mô tả):**
+
+```swift
+func test() {
+    fatalError("Hàm này chưa được triển khai hoặc trạng thái không hợp lệ")
+}
+```
+
+**Tools:** SwiftLint (fatal_error_message)

package/skill-assets/sunlint-code-quality/rules/swift/SW013-for-where.md

@@ -0,0 +1,30 @@
+---
+title: Ưu tiên for-where thay vì if trong loop
+impact: LOW
+impactDescription: Code gọn gàng hơn, giảm bớt một tầng lồng nhau (nesting) và thể hiện rõ ý định lọc phần tử.
+tags: swift, ios, loops, for-where, readability
+---
+
+## Ưu tiên for-where thay vì if trong loop
+
+Nếu chỉ có một điều kiện lọc duy nhất bên trong toàn bộ nội dung của vòng lặp, nên sử dụng cú pháp `for ... where` thay vì dùng câu lệnh `if` lồng bên trong. Điều này giúp mã nguồn phẳng hơn và làm rõ mục đích duyệt các phần tử thỏa mãn điều kiện.
+
+**Incorrect (dùng if lồng):**
+
+```swift
+for user in users {
+    if user.isActive {
+        print(user.name)
+    }
+}
+```
+
+**Correct (dùng for-where):**
+
+```swift
+for user in users where user.isActive {
+    print(user.name)
+}
+```
+
+**Tools:** SwiftLint (for_where)

package/skill-assets/sunlint-code-quality/rules/swift/SW014-force-cast.md

@@ -0,0 +1,26 @@
+---
+title: Tránh as! (force cast)
+impact: CRITICAL
+impactDescription: Ngăn chặn crash ứng dụng do ép kiểu sai thực tế. Force-cast là nguyên nhân phổ biến gây lỗi runtime.
+tags: swift, ios, casting, force-cast, safety
+---
+
+## Tránh as! (force cast)
+
+Không sử dụng ép kiểu bắt buộc `as!`, thay vào đó nên dùng `as?` kết hợp với kiểm tra null (optional binding). Force-cast sẽ khiến ứng dụng bị crash ngay lập tức nếu đối tượng không thuộc kiểu dữ liệu mong đợi.
+
+**Incorrect (force cast):**
+
+```swift
+let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as! MyCustomCell
+```
+
+**Correct (safe cast):**
+
+```swift
+guard let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as? MyCustomCell else {
+    fatalError("Không thể cast cell sang MyCustomCell")
+}
+```
+
+**Tools:** SwiftLint (force_cast)