fortrangoingonforty/facsimile / ad49903

+          src/lsp/json_module.f90 \

+          src/lsp/lsp_protocol_module.f90 \

+          src/lsp/lsp_server_manager_module.f90 \

+          src/lsp/lsp_client_module.f90 \

+	@$(FC) $(FFLAGS_DEBUG) tests/lsp/test_json.f90 src/lsp/json_module.o -o tests/lsp/test_json 2>/dev/null && tests/lsp/test_json || true

+	@$(FC) $(FFLAGS_DEBUG) tests/lsp/test_lsp_init.f90 src/lsp/json_module.o src/lsp/lsp_protocol_module.o src/lsp/lsp_process_wrapper.o src/lsp/lsp_client_module.o src/lsp/lsp_server_manager_module.o -o tests/lsp/test_lsp_init 2>/dev/null && tests/lsp/test_lsp_init || true

+

+test-lsp-editor: all

+	@echo "Testing LSP in editor with sample C file..."

+	@echo "Opening tests/lsp/sample.c - check for LSP server initialization"

+	@timeout 2 ./fac tests/lsp/sample.c < /dev/null 2>&1 | grep -q "LSP server initialized" && \

+		echo "✓ LSP server initialized for C file" || \

+		echo "✗ LSP server did not initialize (check if clangd is installed)"

+.PHONY: all clean dev debug info bump-patch bump-minor bump-major version release lsp-modules test-lsp test-lsp-editor clean-lsp lsp-dev

+    use lsp_server_manager_module, only: notify_file_opened, notify_file_changed, &

+                                         notify_file_closed, process_server_messages

+

+            ! Send LSP didOpen notification if LSP server is active

+            if (editor%active_tab_index > 0 .and. editor%active_tab_index <= size(editor%tabs)) then

+                if (editor%tabs(editor%active_tab_index)%lsp_server_index > 0) then

+                    call notify_file_opened(editor%lsp_manager, &

+                        editor%tabs(editor%active_tab_index)%lsp_server_index, &

+                        trim(filename), buffer_to_string(buffer))

+                end if

+            end if

+        ! Process any LSP messages

+        call process_server_messages(editor%lsp_manager)

+

+    public :: buffer_to_string

+    ! Convert buffer contents to a string

+    function buffer_to_string(buffer) result(str)

+        type(buffer_t), intent(in) :: buffer

+        character(len=:), allocatable :: str

+        integer :: content_len

+

+        if (buffer%gap_start == 1) then

+            ! No content before gap

+            content_len = buffer%size - buffer%gap_end + 1

+            if (content_len > 0) then

+                allocate(character(len=content_len) :: str)

+                str = buffer%data(buffer%gap_end:buffer%size)

+            else

+                allocate(character(len=0) :: str)

+                str = ""

+            end if

+        else if (buffer%gap_end > buffer%size) then

+            ! No gap (full buffer)

+            content_len = buffer%gap_start - 1

+            allocate(character(len=content_len) :: str)

+            str = buffer%data(1:content_len)

+        else

+            ! Content on both sides of gap

+            content_len = (buffer%gap_start - 1) + (buffer%size - buffer%gap_end + 1)

+            allocate(character(len=content_len) :: str)

+            str = buffer%data(1:buffer%gap_start-1) // buffer%data(buffer%gap_end:buffer%size)

+        end if

+    end function buffer_to_string

+

+    use lsp_server_manager_module, only: lsp_manager_t, init_lsp_manager, cleanup_lsp_manager, &

+                                         get_or_start_server, process_server_messages, &

+                                         start_lsp_for_file, notify_file_opened, &

+                                         notify_file_changed, notify_file_closed

+

+        ! LSP support

+        integer :: lsp_server_index = 0  ! Index of LSP server handling this file

+

+        ! LSP support

+        type(lsp_manager_t) :: lsp_manager

+

+        ! Initialize LSP manager

+        call init_lsp_manager(editor%lsp_manager)

+

+        ! Cleanup LSP manager

+        call cleanup_lsp_manager(editor%lsp_manager)

+        ! Start LSP server for this file if applicable

+        temp_tabs(new_index)%lsp_server_index = start_lsp_for_file(editor%lsp_manager, filename)

+

+    public :: get_language_for_file, start_lsp_for_file

+    public :: notify_file_opened, notify_file_changed, notify_file_closed

+    ! Helper to get language from filename

+    function get_language_for_file(filename) result(language)

+        character(len=*), intent(in) :: filename

+        character(len=:), allocatable :: language

+        integer :: dot_pos

