@sun-asterisk/sunlint 1.3.41 → 1.3.42

package/skill-assets/sunlint-code-quality/rules/dart/D017-review-dependencies.md

@@ -0,0 +1,24 @@
+---
+title: Pubspec dependencies should be reviewed regularly
+impact: MEDIUM
+impactDescription: Ensure dependencies are kept up-to-date for security and stability
+tags: maintenance, security, dependencies
+---
+
+## Pubspec dependencies should be reviewed regularly
+
+Dependencies in `pubspec.yaml` should be reviewed and updated regularly (at least every 4 months). Outdated dependencies may contain security vulnerabilities or miss critical performance improvements.
+
+**Incorrect (old lock file):**
+
+```text
+# pubspec.lock last modified: 6 months ago
+```
+
+**Correct (regularly updated):**
+
+```text
+# run 'flutter pub upgrade' and review dependencies regularly
+```
+
+**Tools:** Custom analyzer (D017)

package/skill-assets/sunlint-code-quality/rules/dart/D018-no-commented-code.md

@@ -0,0 +1,34 @@
+---
+title: Remove Commented-Out Code
+impact: LOW
+impactDescription: Keep codebase clean by removing commented-out code
+tags: cleanliness, readability, maintenance
+---
+
+## Remove Commented-Out Code
+
+Commented-out code should be removed instead of being left in the source files. Dead code comments create clutter and confusion. If you need to reference old code, rely on version control (Git).
+
+**Incorrect (abandoned code):**
+
+```dart
+void calculate() {
+  final result = 10 + 5;
+  // print("Debug result: $result");
+  // if (result > 10) {
+  //   doSomething();
+  // }
+  return result;
+}
+```
+
+**Correct (clean file):**
+
+```dart
+void calculate() {
+  final result = 10 + 5;
+  return result;
+}
+```
+
+**Tools:** Custom analyzer (D018)

package/skill-assets/sunlint-code-quality/rules/dart/D019-single-child-wrappers.md

@@ -0,0 +1,31 @@
+---
+title: Avoid Single Child in Multi-Child Widget
+impact: LOW
+impactDescription: Use appropriate widget types for the number of children
+tags: performance, efficiency, best-practices
+---
+
+## Avoid Single Child in Multi-Child Widget
+
+Multi-child widgets like `Column`, `Row`, `Stack`, `ListView`, or `GridView` are inefficient when used with only a single child. Use single-child optimized widgets like `SizedBox`, `Padding`, `Center`, or `Container` instead.
+
+**Incorrect (inefficient Column):**
+
+```dart
+Column(
+  children: [
+    Text("Only one child here"),
+  ],
+)
+```
+
+**Correct (efficient wrapper):**
+
+```dart
+Padding(
+  padding: const EdgeInsets.all(8.0),
+  child: Text("Only one child here"),
+)
+```
+
+**Tools:** Custom analyzer (D019)

package/skill-assets/sunlint-code-quality/rules/dart/D020-if-else-limit.md

@@ -0,0 +1,41 @@
+---
+title: Limit If/Else Branches
+impact: LOW
+impactDescription: Reduce complexity by limiting the number of if/else branches
+tags: readability, complexity, clean-code
+---
+
+## Limit If/Else Branches
+
+Complex if/else chains with more than 3 branches reduce code readability and increase cyclomatic complexity. When facing multiple branches, consider using `switch` statements, lookup tables (Maps), or the Strategy pattern.
+
+**Incorrect (long if/else chain):**
+
+```dart
+if (type == 'A') {
+  doA();
+} else if (type == 'B') {
+  doB();
+} else if (type == 'C') {
+  doC();
+} else if (type == 'D') {
+  doD();
+} else {
+  doDefault();
+}
+```
+
+**Correct (using switch or Map):**
+
+```dart
+// Option 1: Switch (better readability)
+switch (type) {
+  case 'A': doA(); break;
+  case 'B': doB(); break;
+  case 'C': doC(); break;
+  case 'D': doD(); break;
+  default: doDefault();
+}
+```
+
+**Tools:** Custom analyzer (D020)

package/skill-assets/sunlint-code-quality/rules/dart/D021-negated-booleans.md

@@ -0,0 +1,26 @@
+---
+title: Avoid Negated Boolean Checks
+impact: LOW
+impactDescription: Improve code readability by avoiding inverted or negated boolean conditions
+tags: readability, logic, clean-code
+---
+
+## Avoid Negated Boolean Checks
+
+Negated boolean checks (using `!`) make code harder to read and understand. Replace negative conditions with positive ones wherever possible, and avoid double negations like `!!`.
+
+**Incorrect (fragmented logic):**
+
+```dart
+if (!isNotAuthorized) { ... }
+if (!(a == b)) { ... }
+```
+
+**Correct (clear logic):**
+
+```dart
+if (isAuthorized) { ... }
+if (a != b) { ... }
+```
+
+**Tools:** Custom analyzer (D021)

package/skill-assets/sunlint-code-quality/rules/dart/D022-setstate-usage.md

@@ -0,0 +1,35 @@
+---
+title: Use setState Correctly
+impact: HIGH
+impactDescription: Ensure setState is used correctly in StatefulWidget to avoid performance issues and bugs
+tags: performance, best-practices, lifecycle, state-management
+---
+
+## Use setState Correctly
+
+Common `setState` anti-patterns include: calling `setState` inside `build()`, nesting `setState` calls, making multiple `setState` calls in the same method, or using async callbacks inside `setState`. These lead to performance issues, unnecessary rebuilds, or hard-to-track UI bugs.
+
+**Incorrect (async inside setState):**
+
+```dart
+setState(() async {
+  await fetchData(); // WRONG: setState should be synchronous
+  _data = "new data";
+});
+```
+
+**Correct (sync update after async):**
+
+```dart
+// Fetch data first
+final newData = await fetchData();
+
+// Update state synchronously
+if (mounted) {
+  setState(() {
+    _data = newData;
+  });
+}
+```
+
+**Tools:** Custom analyzer (D022)

package/skill-assets/sunlint-code-quality/rules/dart/D023-unnecessary-overrides.md

@@ -0,0 +1,32 @@
+---
+title: Avoid Unnecessary Method Overrides
+impact: LOW
+impactDescription: Remove methods that only call super with the same parameters as they add no value
+tags: readability, clean-code, refactoring
+---
+
+## Avoid Unnecessary Method Overrides
+
+Methods that override a parent method but only call `super.methodName()` with the same parameters are unnecessary and should be removed. These empty overrides add no functionality and create unnecessary code clutter. Common examples include lifecycle methods like `initState()`, `dispose()`, or `didUpdateWidget()` that only call their super implementation.
+
+**Incorrect (super call only):**
+
+```dart
+@override
+void initState() {
+  super.initState();
+}
+
+@override
+void dispose() {
+  super.dispose();
+}
+```
+
+**Correct (remove if no logic):**
+
+```dart
+// Just remove the method override entirely if it only calls super
+```
+
+**Tools:** Custom analyzer (D023)

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