[Request for new rule] - FLUTTER

[LosokosG]

Must have dla robienia aplikacji mobilnych na wszystkie platformy!

[psmyrdek]

Byłbyś w stanie wrzucić taki draft 5-10 reguł do Fluttera? Z twojej praktyki? Możesz otworzyć sekcję mobile ;)

[LosokosG]

1. Use const Constructors for Immutable Widgets and Objects

• Why: Using const minimizes object recreation, reduces garbage collection, and enhances performance by enabling compile-time optimizations and faster hot-reloading.
• How: Apply const to widgets, styles, or data objects that remain static during runtime.
• Example:

  const Text('Welcome', style: TextStyle(fontSize: 16))

  Instead of:

  Text('Welcome', style: TextStyle(fontSize: 16))

• When: Use whenever a widget or object won’t change after initialization.

2. Modularize the UI into Small, Reusable Widgets

• Why: Smaller widgets improve code reusability, readability, and ease of debugging or updating.
• How: Split complex UIs into components like buttons, headers, or screens, each in its own file or class.
• Example: Create a PrimaryButton widget:

  class PrimaryButton extends StatelessWidget {
    final String label;
    final VoidCallback onPressed;
    const PrimaryButton({required this.label, required this.onPressed});
    @override
    Widget build(BuildContext context) {
      return ElevatedButton(onPressed: onPressed, child: Text(label));
    }
  }

• Benefit: Reusable across screens, e.g., PrimaryButton(label: 'Login', onPressed: () {}).

3. Choose State Management Based on App Complexity and Team Expertise

• Why: The right state management balances scalability, performance, and maintainability.
• How:
  • Simple apps: Use Provider for lightweight state.
  • Medium complexity: Use Riverpod for dependency injection and state.
  • Large-scale apps: Use BLoC for strict separation of logic and UI.
• Example: For a counter app, use Provider:

  Provider.of<Counter>(context).increment();

• Consider: Team familiarity, app size, and whether real-time updates are needed.

4. Keep build Methods Pure by Avoiding Side Effects

• Why: Side effects (e.g., API calls) in build cause unpredictable rebuilds, degrading performance.
• How: Move logic to initState, didChangeDependencies, or state management solutions.
• Example:

  @override
  void initState() {
    super.initState();
    fetchData(); // Fetch outside build
  }
  @override
  Widget build(BuildContext context) {
    return Text(data); // Pure UI
  }

• Avoid: Async calls or state mutations in build.

5. Adhere to Consistent Naming Conventions

• Why: Uniform naming enhances collaboration and code navigation.
• How:
  • Files: snake_case (e.g., profile_screen.dart).
  • Variables: lowerCamelCase (e.g., userAge).
  • Classes: UpperCamelCase (e.g., ProfileScreen).
  • Constants: kUpperCamelCase (e.g., kDefaultPadding).
• Example: File login_page.dart with class LoginPage.

6. Leverage Static Analysis Tools for Code Quality

• Why: Catches errors, enforces style, and prevents technical debt.
• How: Use dart analyze and tools like Dart Code Metrics or Very Good Analysis. Configure rules in analysis_options.yaml.
• Example: Add to pubspec.yaml:

  dev_dependencies:
    dart_code_metrics: ^5.0.0

  Run: dart analyze or integrate with CI/CD.
• Tip: Customize rules for team standards.

7. Prefer SizedBox Over Container for Lightweight Spacing

• Why: SizedBox is a simpler, const-capable widget, reducing rendering overhead.
• How: Use SizedBox for spacing or fixed sizes without styling.
• Example:

  SizedBox(height: 16)

  Instead of:

  Container(height: 16)

• Exception: Use Container for complex styling (e.g., borders, colors).

8. Restrict Stream Usage to Real-Time Requirements

• Why: Overusing streams increases complexity and risks memory leaks.
• How: Opt for ChangeNotifier, ValueNotifier, or BLoC for non-real-time state. Use streams for live data (e.g., chat, stock prices).
• Example: Use ValueNotifier for a toggle:

  final isEnabled = ValueNotifier<bool>(false);

• Caution: Always close streams with StreamController.close().

9. Refactor UI Logic into Dedicated Widget Classes

