Task: Add async support and functions for configurable and add tests for async testing and updated the functions with default

CHANGELOG.md

@@ -22,4 +22,8 @@
 
 ## 1.0.5
 - Fixed simple provider for final configs variable
-- Fixed setAll function that set itself, in simple provider
+- Fixed setAll function that set itself, in simple provider
+
+## 1.0.6
+- Add async function support
+- Add functions for set and remove for system config and file functions

README.md

@@ -8,9 +8,13 @@
 - [x] Support functions (getConfig, getConfigOrNull, hasConfigKey, setConfig)
 - [x] Support nullsafety (dart 2.12.2+)
 - [x] Custom configuration provider
+- [x] Add Async functions support
 
 # Issue
-- Flutter app not support for dotenv (.env) when run on devices
+- Flutter app not support for dotenv (.env) when run on devices (because of runtime in device)
+
+# Resolution
+- Flutter app can be use persistence storage like SharedPreference or FlutterSecureStorage to implement the configuration provider
 
 # Example
 

example/example_flutter_secure_storage_provider.dart

@@ -0,0 +1,90 @@
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:configurable/mutable_configurable_provider.dart';
+
+class LocalStorageProvider
+    extends MutableConfigurationProvider  {
+  static FlutterSecureStorage _storage;
+
+  FlutterSecureStorage _getStorage() {
+    if (_storage == null) {
+      _storage = new FlutterSecureStorage();
+    }
+
+    return _storage;
+  }
+
+  @override
+  bool containsKey(String key) {
+    var _hasKey = false;
+    _getStorage().containsKey(key: key).then((value) => _hasKey = value);
+
+    return _hasKey;
+  }
+
+  @override
+  Future<bool> containsKeyAsync(String key) async {
+    return await _getStorage().containsKey(key: key);
+  }
+
+  @override
+  String? getOrNull(String key, {String defaultValue}) {
+    String _value;
+    _getStorage().read(key: key).then((value) => {
+      _value = value
+    });
+
+    if (_value == null && defaultValue != null) {
+      return defaultValue;
+    } else {
+      return _value;
+    }
+  }
+
+  @override
+  Future<String?> getOrNullAsync(String key, {String defaultValue}) async {
+    String _value = await _getStorage().read(key: key);
+
+    if (_value == null && defaultValue != null) {
+      return defaultValue;
+    } else {
+      return _value;
+    }
+  }
+
+  @override
+  void remove(String key) {
+    _getStorage().delete(key: key);
+  }
+
+  @override
+  Future<void> removeAsync(String key) async {
+    await _getStorage().delete(key: key);
+  }
+
+  @override
+  void removeAll() {
+    _getStorage().deleteAll();
+  }
+
+  @override
+  Future<void> removeAllAsync() async {
+    await _getStorage().deleteAll();
+  }
+
+  @override
+  void set(String key, String value) {
+    _getStorage().write(key: key, value: value);
+  }
+
+  @override
+  Future<void> setAsync(String key, String value) async {
+    await _getStorage().write(key: key, value: value);
+  }
+
+  @override
+  Future<void> setAllAsync(Map<String, String> configs) async {
+    configs.entries.forEach((element) {
+      setAsync(element.key, element.value);
+    });
+  }
+}

lib/configurable.dart

@@ -6,6 +6,11 @@ import 'package:configurable/system_config.dart';
 String? getConfigOrNull(String key, {String? defaultValue}) =>
     SystemConfig.getOrNull(key, defaultValue: defaultValue);
 
+/// get config or null from system config in async
+Future<String?> getConfigOrNullAsync(String key,
+        {String? defaultValue}) async =>
+    await SystemConfig.getOrNullAsync(key, defaultValue: defaultValue);
+
 /// get config with non-null from system config
 String getConfig(String key, {String? defaultValue}) =>
     SystemConfig.get(key, defaultValue: defaultValue);
