@sun-asterisk/sunlint 1.3.40 → 1.3.42

package/skill-assets/sunlint-code-quality/rules/ruby/RB011-use-find-each.md

@@ -0,0 +1,30 @@
+---
+title: Use find_each for large collections
+impact: HIGH
+impactDescription: Reduce memory consumption when iterating over large datasets.
+tags: rails, performance, database, memory, active-record
+---
+
+## Use find_each for large collections
+
+Reduce memory consumption when iterating over large datasets. Use `find_each` or `find_in_batches` instead of `each` for large ActiveRecord collections. `find_each` loads records in batches (default 1000) to avoid loading all records into memory at once.
+
+**Incorrect:**
+
+```ruby
+# Loads ALL users into memory, which can crash the process for large datasets
+User.all.each do |user|
+  user.do_something
+end
+```
+
+**Correct:**
+
+```ruby
+# Loads users in batches of 1000
+User.find_each do |user|
+  user.do_something
+end
+```
+
+**Tools:** RuboCop (`Rails/FindEach`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB012-sql-injection.md

@@ -0,0 +1,29 @@
+---
+title: Avoid SQL injection with parameterized queries
+impact: CRITICAL
+impactDescription: Prevent SQL injection vulnerabilities.
+tags: ruby, rails, security, sql-injection, active-record
+---
+
+## Avoid SQL injection with parameterized queries
+
+Prevent SQL injection vulnerabilities. Never use string interpolation in SQL queries. Use parameterized queries with `?` or named placeholders (`:name`). Use hash conditions for `where` clauses instead of SQL fragments.
+
+**Incorrect (Vulnerable):**
+
+```ruby
+# Direct interpolation is dangerous
+User.where("name = '#{params[:name]}'")
+```
+
+**Correct (Safe):**
+
+```ruby
+# Parameterized
+User.where("name = ?", params[:name])
+
+# Hash-based (Recommended)
+User.where(name: params[:name])
+```
+
+**Tools:** Brakeman, RuboCop (`Rails/SquishedSQLHeredocs`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB013-prefer-has-many-through.md

@@ -0,0 +1,35 @@
+---
+title: Prefer has_many :through over HABTM
+impact: MEDIUM
+impactDescription: Allow for additional attributes and validations on join models.
+tags: rails, database, associations, active-record
+---
+
+## Prefer has_many :through over HABTM
+
+Allow for additional attributes and validations on join models. Use `has_many :through` instead of `has_and_belongs_to_many` for many-to-many relationships. This provides more flexibility for adding attributes or validations to the join table later.
+
+**Incorrect:**
+
+```ruby
+class User < ApplicationRecord
+  has_and_belongs_to_many :roles
+end
+```
+
+**Correct:**
+
+```ruby
+class User < ApplicationRecord
+  has_many :assignments
+  has_many :roles, through: :assignments
+end
+
+class Assignment < ApplicationRecord
+  belongs_to :user
+  belongs_to :role
+  # Can add validations or extra fields here
+end
+```
+
+**Tools:** RuboCop (`Rails/HasAndBelongsToMany`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB014-dependent-associations.md

@@ -0,0 +1,28 @@
+---
+title: Always define dependent option for associations
+impact: HIGH
+impactDescription: Prevent orphaned records and ensure data integrity.
+tags: rails, database, data-integrity, active-record
+---
+
+## Always define dependent option for associations
+
+Prevent orphaned records and ensure data integrity. Always specify the `dependent` option for `has_many` and `has_one` associations to define what happens to associated records when the parent is deleted.
+
+**Incorrect:**
+
+```ruby
+class User < ApplicationRecord
+  has_many :posts # No dependent option
+end
+```
+
+**Correct:**
+
+```ruby
+class User < ApplicationRecord
+  has_many :posts, dependent: :destroy
+end
+```
+
+**Tools:** Custom linter, Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB015-modern-validations.md

@@ -0,0 +1,29 @@
+---
+title: Use new-style validations
+impact: MEDIUM
+impactDescription: Follow modern Rails conventions for model validations.
+tags: rails, conventions, validations, active-record
+---
+
+## Use new-style validations
+
+Follow modern Rails conventions for model validations. Use the `validates` method with a hash of options. Avoid old-style validations like `validates_presence_of`.
+
+**Incorrect:**
+
+```ruby
+class User < ApplicationRecord
+  validates_presence_of :email
+  validates_uniqueness_of :email
+end
+```
+
+**Correct:**
+
+```ruby
+class User < ApplicationRecord
+  validates :email, presence: true, uniqueness: true
+end
+```
+
+**Tools:** RuboCop (`Rails/Validation`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB016-thin-controllers.md

@@ -0,0 +1,45 @@
+---
+title: Keep controllers thin
+impact: HIGH
+impactDescription: Maintain single responsibility and improve testability.
+tags: rails, architecture, controllers, mvc
+---
+
+## Keep controllers thin
+
+Maintain single responsibility and improve testability. Controllers should only handle HTTP requests and responses (parsing params, calling logic, redirecting/rendering). Extract complex business logic into service objects, models, or concerns.
+
+**Incorrect:**
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    @order = Order.new(order_params)
+    # Complex business logic in controller
+    if @order.save
+      Inventory.decrease(@order.product_id)
+      EmailService.send_confirmation(@order.user)
+      redirect_to @order
+    else
+      render :new
+    end
+  end
+end
+```
+
+**Correct:**
+
+```ruby
+class OrdersController < ApplicationController
+  def create
+    @order = Order.new(order_params)
+    if OrderCreationService.call(@order)
+      redirect_to @order
+    else
+      render :new
+    end
+  end
+end
+```
+
+**Tools:** RuboCop (`Metrics/MethodLength`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB017-avoid-fat-models.md

@@ -0,0 +1,41 @@
+---
+title: Avoid fat models
+impact: HIGH
+impactDescription: Prevent models from becoming monolithic and hard to maintain.
+tags: rails, architecture, models, mvc
+---
+
+## Avoid fat models
+
+Prevent models from becoming monolithic and hard to maintain. Keep models focused on associations, validations, and simple domain logic. Extract complex workflows or unrelated concerns into service objects or specific classes.
+
+**Incorrect:**
+
+```ruby
+# User model handling too many things (auth, analytics, profile, etc.)
+class User < ApplicationRecord
+  def generate_analytics_report
+    # complex logic unrelated to core User state
+  end
+  
+  def process_subscription_upgrade
+    # complex workflow
+  end
+end
+```
+
+**Correct:**
+
+```ruby
+class User < ApplicationRecord
+  # core logic only
+end
+
+class AnalyticsReportGenerator
+  def self.call(user)
+    # complex logic
+  end
+end
+```
+
+**Tools:** RuboCop (`Metrics/ClassLength`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB018-service-objects.md

@@ -0,0 +1,36 @@
+---
+title: Use service objects for complex business logic
+impact: HIGH
+impactDescription: Improve code organization and testability.
+tags: rails, architecture, service-objects, patterns
+---
+
+## Use service objects for complex business logic
+
+Improve code organization and testability. Extract complex business logic (payments, onboarding, multi-step processes) into service objects. Service objects should have a single public method (e.g., `call`, `execute`) and reside in `app/services/`.
+
+**Incorrect (Logic inside model):**
+
+```ruby
+class Payment < ApplicationRecord
+  def process!
+    # API calls, state changes, email triggers...
+  end
+end
+```
+
+**Correct (Decoupled Service):**
+
+```ruby
+class PaymentProcessor
+  def initialize(payment)
+    @payment = payment
+  end
+
+  def call
+    # API calls, state changes, email triggers...
+  end
+end
+```
+
+**Tools:** Custom linter, Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB019-avoid-metaprogramming.md

@@ -0,0 +1,40 @@
+---
+title: Avoid needless metaprogramming
+impact: MEDIUM
+impactDescription: Maintain code clarity and debuggability.
+tags: ruby, metaprogramming, readability, simplicity
+---
+
+## Avoid needless metaprogramming
+
+Maintain code clarity and debuggability. Avoid using metaprogramming (`define_method`, `method_missing`, `class_eval`) unless absolutely necessary. Metaprogramming makes code harder to understand, debug, and maintain.
+
+**Incorrect (Over-engineered):**
+
+```ruby
+class User
+  [:name, :email, :phone].each do |attr|
+    define_method("display_#{attr}") do
+      send(attr) || "N/A"
+    end
+  end
+end
+```
+
+**Correct (Explicit):**
+
+```ruby
+class User
+  def display_name
+    name || "N/A"
+  end
+  
+  def display_email
+    email || "N/A"
+  end
+  
+  # ...
+end
+```
+
+**Tools:** RuboCop (`Style/MethodMissingSuper`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB020-use-pluck.md

@@ -0,0 +1,29 @@
+---
+title: Use pluck for selecting specific columns
+impact: MEDIUM
+impactDescription: Improve query performance by selecting only needed columns.
+tags: rails, performance, database, active-record
+---
+
+## Use pluck for selecting specific columns
+
+Improve query performance by selecting only needed columns. Use `pluck` to select columns from multiple records. Use `pick` for a single value from a single record.
+
+**Incorrect:**
+
+```ruby
+# Loads whole User objects into memory just to get ids
+User.all.map(&:id)
+```
+
+**Correct:**
+
+```ruby
+# Only selects 'id' in SQL
+User.pluck(:id)
+
+# Even better for IDs specifically
+User.ids
+```
+
+**Tools:** RuboCop (`Rails/Pluck`, `Rails/PluckId`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB021-use-size.md

@@ -0,0 +1,27 @@
+---
+title: Use size over count or length
+impact: LOW
+impactDescription: Optimize performance by using the most efficient method.
+tags: rails, performance, active-record, database
+---
+
+## Use size over count or length
+
+Optimize performance by using the most efficient method. Use `size` instead of `count` or `length` for ActiveRecord collections. `size` intelligently chooses between `count` (SQL query if not loaded) and `length` (array size if already loaded).
+
+**Incorrect:**
+
+```ruby
+# Always triggers a SELECT COUNT(*) query even if data is already loaded
+users = User.all.to_a
+puts users.count 
+```
+
+**Correct:**
+
+```ruby
+# Uses the array size if already loaded, otherwise queries DB
+puts User.all.size
+```
+
+**Tools:** RuboCop (`Rails/SkipsModelValidations`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB022-order-by-timestamps.md

@@ -0,0 +1,24 @@
+---
+title: Order by timestamp columns, not id
+impact: MEDIUM
+impactDescription: Ensure consistent ordering across database systems.
+tags: database, rails, active-record, ordering
+---
+
+## Order by timestamp columns, not id
+
+Ensure consistent ordering across database systems. Order records chronologically by timestamp columns (`created_at`, `updated_at`) instead of `id`. IDs may not be sequential in distributed systems (e.g., UUIDs).
+
+**Incorrect:**
+
+```ruby
+scope :recent, -> { order(id: :desc) }
+```
+
+**Correct:**
+
+```ruby
+scope :recent, -> { order(created_at: :desc) }
+```
+
+**Tools:** Manual Review

package/skill-assets/sunlint-code-quality/rules/ruby/RB023-where-missing.md

@@ -0,0 +1,24 @@
+---
+title: Use where.missing for Rails 6.1+
+impact: LOW
+impactDescription: Use modern Rails APIs for finding records with missing associations.
+tags: rails, active-record, simplicity, associations
+---
+
+## Use where.missing for Rails 6.1+
+
+Use modern Rails APIs for finding records with missing associations. Use `where.missing(:association)` instead of left joins with null checks. This is more readable and expressive.
+
+**Incorrect:**
+
+```ruby
+Post.left_outer_joins(:comments).where(comments: { id: nil })
+```
+
+**Correct:**
+
+```ruby
+Post.where.missing(:comments)
+```
+
+**Tools:** RuboCop (`Rails/WhereMissing`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB024-method-length.md

@@ -0,0 +1,41 @@
+---
+title: Keep methods under 10 lines
+impact: MEDIUM
+impactDescription: Improve code readability and maintainability.
+tags: ruby, quality, metrics, readability
+---
+
+## Keep methods under 10 lines
+
+Improve code readability and maintainability. Limit methods to 10 lines of code (excluding blank lines and comments). Extract complex logic into smaller, well-named private methods.
+
+**Incorrect (Too long):**
+
+```ruby
+def process_order(order)
+  validate_order(order)
+  apply_discount(order)
+  notify_user(order)
+  update_inventory(order)
+  generate_invoice(order)
+  archive_order(order)
+  # ... many more lines
+end
+```
+
+**Correct:**
+
+```ruby
+def process_order(order)
+  prepare_order(order)
+  finalize_order(order)
+end
+
+private
+
+def prepare_order(order)
+  # sub-logic < 10 lines
+end
+```
+
+**Tools:** RuboCop (`Metrics/MethodLength`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB025-parameter-limits.md

@@ -0,0 +1,28 @@
+---
+title: Limit method parameters to 4
+impact: MEDIUM
+impactDescription: Reduce method complexity and improve readability.
+tags: ruby, quality, design, parameters
+---
+
+## Limit method parameters to 4
+
+Reduce method complexity and improve readability. Limit methods to 4 parameters maximum. If more parameters are needed, consider using a hash or a specific parameter object.
+
+**Incorrect:**
+
+```ruby
+def send_email(to, from, subject, body, cc, bcc, attachments)
+  # logic
+end
+```
+
+**Correct:**
+
+```ruby
+def send_email(to:, from:, subject:, body:, options: {})
+  # logic
+end
+```
+
+**Tools:** RuboCop (`Metrics/ParameterLists`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB026-avoid-deep-nesting.md

@@ -0,0 +1,38 @@
+---
+title: Avoid deep nesting (max 3 levels)
+impact: MEDIUM
+impactDescription: Improve code readability and reduce cyclomatic complexity.
+tags: ruby, quality, metrics, nesting
+---
+
+## Avoid deep nesting (max 3 levels)
+
+Improve code readability and reduce cyclomatic complexity. Limit nesting (if/else, blocks) to 3 levels maximum. Use guard clauses, early returns, or extract methods to flatten code.
+
+**Incorrect:**
+
+```ruby
+def update_user
+  if logged_in?
+    if admin?
+      if params[:id].present?
+         # 4th level nesting
+      end
+    end
+  end
+end
+```
+
+**Correct:**
+
+```ruby
+def update_user
+  return unless logged_in?
+  return unless admin?
+  return if params[:id].blank?
+  
+  # Logic at level 1
+end
+```
+
+**Tools:** RuboCop (`Metrics/BlockNesting`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB027-guard-clauses.md

@@ -0,0 +1,37 @@
+---
+title: Use guard clauses for early returns
+impact: MEDIUM
+impactDescription: Reduce nesting and improve code clarity.
+tags: ruby, quality, style, clean-code
+---
+
+## Use guard clauses for early returns
+
+Reduce nesting and improve code clarity. Use guard clauses to handle edge cases or invalid states early and return. This keeps the main happy path at the top level of the method.
+
+**Incorrect:**
+
+```ruby
+def notify(user)
+  if user.active?
+    if user.email_notifications?
+      # Main logic here
+      UserMailer.notification(user).deliver_now
+    end
+  end
+end
+```
+
+**Correct:**
+
+```ruby
+def notify(user)
+  return unless user.active?
+  return unless user.email_notifications?
+
+  # Main logic here
+  UserMailer.notification(user).deliver_now
+end
+```
+
+**Tools:** RuboCop (`Style/GuardClause`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB028-class-length.md

@@ -0,0 +1,32 @@
+---
+title: Keep classes under 100 lines
+impact: MEDIUM
+impactDescription: Maintain single responsibility and improve maintainability.
+tags: ruby, quality, design, architecture
+---
+
+## Keep classes under 100 lines
+
+Maintain single responsibility and improve maintainability. Limit classes to 100 lines of code (excluding blank lines and comments). Extract responsibilities into separate classes or modules if a class grows too large.
+
+**Incorrect:**
+
+```ruby
+class BigManager
+  # 200 lines of mixed logic
+end
+```
+
+**Correct:**
+
+```ruby
+class OrderProcessor
+  # focused logic < 100 lines
+end
+
+class OrderNotifier
+  # focused logic < 100 lines
+end
+```
+
+**Tools:** RuboCop (`Metrics/ClassLength`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB029-meaningful-names.md

@@ -0,0 +1,30 @@
+---
+title: Use meaningful variable and method names
+impact: MEDIUM
+impactDescription: Improve code self-documentation and readability.
+tags: ruby, naming, readability, quality
+---
+
+## Use meaningful variable and method names
+
+Improve code self-documentation and readability. Use descriptive names that clearly convey purpose. Avoid single-letter variables except for common iterators (i, j, k).
+
+**Incorrect:**
+
+```ruby
+def calc(a, b)
+  r = a * b
+  return r
+end
+```
+
+**Correct:**
+
+```ruby
+def calculate_area(width, height)
+  area = width * height
+  return area
+end
+```
+
+**Tools:** RuboCop (`Naming/VariableName`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB030-dry-principle.md

@@ -0,0 +1,37 @@
+---
+title: Don't Repeat Yourself (DRY)
+impact: MEDIUM
+impactDescription: Reduce code duplication and improve maintainability.
+tags: ruby, abstraction, maintenance, quality
+---
+
+## Don't Repeat Yourself (DRY)
+
+Reduce code duplication and improve maintainability. Extract repeated code into methods, helpers, concerns, or partials. Use inheritance or modules to share behavior instead of copy-pasting code blocks.
+
+**Incorrect:**
+
+```ruby
+def create_admin
+  user = User.new(admin: true)
+  user.save!
+  Log.create(action: "admin created")
+end
+
+def create_user
+  user = User.new(admin: false)
+  user.save!
+  Log.create(action: "user created")
+end
+```
+
+**Correct:**
+
+```ruby
+def create_account(admin: false)
+  user = User.create!(admin: admin)
+  Log.create(action: "#{admin ? 'admin' : 'user'} created")
+end
+```
+
+**Tools:** Reek, RuboCop (`Style/IdenticalConditionalBranches`)