ms_map_utils

Description:

ms map utils

Overview #






A simple lib to increase Map with useful functions
Whats MS_Map_Utils do #
Add useful functions to map:

compact remove all MapEntries that's values is null it's recursive too.
containsKeys check if map contains all keys of list.
diff returns a new map contend only difference between maps.
doIfContains do some work if map contains a key.
listCombine creates an Map by using one array for keys and another for its values
putIfAbsentAsync put an item if absent or return existent value async.
reduce iterate all items in Map for reduce to a unique value returned from callback ReduceFunction .
removeKeysExcept remove all entries that NOT contains a key in list.
removeKeys remove all entries that contains a key in list.
trim trim all Strings in a map it's recursive.

Usage #
Just import lib and use extensions, call the functions to starts work:
// Don't forget to import
import 'package:ms_map_utils/ms_map_utils.dart';

Map itsAMap = {'key1' : null, 'key2' : 'just a String'};
compact(itsAMap); // Output: {'key2':'just a String'}
// or using extensions.
itsAMap.compact(); // Output: {'key2':'just a String'}
copied to clipboard
compact #
The function compact remove all MapEntries that's values is null it's recursive.
test('Must return a new empty HashMap without null values', () {
var mapWithNullValues = {
'k1': null,
'k2': null,
'k3': null,
'map': {
'k1': null,
'k2': null,
'k3': null,
},
'list': [
{
'k1': null,
'k2': null,
'k3': null,
},
{
'k1': null,
'k2': null,
'k3': null,
},
]
};
var mapWithoutNull = compact(mapWithNullValues);
expect(mapWithoutNull, {
'map': {},
'list': [{}, {}]
});
});
copied to clipboard
see more in test file.
containsKeys #
The function containsKeys check if map contains all keys of list.
test('Must return true if contains a list of keys', () {
var listOfKeyToCheck = ['key1', 'key2'];
var mapToCheck = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'};
expect(mapToCheck.containsKeys(listOfKeyToCheck), isTrue);
});
copied to clipboard
see more in test file.
diff #
The function diff returns a new map contend only difference between maps
test(
'must return a new map with differences in values with differences is in nested map',
() {
var fromMap = {
'key1': 'value1',
'nestedMap': {'key2': 'value2', 'key3': 'value3'},
'otherNestedMap': {'randomKey': []}
};
var toMap = {
'key1': 'value1',
'nestedMap': {'key2': 123, 'key3': 'value3'},
'otherNestedMap': 'random value'
};
expect(diff(fromMap, toMap), {
'nestedMap': {'key2': 123},
'otherNestedMap': 'random value'
});
});
copied to clipboard
see more in test file.
doIfContains #
The function doIfContains will be call a callback function if the map contains a key ou else it will be a callback function elseIf if elseIf is null, null will return.
test('must return a object if contains a key', () {
final testMap = {'key1': 'value1', 'key2': 'value2'};
final newThing = doIfContains<List<String>>(testMap, 'key2',
doWork: (key, value) =>
[value.toString(), 'new awesome thing', key.toString()],
elseIf: () => ['nothing']);
expect(newThing, ['value2', 'new awesome thing', 'key2']);
});
copied to clipboard
see more in test file.
listCombine #
The function listCombine creates an Map by using one array for keys and another for its values.
test('combine two list as map', () {
final keys = ['red', 'green', 'blue', 'white', 'black'];
final values = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFFFF, 0x000000];
final newMap = listCombine<String, int>(keys, values);
expect(newMap is Map<String, int>, isTrue);
expect({
'red': 0xFF0000,
'green': 0x00FF00,
'blue': 0x0000FF,
'white': 0xFFFFFF,
'black': 0x000000,
}, newMap);
});
copied to clipboard
see more in test file.
putIfAbsentAsync #
The function putIfAbsentAsync put an item if absent or return existent value async.
test('Call async function for empty map', () async {
var emptyMap = <String, String>{};
expect(emptyMap.containsKey('test'), isFalse);
var item = await emptyMap.putIfAbsentAsync('test', () async {
await Future.delayed(Duration(milliseconds: 1500));
return 'Random String';
});
expect(emptyMap, isNotEmpty);
expect(emptyMap.containsKey('test'), isTrue);
expect(item, 'Random String');
});
copied to clipboard
see more in test file.
reduce #
The function reduce iterate all items in Map for reduce to a unique value returned from callback ReduceFunction .
test('Multiplies all int values to 120', () {
Map mapNumbers = <String, int>{
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
'key5': 5,
};
var value = mapNumbers
.reduce<int>((int acc, _, value) => (acc ?? 1) * (value as int));
expect(value, 120, reason: 'Value reduced must be 120');
});
copied to clipboard
see more in test file.
removeKeys #
The function removeKeys remove all entries that contains a key in list.
test('Remove all entries that has a key in list with recursive', () {
Map mapNumbers = {
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
'key5': 5,
'map': {
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
'key5': 5,
}
};
mapNumbers.removeKeys(['key1', 'key2'], true);
expect(mapNumbers.length, 4);
expect(mapNumbers['map'].length, 3);
});
copied to clipboard
see more in test file.
removeKeysExcept #
The function removeKeysExcept remove all entries that NOT contains a key in list.
test('Remove all entries that has a key NOT in list with recursive', () {
Map mapNumbers = {
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
'key5': 5,
'map': {
'key1': 1,
'key2': 2,
'key3': 3,
'key4': 4,
'key5': 5,
}
};
mapNumbers.removeKeysExcept(['key1', 'key2', 'map'], true);
expect(mapNumbers.length, 3);
expect(mapNumbers['map'].length, 2);
});
copied to clipboard
see more in test file.
trim #
The function trim all Strings in a map it's recursive.
test('Most trim any Strings values', () {
const mapToTrim = {
'key1': ' random string ',
'key2': ' another random string ',
'key3': 321
};
expect(mapToTrim.trim(true), {
'key1': 'random string',
'key2': 'another random string',
'key3': 321
});
});
copied to clipboard
see more in test file.
See another libs here