5187986255

Committed 06 Jun 2023 11:28AM UTC coverage: 92.921%. First build

Build # 5187986255

Build Type

Pull #103

github

Committed by

web-flow

Commit Message

Merge 6cb95b449 into 2dbf25209

Pull Request Pull Request #103: Release v4.0.0

Run Details

475 of 475 new or added lines in 17 files covered. (100.0%)

722 of 777 relevant lines covered (92.92%)

2.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.39

/lib/src/persistent_queue.dart

import 'dart:async';
import 'dart:collection';
import 'dart:convert';

import 'package:collection/collection.dart';
import 'package:flutter/foundation.dart';
import 'package:matomo_tracker/src/dispatch_settings.dart';
import 'package:matomo_tracker/src/local_storage/local_storage.dart';

class PersistentQueue extends DelegatingQueue<Map<String, String>> {
  PersistentQueue._(this._storage, Queue<Map<String, String>> base)
      : _needsSave = false,
        super(base);

  static Future<PersistentQueue> load({
    required LocalStorage storage,
    required PersistenceFilter onLoadFilter,
  }) async {
    final actionsData = await storage.loadActions();
    final actions = decode(actionsData)..retainWhere(onLoadFilter);
    final queue = PersistentQueue._(storage, Queue.of(actions));
    await queue.save();
    return queue;
  }

  @visibleForTesting
  static List<Map<String, String>> decode(String? actionsData) {
    if (actionsData != null) {
      return (json.decode(actionsData) as List)
          .cast<Map<String, dynamic>>()
          .map<Map<String, String>>((element) => element.cast())
          .toList();
    } else {
      return [];
    }
  }

  final LocalStorage _storage;
  bool _needsSave;
  Completer<void>? _saveInProgress;
  @visibleForTesting
  bool get saveInProgress => _saveInProgress != null;

  @visibleForTesting
  Future<void> save() {
    _needsSave = true;
    final effectiveSaveInProgress = _saveInProgress ?? Completer<void>();
    if (effectiveSaveInProgress != _saveInProgress) {
      assert(_saveInProgress == null);
      _saveInProgress = effectiveSaveInProgress;
      unawaited(
        Future(() async {
          try {
            while (_needsSave) {
              _needsSave = false;
              final data = json.encode(toList());
              await _storage.storeActions(data);
            }
            effectiveSaveInProgress.complete();
          } catch (error, stackTrace) {
            effectiveSaveInProgress.completeError(error, stackTrace);
          } finally {
            _saveInProgress = null;
          }
        }),
      );
    }
    return effectiveSaveInProgress.future;
  }

  void _unawaitedSave() => unawaited(save());

  @override
  void add(Map<String, String> value) {
    super.add(value);
    _unawaitedSave();
  }

  @override
  void addAll(Iterable<Map<String, String>> iterable) {
    super.addAll(iterable);
    _unawaitedSave();
  }

  @override
  void addFirst(Map<String, String> value) {
    super.addFirst(value);
    _unawaitedSave();
  }

  @override
  void addLast(Map<String, String> value) {
    super.addLast(value);
    _unawaitedSave();
  }

  @override
  void clear() {
    super.clear();
    _unawaitedSave();
  }

  @override
  bool remove(Object? object) {
    final result = super.remove(object);
    _unawaitedSave();
    return result;
  }

  @override
  Map<String, String> removeFirst() {
    final result = super.removeFirst();
    _unawaitedSave();
    return result;
  }

  @override
  Map<String, String> removeLast() {
    final result = super.removeLast();
    _unawaitedSave();
    return result;
  }

  @override
  void removeWhere(bool Function(Map<String, String> element) test) {
    super.removeWhere(test);
    _unawaitedSave();
  }

  @override
  void retainWhere(bool Function(Map<String, String> element) test) {
    super.retainWhere(test);
    _unawaitedSave();
  }
}