@@ -13,5 +18,20 @@ String getConfig(String key, {String? defaultValue}) =>
 /// check has config key or not from system config
 bool hasConfigkey(String key) => SystemConfig.containsKey(key);
 
-/// set config into memory
+/// check has config key or not from system config in async function
+Future<bool> hasConfigkeyAsync(String key) async =>
+    await SystemConfig.containsKeyAsync(key);
+
+/// set config into memory or custom provider
 void setConfig(String key, String? value) => SystemConfig.set(key, value);
+
+/// set config into memory or custom provider in async function
+Future<void> setConfigAsync(String key, String? value) async =>
+    await SystemConfig.setAsync(key, value);
+
+/// remove config into memory or custom provider
+void removeConfig(String key) => SystemConfig.remove(key);
+
+/// remove config into memory or custom provider in async function
+Future<void> removeConfigAsync(String key) async =>
+    await SystemConfig.removeAsync(key);

lib/configuration_provider.dart

@@ -8,4 +8,14 @@ abstract class ConfigurationProvider {
 
   /// get or null in implemented classes
   String? getOrNull(String key, {String? defaultValue});
+
+  /// check has key or not for async function
+  Future<bool> containsKeyAsync(String key) async {
+    return Future.value(containsKey(key));
+  }
+
+  /// get or null for async function
+  Future<String?> getOrNullAsync(String key, {String? defaultValue}) async {
+    return Future.value(getOrNull(key, defaultValue: defaultValue));
+  }
 }

lib/dotenv_configuration_provider.dart

@@ -5,7 +5,7 @@ import 'package:configurable/dotenv/dotenv.dart' show env, load;
 ///
 /// @author sombochea
 /// @since 1.0.0
