@sun-asterisk/sunlint 1.3.41 → 1.3.43

package/skill-assets/sunlint-code-quality/rules/dart/D024-avoid-unnecessary-statefulwidget.md

@@ -0,0 +1,45 @@
+---
+title: Avoid Unnecessary StatefulWidget
+impact: LOW
+impactDescription: Use StatelessWidget when no state management is needed to improve performance
+tags: performance, flutter, widgets, best-practices
+---
+
+## Avoid Unnecessary StatefulWidget
+
+StatefulWidget should only be used when the widget needs to maintain mutable state that changes over time. If a widget extends StatefulWidget but its State class has no mutable fields, never calls setState(), and doesn't use lifecycle methods beyond build(), it should be converted to StatelessWidget. StatelessWidget is more efficient as it doesn't maintain state and has less overhead.
+
+**Incorrect (StatefulWidget with no state):**
+
+```dart
+class MyTitle extends StatefulWidget {
+  final String text;
+  const MyTitle({super.key, required this.text});
+
+  @override
+  State<MyTitle> createState() => _MyTitleState();
+}
+
+class _MyTitleState extends State<MyTitle> {
+  @override
+  Widget build(BuildContext context) {
+    return Text(widget.text);
+  }
+}
+```
+
+**Correct (StatelessWidget):**
+
+```dart
+class MyTitle extends StatelessWidget {
+  final String text;
+  const MyTitle({super.key, required this.text});
+
+  @override
+  Widget build(BuildContext context) {
+    return Text(text);
+  }
+}
+```
+
+**Tools:** Custom analyzer (D024)

package/skill-assets/sunlint-code-quality/rules/dart/D025-nested-ternaries.md

@@ -0,0 +1,35 @@
+---
+title: Avoid Nested Conditional Expressions
+impact: LOW
+impactDescription: Improve code readability by avoiding nested ternary operators
+tags: readability, maintainability, clean-code
+---
+
+## Avoid Nested Conditional Expressions
+
+Nested conditional expressions (ternary operators like `a ? b : c ? d : e`) reduce code readability significantly. When logic is complex, use if-else statements or extract the logic into a well-named variable or function.
+
+**Incorrect (hard to follow):**
+
+```dart
+final color = isAdmin ? Colors.red : isLogged ? Colors.green : Colors.grey;
+```
+
+**Correct (descriptive logic):**
+
+```dart
+// Option 1: if-else
+Color userColor;
+if (isAdmin) {
+  userColor = Colors.red;
+} else if (isLogged) {
+  userColor = Colors.green;
+} else {
+  userColor = Colors.grey;
+}
+
+// Option 2: Extracted getter
+Color get userColor => _calculateUserColor();
+```
+
+**Tools:** Custom analyzer (D025)

package/skill-assets/sunlint-code-quality/rules/ruby/RB001-use-snake-case.md