1	import 'dart:async';
2	import 'dart:collection';
3	import 'dart:convert';
4
5	import 'package:collection/collection.dart';
6	import 'package:flutter/foundation.dart';
7	import 'package:matomo_tracker/src/dispatch_settings.dart';
8	import 'package:matomo_tracker/src/local_storage/local_storage.dart';
9
10	class PersistentQueue extends DelegatingQueue<Map<String, String>> {
11	PersistentQueue._(this._storage, Queue<Map<String, String>> base)	1✔
12	: _needsSave = false,
13	super(base);	1✔
14
15	static Future<PersistentQueue> load({	1✔
16	required LocalStorage storage,
17	required PersistenceFilter onLoadFilter,
18	}) async {
19	final actionsData = await storage.loadActions();	1✔
20	final actions = decode(actionsData)..retainWhere(onLoadFilter);	2✔
21	final queue = PersistentQueue._(storage, Queue.of(actions));	2✔
22	await queue.save();	1✔
23	return queue;
24	}
25
26	@visibleForTesting	1✔
27	static List<Map<String, String>> decode(String? actionsData) {
28	if (actionsData != null) {
29	return (json.decode(actionsData) as List)	1✔
30	.cast<Map<String, dynamic>>()	1✔
31	.map<Map<String, String>>((element) => element.cast())	3✔
32	.toList();	1✔
33	} else {
34	return [];	1✔
35	}
36	}
37
38	final LocalStorage _storage;
39	bool _needsSave;
40	Completer<void>? _saveInProgress;
41	@visibleForTesting	1✔
42	bool get saveInProgress => _saveInProgress != null;	1✔
43
44	@visibleForTesting	1✔
45	Future<void> save() {
46	_needsSave = true;	1✔
47	final effectiveSaveInProgress = _saveInProgress ?? Completer<void>();	2✔
48	if (effectiveSaveInProgress != _saveInProgress) {	2✔
49	assert(_saveInProgress == null);	1✔
50	_saveInProgress = effectiveSaveInProgress;	1✔
51	unawaited(	1✔
52	Future(() async {	2✔
53	try {
54	while (_needsSave) {	1✔
55	_needsSave = false;	1✔
56	final data = json.encode(toList());	2✔
57	await _storage.storeActions(data);	2✔
58	}
59	effectiveSaveInProgress.complete();	1✔
60	} catch (error, stackTrace) {
61	effectiveSaveInProgress.completeError(error, stackTrace);	×
62	} finally {
63	_saveInProgress = null;	1✔
64	}
65	}),
66	);
67	}
68	return effectiveSaveInProgress.future;	1✔
69	}
70
71	void _unawaitedSave() => unawaited(save());	3✔
72
73	@override	1✔
74	void add(Map<String, String> value) {
75	super.add(value);	1✔
76	_unawaitedSave();	1✔
77	}
78
79	@override	1✔
80	void addAll(Iterable<Map<String, String>> iterable) {
81	super.addAll(iterable);	1✔
82	_unawaitedSave();	1✔
83	}
84
85	@override	1✔
86	void addFirst(Map<String, String> value) {
87	super.addFirst(value);	1✔
88	_unawaitedSave();	1✔
89	}
90
91	@override	1✔
92	void addLast(Map<String, String> value) {
93	super.addLast(value);	1✔
94	_unawaitedSave();	1✔
95	}
96
97	@override	1✔
98	void clear() {
99	super.clear();	1✔
100	_unawaitedSave();	1✔
101	}
102
103	@override	1✔
104	bool remove(Object? object) {
105	final result = super.remove(object);	1✔
106	_unawaitedSave();	1✔
107	return result;
108	}
109
110	@override	1✔
111	Map<String, String> removeFirst() {
112	final result = super.removeFirst();	1✔
113	_unawaitedSave();	1✔
114	return result;
115	}
116
117	@override	1✔
118	Map<String, String> removeLast() {
119	final result = super.removeLast();	1✔
120	_unawaitedSave();	1✔
121	return result;
122	}
123
124	@override	1✔
125	void removeWhere(bool Function(Map<String, String> element) test) {
126	super.removeWhere(test);	1✔
127	_unawaitedSave();	1✔
128	}
129
130	@override	1✔
131	void retainWhere(bool Function(Map<String, String> element) test) {
132	super.retainWhere(test);	1✔
133	_unawaitedSave();	1✔
134	}
135	}

Floating-Dartists / matomo-tracker / 5187986255

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous