update: updating support files

packages/support/lib/platform_support.dart

@@ -44,6 +44,7 @@ export 'src/deferred/deferred_callback_collection.dart';
 export 'src/process/executable_finder.dart';
 
 // Traits
+export 'src/traits/capsule_manager.dart';
 export 'src/traits/dumpable.dart';
 export 'src/traits/forwards_calls.dart';
 export 'src/traits/interacts_with_data.dart';

packages/support/lib/src/manager.dart

@@ -0,0 +1,136 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_support/src/fluent.dart';
+
+/// Base class for managing drivers with different implementations.
+///
+/// This class provides a foundation for managing different implementations of a service,
+/// similar to Laravel's Manager class. It handles driver creation, caching, and custom
+/// driver registration.
+abstract class Manager {
+  /// The container instance.
+  final Container container;
+
+  /// The configuration repository instance.
+  final Fluent config;
+
+  /// The registered custom driver creators.
+  final Map<String, dynamic Function(Container)> _customCreators = {};
+
+  /// The array of created "drivers".
+  final Map<String, dynamic> _drivers = {};
+
+  /// Create a new manager instance.
+  ///
+  /// Parameters:
+  ///   - [container]: The container instance to use for resolving dependencies
+  Manager(this.container) : config = container.make<Fluent>();
+
+  /// Get the default driver name.
+  ///
+  /// This method must be implemented by concrete managers to specify which
+  /// driver should be used by default. Returns null if no default driver is set.
+  String? getDefaultDriver();
+
+  /// Get a driver instance.
+  ///
+  /// This method returns an instance of the requested driver. If the driver
+  /// has already been created, it returns the cached instance. Otherwise,
+  /// it creates a new instance.
+  ///
+  /// Parameters:
+  ///   - [driver]: The name of the driver to get. If null, uses default driver.
+  ///
+  /// Returns:
+  ///   The driver instance.
+  ///
+  /// Throws:
+  ///   - [ArgumentError] if no driver name is provided and no default exists
+  T driver<T>([String? driver]) {
+    driver ??= getDefaultDriver();
+
+    if (driver == null) {
+      throw ArgumentError(
+          'Unable to resolve NULL driver for [${runtimeType}].');
+    }
+
+    return _drivers.putIfAbsent(driver, () => createDriver(driver!)) as T;
+  }
+
+  /// Create a new driver instance.
+  ///
+  /// This method creates a new instance of the requested driver. It first checks
+  /// for custom creators, then looks for a create{Driver}Driver method.
+  ///
+  /// Parameters:
+  ///   - [driver]: The name of the driver to create
+  ///
+  /// Returns:
+  ///   The new driver instance
+  ///
+  /// Throws:
+  ///   - [ArgumentError] if the driver is not supported
+  dynamic createDriver(String driver) {
+    // Check for custom creator
+    if (_customCreators.containsKey(driver)) {
+      return _customCreators[driver]!(container);
+    }
+
+    // Look for create{Driver}Driver method
+    var methodName =
+        'create${driver[0].toUpperCase()}${driver.substring(1)}Driver';
+    var result = callDriverCreator(methodName);
+    if (result != null) {
+      return result;
+    }
+
+    throw ArgumentError('Driver [$driver] not supported.');
+  }
+
+  /// Call a driver creator method.
+  ///
+  /// This method must be implemented by concrete managers to handle calling
+  /// the appropriate creator method based on the method name.
+  ///
+  /// Parameters:
+  ///   - [method]: The name of the creator method to call
+  ///
+  /// Returns:
+  ///   The created driver instance, or null if the method doesn't exist
+  dynamic callDriverCreator(String method);
+
+  /// Register a custom driver creator.
+  ///
+  /// This method allows registering custom driver creators that will be used
+  /// instead of the default creation logic.
+  ///
+  /// Parameters:
+  ///   - [driver]: The name of the driver
+  ///   - [creator]: The function that creates the driver
+  ///
+  /// Returns:
+  ///   This manager instance for method chaining
+  Manager extend(String driver, dynamic Function(Container) creator) {
+    _customCreators[driver] = creator;
+    return this;
+  }
+
+  /// Get all of the created drivers.
+  ///
+  /// Returns a map of all driver instances that have been created.
+  Map<String, dynamic> getDrivers() => Map.unmodifiable(_drivers);
+
+  /// Get the container instance used by the manager.
+  Container getContainer() => container;
+
+  /// Forget all of the resolved driver instances.
+  ///
+  /// This method clears the driver cache, forcing new instances to be created
+  /// on next access.
+  ///
+  /// Returns:
+  ///   This manager instance for method chaining
+  Manager forgetDrivers() {
+    _drivers.clear();
+    return this;
+  }
+}

packages/support/lib/src/traits/capsule_manager.dart

