Merge pull request #14 from anirudhb/null-safety

Migrate to null safety

Author: comigor

CHANGELOG.md

@@ -1,5 +1,8 @@
 # CHANGELOG
 
+## 0.4.0-nullsafety.0
+- Migrate to null safety
+
 ## 0.3.0
 - Improve search results on weighted search to combine scores from all keys
 - Improve search results on single-keyed search, making it consistent with non-weighted search

analysis_options.yaml

@@ -5,9 +5,6 @@ include: package:pedantic/analysis_options.yaml
 analyzer:
   strong-mode:
     implicit-casts: false
-  exclude:
-    - example/**/*.dart
-    - test/**/*.dart
 linter:
   rules:
     - public_member_api_docs

example/pubspec.yaml

@@ -7,6 +7,8 @@ authors:
 environment:
   sdk: '>=2.0.0 <3.0.0'
 
+publish_to: none
+
 dependencies:
   fuzzy:
     path: ../

lib/bitap/bitap.dart

@@ -1,5 +1,4 @@
 import 'package:latinize/latinize.dart';
-
 import '../data/fuzzy_options.dart';
 import 'bitap_pattern_alphabet.dart' as pa;
 import 'bitap_search.dart';
@@ -18,7 +17,7 @@ import 'data/match_index.dart';
 /// work with bitwise operations, which are extremely fast.
 class Bitap {
   /// Instantiates a bitap, given options
-  Bitap(String pattern, {FuzzyOptions options}) : options = options {
+  Bitap(String pattern, {required FuzzyOptions options}) : options = options {
     this.pattern = options.isCaseSensitive ? pattern : pattern.toLowerCase();
     this.pattern =
         options.shouldNormalize ? latinize(this.pattern) : this.pattern;
@@ -31,7 +30,7 @@ class Bitap {
   final FuzzyOptions options;
 
   /// The pattern to search for
-  String pattern;
+  late String pattern;
 
   /// The laphabet derived from the pattern
   Map<String, int> patternAlphabet = {};

lib/bitap/bitap_matched_indices.dart

@@ -2,9 +2,6 @@ import 'data/match_index.dart';
 
 /// Retrieve all matched indexes given a mask and minimum length
 List<MatchIndex> matchedIndices(List<int> matchmask, int minMatchCharLength) {
-  matchmask ??= [];
-  minMatchCharLength ??= 1;
-
   final matchedIndices = <MatchIndex>[];
   var start = -1;
   var end = -1;

lib/bitap/bitap_regex_search.dart

@@ -8,8 +8,6 @@ final Pattern SPECIAL_CHARS_REGEX =
 /// Execute a bitap regex search
 MatchScore bitapRegexSearch(
     String text, String pattern, Pattern tokenSeparator) {
-  tokenSeparator ??= RegExp(r' +');
-
   final regex = RegExp(pattern
       .replaceAll(SPECIAL_CHARS_REGEX, r'\$&')
       .replaceAll(tokenSeparator, '|'));

lib/bitap/data/match_score.dart

@@ -4,8 +4,8 @@ import 'match_index.dart';
 class MatchScore {
   /// Instantiates a match with score and matched locations
   MatchScore({
-    this.score,
-    this.isMatch,
+    required this.score,
+    required this.isMatch,
     this.matchedIndices = const [],
   });
 

lib/data/fuzzy_options.dart

@@ -1,14 +1,12 @@
-import 'package:meta/meta.dart';
-
 import 'result.dart';
 
 /// Represents a weighted getter of an item
 class WeightedKey<T> {
   /// Instantiates it
   WeightedKey({
-    @required this.name,
-    @required this.getter,
-    @required this.weight,
+    required this.name,
+    required this.getter,
+    required this.weight,
   }) : assert(weight > 0, 'Weight should be positive and non-zero');
 
   /// Name of this getter
@@ -23,7 +21,7 @@ class WeightedKey<T> {
   final double weight;
 }
 
-/// Sorter function
+/// Function used to sort results.
 typedef SorterFn<T> = int Function(Result<T> a, Result<T> b);
 
 int _defaultSortFn<T>(Result<T> a, Result<T> b) => a.score.compareTo(b.score);
@@ -39,13 +37,13 @@ class FuzzyOptions<T> {
     this.threshold = 0.6,
     this.maxPatternLength = 32,
     this.isCaseSensitive = false,
-    Pattern tokenSeparator,
-    this.minTokenCharLength = 1,
+    Pattern? tokenSeparator,
     this.findAllMatches = false,
+    this.minTokenCharLength = 1,
     this.minMatchCharLength = 1,
     List<WeightedKey<T>> keys = const [],
     this.shouldSort = true,
-    SorterFn<T> sortFn,
+    SorterFn<T>? sortFn,
     this.tokenize = false,
     this.matchAllTokens = false,
     this.verbose = false,
@@ -113,24 +111,42 @@ class FuzzyOptions<T> {
   /// characters before searching.
   final bool shouldNormalize;
 
-  /// Merge two options instances. Useful for overriding just some options.
-  FuzzyOptions<T> mergeWith(FuzzyOptions<T> options) => FuzzyOptions(
-        location: options?.location ?? location,
-        distance: options?.distance ?? distance,
-        threshold: options?.threshold ?? threshold,
-        maxPatternLength: options?.maxPatternLength ?? maxPatternLength,
-        isCaseSensitive: options?.isCaseSensitive ?? isCaseSensitive,
-        tokenSeparator: options?.tokenSeparator ?? tokenSeparator,
-        minTokenCharLength: options?.minTokenCharLength ?? minTokenCharLength,
-        findAllMatches: options?.findAllMatches ?? findAllMatches,
-        minMatchCharLength: options?.minMatchCharLength ?? minMatchCharLength,
-        keys: options?.keys ?? keys,
-        shouldSort: options?.shouldSort ?? shouldSort,
-        sortFn: options?.sortFn ?? sortFn,
-        tokenize: options?.tokenize ?? tokenize,
-        matchAllTokens: options?.matchAllTokens ?? matchAllTokens,
-        verbose: options?.verbose ?? verbose,
-        shouldNormalize: options?.shouldNormalize ?? shouldNormalize,
+  /// Copy these options with some modifications.
+  FuzzyOptions<T> copyWith({
+    int? location,
+    int? distance,
+    double? threshold,
+    int? maxPatternLength,
+    bool? isCaseSensitive,
+    Pattern? tokenSeparator,
+    bool? findAllMatches,
+    int? minTokenCharLength,
+    int? minMatchCharLength,
+    List<WeightedKey<T>>? keys,
+    bool? shouldSort,
+    SorterFn<T>? sortFn,
+    bool? tokenize,
+    bool? matchAllTokens,
+    bool? verbose,
+    bool? shouldNormalize,
+  }) =>
+      FuzzyOptions(
+        location: location ?? this.location,
+        distance: distance ?? this.distance,
+        threshold: threshold ?? this.threshold,
+        maxPatternLength: maxPatternLength ?? this.maxPatternLength,
+        isCaseSensitive: isCaseSensitive ?? this.isCaseSensitive,
+        tokenSeparator: tokenSeparator ?? this.tokenSeparator,
+        findAllMatches: findAllMatches ?? this.findAllMatches,
+        minTokenCharLength: minTokenCharLength ?? this.minTokenCharLength,
+        minMatchCharLength: minMatchCharLength ?? this.minMatchCharLength,
+        keys: keys ?? this.keys,
+        shouldSort: shouldSort ?? this.shouldSort,
+        sortFn: sortFn ?? this.sortFn,
+        tokenize: tokenize ?? this.tokenize,
+        matchAllTokens: matchAllTokens ?? this.matchAllTokens,
+        verbose: verbose ?? this.verbose,
+        shouldNormalize: shouldNormalize ?? this.shouldNormalize,
       );
 
   static List<WeightedKey<T>> _normalizeWeights<T>(List<WeightedKey<T>> keys) {

lib/data/result.dart

@@ -5,8 +5,8 @@ import '../bitap/data/match_index.dart';
 class Searchers {
   /// Instantiates it
   Searchers({
-    this.tokenSearchers,
-    this.fullSearcher,
+    required this.tokenSearchers,
+    required this.fullSearcher,
   });
 
   /// All searchers, if tokenized
@@ -24,8 +24,8 @@ class Searchers {
 class ResultsAndWeights<T> {
   /// Instantiates it
   ResultsAndWeights({
-    this.results,
-    this.weights,
+    required this.results,
+    required this.weights,
   });
 
   /// The list of results
@@ -39,7 +39,7 @@ class ResultsAndWeights<T> {
 class Result<T> {
   /// Instantiates it
   Result({
-    this.item,
+    required this.item,
     this.matches = const [],
     this.score = 0,
   });
@@ -62,11 +62,11 @@ class ResultDetails<T> {
   /// Instantiates it
   ResultDetails({
     this.key = '',
-    this.arrayIndex,
-    this.value,
-    this.score,
-    this.matchedIndices,
-    this.nScore,
+    required this.arrayIndex,
+    required this.value,
+    required this.score,
+    required this.matchedIndices,
+    this.nScore = 0,
   });
 
   /// Key ([WeightedKey.name]) used to create this

lib/fuzzy.dart

@@ -18,8 +18,8 @@ export 'data/fuzzy_options.dart';
 class Fuzzy<T> {
   /// Instantiates it given a list of strings to look into, and options
   Fuzzy(
-    List<T> list, {
-    FuzzyOptions<T> options,
+    List<T>? list, {
+    FuzzyOptions<T>? options,
   })  : list = list ?? [],
         options = options ?? FuzzyOptions<T>();
 
@@ -117,7 +117,7 @@ class Fuzzy<T> {
         final key = options.keys[j].name;
         final value = options.keys[j].getter(item);
 
-        final weight = 1.0 - options.keys[j].weight ?? 0.0;
+        final weight = 1.0 - options.keys[j].weight;
         weights.update(key, (_) => weight, ifAbsent: () => weight);
 
         _analyze(
@@ -138,18 +138,16 @@ class Fuzzy<T> {
 
   List<Result<T>> _analyze({
     String key = '',
-    String value,
-    T record,
-    int index,
+    required String value,
+    required T record,
+    required int index,
     List<Bitap> tokenSearchers = const [],
-    Bitap fullSearcher,
-    List<Result<T>> results,
-    Map<int, Result<T>> resultMap,
+    required Bitap fullSearcher,
+    List<Result<T>> results = const [],
+    Map<int, Result<T>> resultMap = const {},
   }) {
-    results ??= <Result<T>>[];
-    resultMap ??= <int, Result<T>>{};
     // Check if the texvaluet can be searched
-    if (value == null) {
+    if (value.isEmpty) {
       return [];
     }
 
@@ -282,7 +280,7 @@ class Fuzzy<T> {
 
         // We don't use 0 so that the weight differences don't get zeroed out
         final score = match.score == 0.0 ? 0.001 : match.score;
-        final nScore = score * weight;
+        final nScore = score * (weight ?? 1.0);
 
         match.nScore = nScore;
         currScore *= nScore;