`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
++            ! Check what we're currently on
--            in_word = is_word_char(line(pos:pos))
++            if (pos <= len(line) .and. is_word_char(line(pos:pos))) then
--            do while (pos <= len(line) .and. is_word_char(line(pos:pos)) .eqv. in_word)
++                ! We're on a word character - skip to end of word
--                pos = pos + 1
++                do while (pos <= len(line) .and. is_word_char(line(pos:pos)))
--            end do
++                    pos = pos + 1
--
++                end do
--            ! Skip whitespace
++            else
--            do while (pos <= len(line) .and. line(pos:pos) == ' ')
++                ! We're on whitespace or punctuation - skip to next word
--                pos = pos + 1
++                ! Skip non-word characters
--            end do
++                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
++                col_in_line = 1
--            else if (current_line == line) then
++            else
--                pos = pos + 1
++                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 = get_buffer_content_size(buffer) + 1
--            pos = i
--        else
--            pos = get_buffer_content_size(buffer) + 1
--        end if
      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
++        ! Count leading whitespace in next line
--        call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, 1)
++        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
++        ! Delete the newline and leading whitespace from next line
--        if (len(trim(next_line)) > 0) then
++        if (leading_spaces > 0) then
--            ! Find first non-whitespace character in next line
++            call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, leading_spaces + 1)
--            do while (len(next_line) > 0 .and. &
++        else
--                     (next_line(1:1) == ' ' .or. next_line(1:1) == char(9)))
++            call buffer_delete_range(buffer, cursor%line, current_len + 1, cursor%line + 1, 1)
--                next_line = next_line(2:)
++        end if
--            end do
--            ! Insert a space if current line doesn't end with space and next line has content
++        ! If the next line had non-whitespace content, insert a space between the lines
--            if (current_len > 0 .and. len(next_line) > 0) then
++        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')
++            try:
--            self.process.expect(pexpect.EOF)
++                # Save first to avoid unsaved changes prompt
--            self.process = None
++                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():
++                if editor:
--                    editor.stop()
++                    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}'"