@@ -0,0 +1,51 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_support/src/fluent.dart';
+
+/// A mixin that provides capsule management functionality.
+///
+/// This mixin allows classes to manage a global instance and a container instance,
+/// similar to Laravel's CapsuleManagerTrait.
+mixin CapsuleManager {
+  /// The current globally used instance.
+  static dynamic _instance;
+
+  /// The container instance.
+  Container? _container;
+
+  /// Setup the IoC container instance.
+  ///
+  /// This method initializes the container and ensures it has a config binding.
+  /// If no config binding exists, it creates one with an empty [Fluent] instance.
+  void setupContainer(Container container) {
+    _container = container;
+
+    if (!_container!.has<Fluent>()) {
+      _container!.registerSingleton(Fluent(), as: Fluent);
+    }
+  }
+
+  /// Make this capsule instance available globally.
+  ///
+  /// This method sets the current instance as the global instance that can be
+  /// accessed throughout the application.
+  void setAsGlobal() {
+    _instance = this;
+  }
+
+  /// Get the IoC container instance.
+  ///
+  /// Returns the current container instance used by this capsule.
+  Container? getContainer() => _container;
+
+  /// Set the IoC container instance.
+  ///
+  /// This method allows changing the container instance used by this capsule.
+  void setContainer(Container container) {
+    _container = container;
+  }
+
+  /// Get the current globally used instance.
+  ///
+  /// Returns the current global instance of this capsule.
+  static dynamic getInstance() => _instance;
+}

packages/support/lib/src/traits/localizable.dart

@@ -0,0 +1,56 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_support/src/fluent.dart';
+
+/// A mixin that provides localization functionality.
+///
+/// This mixin allows classes to execute code with a specific locale while ensuring
+/// the original locale is restored afterward, similar to Laravel's Localizable trait.
+mixin Localizable {
+  /// Run the callback with the given locale.
+  ///
+  /// This method temporarily changes the application's locale, executes the callback,
+  /// and then restores the original locale. This ensures that the locale change is
+  /// localized to just the callback execution.
+  ///
+  /// If no locale is provided (null), the callback is executed with the current locale.
+  ///
+  /// Parameters:
+  ///   - [locale]: The locale to use during callback execution
+  ///   - [callback]: The function to execute with the specified locale
+  ///
+  /// Returns:
+  ///   The result of executing the callback
+  ///
+  /// Example:
+  /// ```dart
+  /// withLocale('es', () {
+  ///   // Code here runs with Spanish locale
+  ///   return someValue;
+  /// });
+  /// ```
+  T withLocale<T>(String? locale, T Function() callback) {
+    if (locale == null) {
+      return callback();
+    }
+
+    // Get the current locale
+    final config = container.make<Fluent>();
+    final original = config['locale'] as String;
+
+    try {
+      // Set the new locale
+      config['locale'] = locale;
+      return callback();
+    } finally {
+      // Restore the original locale
+      config['locale'] = original;
+    }
+  }
+
+  /// Get the container instance.
+  ///
+  /// This is a helper method to access the container. In a real application,
+  /// you would typically get this from your application's service container.
+  Container get container => throw UnimplementedError(
+      'You must implement the container getter to use Localizable');
+}

packages/support/pubspec.yaml

@@ -18,6 +18,7 @@ dependencies:
   pub_semver: ^2.1.4
   platform_collections: ^1.0.0
   platform_conditionable: ^1.0.0
+  platform_container: ^1.0.0
   platform_contracts: ^1.0.0
   platform_macroable: ^1.0.0
   platform_mirrors: ^1.0.0

packages/support/test/manager_test.dart

