`098cb2b`

bug fixes with tabs and f6 menu

Authored by

espadonne 5 months ago

SHA: 098cb2b7b6f04c4b57ab14e284973a763d2a52ca
Parents: b845f07
Tree: 878a44f

3 changed files

Status	File	+	-
M	`app/main.f90`	47	6
M	`src/commands/command_handler_module.f90`	105	10
M	`src/lsp/lsp_server_manager_module.f90`	31	25

app/main.f90modified

      use binary_prompt_module, only: binary_file_prompt
      use lsp_server_manager_module, only: notify_file_opened, notify_file_changed, &
                                           notify_file_closed, process_server_messages, &
--                                         set_diagnostics_handler
++                                         set_diagnostics_handler, set_lsp_workspace_root
      use lsp_protocol_module, only: lsp_message_t
      implicit none
      type(editor_state_t) :: editor
      type(buffer_t) :: buffer
      character(len=32) :: key_input
--    character(len=512) :: filename, arg, workspace_dir
++    character(len=512) :: filename, arg, workspace_dir, lsp_workspace
      logical :: running, should_quit, is_workspace_mode, workspace_success
      logical :: welcome_cancelled, is_browse, nav_cancelled, is_directory
++    logical :: explicit_lsp_workspace
      character(len=:), allocatable :: selected_path
--    integer :: status, argc, rows, cols
++    integer :: status, argc, rows, cols, i
      ! Get command line arguments
      is_workspace_mode = .false.
      workspace_dir = ""
      filename = ""
++    lsp_workspace = ""
++    explicit_lsp_workspace = .false.
++
++    ! First pass: look for -w/--workspace flag
++    i = 1
++    do while (i <= argc)
++        call get_command_argument(i, arg)
++        if (trim(arg) == '-w' .or. trim(arg) == '--workspace') then
++            if (i < argc) then
++                call get_command_argument(i + 1, lsp_workspace)
++                explicit_lsp_workspace = .true.
++                i = i + 2
++            else
++                write(error_unit, '(A)') 'Error: -w/--workspace requires a directory argument'
++                stop 1
++            end if
++        else
++            i = i + 1
++        end if
++    end do
--    if (argc > 0) then
++    ! Second pass: handle other arguments
--        call get_command_argument(1, arg)
++    i = 1
++    do while (i <= argc)
++        call get_command_argument(i, arg)
++
++        ! Skip -w and its argument (already processed)
++        if (trim(arg) == '-w' .or. trim(arg) == '--workspace') then
++            i = i + 2
++            cycle
++        end if
          ! Handle version flags
          if (trim(arg) == '--version' .or. trim(arg) == '-v') then
              stop
          end if
++        ! This must be the file/directory argument
          ! Check if argument is a directory (workspace mode)
          ! Use test -d which is POSIX compliant (works on Linux, macOS, BSD)
          call execute_command_line("test -d '" // trim(arg) // &
              end if
              filename = arg
          end if
--    else
++        i = i + 1
++    end do
++
++    if (argc == 0) then
          ! No arguments - launch Fortress welcome menu (Phase 5)
          call terminal_init()
          call show_welcome_menu(selected_path, welcome_cancelled)
      call init_editor(editor)
      running = .true.
++    ! Set LSP workspace root if explicit -w flag was provided
++    if (explicit_lsp_workspace) then
++        call set_lsp_workspace_root(editor%lsp_manager, trim(lsp_workspace))
++    end if
++
      ! Set up diagnostics handler for LSP
      call set_diagnostics_handler(editor%lsp_manager, handle_diagnostics)
          write(output_unit, '(A)') ''
          write(output_unit, '(A)') 'Usage:'
          write(output_unit, '(A)') '  fac [filename]       Open a file for editing'
++        write(output_unit, '(A)') '  fac [directory]      Open directory in workspace mode'
          write(output_unit, '(A)') '  fac                  Start with empty buffer'
          write(output_unit, '(A)') '  fac --version, -v    Show version information'
          write(output_unit, '(A)') '  fac --help, -h       Show this help message'
++        write(output_unit, '(A)') '  fac -w <dir> [file]  Set LSP workspace root to <dir>'
++        write(output_unit, '(A)') '  fac --workspace <dir> Same as -w'
          write(output_unit, '(A)') ''
          write(output_unit, '(A)') 'Key Bindings:'
          write(output_unit, '(A)') '  Ctrl-Q               Quit'

src/commands/command_handler_module.f90modified

      subroutine navigate_to_workspace_symbol(editor, buffer, symbol, should_quit)
          use workspace_symbols_panel_module, only: workspace_symbol_t
          use jump_stack_module, only: push_jump_location
--        use editor_state_module, only: switch_to_tab, create_tab, sync_pane_to_editor, sync_editor_to_pane
++        use editor_state_module, only: switch_to_tab_with_buffer, create_tab, sync_pane_to_editor, sync_editor_to_pane
          use text_buffer_module, only: buffer_load_file, copy_buffer
          type(editor_state_t), intent(inout) :: editor
          type(buffer_t), intent(inout) :: buffer
                  editor%cursors(editor%active_cursor)%column)
          end if
