`1b015a7`

fixes

Authored by

espadonne 6 months ago

SHA: 1b015a78276f2abe6f61a587e76fa8b531d0b08a
Parents: 66cb258
Tree: a3ec4a3

2 changed files

Status	File	+	-
M	`src/commands/command_handler_module.f90`	44	32
M	`test/integration_test.py`	32	7

src/commands/command_handler_module.f90modified

          pos = cursor%column
          if (pos <= len(line)) then
 -            ! Skip current word
 -            in_word = is_word_char(line(pos:pos))
 -            do while (pos <= len(line) .and. is_word_char(line(pos:pos)) .eqv. in_word)
 -                pos = pos + 1
 -            end do
+-
 -            ! Skip whitespace
 -            do while (pos <= len(line) .and. line(pos:pos) == ' ')
 -                pos = pos + 1
 -            end do
 +            ! Check what we're currently on
 +            if (pos <= len(line) .and. is_word_char(line(pos:pos))) then
 +                ! We're on a word character - skip to end of word
 +                do while (pos <= len(line) .and. is_word_char(line(pos:pos)))
 +                    pos = pos + 1
 +                end do
 +            else
 +                ! We're on whitespace or punctuation - skip to next word
 +                ! Skip non-word characters
 +                do while (pos <= len(line) .and. .not. is_word_char(line(pos:pos)))
 +                    pos = pos + 1
 +                end do
 +                ! Then skip to end of that word
 +                do while (pos <= len(line) .and. is_word_char(line(pos:pos)))
 +                    pos = pos + 1
 +                end do
 +            end if
              cursor%column = pos
          else if (cursor%line < line_count) then
          type(buffer_t), intent(in) :: buffer
          integer, intent(in) :: line, column
          integer :: pos
 -        integer :: current_line, i
 +        integer :: current_line, i, col_in_line
          character :: ch
          pos = 1
          current_line = 1
 +        col_in_line = 1
          ! Find the position for the given line and column
          do i = 1, get_buffer_content_size(buffer)
 -            if (current_line == line .and. pos == column) then
 +            if (current_line == line .and. col_in_line == column) then
 +                pos = i
                  return
              end if
              if (ch == char(10)) then
                  if (current_line == line) then
                      ! We're at the end of the target line
 +                    pos = i
                      return
                  end if
                  current_line = current_line + 1
 -                pos = 1
 -            else if (current_line == line) then
 -                pos = pos + 1
 +                col_in_line = 1
 +            else
 +                col_in_line = col_in_line + 1
              end if
          end do
          ! If we reach here, we're at the end of the buffer
 -        if (current_line == line) then
 -            pos = i
 -        else
 -            pos = get_buffer_content_size(buffer) + 1
 -        end if
 +        pos = get_buffer_content_size(buffer) + 1
      end function get_buffer_position
      function get_buffer_content_size(buffer) result(size)
          type(cursor_t), intent(inout) :: cursor
          type(buffer_t), intent(inout) :: buffer
          character(len=:), allocatable :: current_line, next_line
 -        integer :: line_count, current_len
 +        integer :: line_count, current_len, leading_spaces
          line_count = buffer_get_line_count(buffer)
          next_line = buffer_get_line(buffer, cursor%line + 1)
          current_len = len(current_line)
 -        ! Delete the newline at the end of the current line
 -        call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, 1)
 +        ! Count leading whitespace in next line
 +        leading_spaces = 0
 +        do while (leading_spaces < len(next_line) .and. &
 +                 (next_line(leading_spaces + 1:leading_spaces + 1) == ' ' .or. &
 +                  next_line(leading_spaces + 1:leading_spaces + 1) == char(9)))
 +            leading_spaces = leading_spaces + 1
 +        end do
 -        ! If the next line wasn't empty, insert a space between the lines
 -        if (len(trim(next_line)) > 0) then
 -            ! Find first non-whitespace character in next line
 -            do while (len(next_line) > 0 .and. &
 -                     (next_line(1:1) == ' ' .or. next_line(1:1) == char(9)))
 -                next_line = next_line(2:)
 -            end do
 +        ! Delete the newline and leading whitespace from next line
 +        if (leading_spaces > 0) then
 +            call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, leading_spaces + 1)
 +        else
 +            call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, 1)
 +        end if
 -            ! Insert a space if current line doesn't end with space and next line has content
 -            if (current_len > 0 .and. len(next_line) > 0) then
 +        ! If the next line had non-whitespace content, insert a space between the lines
 +        if (leading_spaces < len(next_line)) then
 +            ! Insert a space if current line doesn't end with space
 +            if (current_len > 0) then
                  if (current_line(current_len:current_len) /= ' ') then
                      call buffer_insert_text_at(buffer, cursor%line, current_len + 1, ' ')
                  end if