@@ -0,0 +1,122 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_container/mirrors.dart';
+import 'package:platform_support/src/fluent.dart';
+import 'package:platform_support/src/manager.dart';
+import 'package:test/test.dart';
+
+// Test driver interface
+abstract class TestDriver {
+  String getName();
+}
+
+// Test driver implementations
+class LocalDriver implements TestDriver {
+  @override
+  String getName() => 'local';
+}
+
+class CloudDriver implements TestDriver {
+  final String region;
+  CloudDriver(this.region);
+  @override
+  String getName() => 'cloud:$region';
+}
+
+// Test manager implementation
+class TestManager extends Manager {
+  TestManager(Container container) : super(container);
+
+  @override
+  String? getDefaultDriver() {
+    var attributes = config.getAttributes();
+    print('Config attributes: $attributes'); // Debug print
+    return config.get('test.driver');
+  }
+
+  @override
+  dynamic callDriverCreator(String method) {
+    print('Creating driver with method: $method'); // Debug print
+    switch (method) {
+      case 'createLocalDriver':
+        return LocalDriver();
+      case 'createCloudDriver':
+        var region = config.get('test.cloud.region', 'us-east-1');
+        return CloudDriver(region);
+      default:
+        return null;
+    }
+  }
+
+  String getName() => driver<TestDriver>().getName();
+}
+
+void main() {
+  group('Manager', () {
+    late Container container;
+    late TestManager manager;
+
+    setUp(() {
+      container = Container(MirrorsReflector());
+      var attributes = {
+        'test': {'driver': 'local'}
+      }; // Nested attributes
+      var config = Fluent(attributes);
+      print('Setting up config with attributes: $attributes'); // Debug print
+      container.registerSingleton<Fluent>(config);
+      manager = TestManager(container);
+    });
+
+    test('uses default driver when no driver specified', () {
+      var driver = manager.driver<TestDriver>();
+      expect(driver.getName(), equals('local'));
+    });
+
+    test('creates driver instance', () {
+      var driver = manager.driver<TestDriver>('local');
+      expect(driver.getName(), equals('local'));
+    });
+
+    test('caches driver instances', () {
+      var driver1 = manager.driver<TestDriver>('local');
+      var driver2 = manager.driver<TestDriver>('local');
+      expect(identical(driver1, driver2), isTrue);
+    });
+
+    test('supports custom driver creators', () {
+      manager.extend('custom', (container) => CloudDriver('custom-region'));
+      var driver = manager.driver<TestDriver>('custom');
+      expect(driver.getName(), equals('cloud:custom-region'));
+    });
+
+    test('throws on unsupported driver', () {
+      expect(
+          () => manager.driver('unsupported'), throwsA(isA<ArgumentError>()));
+    });
+
+    test('throws on null driver with no default', () {
+      // Create new container and manager for this test
+      var testContainer = Container(MirrorsReflector());
+      testContainer.registerSingleton<Fluent>(Fluent());
+      var testManager = TestManager(testContainer);
+      expect(() => testManager.driver(), throwsA(isA<ArgumentError>()));
+    });
+
+    test('forgets cached drivers', () {
+      var driver1 = manager.driver<TestDriver>('local');
+      manager.forgetDrivers();
+      var driver2 = manager.driver<TestDriver>('local');
+      expect(identical(driver1, driver2), isFalse);
+    });
+
+    test('returns unmodifiable driver map', () {
+      manager.driver<TestDriver>('local');
+      var drivers = manager.getDrivers();
+      expect(() => drivers['local'] = LocalDriver(),
+          throwsA(isA<UnsupportedError>()));
+    });
+
+    test('forwards method calls to default driver', () {
+      expect(manager.getName(), equals('local'));
+    });
+  });
+}

packages/support/test/traits/capsule_manager_test.dart

@@ -0,0 +1,41 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_container/mirrors.dart';
+import 'package:platform_support/src/fluent.dart';
+import 'package:platform_support/src/traits/capsule_manager.dart';
+import 'package:test/test.dart';
+
+class TestCapsule with CapsuleManager {}
+
+void main() {
+  group('CapsuleManager', () {
+    late Container container;
+    late TestCapsule capsule;
+
+    setUp(() {
+      container = Container(MirrorsReflector());
+      capsule = TestCapsule();
+    });
+
+    test('can set and get container', () {
+      capsule.setContainer(container);
+      expect(capsule.getContainer(), equals(container));
+    });
+
+    test('setupContainer initializes config if not bound', () {
+      capsule.setupContainer(container);
+      expect(capsule.getContainer()!.make<Fluent>(), isA<Fluent>());
+    });
+
+    test('setupContainer preserves existing config if bound', () {
+      var config = Fluent();
+      container.registerSingleton(config, as: Fluent);
+      capsule.setupContainer(container);
+      expect(capsule.getContainer()!.make<Fluent>(), same(config));
+    });
+
+    test('can set as global instance', () {
+      capsule.setAsGlobal();
+      expect(CapsuleManager.getInstance(), same(capsule));
+    });
+  });
+}

packages/support/test/traits/localizable_test.dart

@@ -0,0 +1,58 @@
+import 'package:platform_container/container.dart';
+import 'package:platform_container/mirrors.dart';
+import 'package:platform_support/src/fluent.dart';
+import 'package:platform_support/src/traits/localizable.dart';
+import 'package:test/test.dart';
+
+class TestLocalizable with Localizable {
+  final Container _container;
+
+  TestLocalizable(this._container);
+
+  @override
+  Container get container => _container;
+}
+
+void main() {
+  group('Localizable', () {
+    late Container container;
+    late TestLocalizable localizable;
+    late Fluent config;
+
+    setUp(() {
+      container = Container(MirrorsReflector());
+      config = Fluent();
+      config['locale'] = 'en';
+      container.registerSingleton(config);
+      localizable = TestLocalizable(container);
+    });
+
+    test('executes callback with given locale', () {
+      var result = localizable.withLocale('es', () {
+        expect(config['locale'], equals('es'));
+        return 'done';
+      });
+      expect(result, equals('done'));
+    });
+
+    test('restores original locale after callback', () {
+      localizable.withLocale('es', () {});
+      expect(config['locale'], equals('en'));
+    });
+
+    test('restores original locale even if callback throws', () {
+      try {
+        localizable.withLocale('es', () => throw Exception('test'));
+      } catch (_) {}
+      expect(config['locale'], equals('en'));
+    });
+
+    test('executes callback with current locale if no locale provided', () {
+      var result = localizable.withLocale(null, () {
+        expect(config['locale'], equals('en'));
+        return 'done';
+      });
+      expect(result, equals('done'));
+    });
+  });
+}