Issue248 backspace (akvelon#249)

* wip

* Change from String.getChangedRangeAroundSelection to TextEditingValue.getChangedRange (akvelon#248)

* Clean up (akvelon#248)

---------

Co-authored-by: Darkhan Nausharipov <nausharipov@gmail.com>

Author: alexeyinkin

lib/src/code/code.dart

@@ -5,6 +5,7 @@ import 'package:flutter/material.dart';
 import 'package:highlight/highlight_core.dart';
 
 import '../../src/highlight/result.dart';
+import '../code_field/text_editing_value.dart';
 import '../folding/foldable_block.dart';
 import '../folding/foldable_block_matcher.dart';
 import '../folding/invalid_foldable_block.dart';
@@ -325,7 +326,7 @@ class Code {
     TextSelection oldSelection,
     TextEditingValue visibleAfter,
   ) {
-    final visibleRangeAfter = visibleAfter.text.getChangedRangeAroundSelection(
+    final visibleRangeAfter = visibleAfter.getChangedRange(
           TextEditingValue(text: visibleText, selection: oldSelection),
         ) ??
         visibleAfter.text.getChangedRange(
@@ -385,7 +386,7 @@ class Code {
         foldedBlocks.any(
           (block) =>
               block.lastLine >= firstChangedLine &&
-              block.lastLine <= lastChangedLine,
+              block.lastLine < lastChangedLine,
         )) {
       return CodeEditResult(
         fullTextAfter: text,

lib/src/code/string.dart

@@ -5,41 +5,6 @@ import 'package:flutter/widgets.dart';
 import '../code_field/text_editing_value.dart';
 
 extension StringExtension on String {
-  /// Returns a [TextRange] round selection in [oldValue]
-  /// that is different from this.
-  ///
-  /// This is useful if the ordinary diff with [getChangedRange]
-  /// may be ambiguous. This method tests for the most common changes
-  /// and snaps the changed range to the old selection.
-  ///
-  /// Handles these special cases:
-  /// - Selected text is replaced / deleted / inserted, outside is unchanged.
-  /// - Insertion at a collapsed selection.
-  ///
-  /// Returns null if neither of the above cases apply.
-  TextRange? getChangedRangeAroundSelection(TextEditingValue oldValue) {
-    final oldBefore = oldValue.beforeSelection;
-    final oldAfter = oldValue.afterSelection;
-
-    if (length < oldBefore.length + oldAfter.length) {
-      // The outside of the selection has shortened.
-      // definitely not an above special case.
-      return null;
-    }
-
-    final newBefore = substring(0, oldBefore.length);
-    final newAfter = substring(length - oldAfter.length);
-
-    if (oldBefore == newBefore && oldAfter == newAfter) {
-      return TextRange(
-        start: newBefore.length,
-        end: length - newAfter.length,
-      );
-    }
-
-    return null;
-  }
-
   /// Returns the widest [TextRange] of this that is different from [old].
   ///
   /// `start` refers to the common prefix. It is the first character of this
@@ -55,7 +20,8 @@ extension StringExtension on String {
   ///  - Inserting a duplicate: aBc -> aBBc
   ///  - Deletion of a duplicate: aBBc -> aBc
   ///
-  /// This method should be used if [getChangedRangeAroundSelection] failed.
+  /// This method should be used
+  /// if [TextEditingValueExtension.getChangedRange] failed.
   TextRange getChangedRange(
     String old, {
     required TextAffinity attributeChangeTo,

lib/src/code_field/text_editing_value.dart

@@ -3,6 +3,8 @@ import 'package:flutter/widgets.dart';
 import '../code/reg_exp.dart';
 import '../code/string.dart';
 import '../code/text_range.dart';
+import '../code_field/code_controller.dart';
+import '../util/edit_type.dart';
 import 'text_selection.dart';
 
 extension TextEditingValueExtension on TextEditingValue {
@@ -185,4 +187,73 @@ extension TextEditingValueExtension on TextEditingValue {
       text: text,
     );
   }
+
+  /// Returns the widest [TextRange] of this that is different from [oldValue]
+  /// if it can be produced by any of common edits allowed for user input.
+  /// These are all edits that go through [CodeController.value] setter
+  /// and do not include undo/redo.
+  ///
+  /// Returns null if the change cannot be produced by such user edits.
+  TextRange? getChangedRange(TextEditingValue oldValue) {
+    switch (getEditType(oldValue)) {
+      case EditType.backspaceBeforeCollapsedSelection:
+        return TextRange.collapsed(
+          text.length - oldValue.afterSelection.length,
+        );
+
+      case EditType.deleteSelection:
+      case EditType.deleteAfterCollapsedSelection:
+        return TextRange.collapsed(oldValue.beforeSelection.length);
+
+      case EditType.replaceSelection:
+      case EditType.insertAtCollapsedSelection:
+        return TextRange(
+          start: oldValue.beforeSelection.length,
+          end: text.length - oldValue.afterSelection.length,
+        );
+
+      case EditType.unchanged:
+      case EditType.other:
+        return null;
+    }
+  }
+
+  EditType getEditType(TextEditingValue oldValue) {
+    if (oldValue.text == text) {
+      return EditType.unchanged;
+    }
+
+    final oldBefore = oldValue.beforeSelection;
+    final oldAfter = oldValue.afterSelection;
+    final oldUnselectedLength = oldBefore.length + oldAfter.length;
+
+    if (text.length < oldUnselectedLength) {
+      if (text.startsWith(oldBefore) && selection == oldValue.selection) {
+        return EditType.deleteAfterCollapsedSelection;
+      }
+
+      if (text.endsWith(oldAfter) &&
+          selection.isCollapsed &&
+          selection.start ==
+              text.length - oldValue.text.length + oldValue.selection.start) {
+        return EditType.backspaceBeforeCollapsedSelection;
+      }
+
+      return EditType.other;
+    }
+
+    if (text.startsWith(oldBefore) && text.endsWith(oldAfter)) {
+      if (oldValue.selection.isCollapsed) {
+        return EditType.insertAtCollapsedSelection;
+      }
+
+      if (text.length == oldUnselectedLength) {
+        return EditType.deleteSelection;
+      }
+
+      return EditType.replaceSelection;
+    }
+
+    return EditType.other;
+  }
 }

lib/src/util/edit_type.dart

@@ -0,0 +1,12 @@
+enum EditType {
+  backspaceBeforeCollapsedSelection,
+  deleteAfterCollapsedSelection,
+  deleteSelection,
+  insertAtCollapsedSelection,
+  replaceSelection,
+  unchanged,
+
+  /// A change beyond a user's ability to interact with the editor
+  /// like replacing an unselected text in one action.
+  other,
+}

test/src/code/code_get_edit_result_test.dart

@@ -42,6 +42,7 @@ void main() {
         'Empty -> Something',
         fullTextBefore: '',
         visibleValueAfter: TextEditingValue(text: _visibleText1),
+        visibleSelectionBefore: TextSelection.collapsed(offset: 0),
         expected: CodeEditResult(
           fullTextAfter: _visibleText1,
           linesChanged: TextRange(start: 0, end: 0),
@@ -52,6 +53,7 @@ void main() {
         'Something -> Empty',
         fullTextBefore: _fullText1,
         visibleValueAfter: TextEditingValue.empty,
+        visibleSelectionBefore: TextSelection.collapsed(offset: 0), // any
         expected: CodeEditResult(
           fullTextAfter: '',
           linesChanged: TextRange(start: 0, end: 8), // Empty line 9 is intact.
@@ -61,6 +63,7 @@ void main() {
       _Example(
         'Change not touching hidden range borders',
         fullTextBefore: _fullText1,
+        visibleSelectionBefore: TextSelection.collapsed(offset: 64),
         visibleValueAfter: TextEditingValue(
           // Each blank line has two spaces here:
           text: '''
@@ -69,11 +72,12 @@ public class MyClass {
   }
   
   
-  method(int a) {{
-  }}
+  voidmethod(int a) {
+  }
   
 }
 ''',
+          selection: TextSelection.collapsed(offset: 63),
         ),
         expected: CodeEditResult(
           fullTextAfter: '''
@@ -82,18 +86,19 @@ public class MyClass {
   }
   // [END section1]
   // [START section2]
-  method(int a) {{
-  }}
+  voidmethod(int a) {
+  }
   // [END section2]
 }
 ''',
-          linesChanged: TextRange(start: 5, end: 6),
+          linesChanged: TextRange(start: 5, end: 5),
         ),
       ),
 
       _Example(
         'Insertion at a range collapse - Inserts before the range',
         fullTextBefore: _fullText1,
+        visibleSelectionBefore: TextSelection.collapsed(offset: 81),
         visibleValueAfter: TextEditingValue(
           // Each blank line has two spaces here:
           text: '''
@@ -107,6 +112,7 @@ public class MyClass {
   ;
 }
 ''',
+          selection: TextSelection.collapsed(offset: 82),
         ),
         expected: CodeEditResult(
           fullTextAfter: '''
@@ -125,18 +131,21 @@ public class MyClass {
       ),
 
       _Example(
-        'Removing a block that is both before and after a hidden range - '
+        'Backspace on a block that is both before and after a hidden range - '
         'Removes it before',
+        // block == '\n'
         fullTextBefore: '''
 {
 //[START section1]
 }
 ''',
+        visibleSelectionBefore: TextSelection.collapsed(offset: 2),
         visibleValueAfter: TextEditingValue(
           text: '''
 {
 }
 ''',
+          selection: TextSelection.collapsed(offset: 1),
         ),
         expected: CodeEditResult(
           fullTextAfter: '''
@@ -148,13 +157,40 @@ public class MyClass {
       ),
 
       _Example(
-        'Replacing between ranges keeps the ranges - '
+        'Delete on a block that is both before and after a hidden range - '
+        'Removes it before',
+        // block == '\n'
+        fullTextBefore: '''
+{
+//[START section1]
+}
+''',
+        visibleSelectionBefore: TextSelection.collapsed(offset: 1),
+        visibleValueAfter: TextEditingValue(
+          text: '''
+{
+}
+''',
+          selection: TextSelection.collapsed(offset: 1),
+        ),
+        expected: CodeEditResult(
+          fullTextAfter: '''
+{//[START section1]
+}
+''',
+          linesChanged: TextRange(start: 0, end: 1),
+        ),
+      ),
+
+      _Example(
+        'Replacing between ranges - '
         'Keeps the range after, Deletes the range before',
         fullTextBefore: '''
 {//[START section1]
 ;//[END section1]
 }
 ''',
+        visibleSelectionBefore: TextSelection(baseOffset: 1, extentOffset: 3),
         visibleValueAfter: TextEditingValue(
           text: '''
 {()
@@ -173,8 +209,10 @@ public class MyClass {
       _Example(
         'If all text is a single hidden range, insert before it',
         fullTextBefore: '//[START section1]',
+        visibleSelectionBefore: TextSelection.collapsed(offset: 0),
         visibleValueAfter: TextEditingValue(
           text: ';',
+          selection: TextSelection.collapsed(offset: 1),
         ),
         expected: CodeEditResult(
           fullTextAfter: ';//[START section1]',
@@ -196,38 +234,39 @@ public class MyClass {
         namedSectionParser: const BracketsStartEndNamedSectionParser(),
       );
 
-      final selections = [
-        for (int n = code.visibleText.length; --n >= -1;)
-          TextSelection.collapsed(offset: n),
-      ];
-
-      for (final selection in selections) {
-        expect(
-          () => code.getEditResult(selection, example.visibleValueAfter),
-          returnsNormally,
-          reason: example.name,
-        );
-
-        final result = code.getEditResult(selection, example.visibleValueAfter);
-        expect(
-          result,
-          example.expected,
-          reason: example.name,
-        );
-      }
+      expect(
+        () => code.getEditResult(
+          example.visibleSelectionBefore,
+          example.visibleValueAfter,
+        ),
+        returnsNormally,
+        reason: example.name,
+      );
+
+      final result = code.getEditResult(
+        example.visibleSelectionBefore,
+        example.visibleValueAfter,
+      );
+      expect(
+        result,
+        example.expected,
+        reason: example.name,
+      );
     }
   });
 }
 
 class _Example {
   final String name;
   final String fullTextBefore;
+  final TextSelection visibleSelectionBefore;
   final TextEditingValue visibleValueAfter;
   final CodeEditResult? expected;
 
   const _Example(
     this.name, {
     required this.fullTextBefore,
+    required this.visibleSelectionBefore,
     required this.visibleValueAfter,
     this.expected,
   });