Updated tests and bugfix

Author: ubaldot

lib/utils.vim

@@ -159,7 +159,7 @@ export def SurroundNew(open_delimiter: string, close_delimiter: string, text_obj
   #
   # Note that Visual Selections and Text Objects are cousins
   #
-  if !empty(CursorDelimitersInterval(open_delimiter, close_delimiter))
+  if !empty(IsInRange(open_delimiter, close_delimiter))
     RemoveSurrounding(open_delimiter, close_delimiter)
   else
     # Set marks
@@ -215,7 +215,7 @@ export def SurroundNew(open_delimiter: string, close_delimiter: string, text_obj
     # Check if A falls in an existing interval
     cursor(xA, yA)
     for delimiterg in ZipLists(open_delimiters, close_delimiters)
-      found_delimiters_interval = CursorDelimitersInterval(delimiterg[0], delimiterg[1])
+      found_delimiters_interval = IsInRange(delimiterg[0], delimiterg[1])
       if !empty(found_delimiters_interval)
         old_right_delimiter = delimiterg[0]
         # Existing blocks shall be disjoint,
@@ -234,7 +234,7 @@ export def SurroundNew(open_delimiter: string, close_delimiter: string, text_obj
     # Check if also B falls in an existing interval
     cursor(xB, yB)
     for delimiterg in ZipLists(open_delimiters, close_delimiters)
-      found_delimiters_interval = CursorDelimitersInterval(delimiterg[0], delimiterg[1])
+      found_delimiters_interval = IsInRange(delimiterg[0], delimiterg[1])
       if !empty(found_delimiters_interval)
         old_left_delimiter = delimiterg[0]
         break
@@ -419,11 +419,12 @@ enddef
 
 export def GetDelimitersRanges(open_delimiter: string,
     close_delimiter: string,
-    open_delimiter_length_max: number = 5,
-    close_delimiter_length_max: number = 5
+    open_delimiter_length_max: number = 2,
+    close_delimiter_length_max: number = 2
     ): list<list<list<number>>>
   # It returns open-intervals, i.e. the delimiters are excluded
-  # If there is a spare delimiter, it won't be considered
+  # If there is a spare delimiter, it won't be considered. Delimiters are
+  # regex
   #
   # TODO: It is assumed that the ranges have no intersections. Note that this
   # won't happen if open_delimiter = close_delimiter, as in many languages.
@@ -447,6 +448,7 @@ export def GetDelimitersRanges(open_delimiter: string,
   var close_delimiter_match = ''
 
   while open_delimiter_pos_short != [0, 0]
+    echom "open_delimiter: " .. open_delimiter
     open_delimiter_pos_short = searchpos(open_delimiter, 'W')
 
     # If you pass a regex, you don't know how long is the captured string
@@ -456,7 +458,7 @@ export def GetDelimitersRanges(open_delimiter: string,
       ->matchstr(open_delimiter)
     open_delimiter_length = len(open_delimiter_match)
 
-    if getline(open_delimiter_pos_short[0]) =~ $'{open_delimiter}$'
+    if open_delimiter_pos_short[1] + open_delimiter_length == col('$')
       # If the open delimiter is the tail of the line, then the open-interval starts from
       # the next line, column 1
       open_delimiter_pos_short_final[0] = open_delimiter_pos_short[0] + 1
@@ -468,8 +470,8 @@ export def GetDelimitersRanges(open_delimiter: string,
     endif
     open_delimiter_pos = [0] + open_delimiter_pos_short_final + [0]
 
+    # Close delimiter
     close_delimiter_pos_short = searchpos(close_delimiter, 'W')
-
     # If you pass a regex, you don't know how long is the captured string
     close_delimiter_match = strcharpart(
       getline(close_delimiter_pos_short[0]),
@@ -479,7 +481,7 @@ export def GetDelimitersRanges(open_delimiter: string,
 
     # If the closed delimiter is the lead of the line, then the open-interval starts from
     # the previous line, last column
-    if getline(close_delimiter_pos_short[0]) =~ $'^{close_delimiter}'
+    if close_delimiter_pos_short[1] - 1 == 0
       close_delimiter_pos_short_final[0] = close_delimiter_pos_short[0] - 1
       close_delimiter_pos_short_final[1] = len(getline(close_delimiter_pos_short_final[0]))
     else
@@ -512,9 +514,9 @@ export def IsBetweenMarks(A: string, B: string): bool
     var cursor_pos_float = str2float($'{getcharpos(".")[1]}.{getcharpos(".")[2]}')
 
     # Debugging
-    echom "cur_pos: " .. cursor_pos_float
-    echom "a: " .. string(lower_float)
-    echom "b: " .. string(upper_float)
+    # echom "cur_pos: " .. cursor_pos_float
+    # echom "a: " .. string(lower_float)
+    # echom "b: " .. string(upper_float)
 
     # In case the lower limit is larger than the higher limit, swap
     if upper_float < lower_float
@@ -527,31 +529,33 @@ export def IsBetweenMarks(A: string, B: string): bool
 
 enddef
 
-export def CursorDelimitersInterval(open_delimiter: string, close_delimiter: string): list<list<number>>
+export def IsInRange(open_delimiter: string, close_delimiter: string): list<list<number>>
   # Return the range of the delimiters if the cursor is within such a range,
   # otherwise return an empty list.
+  # Arguments must be regex.
   var interval = []
 
   # OBS! Ranges are open-intervals!
-  var ranges = g:GetBlocksRangesNew(open_delimiter, close_delimiter)
+  var ranges = GetDelimitersRanges(open_delimiter, close_delimiter)
 
   var saved_mark_a = getcharpos("'a")
   var saved_mark_b = getcharpos("'b")
 
   for range in ranges
-    var A = setcharpos("'a", range[0])
-    var B = setcharpos("'b", range[1])
+    setcharpos("'a", range[0])
+    setcharpos("'b", range[1])
     if IsBetweenMarks("'a", "'b")
-      interval = [A, B]
+      interval = [range[0], range[1]]
       break
     endif
   endfor
 
+  echom "interval: " .. string(interval)
   # Restore marks 'a and 'b
   setcharpos("'a", saved_mark_a)
   setcharpos("'b", saved_mark_b)
 
-  return is_inside_block
+  return interval
 enddef
 
 export def DeleteTextBetweenMarks(A: string, B: string): string

test/results.txt

@@ -47,9 +47,9 @@ eval $VIM_CMD " -c \"vim9cmd g:TestName = [$TESTS_STRING]\" -S runner.vim"
 
 # Check that Vim started and that the runner did its job
 if [ $? -eq 0 ]; then
-    echo "\nVim executed successfully."
+    echo "Vim executed successfully.\n"
 else
-    echo "\nVim execution failed with exit code $?."
+    echo "Vim execution failed with exit code $?.\n"
 		exit 1
 fi
 

test/run_tests.sh

@@ -24,7 +24,7 @@ def RunTests(test_file: string)
 		->sort()
 
 	# Check is user defined some function name erroneously
-	var wrong_test_functions = copy(all_functions)->filter('v:val !~ "g:Test_"')
+	var wrong_test_functions = copy(all_functions)->filter('v:val !~ "Test_"')
 	echom "wrong_functions: " .. string(wrong_test_functions)
   if !empty(wrong_test_functions)
 		writefile([$'WARNING: The following tests are skipped: {wrong_test_functions}'], 'results.txt', 'a')

test/runner.vim

@@ -7,6 +7,10 @@ import "./common.vim"
 import "../lib/utils.vim"
 var WaitForAssert = common.WaitForAssert
 
+var code_regex = '\(^\|[^`]\)\zs`\ze\([^`]\|$\)'
+var italic_regex = '\(^\|[^\*]\)\zs\*\ze\([^\*]\|$\)'
+var bold_regex = '\(^\|[^\*]\)\zs\*\*\ze\([^\*]\|$\)'
+var strikethrough_regex = '\(^\|[^\~]\)\zs\~\~\ze\([^\~]\|$\)'
 
 var src_name = 'testfile.md'
 
@@ -23,11 +27,17 @@ def Generate_markdown_testfile()
         consectetur, adipisci velit, `sed quia non numquam eius modi tempora
         incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut
         enim ad minima veniam, quis nostrum exercitationem ullam corporis
-        suscipit laboriosam`, nisi ut aliquid ex ea commodi consequatur?
+        suscipit laboriosam`, nisi ut ~~aliquid ex ea commodi consequatur?~~
 
         Quis autem vel eum **iure reprehenderit qui in ea voluptate velit esse
         quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo
         voluptas nulla** pariatur?
+
+        At vero eos et accusamus et iusto odio dignissimos ducimus qui
+        blanditiis praesentium voluptatum deleniti atque corrupti quos dolores~~
+        et quas molestias excepturi sint~~ occaecati cupiditate non provident,
+        similique sunt in culpa qui officia ~~deserunt mollitia animi, id est
+        ~~laborum et dolorum fuga.
   END
    writefile(lines, src_name)
 enddef
@@ -62,22 +72,78 @@ def g:Test_GetDelimitersRanges()
 
   exe $"edit {src_name}"
 
-  var code_regex = '\(^\|[^`]\)\zs`\ze\([^`]\|$\)'
   var expected_ranges = [[[0, 9, 31, 0], [0, 12, 19, 0]]]
   var actual_ranges = utils.GetDelimitersRanges(code_regex, code_regex)
-  assert_true(expected_ranges == actual_ranges)
+  assert_equal(expected_ranges, actual_ranges)
 
-  var italic_regex = '\(^\|[^\*]\)\zs\*\ze\([^\*]\|$\)'
   expected_ranges = [[[0, 3, 20, 0], [0, 3, 28, 0]],
     [[0, 4, 18, 0], [0, 5, 29, 0]]]
   actual_ranges = utils.GetDelimitersRanges(italic_regex, italic_regex)
-  assert_true(expected_ranges == actual_ranges)
+  assert_equal(expected_ranges, actual_ranges)
 
-  var bold_regex = '\(^\|[^\*]\)\zs\*\*\ze\([^\*]\|$\)'
   expected_ranges = [[[0, 1, 23, 0], [0, 1, 37, 0]],
     [[0, 14, 22, 0], [0, 16, 14, 0]]]
   actual_ranges = utils.GetDelimitersRanges(bold_regex, bold_regex)
-  assert_true(expected_ranges == actual_ranges)
+  assert_equal(expected_ranges, actual_ranges)
+
+  expected_ranges = [[[0, 12, 33, 0], [0, 12, 66, 0]],
+  [[0, 20, 1, 0], [0, 20, 32, 0]],
+  [[0, 21, 39, 0], [0, 21, 69, 0]]]
+  actual_ranges = utils.GetDelimitersRanges(strikethrough_regex, strikethrough_regex)
+  assert_equal(expected_ranges, actual_ranges)
+
+  :%bw!
+  Cleanup_markdown_testfile()
+enddef
+
+def g:Test_IsBetweenMarks()
+  Generate_markdown_testfile()
+  exe $"edit {src_name}"
+
+  setpos("'A", [4, 23])
+  setpos("'B", [9, 11])
+
+  cursor(2, 15)
+  assert_false(utils.IsBetweenMarks("'A", "'B"))
+
+  cursor(8, 3)
+  assert_true(utils.IsBetweenMarks("'A", "'B"))
+
+  :%bw!
+  Cleanup_markdown_testfile()
+enddef
+
+def g:Test_IsInRange()
+  Generate_markdown_testfile()
+  exe $"edit {src_name}"
+
+  cursor(5, 18)
+  var expected_value = [[0, 4, 18, 0], [0, 5, 29, 0]]
+  var range = utils.IsInRange(italic_regex, italic_regex)
+  assert_equal(expected_value, range)
+
+  range = utils.IsInRange(bold_regex, bold_regex)
+  assert_true(empty(range))
+
+  range = utils.IsInRange(code_regex, code_regex)
+  assert_true(empty(range))
+
+  range = utils.IsInRange(strikethrough_regex, strikethrough_regex)
+  assert_true(empty(range))
+
+  # Test singularity: cursor on a delimiter
+  cursor(14, 21)
+  range = utils.IsInRange(italic_regex, italic_regex)
+  assert_true(empty(range))
+
+  range = utils.IsInRange(bold_regex, bold_regex)
+  assert_true(empty(range))
+
+  range = utils.IsInRange(code_regex, code_regex)
+  assert_true(empty(range))
+
+  range = utils.IsInRange(strikethrough_regex, strikethrough_regex)
+  assert_true(empty(range))
 
   :%bw!
   Cleanup_markdown_testfile()