all repos

clerk @ e00aad8

missing tooling for ledger/hledger
9 files changed, 26 insertions(+), 47 deletions(-)
bump go to 1.27
Author: Oleksandr Smirnov olexsmir@gmail.com
Committed at: 2026-08-20 12:50:19 +0300
Authored at: 2026-08-19 20:54:55 +0300
Change ID: ukwosnlzomyxsytklzlkxylupnwmvlnz
Parent: 4047965
M go.mod
···
        1
        1
         module olexsmir.xyz/clerk

      
        2
        2
         

      
        3
        
        -go 1.26.4

      
        
        3
        +go 1.27.0

      
        4
        4
         

      
        5
        5
         tool golang.org/x/tools/cmd/stringer

      
        6
        6
         

      
M internal/lsp/textdocument_completion_test.go
···
        187
        187
         		b.Run(tname, func(b *testing.B) {

      
        188
        188
         			line, col := lsputil.LineCol(content, tt)

      
        189
        189
         			params := &protocol.CompletionParams{

      
        190
        
        -				TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        191
        
        -					TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        192
        
        -					Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        193
        
        -				},

      
        
        190
        +				TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        
        191
        +				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        194
        192
         			}

      
        195
        193
         

      
        196
        194
         			// warm up

      ···
        231
        229
         

      
        232
        230
         	line, col := lsputil.LineCol(content, len(content))

      
        233
        231
         	params := &protocol.CompletionParams{

      
        234
        
        -		TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        235
        
        -			TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        236
        
        -			Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        237
        
        -		},

      
        
        232
        +		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        
        233
        +		Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        238
        234
         	}

      
        239
        235
         

      
        240
        236
         	warm, err := srv.server.Completion(b.Context(), params)

      