@@ -0,0 +1,30 @@
+---
+title: Use snake_case for symbols, methods, and variables
+impact: MEDIUM
+impactDescription: Follow Ruby community naming conventions for consistency and readability.
+tags: ruby, naming, snake_case, convention
+---
+
+## Use snake_case for symbols, methods, and variables
+
+Follow Ruby community naming conventions for consistency and readability. Use `snake_case` (all lowercase with underscores) for symbols, methods, and variables. Avoid camelCase or other naming styles for these elements.
+
+**Incorrect:**
+
+```ruby
+def calculateTotal(price, taxRate)
+  totalAmount = price * taxRate
+  :orderStatus
+end
+```
+
+**Correct:**
+
+```ruby
+def calculate_total(price, tax_rate)
+  total_amount = price * tax_rate
+  :order_status
+end
+```
+
+**Tools:** RuboCop (`Naming/VariableName`, `Naming/MethodName`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB002-use-camel-case.md

@@ -0,0 +1,38 @@
+---
+title: Use CamelCase for classes and modules
+impact: MEDIUM
+impactDescription: Follow Ruby community naming conventions for classes and modules.
+tags: ruby, naming, CamelCase, architecture
+---
+
+## Use CamelCase for classes and modules
+
+Use `CamelCase` (also known as PascalCase) for class and module names. Keep acronyms uppercase (e.g., `HTTPClient`, `XMLParser`).
+
+**Incorrect:**
+
+```ruby
+class User_profile
+end
+
+module Api_Helper
+end
+
+class HttpClient # Acronym 'HTTP' should be all caps
+end
+```
+
+**Correct:**
+
+```ruby
+class UserProfile
+end
+
+module ApiHelper
+end
+
+class HTTPClient
+end
+```
+
+**Tools:** RuboCop (`Naming/ClassName`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB003-use-screaming-snake-case.md

@@ -0,0 +1,26 @@
+---
+title: Use SCREAMING_SNAKE_CASE for constants
+impact: LOW
+impactDescription: Clearly distinguish constants from other identifiers.
+tags: ruby, naming, constants, readability
+---
+
+## Use SCREAMING_SNAKE_CASE for constants
+
+Clearly distinguish constants from other identifiers. Use `SCREAMING_SNAKE_CASE` for constants that do not refer to classes or modules.
+
+**Incorrect:**
+
+```ruby
+DefaultTimeout = 30
+Max_Retry_Count = 5
+```
+
+**Correct:**
+
+```ruby
+DEFAULT_TIMEOUT = 30
+MAX_RETRY_COUNT = 5
+```
+
+**Tools:** RuboCop (`Naming/ConstantName`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB004-predicate-methods.md

@@ -0,0 +1,36 @@
+---
+title: Predicate methods should end with ?
+impact: MEDIUM
+impactDescription: Make boolean-returning methods immediately recognizable.
+tags: ruby, naming, predicate, boolean
+---
+
+## Predicate methods should end with ?
+
+Make boolean-returning methods immediately recognizable. Methods that return boolean values should end with a question mark (`?`). Avoid prefixing with auxiliary verbs like `is_`, `does_`, or `can_`.
+
+**Incorrect:**
+
+```ruby
+def is_valid
+  # logic
+end
+
+if user.is_authenticated
+  # logic
+end
+```
+
+**Correct:**
+
+```ruby
+def valid?
+  # logic
+end
+
+if user.authenticated?
+  # logic
+end
+```
+
+**Tools:** RuboCop (`Naming/PredicateName`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB005-dangerous-methods.md

@@ -0,0 +1,36 @@
+---
+title: Dangerous methods should end with !
+impact: MEDIUM
+impactDescription: Clearly indicate methods that modify the receiver or can raise exceptions.
+tags: ruby, naming, bang, side-effect
+---
+
+## Dangerous methods should end with !
+
+Clearly indicate methods that modify the receiver or can raise exceptions. Methods that modify the object in place or can raise exceptions should end with a bang (`!`).
+
+**Incorrect:**
+
+```ruby
+# Method raises an exception if validation fails
+def save
+  # complex logic
+end
+
+# In-place sort
+values.sort
+```
+
+**Correct:**
+
+```ruby
+# Recommends save! for raising exceptions
+def save!
+  # complex logic
+end
+
+# Indicates in-place sort
+values.sort!
+```
+
+**Tools:** RuboCop (`Style/BangPredicate`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB006-indentation.md

@@ -0,0 +1,32 @@
+---
+title: Use 2 spaces for indentation
+impact: LOW
+impactDescription: Follow Ruby community standard for code formatting.
+tags: ruby, formatting, indentation, style
+---
+
+## Use 2 spaces for indentation
+
+Follow Ruby community standard for code formatting. Use 2 spaces for indentation, never tabs. Ensure consistent indentation throughout the codebase.
+
+**Incorrect:**
+
+```ruby
+def hello
+	puts "hello" # Tab used
+end
+
+def world
+    puts "world" # 4 spaces used
+end
+```
+
+**Correct:**
+
+```ruby
+def hello
+  puts "hello" # 2 spaces
+end
+```
+
+**Tools:** RuboCop (`Layout/IndentationWidth`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB007-line-length.md

@@ -0,0 +1,25 @@
+---
+title: Keep lines under 120 characters
+impact: LOW
+impactDescription: Improve code readability and prevent horizontal scrolling.
+tags: ruby, formatting, readability, side-scrolling
+---
+
+## Keep lines under 120 characters
+
+Improve code readability and prevent horizontal scrolling. Limit line length to 120 characters maximum. Break long lines into multiple lines when necessary.
+
+**Incorrect:**
+
+```ruby
+puts "This is an extremely long string that definitely exceeds the recommended limit of one hundred and twenty characters that we have set for our coding standards in this project."
+```
+
+**Correct:**
+
+```ruby
+puts "This is an extremely long string that definitely exceeds " \
+     "the recommended limit of one hundred and twenty characters..."
+```
+
+**Tools:** RuboCop (`Layout/LineLength`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB008-rescue-exception.md

@@ -0,0 +1,36 @@
+---
+title: Avoid rescuing the Exception class
+impact: HIGH
+impactDescription: Prevent hiding critical system errors.
+tags: ruby, errors, exception, safety
+---
+
+## Avoid rescuing the Exception class
+
+Prevent hiding critical system errors. Never rescue the generic `Exception` class as it catches system-level errors (like `SignalException`, `NoMemoryError`, `SystemExit`). Rescue specific exception classes or `StandardError` instead.
+
+**Incorrect (Dangerous):**
+
+```ruby
+begin
+  do_something
+rescue Exception => e
+  logger.error(e.message)
+end
+```
+
+**Correct (Safe):**
+
+```ruby
+begin
+  do_something
+rescue StandardError => e # Or just 'rescue => e' which defaults to StandardError
+  logger.error(e.message)
+end
+
+# Or specific
+rescue ActiveRecord::RecordNotFound => e
+  # handle
+```
+
+**Tools:** RuboCop (`Lint/RescueException`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB009-save-bang.md

@@ -0,0 +1,41 @@
+---
+title: Use save! or handle return values
+impact: HIGH
+impactDescription: Ensure database operations are properly validated and errors are not silently ignored.
+tags: rails, database, validations, active-record
+---
+
+## Use save! or handle return values
+
+Ensure database operations are properly validated and errors are not silently ignored. Use bang methods (`save!`, `create!`, `update!`, `destroy!`) to raise exceptions on failure. If using non-bang methods, always check the return value.
+
+**Incorrect:**
+
+```ruby
+def create
+  @user = User.new(user_params)
+  @user.save # Failure will be silent
+  redirect_to @user
+end
+```
+
+**Correct:**
+
+```ruby
+def create
+  @user = User.new(user_params)
+  if @user.save
+    redirect_to @user
+  else
+    render :new
+  end
+end
+
+# Or using bang
+def create
+  @user = User.create!(user_params)
+  redirect_to @user
+end
+```
+
+**Tools:** RuboCop (`Rails/SaveBang`)

package/skill-assets/sunlint-code-quality/rules/ruby/RB010-avoid-n-plus-one.md

@@ -0,0 +1,32 @@
+---
+title: Avoid N+1 queries with eager loading
+impact: HIGH
+impactDescription: Prevent performance issues caused by N+1 query problems.
+tags: rails, performance, database, n+1, active-record
+---
+
+## Avoid N+1 queries with eager loading
+
+Prevent performance issues caused by N+1 query problems. Use `includes`, `preload`, or `eager_load` to load associations upfront. Avoid iterating over collections and accessing associations without eager loading.
+
+**Incorrect:**
+
+```ruby
+# Triggers N+1 queries (one query for users, and one query per user for posts)
+users = User.limit(10)
+users.each do |user|
+  puts user.posts.count
+end
+```
+
+**Correct:**
+
+```ruby
+# Eager loads posts in 2 queries total
+users = User.includes(:posts).limit(10)
+users.each do |user|
+  puts user.posts.count
+end
+```
+
+**Tools:** Bullet gem, RuboCop Rails (`Rails/FindEach`)

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`)