• Why: Widgets leverage Flutter’s lifecycle, improving performance and testability.
• How: Convert helper methods into stateless or stateful widgets.
• Example: Before:

  Widget buildItem() => Text('Item');

  After:

  class ItemWidget extends StatelessWidget {
    @override
    Widget build(BuildContext context) => Text('Item');
  }

• Benefit: Easier to test and reuse.

10. Offload Heavy Computations to Isolates

• Why: Prevents UI freezes by running tasks in separate threads.
• How: Use compute() for CPU-intensive work like JSON parsing or image processing.
• Example:

  Future<int> processData(List<int> data) async {
    return await compute(_processHeavyTask, data);
  }
  static int _processHeavyTask(List<int> data) => data.reduce((a, b) => a + b);

• Use Case: Encryption, large dataset processing.

11. Write Unit, Widget, and Integration Tests for Key Features

• Why: Ensures reliability and reduces regression bugs.
• How: Use flutter_test for unit/widget tests and integration_test for app flows.
• Example: Unit test:

  test('Counter increments', () {
    final counter = Counter();
    counter.increment();
    expect(counter.value, 1);
  });

• Goal: 80%+ coverage for critical paths (e.g., login, payments).

12. Regularly Update Flutter SDK and Dependencies

• Why: Accesses bug fixes, performance improvements, and new features.
• How: Run flutter upgrade for SDK, flutter pub upgrade for packages. Automate with Dependabot or CI.
• Example: Check versions:

  flutter doctor
  flutter pub outdated

• Tip: Test updates in a staging environment first.

13. Implement Robust Security Practices

• Why: Protects user data and app integrity.
• How:
  • Use HTTPS for all network requests.
  • Obfuscate code with flutter build --obfuscate --split-debug-info=/<path>.
  • Encrypt sensitive data with flutter_secure_storage.
• Example: Store a token:

  final storage = FlutterSecureStorage();
  await storage.write(key: 'token', value: 'abc123');

• Extra: Detect rooted devices with flutter_jailbreak_detection.

14. Automate Builds and Releases with CI/CD Tools

• Why: Reduces manual errors and speeds up deployment.
• How: Use GitHub Actions, fastlane, or Codemagic for testing, building, and deploying APKs or iOS apps.
• Example: GitHub Actions workflow:

  jobs:
    build:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v3
        - uses: subosito/flutter-action@v2
        - run: flutter build apk

• Benefit: Consistent, reproducible builds.

15. Master Core Flutter CLI Commands

• Why: Boosts productivity across development stages.
• How: Learn and use:
  • flutter analyze: Check code quality.
  • flutter run --release: Test release builds.
  • flutter build apk --split-per-abi: Build optimized Android APKs.
  • flutter build ios --no-codesign: Build iOS apps (sign separately).
  • flutter clean: Reset build cache.
• Example: Build for web:

  flutter build web --release

• Tip: Alias frequent commands in your shell.

[pawel-twardziak]

Wow! @LosokosG Super propka reguł! Kudos! ❤
@psmyrdek @LosokosG a co myślicie o tym https://cursor.directory/rules/flutter?

[psmyrdek]

Ja w tym ekosystemie nie pracowałem, więc przyjmiemy każde sugestie. Ważne tylko, żeby format odpowiadał temu jak działa aplikacja (w readme jest również opis) bo niestety tego obszernego tekstu teraz nie wkleimy - czyli kilka precyzyjnych wpisów w folderze "rules" (może być pod mobile) przykładowo.

[LosokosG]

