feat: JsonCacheCrossLocalStorage class

* feat: JsonCacheCrossLocalStorage class

* doc(README): remove unnecessary comma

Author: rafamizes

CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- JsonCacheCrossLocalStorage: implementation on top of the cross_local_storage
+  package — [32](https://github.com/dartoos-dev/json_cache/issues/32).
+
 ### Changed
 
 - several fixes and improvements to documentation.

README.md

@@ -25,6 +25,7 @@ Rultor.com](https://www.rultor.com/b/dartoos-dev/json_cache)](https://www.rultor
   - [JsonCacheMem — Thread-safe In-memory cache](#jsoncachemem)
   - [JsonCachePrefs — SharedPreferences](#jsoncacheprefs)
   - [JsonCacheLocalStorage — LocalStorage](#jsoncachelocalstorage)
+  - [JsonCacheCrossLocalStorage — CrossLocalStorage](#jsoncachecrosslocalstorage)
 - [Demo application](#demo-application)
 - [References](#references)
 
@@ -39,13 +40,13 @@ Rultor.com](https://www.rultor.com/b/dartoos-dev/json_cache)](https://www.rultor
 > Retrieved 09:55, August 22,
 > 2021](https://en.wikipedia.org/wiki/Cache_(computing))
 
-**JsonCache** is an object-oriented package to cache user data locally in json.
-It can also be thought of as a layer on top of Flutter's local storage packages
-like the [sharable_preferences](https://pub.dev/packages/shared_preferences) and
-[localstorage](https://pub.dev/packages/localstorage) packages.
-
-Therefore, this package aims to unify most of Flutter's local caching packages
-into an elegant caching API.
+**JsonCache** is an object-oriented package for the local caching of user data
+in json. It can also be thought of as a layer on top of Flutter's local storage
+packages like the
+[sharable_preferences](https://pub.dev/packages/shared_preferences) and
+[localstorage](https://pub.dev/packages/localstorage) packages. Thus, this
+package aims to unify most of Flutter's local caching packages into a stable and
+elegant caching API.
 
 **Why Json?**
 
@@ -181,7 +182,7 @@ is an implementation on top of the
 
 [JsonCacheLocalStorage](https://pub.dev/documentation/json_cache/latest/json_cache/JsonCacheLocalStorage-class.html)
 is an implementation on top of the
-[localstorage](https://pub.dev/packages/localstorage)
+[localstorage](https://pub.dev/packages/localstorage) package.
 
 ```dart
   …
@@ -190,6 +191,19 @@ is an implementation on top of the
   …
 ```
 
+### JsonCacheCrossLocalStorage
+
+[JsonCacheLocalCrossStorage](https://pub.dev/documentation/json_cache/latest/json_cache/JsonCacheCrossLocalStorage-class.html)
+is an implementation on top of the
+[cross_local_storage](https://pub.dev/packages/cross_local_storage) package.
+
+```dart
+  …
+  final LocalStorageInterface prefs = await LocalStorage.getInstance();
+  final JsonCache jsonCache = JsonCacheMem(JsonCacheCrossLocalStorage(prefs));
+  …
+```
+
 ## Demo application
 
 The demo application provides a fully working example, focused on demonstrating

lib/json_cache.dart

@@ -2,6 +2,7 @@
 library json_cache;
 
 export 'src/json_cache.dart';
+export 'src/json_cache_cross_local_storage.dart';
 export 'src/json_cache_fake.dart';
 export 'src/json_cache_hollow.dart';
 export 'src/json_cache_local_storage.dart';

lib/src/json_cache_cross_local_storage.dart

@@ -0,0 +1,47 @@
+import 'dart:convert';
+
+import 'package:cross_local_storage/cross_local_storage.dart';
+
+import 'json_cache.dart';
+
+/// [JsonCache] on top of the Cross Local Storage package.
+///
+/// See:
+/// - [cross local storage](https://pub.dev/packages/cross_local_storage)
+class JsonCacheCrossLocalStorage implements JsonCache {
+  /// Ctor.
+  JsonCacheCrossLocalStorage(this._prefs);
+
+  final LocalStorageInterface _prefs;
+
+  /// Clears user preferences.
+  @override
+  Future<void> clear() async {
+    await _prefs.clear();
+  }
+
+  /// Removes an entry located at [key] from persistence storage
+  @override
+  Future<void> remove(String key) async {
+    await _prefs.remove(key);
+  }
+
+  /// Writes [value] to persistence storage.
+  ///
+  /// **Note**: [value] must be json encodable — `json.encode()` is called under
+  /// the hood.
+  @override
+  Future<void> refresh(String key, Map<String, dynamic> value) async {
+    await _prefs.setString(key, json.encode(value));
+  }
+
+  /// The value at [key] from the preferences file; it returns null if a cache
+  /// miss occurs.
+  @override
+  Future<Map<String, dynamic>?> value(String key) async {
+    final strJson = _prefs.getString(key);
+    return strJson == null
+        ? null
+        : json.decode(strJson) as Map<String, dynamic>;
+  }
+}

test/json_cache_cross_local_storage_test.dart

@@ -0,0 +1,51 @@
+import 'package:cross_local_storage/cross_local_storage.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:json_cache/json_cache.dart';
+
+void main() {
+  group('JsonCacheCrossLocalStorage', () {
+    test('clear, recover and refresh', () async {
+      final prefs = await LocalStorage.getInstance();
+      const profKey = 'profile';
+      const profData = <String, Object>{'id': 1, 'name': 'John Due'};
+      final JsonCacheCrossLocalStorage crossCache =
+          JsonCacheCrossLocalStorage(prefs);
+      await crossCache.refresh(profKey, profData);
+      var prof = await crossCache.value(profKey);
+      expect(prof, profData);
+      await crossCache.clear();
+      prof = await crossCache.value(profKey);
+      expect(prof, isNull);
+      await prefs.clear();
+    });
+
+    test('remove', () async {
+      final prefs = await LocalStorage.getInstance();
+      const profKey = 'profile';
+      const prefKey = 'preferences';
+      final profData = <String, Object>{'id': 1, 'name': 'John Due'};
+      final prefData = <String, Object>{
+        'theme': 'dark',
+        'notifications': {'enabled': true}
+      };
+      final JsonCacheCrossLocalStorage crossCache =
+          JsonCacheCrossLocalStorage(prefs);
+      await crossCache.refresh(profKey, profData);
+      await crossCache.refresh(prefKey, prefData);
+
+      var prof = await crossCache.value(profKey);
+      expect(prof, profData);
+
+      await crossCache.remove(profKey);
+      prof = await crossCache.value(profKey);
+      expect(prof, isNull);
+
+      var pref = await crossCache.value(prefKey);
+      expect(pref, prefData);
+      await crossCache.remove(prefKey);
+      pref = await crossCache.value(prefKey);
+      expect(pref, isNull);
+      await prefs.clear();
+    });
+  });
+}