M internal/lsp/textdocument_definition_test.go
···
        17
        17
         func TestServer_Definition_DocumentNotFound(t *testing.T) {

      
        18
        18
         	srv := NewServer("test")

      
        19
        19
         	res, err := srv.server.Definition(t.Context(), &protocol.DefinitionParams{

      
        20
        
        -		TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        21
        
        -			TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        22
        
        -			Position:     protocol.Position{Line: 0, Character: 0},

      
        23
        
        -		},

      
        
        20
        +		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        
        21
        +		Position:     protocol.Position{Line: 0, Character: 0},

      
        24
        22
         	})

      
        25
        23
         	if err != nil {

      
        26
        24
         		t.Fatal(err)

      ···
        85
        83
         		b.Run(tname, func(b *testing.B) {

      
        86
        84
         			line, col := lsputil.LineCol(content, tt)

      
        87
        85
         			params := &protocol.DefinitionParams{

      
        88
        
        -				TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        89
        
        -					TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        90
        
        -					Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        91
        
        -				},

      
        
        86
        +				TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        
        87
        +				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        92
        88
         			}

      
        93
        89
         			// warm up: first request resolves the symbol lazily; assert it found one

      
        94
        90
         			res, err := srv.server.Definition(b.Context(), params)

      
M internal/lsp/textdocument_hover_test.go
···
        46
        46
         func TestServer_Hover_DocumentNotFound(t *testing.T) {

      
        47
        47
         	srv := NewServer("test")

      
        48
        48
         	res, err := srv.server.Hover(context.Background(), &protocol.HoverParams{

      
        49
        
        -		TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        50
        
        -			TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        51
        
        -			Position:     protocol.Position{Line: 0, Character: 0},

      
        52
        
        -		},

      
        
        49
        +		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        
        50
        +		Position:     protocol.Position{Line: 0, Character: 0},

      
        53
        51
         	})

      
        54
        52
         	if err != nil {

      
        55
        53
         		t.Fatal(err)

      ···
        111
        109
         		b.Run(tname, func(b *testing.B) {

      
        112
        110
         			line, col := lsputil.LineCol(content, tt)

      
        113
        111
         			params := &protocol.HoverParams{

      
        114
        
        -				TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        115
        
        -					TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        116
        
        -					Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        117
        
        -				},

      
        
        112
        +				TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

      
        
        113
        +				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        118
        114
         			}

      
        119
        115
         

      
        120
        116
         			// warm up: assert the cursor resolved to a hover

      
M internal/lsp/textdocument_references_test.go
···
        18
        18
         func TestServer_References_DocumentNotFound(t *testing.T) {

      
        19
        19
         	srv := NewServer("test")

      
        20
        20
         	res, err := srv.server.References(context.Background(), &protocol.ReferenceParams{

      
        21
        
        -		TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        22
        
        -			TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        23
        
        -			Position:     protocol.Position{Line: 0, Character: 0},

      
        24
        
        -		},

      
        
        21
        +		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///nonexistent.journal")},

      
        
        22
        +		Position:     protocol.Position{Line: 0, Character: 0},

      
        25
        23
         	})

      
        26
        24
         	if err != nil {

      
        27
        25
         		t.Fatal(err)

      ···
        83
        81
         		b.Run(tname, func(b *testing.B) {

      
        84
        82
         			line, col := lsputil.LineCol(content, tt)

      
        85
        83
         			params := &protocol.ReferenceParams{

      
        86
        
        -				Context: protocol.ReferenceContext{IncludeDeclaration: true},

      
        87
        
        -				TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        88
        
        -					TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        89
        
        -					Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        90
        
        -				},

      
        
        84
        +				Context:      protocol.ReferenceContext{IncludeDeclaration: true},

      
        
        85
        +				TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        
        86
        +				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        91
        87
         			}

      
        92
        88
         

      
        93
        89
         			// warm up: first request resolves the symbol lazily; assert it found references

      
M internal/lsp/textdocument_rename_test.go
···
        154
        154
         		b.Run(tname, func(b *testing.B) {

      
        155
        155
         			line, col := lsputil.LineCol(content, tt.pos)

      
        156
        156
         			params := &protocol.RenameParams{

      
        157
        
        -				TextDocumentPositionParams: protocol.TextDocumentPositionParams{

      
        158
        
        -					TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        159
        
        -					Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        160
        
        -				},

      
        161
        
        -				NewName: tt.newName,

      
        
        157
        +				TextDocument: protocol.TextDocumentIdentifier{URI: u},

      
        
        158
        +				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

      
        
        159
        +				NewName:      tt.newName,

      
        162
        160
         			}

      
        163
        161
         			// warm up: first request generates the workspace edits; assert it found one

      
        164
        162
         			edit, err := srv.server.Rename(b.Context(), params)

      
M internal/lsp/workspace_symbol.go
···
        87
        87
         			continue

      
        88
        88
         		}

      
        89
        89
         		symbols = append(symbols, protocol.WorkspaceSymbol{

      
        90
        
        -			BaseSymbolInformation: protocol.BaseSymbolInformation{

      
        91
        
        -				Name: s.name,

      
        92
        
        -				Kind: s.kind.ToProtocol(),

      
        93
        
        -			},

      
        
        90
        +			Name:     s.name,

      
        
        91
        +			Kind:     s.kind.ToProtocol(),

      
        94
        92
         			Location: loc,

      
        95
        93
         		})

      
        96
        94
         	}

      
M internal/testutil/txtar/fs.go
···
        23
        23
         // file system return an ErrModified error.

      
        24
        24
         func FS(a *Archive) (fs.FS, error) {

      
        25
        25
         	// Create a filesystem with a root directory.

      
        26
        
        -	root := &node{fileinfo: fileinfo{path: ".", mode: readOnlyDir}}

      
        
        26
        +	root := &node{path: ".", mode: readOnlyDir}

      
        27
        27
         	fsys := &filesystem{a, map[string]*node{root.path: root}}

      
        28
        28
         

      
        29
        29
         	if err := initFiles(fsys); err != nil {

      ···
        77
        77
         			return fmt.Errorf("file %q is an invalid path", name)

      
        78
        78
         		}

      
        79
        79
         

      
        80
        
        -		n := &node{idx: idx, fileinfo: fileinfo{path: name, size: len(file.Data), mode: readOnly}}

      
        
        80
        +		n := &node{idx: idx, path: name, size: len(file.Data), mode: readOnly}

      
        81
        81
         		if err := insert(fsys, n); err != nil {

      
        82
        82
         			return err

      
        83
        83
         		}

      ···
        108
        108
         		return m, nil // pre-existing directory

      
        109
        109
         	}

      
        110
        110
         

      
        111
        
        -	n := &node{fileinfo: fileinfo{path: dir, mode: readOnlyDir}}

      
        
        111
        +	n := &node{path: dir, mode: readOnlyDir}

      
        112
        112
         	if err := insert(fsys, n); err != nil {

      
        113
        113
         		return nil, err

      
        114
        114
         	}