@sun-asterisk/sunlint 1.3.40 → 1.3.42

package/skill-assets/sunlint-code-quality/rules/ruby/RB031-mvc-architecture.md

@@ -0,0 +1,37 @@
+---
+title: Follow MVC architecture strictly
+impact: CRITICAL
+impactDescription: Maintain clear separation of concerns.
+tags: rails, architecture, mvc, design
+---
+
+## Follow MVC architecture strictly
+
+Maintain clear separation of concerns. Models should handle data and business logic, Views should only handle presentation, and Controllers should coordinate between them. Avoid business logic in views or controllers.
+
+**Incorrect:**
+
+```erb
+<%# View with business logic %>
+<% if @user.orders.sum(&:price) > 1000 %>
+  <span class="premium">Premium</span>
+<% end %>
+```
+
+**Correct:**
+
+```ruby
+# Model
+class User < ApplicationRecord
+  def premium?
+    orders.sum(&:price) > 1000
+  end
+end
+
+# View
+<% if @user.premium? %>
+  <span class="premium">Premium</span>
+<% end %>
+```
+
+**Tools:** Manual Review, Architectural Check

package/skill-assets/sunlint-code-quality/rules/ruby/RB032-use-concerns.md

@@ -0,0 +1,31 @@
+---
+title: Use concerns judiciously
+impact: MEDIUM
+impactDescription: Prevent concerns from becoming dumping grounds for unrelated code.
+tags: rails, architecture, concerns, design
+---
+
+## Use concerns judiciously
+
+Prevent concerns from becoming dumping grounds for unrelated code. Only use concerns for clearly reusable behavior across multiple models/controllers. Each concern should have a single, well-defined responsibility.
+
+**Incorrect:**
+
+```ruby
+# A concern that handles too many unrelated things
+module UserHelper
+  extend ActiveSupport::Concern
+  # logic for auth, analytics, and image processing mixed together
+end
+```
+
+**Correct:**
+
+```ruby
+module Authenticatable
+  extend ActiveSupport::Concern
+  # focus on auth logic only
+end
+```
+
+**Tools:** Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB033-moderate-callbacks.md

@@ -0,0 +1,31 @@
+---
+title: Document callbacks and use them sparingly
+impact: MEDIUM
+impactDescription: Prevent hidden side effects and improve code clarity.
+tags: rails, architecture, callbacks, documentation
+---
+
+## Document callbacks and use them sparingly
+
+Prevent hidden side effects and improve code clarity. Use callbacks (like `before_save`, `after_create`) only when necessary. Consider using service objects if a callback triggers complex business logic.
+
+**Incorrect (Hidden side effects):**
+
+```ruby
+class Order < ApplicationRecord
+  after_create :charge_credit_card # Dangerous side effect hidden in model lifecycle
+end
+```
+
+**Correct (Explicit action):**
+
+```ruby
+class CheckoutService
+  def self.call(order)
+    order.save!
+    PaymentGateway.charge(order) # Explicit and easier to test
+  end
+end
+```
+
+**Tools:** Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB034-use-decorators.md

@@ -0,0 +1,33 @@
+---
+title: Use decorators for view logic
+impact: MEDIUM
+impactDescription: Keep models and views clean by separating presentation logic.
+tags: rails, architecture, decorator, presentation
+---
+
+## Use decorators for view logic
+
+Keep models and views clean by separating presentation logic. Use decorators (e.g., using the Draper gem or simple delegate classes) to format model data for the view layer.
+
+**Incorrect (Logic in model):**
+
+```ruby
+class User < ApplicationRecord
+  def full_name_for_display
+    "#{first_name} #{last_name} (#{email})"
+  end
+end
+```
+
+**Correct (Logic in decorator):**
+
+```ruby
+class UserDecorator < Draper::Decorator
+  delegate_all
+  def display_name
+    "#{object.first_name} #{object.last_name} (#{object.email})"
+  end
+end
+```
+
+**Tools:** Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB035-comprehensive-tests.md

@@ -0,0 +1,32 @@
+---
+title: Write comprehensive tests
+impact: CRITICAL
+impactDescription: Ensure code quality and prevent regressions.
+tags: ruby, quality, testing, stability
+---
+
+## Write comprehensive tests
+
+Ensure code quality and prevent regressions. Write unit tests for models/services, integration tests for controllers, and system tests for critical paths. Aim for >80% coverage for business-critical code.
+
+**Incorrect:**
+
+```ruby
+# No tests covering edge cases or failure modes
+```
+
+**Correct:**
+
+```ruby
+RSpec.describe User, type: :model do
+  it "is valid with proper attributes" do
+    # ...
+  end
+  
+  it "is invalid without an email" do
+    # ...
+  end
+end
+```
+
+**Tools:** RSpec, Minitest, SimpleCov

package/skill-assets/sunlint-code-quality/rules/ruby/RB036-frozen-string-literal.md

@@ -0,0 +1,29 @@
+---
+title: Use frozen_string_literal: true
+impact: LOW
+impactDescription: Improve memory efficiency and prepare for Ruby 4.0 string immutability.
+tags: ruby, performance, memory, preparation
+---
+
+## Use frozen_string_literal: true
+
+Improve memory efficiency and prepare for Ruby 4.0 string immutability. Add `# frozen_string_literal: true` magic comment at the top of every Ruby file.
+
+**Incorrect:**
+
+```ruby
+class MyClass
+  DEFAULT_STATUS = "pending" # New string object created every time
+end
+```
+
+**Correct:**
+
+```ruby
+# frozen_string_literal: true
+class MyClass
+  DEFAULT_STATUS = "pending" # String object is frozen and reused
+end
+```
+
+**Tools:** RuboCop (`Style/FrozenStringLiteralComment`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB037-it-parameter.md

@@ -0,0 +1,25 @@
+---
+title: Use 'it' as a default block parameter (Ruby 3.4+)
+impact: LOW
+impactDescription: Enhance code readability for concise block operations.
+tags: ruby, readability, quality, syntax
+---
+
+## Use 'it' as a default block parameter (Ruby 3.4+)
+
+Enhance code readability for concise block operations. In Ruby 3.4+, use the implicit `it` keyword instead of explicit single-use block parameters to make simple iterations cleaner.
+
+**Incorrect:**
+
+```ruby
+users.map { |user| user.name }
+```
+
+**Correct:**
+
+```ruby
+# Ruby 3.4+
+users.map { it.name }
+```
+
+**Tools:** RuboCop (`Style/ItAssignment`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB038-modern-enum-syntax.md

@@ -0,0 +1,28 @@
+---
+title: Use modern hash-based enum syntax
+impact: MEDIUM
+impactDescription: Use the more readable and explicit enum configuration in ActiveRecord.
+tags: rails, active-record, readability, clarity
+---
+
+## Use modern hash-based enum syntax
+
+Use the more readable and explicit enum configuration in ActiveRecord. Prefer mapping values to database integers explicitly via a hash to prevent accidental shifts if elements are reordered.
+
+**Incorrect:**
+
+```ruby
+class Order < ApplicationRecord
+  enum status: [:pending, :active, :shipped] # Dangerous if order changes
+end
+```
+
+**Correct:**
+
+```ruby
+class Order < ApplicationRecord
+  enum :status, { pending: 0, active: 1, shipped: 2 } # Explicit and safe
+end
+```
+
+**Tools:** RuboCop (`Rails/EnumSyntax`)

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)