+

+        ! Find last dot in filename

+        dot_pos = index(filename, '.', back=.true.)

+        if (dot_pos == 0) then

+            language = ""

+            return

+        end if

+

+        ! Match extension to language

+        select case(filename(dot_pos:))

+        case('.py')

+            language = "python"

+        case('.rs')

+            language = "rust"

+        case('.c', '.h')

+            language = "c"

+        case('.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.C', '.H')

+            language = "cpp"

+        case('.go')

+            language = "go"

+        case('.ts', '.tsx')

+            language = "typescript"

+        case('.js', '.jsx')

+            language = "javascript"

+        case('.f90', '.f95', '.f03', '.f08', '.F90', '.F95', '.F03', '.F08')

+            language = "fortran"

+        case('.java')

+            language = "java"

+        case('.rb')

+            language = "ruby"

+        case('.lua')

+            language = "lua"

+        case default

+            language = ""

+        end select

+    end function get_language_for_file

+

+    ! Start LSP server for a file if needed

+    function start_lsp_for_file(manager, filename) result(server_index)

+        type(lsp_manager_t), intent(inout) :: manager

+        character(len=*), intent(in) :: filename

+        integer :: server_index

+        character(len=:), allocatable :: language

+        character(len=256) :: workspace_path

+        integer :: slash_pos

+

+        server_index = 0

+

+        ! Get language from file extension

+        language = get_language_for_file(filename)

+        if (language == "") return

+

+        ! Extract workspace path from filename (directory containing file)

+        slash_pos = index(filename, '/', back=.true.)

+        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

+

+    ! Send textDocument/didOpen notification

+    subroutine notify_file_opened(manager, server_index, filename, content)

+        use lsp_protocol_module, only: create_did_open_notification

+        type(lsp_manager_t), intent(inout) :: manager

+        integer, intent(in) :: server_index

+        character(len=*), intent(in) :: filename

+        character(len=*), intent(in) :: content

+        type(lsp_message_t) :: msg

+        character(len=:), allocatable :: language

+

+        if (server_index < 1 .or. server_index > manager%num_servers) return

+        if (.not. manager%servers(server_index)%initialized) return

+

+        language = get_language_for_file(filename)

+        msg = create_did_open_notification(filename, language, 1, content)

+        call send_notification(manager%servers(server_index), msg)

+    end subroutine notify_file_opened

+

+    ! Send textDocument/didChange notification

+    subroutine notify_file_changed(manager, server_index, filename, content)

+        use lsp_protocol_module, only: create_did_change_notification

+        type(lsp_manager_t), intent(inout) :: manager

+        integer, intent(in) :: server_index

+        character(len=*), intent(in) :: filename

+        character(len=*), intent(in) :: content

+        type(lsp_message_t) :: msg

+

+        if (server_index < 1 .or. server_index > manager%num_servers) return

+        if (.not. manager%servers(server_index)%initialized) return

+

+        msg = create_did_change_notification(filename, 2, content)

+        call send_notification(manager%servers(server_index), msg)

+    end subroutine notify_file_changed

+

+    ! Send textDocument/didClose notification

+    subroutine notify_file_closed(manager, server_index, filename)

+        use lsp_protocol_module, only: create_did_close_notification

+        type(lsp_manager_t), intent(inout) :: manager

+        integer, intent(in) :: server_index

+        character(len=*), intent(in) :: filename

+        type(lsp_message_t) :: msg

+

+        if (server_index < 1 .or. server_index > manager%num_servers) return

+        if (.not. manager%servers(server_index)%initialized) return

+

+        msg = create_did_close_notification(filename)

+        call send_notification(manager%servers(server_index), msg)

+    end subroutine notify_file_closed

+

+# LSP Tests

+

+This directory contains tests for the Language Server Protocol (LSP) integration in the fac editor.

+

+## Test Files

+

+- `test_json.f90` - Tests the JSON parser implementation

+- `test_lsp_init.f90` - Tests LSP server initialization and communication

+- `sample.c` - Sample C file for testing LSP with clangd

+- `sample.py` - Sample Python file for testing LSP with pylsp

+- `sample.rs` - Sample Rust file for testing LSP with rust-analyzer

+

+## Running Tests

+

+### Test JSON Parser

+```bash

+make test-lsp

+```

+

+### Test LSP in Editor

+```bash

+make test-lsp-editor

+```

+

+### Manual Testing

+Open a supported file type in the editor:

+```bash

+./fac tests/lsp/sample.c   # Tests C/C++ with clangd

+./fac tests/lsp/sample.py  # Tests Python with pylsp

+./fac tests/lsp/sample.rs  # Tests Rust with rust-analyzer

+```

+

+## Supported Languages

+

+The editor currently supports LSP for:

+- C/C++ (clangd)

+- Python (pylsp)

+- Rust (rust-analyzer)

+- Go (gopls)

+- TypeScript/JavaScript (typescript-language-server)

+- Fortran (fortls)

+

+## Requirements

+

+For LSP to work, you need the corresponding language servers installed:

+- C/C++: `brew install llvm` (provides clangd)

+- Python: `pip install python-lsp-server`

+- Rust: `rustup component add rust-analyzer`

+- Go: `go install golang.org/x/tools/gopls@latest`

+- TypeScript: `npm install -g typescript typescript-language-server`

+- Fortran: `pip install fortls`

+

+## Current Features

+- ✓ Automatic server startup when opening supported files

+- ✓ textDocument/didOpen notifications

+- ✓ Server initialization handshake

+

+## Planned Features

+- [ ] Code completion (Ctrl+Space)

+- [ ] Hover information (Ctrl+H)

+- [ ] Go to definition (Ctrl+D)

+- [ ] Find references (Ctrl+R)

+- [ ] Diagnostics display

+- [ ] Code actions and fixes

+#include <stdio.h>

+

+// Test file for LSP integration

+int main() {

+    printf("Hello from LSP test!\n");

+

+    int x = 10;

+    int y = 20;

+    int result = x + y;

+

+    printf("Result: %d\n", result);

+    return 0;

+}

+program test_json

+    use json_module

+    use iso_fortran_env, only: real64

+    implicit none

+

+    type(json_value_t) :: json_obj

+    character(len=100) :: json_str

+    real(real64) :: id_value

+

+    ! Test with a simple JSON response like what we get from clangd

+    json_str = '{"id":1,"jsonrpc":"2.0","result":{"capabilities":{}}}'

+

+    print *, "Testing JSON: ", trim(json_str)

+

+    ! Parse it

+    json_obj = json_parse(json_str)

+

+    ! Check if we can find the id

+    if (json_has_key(json_obj, "id")) then

+        print *, "Found id key!"

+        id_value = json_get_number(json_obj, "id", -1.0_real64)

+        print *, "ID value: ", id_value

+    else

+        print *, "No id key found"

+    end if

+

+    ! Check for jsonrpc

+    if (json_has_key(json_obj, "jsonrpc")) then

+        print *, "Found jsonrpc key!"

+    else

+        print *, "No jsonrpc key found"

+    end if

+

+end program test_json

+program test_lsp_init

+    use lsp_server_manager_module

+    use iso_fortran_env, only: output_unit, error_unit

+    implicit none

+

+    type(lsp_manager_t) :: manager

+    integer :: server_index

+    character(len=256) :: test_file

+    integer :: i

+

+    print *, "Testing LSP initialization with fixed JSON parser..."

+

+    ! Create test file

+    test_file = "/tmp/test.c"

+    open(10, file=test_file, status='replace')

+    write(10, '(a)') "#include <stdio.h>"

+    write(10, '(a)') "int main() { return 0; }"

+    close(10)

+

+    ! Initialize manager

+    call init_lsp_manager(manager)

+

+    ! Get or start server for C language

+    server_index = get_or_start_server(manager, "c", "/tmp")

+    if (server_index > 0) then

+        print *, "✓ Server started successfully"

+        print '(a,i0)', "   Server index: ", server_index

+    else

+        print *, "✗ Failed to start server"

+        stop 1

+    end if

+

+    ! Wait a bit for initialization

+    print *, "Waiting for initialization..."

+    call sleep(2)

+

+    ! Process any pending messages

+    call process_server_messages(manager)

+

+    ! Check if server is initialized

+    do i = 1, manager%num_servers

+        if (manager%servers(i)%initialized) then

+            print *, "✓ Server initialized successfully!"

+        else

+            print *, "✗ Server not yet initialized"

+        end if

+

+        ! Show server info

+        print '(a,a)', "   Command: ", trim(manager%servers(i)%command)

+        print '(a,i0)', "   Process ID: ", manager%servers(i)%process_id

+        print '(a,l1)', "   Initialized: ", manager%servers(i)%initialized

+        print '(a,l1)', "   Supports completion: ", manager%servers(i)%supports_completion

+    end do

+

+    ! Cleanup

+    call cleanup_lsp_manager(manager)

+    print *, "Test complete."

+

+end program test_lsp_init