"merge-perf"

Author: KhazP

lib/core/services/diff_calculator.dart

@@ -6,7 +6,42 @@ import 'package:localizer_app_main/data/models/app_settings.dart';
 /// Progress callback for reporting diff calculation progress.
 typedef DiffProgressCallback = void Function(int processed, int total);
 
+/// Cache for string similarity calculations to avoid redundant computation.
+/// This is especially important for Smart Match mode which can have O(n²) comparisons.
+class _SimilarityCache {
+  final Map<String, double> _cache = {};
+  static const int _maxSize = 50000;
+
+  String _makeKey(String a, String b) {
+    // Ensure consistent key regardless of order
+    return a.hashCode < b.hashCode ? '$a\n---\n$b' : '$b\n---\n$a';
+  }
+
+  double? get(String a, String b) => _cache[_makeKey(a, b)];
+
+  void set(String a, String b, double similarity) {
+    if (_cache.length >= _maxSize) {
+      // Clear half the cache when full
+      final keysToRemove = _cache.keys.take(_maxSize ~/ 2).toList();
+      for (final key in keysToRemove) {
+        _cache.remove(key);
+      }
+    }
+    _cache[_makeKey(a, b)] = similarity;
+  }
+
+  void clear() => _cache.clear();
+}
+
 class DiffCalculator {
+  // Similarity cache for avoiding redundant calculations
+  static final _similarityCache = _SimilarityCache();
+
+  /// Clears the similarity cache. Call when starting a new comparison.
+  static void clearCache() {
+    _similarityCache.clear();
+  }
+
   /// Calculates diff between two data maps based on the comparison mode.
   ///
   /// - `Key-based`: Matches entries by key name (traditional approach).
@@ -20,6 +55,9 @@ class DiffCalculator {
     required AppSettings settings,
     DiffProgressCallback? onProgress,
   }) {
+    // Clear cache at start of new comparison
+    _similarityCache.clear();
+
     final mode = settings.comparisonMode;
 
     switch (mode) {
@@ -214,6 +252,7 @@ class DiffCalculator {
         .toList();
 
     // Phase 3: Try to match by value similarity (detect renames)
+    // Uses cached similarity to avoid O(n²) redundant calculations
     final usedKeys2 = <String>{};
     for (final key1 in unmatchedKeys1) {
       String? value1 =
@@ -227,7 +266,8 @@ class DiffCalculator {
             _normalizeValue(targetData[key2], ignoreCase, ignoreWhitespace);
 
         if (value1 != null && value2 != null) {
-          final similarity = value1.similarityTo(value2);
+          // Use cached similarity calculation
+          final similarity = _getCachedSimilarity(value1, value2);
           if (similarity >= similarityThreshold &&
               similarity > bestSimilarity) {
             bestSimilarity = similarity;
@@ -292,10 +332,24 @@ class DiffCalculator {
     } else if (value1 != null && value2 == null) {
       return ComparisonStatusDetail.removed();
     } else if (value1 != value2) {
-      final similarityScore = value1!.similarityTo(value2!);
+      final similarityScore = _getCachedSimilarity(value1!, value2!);
       return ComparisonStatusDetail.modified(similarityScore);
     } else {
       return ComparisonStatusDetail.identical();
     }
   }
+
+  /// Gets similarity score with caching to avoid redundant calculations.
+  static double _getCachedSimilarity(String value1, String value2) {
+    // Check cache first
+    final cached = _similarityCache.get(value1, value2);
+    if (cached != null) {
+      return cached;
+    }
+
+    // Calculate and cache
+    final similarity = value1.similarityTo(value2);
+    _similarityCache.set(value1, value2, similarity);
+    return similarity;
+  }
 }

lib/core/services/file_cache_service.dart

@@ -1,19 +1,30 @@
 import 'dart:io';
+import 'dart:collection';
 
 class _CachedFile {
   final Map<String, String> data;
   final DateTime modifiedTime;
+  DateTime lastAccessed;
 
-  _CachedFile(this.data, this.modifiedTime);
+  _CachedFile(this.data, this.modifiedTime) : lastAccessed = DateTime.now();
+
+  void touch() {
+    lastAccessed = DateTime.now();
+  }
 }
 
+/// File cache service with LRU eviction policy.
+///
+/// Caches parsed file data to avoid re-parsing unchanged files.
+/// Uses LRU (Least Recently Used) eviction when cache is full.
 class FileCacheService {
   static final FileCacheService _instance = FileCacheService._internal();
   factory FileCacheService() => _instance;
   FileCacheService._internal();
 
-  final Map<String, _CachedFile> _cache = {};
-  static const int _maxCacheSize = 10;
+  // LinkedHashMap maintains insertion order for efficient LRU
+  final LinkedHashMap<String, _CachedFile> _cache = LinkedHashMap();
+  static const int _maxCacheSize = 50; // Increased from 10 for better hit rate
 
   Future<Map<String, String>?> getCached(File file, {String? keySuffix}) async {
     final key = file.path + (keySuffix ?? '');
@@ -29,6 +40,10 @@ class FileCacheService {
       final stat = await file.stat();
       // Truncate to seconds for safety
       if (stat.modified.difference(cached.modifiedTime).abs().inSeconds < 2) {
+        // Move to end (most recently used) for LRU
+        _cache.remove(key);
+        cached.touch();
+        _cache[key] = cached;
         return cached.data;
       }
     } catch (e) {
@@ -41,15 +56,26 @@ class FileCacheService {
 
   void cache(File file, Map<String, String> data, DateTime modifiedTime,
       {String? keySuffix}) {
-    // Evict oldest if full
-    if (_cache.length >= _maxCacheSize) {
+    final key = file.path + (keySuffix ?? '');
+
+    // If key exists, remove it first to update position
+    _cache.remove(key);
+
+    // Evict LRU entries if full (remove from front)
+    while (_cache.length >= _maxCacheSize) {
       _cache.remove(_cache.keys.first);
     }
-    final key = file.path + (keySuffix ?? '');
+
     _cache[key] = _CachedFile(data, modifiedTime);
   }
 
   void clear() {
     _cache.clear();
   }
+
+  /// Returns cache statistics for debugging
+  Map<String, dynamic> get stats => {
+        'size': _cache.length,
+        'maxSize': _maxCacheSize,
+      };
 }

lib/core/utils/diff_utils.dart

@@ -4,9 +4,46 @@ import 'package:diff_match_patch/diff_match_patch.dart';
 enum DiffRenderMode { unified, sourceOnly, targetOnly }
 
 /// Utility for calculating and rendering granular diffs.
+///
+/// Includes caching of diff calculations to avoid redundant computation
+/// when the same text pairs are compared multiple times (e.g., during scrolling).
 class DiffUtils {
   static final _dmp = DiffMatchPatch();
 
+  // Cache for diff results to avoid recomputation during scrolling/rebuilds
+  static final Map<String, List<Diff>> _diffCache = {};
+  static const int _maxCacheSize = 1000;
+
+  /// Clears the diff cache. Call when comparison data changes.
+  static void clearCache() {
+    _diffCache.clear();
+  }
+
+  /// Gets or computes diffs between two texts with caching.
+  static List<Diff> _getCachedDiffs(String text1, String text2) {
+    final cacheKey = '$text1\n---DIFF---\n$text2';
+
+    final cached = _diffCache[cacheKey];
+    if (cached != null) {
+      return cached;
+    }
+
+    final diffs = _dmp.diff(text1, text2);
+    _dmp.diffCleanupSemantic(diffs);
+
+    // Manage cache size with simple eviction
+    if (_diffCache.length >= _maxCacheSize) {
+      // Remove oldest entries (first 200)
+      final keysToRemove = _diffCache.keys.take(200).toList();
+      for (final key in keysToRemove) {
+        _diffCache.remove(key);
+      }
+    }
+
+    _diffCache[cacheKey] = diffs;
+    return diffs;
+  }
+
   /// Calculates the difference between [text1] (old) and [text2] (new)
   /// and returns a list of [TextSpan]s for rendering.
   static List<TextSpan> getDiffSpans({
@@ -36,8 +73,7 @@ class DiffUtils {
       return [TextSpan(text: text2, style: baseStyle)];
     }
 
-    final diffs = _dmp.diff(text1, text2);
-    _dmp.diffCleanupSemantic(diffs);
+    final diffs = _getCachedDiffs(text1, text2);
 
     final spans = <TextSpan>[];
     final addColor = addedColor ?? Colors.green.withValues(alpha: 0.25);
@@ -56,7 +92,6 @@ class DiffUtils {
                 style: baseStyle.copyWith(
                   backgroundColor: addColor,
                   fontWeight: FontWeight.bold,
-                  // If unified, maybe underline?
                 ),
               ),
             );
@@ -70,8 +105,7 @@ class DiffUtils {
                 style: baseStyle.copyWith(
                   backgroundColor: delColor,
                   decoration: TextDecoration.lineThrough,
-                  // Make deleted text slightly lighter
-                  color: baseStyle.color?.withOpacity(0.7),
+                  color: baseStyle.color?.withValues(alpha: 0.7),
                 ),
               ),
             );

lib/data/cache/translation_cache.dart

@@ -1,4 +1,5 @@
 // TODO: Implement with Hive for local persistence
+import 'dart:collection';
 import 'package:flutter/foundation.dart';
 
 abstract class TranslationCache {
@@ -9,38 +10,58 @@ abstract class TranslationCache {
   Future<void> clearCache();
 }
 
+/// In-memory translation cache with LRU eviction.
+///
+/// Caches translation results to avoid redundant API calls.
+/// Uses LRU (Least Recently Used) eviction when cache is full.
 class LocalTranslationCache implements TranslationCache {
-  // This will use Hive for storage.
-  // For MVP, we can use a simple in-memory map or return null.
-  final Map<String, String> _cache =
-      {}; // Key: "sourceLang:targetLang:sourceText"
+  // LinkedHashMap maintains insertion order for efficient LRU
+  final LinkedHashMap<String, String> _cache = LinkedHashMap();
+
+  /// Maximum number of cached translations (prevents unbounded memory growth)
+  static const int _maxCacheSize = 5000;
 
   @override
   Future<String?> getCachedTranslation(
       String sourceText, String sourceLang, String targetLang) async {
-    // TODO: Implement Hive retrieval with expiration logic
     final key = '$sourceLang:$targetLang:$sourceText';
     final cached = _cache[key];
     if (cached != null) {
-      debugPrint('Translation found in in-memory cache for key: $key');
-      // TODO: Check timestamp if implementing expiration with in-memory for now
+      // Move to end (most recently used) for LRU
+      _cache.remove(key);
+      _cache[key] = cached;
+      debugPrint('Translation cache hit for: ${key.substring(0, key.length.clamp(0, 50))}...');
     }
     return cached;
   }
 
   @override
   Future<void> cacheTranslation(String sourceText, String sourceLang,
       String targetLang, String translatedText) async {
-    // TODO: Implement Hive storage with timestamp for expiration
     final key = '$sourceLang:$targetLang:$sourceText';
+
+    // Remove if exists to update position
+    _cache.remove(key);
+
+    // Evict LRU entries if full
+    while (_cache.length >= _maxCacheSize) {
+      final oldestKey = _cache.keys.first;
+      _cache.remove(oldestKey);
+    }
+
     _cache[key] = translatedText;
-    debugPrint('Translation cached in-memory for key: $key');
+    debugPrint('Translation cached (${_cache.length}/$_maxCacheSize entries)');
   }
 
   @override
   Future<void> clearCache() async {
-    // TODO: Implement Hive clear
     _cache.clear();
-    debugPrint('In-memory translation cache cleared');
+    debugPrint('Translation cache cleared');
   }
+
+  /// Returns cache statistics for debugging
+  Map<String, dynamic> get stats => {
+        'size': _cache.length,
+        'maxSize': _maxCacheSize,
+      };
 }