chore: add code style improvements

Closes #86

Author: rafamizes

CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - minor changes in the README file.
+- code style improvements —
+  [86](https://github.com/dartoos-dev/json_cache/issues/86).
 
 ### Fixed
 

lib/src/json_cache_fake.dart

@@ -6,10 +6,10 @@ import 'package:json_cache/json_cache.dart';
 ///
 /// **Warning**: do not use it in production code. It is not thread-safe.
 class JsonCacheFake implements JsonCache {
-  /// It will share a static memory with other instances.
+  /// Shares a static memory with other instances.
   JsonCacheFake() : this.mem(_shrMem);
 
-  /// Initializes the cache with [init] — by performing a deep copy.
+  /// Initializes the cache with [init] by performing a deep copy.
   JsonCacheFake.init(Map<String, Map<String, dynamic>?> init)
       : this.mem(Map<String, Map<String, dynamic>?>.of(init));
 
@@ -19,9 +19,9 @@ class JsonCacheFake implements JsonCache {
   /// in-memory storage.
   final Map<String, Map<String, dynamic>?> _memory;
 
-  static late final Map<String, Map<String, dynamic>?> _shrMem = {};
+  static final Map<String, Map<String, dynamic>?> _shrMem = {};
 
-  /// Clears the internal map.
+  /// Clears its internal in-memory storage.
   @override
   Future<void> clear() async => _memory.clear();
 
@@ -34,7 +34,7 @@ class JsonCacheFake implements JsonCache {
   @override
   Future<void> remove(String key) async => _memory.remove(key);
 
-  /// Retrieves a copy of the data at [key] or null if there is no data.
+  /// Retrieves a copy of the data at [key] or `null` if there is no data.
   @override
   Future<Map<String, dynamic>?> value(String key) async {
     final cached = _memory[key];

lib/src/json_cache_hollow.dart

@@ -33,7 +33,5 @@ class JsonCacheHollow implements JsonCache {
 
   /// Always returns null.
   @override
-  Future<Map<String, dynamic>?> value(String key) async {
-    return null;
-  }
+  Future<Map<String, dynamic>?> value(String key) async => null;
 }

lib/src/json_cache_mem.dart

@@ -16,12 +16,12 @@ typedef OnInitError = FutureOr<Null> Function(Object, StackTrace);
 class JsonCacheMem implements JsonCache {
   /// In-memory level1 cache with an optional level2 instance.
   ///
-  /// ATTENTION: if you do not pass an object to the parameter [level2], the
-  /// data will remain cached in-memory only; that is, no data will be persited
-  /// to the user's device's local storage area. Indeed, not persisting data on
-  /// the user's device might be the desired behavior if you are at the
-  /// prototyping or mocking phase. However, its unlikely to be the right
-  /// behavior in production code.
+  /// **Note**: if you do not pass an object to the parameter [level2], the data
+  /// will remain cached in-memory only; that is, no data will be persited to
+  /// the user's device's local storage area. Indeed, not persisting data on the
+  /// user's device might be the desired behavior if you are at the prototyping
+  /// or mocking phase. However, its unlikely to be the right behavior in
+  /// production code.
   JsonCacheMem([JsonCache? level2])
       : this.mem(_shrMem, level2: level2, mutex: _shrMutex);
 
@@ -73,14 +73,14 @@ class JsonCacheMem implements JsonCache {
     Map<String, Map<String, dynamic>?> mem, {
     JsonCache? level2,
     ReadWriteMutex? mutex,
-  })  : _level2 = level2 ?? const JsonCacheHollow(),
-        _memory = mem,
+  })  : _memory = mem,
+        _level2 = level2 ?? const JsonCacheHollow(),
         _mutex = mutex ?? ReadWriteMutex();
 
   /// Slower cache level.
   final JsonCache _level2;
 
-  /// in-memory storage.
+  /// In-memory storage.
   final Map<String, Map<String, dynamic>?> _memory;
 
   /// Mutex lock-guard.
@@ -135,8 +135,9 @@ class JsonCacheMem implements JsonCache {
   Future<Map<String, dynamic>?> value(String key) {
     return _mutex.protectRead(() async {
       final cachedL1 = _memory[key];
-      if (cachedL1 != null) return Map<String, dynamic>.of(cachedL1);
-
+      if (cachedL1 != null) {
+        return Map<String, dynamic>.of(cachedL1);
+      }
       final cachedL2 = await _level2.value(key);
       if (cachedL2 != null) {
         _memory[key] = cachedL2;

lib/src/json_cache_wrap.dart

@@ -1,6 +1,6 @@
 import 'package:json_cache/json_cache.dart';
 
-///  Decorator Envelope of [JsonCache].
+/// Decorator Envelope of [JsonCache].
 ///
 /// It just forwards method calls to its encapsulated [JsonCache] instance.
 abstract class JsonCacheWrap implements JsonCache {