--        ! Check if file is already open in a tab
++        ! FIRST: Check if symbol is in the currently active tab (just jump, no tab switch)
++        if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then
++            if (allocated(editor%tabs(editor%active_tab_index)%filename)) then
++                if (paths_match(editor%tabs(editor%active_tab_index)%filename, filepath)) then
++                    ! Same file - just jump to the position
++                    editor%cursors(editor%active_cursor)%line = symbol%line + 1  ! LSP is 0-based
++                    editor%cursors(editor%active_cursor)%column = symbol%column + 1
++                    editor%cursors(editor%active_cursor)%desired_column = symbol%column + 1
++                    editor%viewport_line = max(1, symbol%line + 1 - editor%screen_rows / 2)
++                    call sync_editor_to_pane(editor)
++                    return
++                end if
++            end if
++        end if
++
++        ! SECOND: Check if file is open in another (inactive) tab
          do i = 1, size(editor%tabs)
++            if (i == editor%active_tab_index) cycle  ! Skip active tab, already checked
              if (allocated(editor%tabs(i)%filename)) then
--                if (trim(editor%tabs(i)%filename) == trim(filepath)) then
++                if (paths_match(editor%tabs(i)%filename, filepath)) then
--                    call switch_to_tab(editor, i)
++                    ! Save current buffer and switch to existing tab
++                    call switch_to_tab_with_buffer(editor, i, buffer)
                      ! Jump to the symbol's position
                      editor%cursors(editor%active_cursor)%line = symbol%line + 1  ! LSP is 0-based
                      editor%cursors(editor%active_cursor)%column = symbol%column + 1
                      editor%cursors(editor%active_cursor)%desired_column = symbol%column + 1
                      editor%viewport_line = max(1, symbol%line + 1 - editor%screen_rows / 2)
++                    call sync_editor_to_pane(editor)
                      return
                  end if
              end if
          end do
          ! File not open - create a new tab and load the file
--        call create_tab(editor, filepath)
--
--        ! Load file content into the new tab's buffer
          block
--            integer :: status, new_tab_idx
++            integer :: status, new_tab_idx, old_tab_idx, old_pane_idx
++
++            ! CRITICAL: Save current buffer to old tab BEFORE create_tab changes active_tab_index
++            old_tab_idx = editor%active_tab_index
++            if (old_tab_idx > 0 .and. old_tab_idx <= size(editor%tabs)) then
++                old_pane_idx = editor%tabs(old_tab_idx)%active_pane_index
++                if (allocated(editor%tabs(old_tab_idx)%panes) .and. &
++                    old_pane_idx > 0 .and. old_pane_idx <= size(editor%tabs(old_tab_idx)%panes)) then
++                    call copy_buffer(editor%tabs(old_tab_idx)%panes(old_pane_idx)%buffer, buffer)
++                end if
++                call copy_buffer(editor%tabs(old_tab_idx)%buffer, buffer)
++            end if
++
++            call create_tab(editor, filepath)
              new_tab_idx = size(editor%tabs)  ! The tab we just created
                      call copy_buffer(editor%tabs(new_tab_idx)%panes(1)%buffer, editor%tabs(new_tab_idx)%buffer)
                  end if
--                ! Switch to the new tab
++                ! Load the new tab's buffer into working buffer (create_tab already switched active_tab_index)
--                call switch_to_tab(editor, new_tab_idx)
++                call copy_buffer(buffer, editor%tabs(new_tab_idx)%buffer)
++
++                ! Update editor%filename to the new tab's filename
++                if (allocated(editor%filename)) deallocate(editor%filename)
++                allocate(character(len=len(editor%tabs(new_tab_idx)%filename)) :: editor%filename)
++                editor%filename = editor%tabs(new_tab_idx)%filename
++                editor%modified = editor%tabs(new_tab_idx)%modified
                  ! Sync the pane to editor state (this updates editor%cursors, etc.)
                  call sync_pane_to_editor(editor, new_tab_idx, 1)
          end block
      end subroutine navigate_to_workspace_symbol
++    ! Helper function to compare file paths (handles relative vs absolute)
++    function paths_match(path1, path2) result(match)
++        character(len=*), intent(in) :: path1, path2
++        logical :: match
++        character(len=:), allocatable :: p1, p2
++
++        match = .false.
++
++        ! Direct comparison first
++        if (trim(path1) == trim(path2)) then
++            match = .true.
++            return
++        end if
++
++        ! Try comparing just the filenames (basename) if one is relative
++        p1 = get_path_basename(path1)
++        p2 = get_path_basename(path2)
++
++        ! If basenames match and one path ends with the other, consider it a match
++        if (trim(p1) == trim(p2)) then
++            ! Check if one path is a suffix of the other
++            if (index(path1, trim(path2)) > 0 .or. index(path2, trim(path1)) > 0) then
++                match = .true.
++                return
++            end if
++            ! Also match if the absolute path ends with the relative path
++            if (len_trim(path1) > len_trim(path2)) then
++                if (path1(len_trim(path1)-len_trim(path2)+1:) == trim(path2)) then
++                    match = .true.
++                    return
++                end if
++            else if (len_trim(path2) > len_trim(path1)) then
++                if (path2(len_trim(path2)-len_trim(path1)+1:) == trim(path1)) then
++                    match = .true.
++                    return
++                end if
++            end if
++        end if
++    end function paths_match
++
++    ! Get basename from a path
++    function get_path_basename(path) result(basename)
++        character(len=*), intent(in) :: path
++        character(len=:), allocatable :: basename
++        integer :: i, last_slash
++
++        last_slash = 0
++        do i = len_trim(path), 1, -1
++            if (path(i:i) == '/') then
++                last_slash = i
++                exit
++            end if
++        end do
++
++        if (last_slash > 0 .and. last_slash < len_trim(path)) then
++            basename = path(last_slash+1:len_trim(path))
++        else
++            basename = trim(path)
++        end if
++    end function get_path_basename
++
      ! ==================================================
      ! LSP Definition Response Handler
      ! ==================================================