test/integration_test.pymodified

      def stop(self) -> None:
          """Stop the editor and clean up."""
          if self.process:
 -            self.send_key('ctrl-q')
 -            self.process.expect(pexpect.EOF)
 -            self.process = None
 +            try:
 +                # Save first to avoid unsaved changes prompt
 +                self.send_key('ctrl-s')
 +                time.sleep(0.1)
 +                # Now quit
 +                self.send_key('ctrl-q')
 +                self.process.expect(pexpect.EOF, timeout=2)
 +            except pexpect.TIMEOUT:
 +                # Force terminate if it doesn't exit cleanly
 +                self.process.terminate()
 +                time.sleep(0.1)
 +            except:
 +                pass
 +            finally:
 +                self.process = None
          # Clean up temp file
          if self.test_file:
              'ctrl-q': '\x11', 'ctrl-r': '\x12', 'ctrl-s': '\x13', 'ctrl-t': '\x14',
              'ctrl-u': '\x15', 'ctrl-v': '\x16', 'ctrl-w': '\x17', 'ctrl-x': '\x18',
              'ctrl-y': '\x19', 'ctrl-z': '\x1a',
 +            'ctrl-shift-z': '\x1a',  # Redo (may need different mapping)
              'escape': '\x1b', 'enter': '\n', 'tab': '\t',
              'backspace': '\x7f', 'delete': '\x1b[3~',
              'up': '\x1b[A', 'down': '\x1b[B', 'right': '\x1b[C', 'left': '\x1b[D',
              'home': '\x1b[H', 'end': '\x1b[F',
              'pageup': '\x1b[5~', 'pagedown': '\x1b[6~',
              'alt-[': '\x1b[', 'alt-]': '\x1b]',
 +            'alt-right': '\x1b[1;3C', 'alt-left': '\x1b[1;3D',
+         }
          if key in key_map:
              self.process.send(key_map[key])
 +            time.sleep(0.05)  # Small delay between key presses
          else:
              print(f"Warning: Unknown key '{key}'")
      def type_text(self, text: str) -> None:
          """Type regular text into the editor."""
 -        self.process.send(text)
 +        for char in text:
 +            self.process.send(char)
 +            time.sleep(0.01)  # Small delay between characters
      def save_file(self) -> None:
          """Save the current file."""
          print("=" * 60)
          for name, test_func in self.tests:
 +            editor = None
              try:
                  editor = FacsimileTest()
                  test_func(editor)
                  print(f"✓ {name}")
                  self.passed += 1
 -            except Exception as e:
 +            except AssertionError as e:
                  print(f"✗ {name}: {str(e)}")
                  self.failed += 1
 +            except Exception as e:
 +                print(f"✗ {name}: Unexpected error: {e.__class__.__name__}: {str(e)}")
 +                self.failed += 1
              finally:
 -                if 'editor' in locals():
 -                    editor.stop()
 +                if editor:
 +                    try:
 +                        editor.stop()
 +                    except:
 +                        pass  # Ignore cleanup errors
          print("-" * 60)
          print(f"Tests run: {self.passed + self.failed}, Passed: {self.passed}, Failed: {self.failed}")
      """Test basic text input."""
      editor.start("")
      editor.type_text("Hello World")
 +    time.sleep(0.5)  # Give more time for text to be typed
      content = editor.get_file_content()
      assert content == "Hello World", f"Expected 'Hello World', got '{content}'"