-class DotenvConfigurationProvider implements ConfigurationProvider {
+class DotenvConfigurationProvider extends ConfigurationProvider {
   /// default constructor to load the platform environment
   DotenvConfigurationProvider() {
     load();

lib/mutable_configurable_provider.dart

@@ -4,16 +4,42 @@ import 'package:configurable/configuration_provider.dart';
 ///
 /// @author sombochea
 /// @since 1.0.3
-abstract class MutableConfigurationProvider implements ConfigurationProvider {
+abstract class MutableConfigurationProvider extends ConfigurationProvider {
   /// Allow to set the value into config values
   void set(String key, String? value);
 
   /// Allow to set all values into config values
-  void setAll(Map<String, String?> configs);
+  void setAll(Map<String, String?> configs) {
+    configs.forEach((key, value) {
+      set(key, value);
+    });
+  }
 
   /// Allow to remove the key from config values
   void remove(String key);
 
   /// Allow to remove all values from config values
   void removeAll();
+
+  /// Allow to set the value into config values in async function
+  Future<void> setAsync(String key, String? value) async {
+    set(key, value);
+  }
+
+  /// Allow to set all values into config values in async function
+  Future<void> setAllAsync(Map<String, String?> configs) async {
+    configs.forEach((key, value) {
+      setAsync(key, value);
+    });
+  }
+
+  /// Allow to remove the key from config values in async function
+  Future<void> removeAsync(String key) async {
+    remove(key);
+  }
+
+  /// Allow to remove all values from config values in async function
+  Future<void> removeAllAsync() async {
+    removeAll();
+  }
 }

lib/simple_configuration_provider.dart

@@ -4,7 +4,7 @@ import 'package:configurable/mutable_configurable_provider.dart';
 ///
 /// @author sombochea
 /// @since 1.0.0
-class SimpleConfigurationProvider implements MutableConfigurationProvider {
+class SimpleConfigurationProvider extends MutableConfigurationProvider {
   final Map<String, String?> _configs = {};
 
   @override

lib/system_config.dart

@@ -30,8 +30,15 @@ class SystemConfig {
     return getProvider().getOrNull(key, defaultValue: defaultValue);
   }
 
+  static Future<String?> getOrNullAsync(String key, {String? defaultValue}) {
+    return getProvider().getOrNullAsync(key, defaultValue: defaultValue);
+  }
+
   static bool containsKey(String key) => getProvider().containsKey(key);
 
+  static Future<bool> containsKeyAsync(String key) =>
+      getProvider().containsKeyAsync(key);
+
   /// Convert to mutable configuration provider
   static MutableConfigurationProvider _getMutableConfigurationProvider() {
     if (_provider is MutableConfigurationProvider) {
@@ -46,7 +53,31 @@ class SystemConfig {
     _getMutableConfigurationProvider().set(key, value);
   }
 
+  static Future<void> setAsync(String key, String? value) async {
+    await _getMutableConfigurationProvider().setAsync(key, value);
+  }
+
   static void setAll(Map<String, String?> values) {
     _getMutableConfigurationProvider().setAll(values);
   }
+
+  static Future<void> setAllAsync(Map<String, String?> values) async {
+    await _getMutableConfigurationProvider().setAllAsync(values);
+  }
+
+  static void remove(String key) {
+    _getMutableConfigurationProvider().remove(key);
+  }
+
+  static Future<void> removeAsync(String key) async {
+    await _getMutableConfigurationProvider().removeAsync(key);
+  }
+
+  static void removeAll() {
+    _getMutableConfigurationProvider().removeAll();
+  }
+
+  static Future<void> removeAllAsync() async {
+    await _getMutableConfigurationProvider().removeAllAsync();
+  }
 }

pubspec.yaml

@@ -1,6 +1,6 @@
 name: configurable
 description: System Configuration and Dotenv Environment for Dart and Flutter
-version: 1.0.5
+version: 1.0.6
 homepage: https://github.com/CUBETIQ/system-config-dart
 repository: https://github.com/CUBETIQ/system-config-dart.git
 

test/config_async_test.dart

@@ -0,0 +1,70 @@
+import 'package:configurable/configurable.dart'
+    show
+        getConfigOrNullAsync,
+        hasConfigkeyAsync,
+        setConfigAsync,
+        removeConfigAsync;
+import 'package:configurable/simple_configuration_provider.dart';
+import 'package:configurable/system_config.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('get system config by key', () async {
+    var key = 'app.name';
+    var value = 'CUBETIQ';
+
+    // set simple provider
+    SystemConfig.setProvider(SimpleConfigurationProvider());
+
+    var result = await SystemConfig.getOrNullAsync(key, defaultValue: value);
+
+    expect(value, equals(result));
+    expect(value, equals(await SystemConfig.getOrNullAsync(key)));
+  });
+
+  test('get config by key with function', () async {
+    var key = 'app.name';
+    var value = 'CUBETIQ Solution';
+
+    // set simple provider
+    SystemConfig.setProvider(SimpleConfigurationProvider());
+
+    var result = await getConfigOrNullAsync(key, defaultValue: value);
+
+    expect(value, equals(result));
+    expect(true, equals(await hasConfigkeyAsync(key)));
+    expect(value, equals(await getConfigOrNullAsync(key)));
+  });
+
+  test('set config by key and value with function', () async {
+    var key = 'app.name';
+    var value = 'CUBETIQ Solution';
+
+    // set simple provider
+    SystemConfig.setProvider(SimpleConfigurationProvider());
+
+    await setConfigAsync(key, value);
+
+    var result = await getConfigOrNullAsync(key);
+
+    expect(value, equals(result));
+  });
+
+  test('set and then remove config by key and value with function', () async {
+    var key = 'app.name';
+    var value = 'CUBETIQ Solution';
+
+    // set simple provider
+    SystemConfig.setProvider(SimpleConfigurationProvider());
+
+    await setConfigAsync(key, value);
+
+    var result = await getConfigOrNullAsync(key);
+
+    expect(value, equals(result));
+
+    await removeConfigAsync(key);
+
+    expect(null, equals(await getConfigOrNullAsync(key)));
+  });
+}