To powinno być lepsze:

    // Dart General Guidelines - Basic Principles
    "Use English for all code and documentation.",
    "Always declare the type of each variable and function (parameters and return value). Avoid using 'any' and create necessary types.",
    "Don't leave blank lines within a function.",
    "Limit one export per file.",

    // Nomenclature
    "Use PascalCase for classes, camelCase for variables, functions, and methods, and underscores_case for file and directory names.",
    "Use UPPERCASE for environment variables. Avoid magic numbers and define constants instead.",
    "Name functions with a verb and ensure boolean variables start with verbs like 'is', 'has', 'can' (e.g., isLoading, hasError, canDelete).",
    "Use complete words instead of abbreviations (except standard ones like 'API', 'URL', or well-known ones like 'i', 'j' for loops, 'err' for errors, 'ctx' for contexts, 'req', 'res', 'next' for middleware).",
    "Ensure correct spelling in all identifiers.",

    // Functions
    "Write short functions with a single purpose (less than 20 instructions). This applies to both functions and methods.",
    "Name functions with a verb and additional context: use 'isX', 'hasX', 'canX' for booleans, and 'executeX', 'saveX' for void returns.",
    "Avoid nesting blocks: use early returns or extract logic into utility functions.",
    "Use higher-order functions (map, filter, reduce) to reduce nesting and prefer arrow functions for simple cases (less than 3 instructions). Use named functions otherwise.",
    "Use default parameter values instead of null checks and reduce parameters with RO-RO (Receive Object, Return Object) pattern, declaring types for inputs and outputs.",
    "Maintain a single level of abstraction within functions.",

    // Data
    "Avoid overusing primitive types; encapsulate data in composite types with internal validation instead of validating in functions.",
    "Prefer immutability: use 'readonly' for unchanging data and 'as const' for literals.",

    // Classes
    "Follow SOLID principles, prefer composition over inheritance, and declare interfaces to define contracts.",
    "Write small classes with a single purpose: less than 200 instructions, 10 public methods, and 10 properties.",

    // Exceptions
    "Use exceptions for unexpected errors. Catch exceptions only to fix expected issues or add context; otherwise, rely on a global handler.",

    // Flutter-Specific Guidelines - Basic Principles
    "Use clean architecture: organize code into modules, controllers, services, repositories, and entities as needed.",
    "Implement the repository pattern for data persistence, incorporating caching where appropriate.",
    "Use the controller pattern for business logic with Riverpod, ensuring controllers take methods as input to update UI state.",
    "Manage state with Riverpod, using 'keepAlive' for persistent state.",
    "Use 'freezed' to manage UI states effectively.",
    "Manage dependencies with 'getIt': use singleton for services/repositories, factory for use cases, and lazy singleton for controllers.",
    "Use 'AutoRoute' for route management and pass data between pages using extras.",
    "Use extensions for reusable code, 'ThemeData' for themes, 'AppLocalizations' for translations, and constants for fixed values.",
    "Avoid deeply nested widget trees: break down complex widgets into smaller, reusable components to improve readability, maintainability, and performance.",
    "Use 'const' constructors wherever possible to reduce rebuilds and optimize performance.",
    "Keep state local to widgets or subtrees when possible to minimize unnecessary rebuilds and simplify state management.",
    "Adhere to platform-specific design: Material Design for Android and Cupertino for iOS.",
    "Ensure responsiveness with flexible layouts (e.g., 'Expanded', 'Flexible', 'MediaQuery').",
    "Implement accessibility features, such as semantic labels and proper focus management.",

    // Testing
    "Follow the Arrange-Act-Assert convention for unit and widget tests, naming variables clearly (e.g., inputX, mockX, actualX, expectedX).",
    "Write unit tests for each public function, using test doubles for dependencies (except inexpensive third-party ones).",
    "Use 'flutter_test' for widget tests to verify UI components.",
    "Write acceptance tests for each module using the Given-When-Then convention.",
    "Implement integration tests for each API module to ensure end-to-end functionality.",

    // Error Handling and Debugging
    "Implement global error handling with 'FlutterError.onError' to catch and log unhandled exceptions.",
    "Use 'try-catch' blocks for asynchronous operations to handle errors gracefully and prevent crashes.",
    "Log errors and exceptions using 'dart:developer' or third-party logging frameworks.",

    // Deployment and CI/CD
    "Set up CI/CD pipelines with tools like GitHub Actions, Codemagic, or Bitrise to automate testing, building, and deployment.",
    "Use 'flutter build' commands for release builds (e.g., 'flutter build apk' for Android, 'flutter build ios' for iOS).",
    "Manage app versions and build numbers consistently, adhering to semantic versioning.",
    "Test on multiple devices, emulators, and simulators to ensure compatibility and catch platform-specific issues."

To bierze pod uwagę te moje poprzenie i @pawel-twardziak z https://cursor.directory/flutter-cursor-rules