src/lsp/lsp_server_manager_module.f90modified

      public :: lsp_server_t
      public :: lsp_manager_t
--    public :: init_lsp_manager, cleanup_lsp_manager
++    public :: init_lsp_manager, cleanup_lsp_manager, set_lsp_workspace_root
      public :: get_or_start_server, stop_server
      public :: send_request, send_notification
      public :: process_server_messages
          type(callback_entry_t), allocatable :: callbacks(:)
          integer :: num_callbacks = 0
          procedure(diagnostics_callback), pointer, nopass :: diagnostics_handler => null()
++        character(len=512) :: workspace_root = '.'  ! LSP workspace root (cwd by default)
      end type lsp_manager_t
      ! C interfaces
  contains
--    subroutine init_lsp_manager(manager)
++    subroutine init_lsp_manager(manager, workspace_root)
          type(lsp_manager_t), intent(out) :: manager
++        character(len=*), intent(in), optional :: workspace_root
++        character(len=512) :: cwd
++        integer :: status
          allocate(manager%servers(0))
          allocate(manager%configs(0))
          allocate(manager%callbacks(0))
++        ! Set workspace root (default to cwd if not provided)
++        if (present(workspace_root) .and. len_trim(workspace_root) > 0) then
++            manager%workspace_root = trim(workspace_root)
++        else
++            call getcwd(cwd, status)
++            if (status == 0) then
++                manager%workspace_root = trim(cwd)
++            else
++                manager%workspace_root = '.'
++            end if
++        end if
++
          ! Load default server configurations
          call load_default_configs(manager)
      end subroutine init_lsp_manager
++    ! Set the workspace root for LSP servers (call before opening files)
++    subroutine set_lsp_workspace_root(manager, workspace_root)
++        type(lsp_manager_t), intent(inout) :: manager
++        character(len=*), intent(in) :: workspace_root
++
++        manager%workspace_root = trim(workspace_root)
++    end subroutine set_lsp_workspace_root
++
      subroutine cleanup_lsp_manager(manager)
          type(lsp_manager_t), intent(inout) :: manager
          integer :: i
          character(len=*), intent(in) :: filename
          integer :: server_index
          character(len=:), allocatable :: language
--        character(len=256) :: workspace_path
--        integer :: slash_pos
          server_index = 0
          language = get_language_for_file(filename)
          if (language == "") return
--        ! Extract workspace path from filename (directory containing file)
++        ! Use manager's workspace_root (set during init, defaults to cwd)
--        slash_pos = index(filename, '/', back=.true.)
++        server_index = get_or_start_server(manager, language, trim(manager%workspace_root))
--        if (slash_pos > 0) then
--            workspace_path = filename(1:slash_pos-1)
--        else
--            workspace_path = "."
--        end if
--
--        ! Get or start server for this language
--        server_index = get_or_start_server(manager, language, trim(workspace_path))
      end function start_lsp_for_file
      ! Start ALL LSP servers that match a file (multi-server support)
          integer, allocatable, intent(out) :: server_indices(:)
          integer, intent(out) :: num_servers
          character(len=:), allocatable :: language
--        character(len=256) :: workspace_path
++        integer :: i, idx
--        integer :: slash_pos, i, idx
          integer :: temp_indices(20)  ! Max 20 servers per file
          num_servers = 0
          language = get_language_for_file(filename)
          if (language == "") return
--        ! Extract workspace path from filename
++        ! Use manager's workspace_root (set during init, defaults to cwd)
--        slash_pos = index(filename, '/', back=.true.)
--        if (slash_pos > 0) then
--            workspace_path = filename(1:slash_pos-1)
--        else
--            workspace_path = "."
--        end if
--
          ! Find ALL configs that match this language and start servers
          do i = 1, manager%num_configs
              if (manager%configs(i)%language == language) then
                  ! Start or get server for this config
--                idx = get_or_start_server_by_config(manager, i, trim(workspace_path))
++                idx = get_or_start_server_by_config(manager, i, trim(manager%workspace_root))
                  if (idx > 0 .and. num_servers < 20) then
                      num_servers = num_servers + 1
                      temp_indices(num_servers) = idx