test/lsp/utils/text_edit.vimspec

   1 function! s:set_text(lines)
   2     % delete _
   3     put =a:lines
   4     execute 'normal ggdd'
   5     execute 'file my-file'
   6 endfunction
   7
   8 function! s:get_text()
   9     return lsp#utils#buffer#_get_lines(bufnr('$'))
  10 endfunction
  11
  12 Describe lsp#utils#text_edit
  13
  14     Before all
  15         let s:endofline_backup = &endofline
  16         set endofline
  17     End
  18
  19     After all
  20         let &endofline = s:endofline_backup
  21     End
  22
  23     Before each
  24         enew!
  25     End
  26
  27     Describe lsp#utils#text_edit#apply_text_edits
  28         It insert newText
  29             call s:set_text(['foo', 'bar'])
  30
  31             call lsp#utils#text_edit#apply_text_edits(
  32                     \ expand('%'),
  33                     \ [{
  34                     \   'range': {
  35                     \       'start': {
  36                     \           'line': 1,
  37                     \           'character': 1
  38                     \       },
  39                     \       'end': {
  40                     \           'line': 1,
  41                     \           'character': 1
  42                     \       }
  43                     \   },
  44                     \   'newText': 'baz'
  45                     \ }])
  46
  47             let l:buffer_text = s:get_text()
  48             Assert Equals(l:buffer_text, ['foo', 'bbazar', ''])
  49         End
  50
  51         It insert empty newText
  52             call s:set_text(['foo', 'bar'])
  53
  54             call lsp#utils#text_edit#apply_text_edits(
  55                     \ expand('%'),
  56                     \ [{
  57                     \   'range': {
  58                     \       'start': {
  59                     \           'line': 1,
  60                     \           'character': 1
  61                     \       },
  62                     \       'end': {
  63                     \           'line': 1,
  64                     \           'character': 1
  65                     \       }
  66                     \   },
  67                     \   'newText': ''
  68                     \ }])
  69
  70             let l:buffer_text = s:get_text()
  71             Assert Equals(l:buffer_text, ['foo', 'bar', ''])
  72         End
  73
  74         It replace range string to newText
  75             call s:set_text(['foo', 'bar'])
  76
  77             call lsp#utils#text_edit#apply_text_edits(
  78                     \ expand('%'),
  79                     \ [{
  80                     \   'range': {
  81                     \       'start': {
  82                     \           'line': 1,
  83                     \           'character': 0
  84                     \       },
  85                     \       'end': {
  86                     \           'line': 1,
  87                     \           'character': 1
  88                     \       }
  89                     \   },
  90                     \   'newText': 'replaced'
  91                     \ }])
  92
  93             let l:buffer_text = s:get_text()
  94             Assert Equals(l:buffer_text, ['foo', 'replacedar', ''])
  95         End
  96
  97         It replace range string to empty newText
  98             call s:set_text(['foo', 'bar'])
  99
 100             call lsp#utils#text_edit#apply_text_edits(
 101                     \ expand('%'),
 102                     \ [{
 103                     \   'range': {
 104                     \       'start': {
 105                     \           'line': 1,
 106                     \           'character': 0
 107                     \       },
 108                     \       'end': {
 109                     \           'line': 1,
 110                     \           'character': 1
 111                     \       }
 112                     \   },
 113                     \   'newText': ''
 114                     \ }])
 115
 116             let l:buffer_text = s:get_text()
 117             Assert Equals(l:buffer_text, ['foo', 'ar', ''])
 118         End
 119
 120         It single line start character is -1
 121             call s:set_text(['foo', 'bar'])
 122
 123             call lsp#utils#text_edit#apply_text_edits(
 124                     \ expand('%'),
 125                     \ [{
 126                     \   'range': {
 127                     \       'start': {
 128                     \           'line': 1,
 129                     \           'character': -1
 130                     \       },
 131                     \       'end': {
 132                     \           'line': 1,
 133                     \           'character': 3
 134                     \       }
 135                     \   },
 136                     \   'newText': ''
 137                     \ }])
 138
 139             let l:buffer_text = s:get_text()
 140             Assert Equals(l:buffer_text, ['foo', '', ''])
 141         End
 142
 143         It single line start character is 0
 144             call s:set_text(['foo', 'bar'])
 145
 146             call lsp#utils#text_edit#apply_text_edits(
 147                     \ expand('%'),
 148                     \ [{
 149                     \   'range': {
 150                     \       'start': {
 151                     \           'line': 1,
 152                     \           'character': 0
 153                     \       },
 154                     \       'end': {
 155                     \           'line': 1,
 156                     \           'character': 3
 157                     \       }
 158                     \   },
 159                     \   'newText': ''
 160                     \ }])
 161
 162             let l:buffer_text = s:get_text()
 163             Assert Equals(l:buffer_text, ['foo', '', ''])
 164         End
 165
 166         It single line start character is 1
 167             call s:set_text(['foo', 'bar'])
 168
 169             call lsp#utils#text_edit#apply_text_edits(
 170                     \ expand('%'),
 171                     \ [{
 172                     \   'range': {
 173                     \       'start': {
 174                     \           'line': 1,
 175                     \           'character': 1
 176                     \       },
 177                     \       'end': {
 178                     \           'line': 1,
 179                     \           'character': 3
 180                     \       }
 181                     \   },
 182                     \   'newText': ''
 183                     \ }])
 184
 185             let l:buffer_text = s:get_text()
 186             Assert Equals(l:buffer_text, ['foo', 'b', ''])
 187         End
 188
 189         It single line end character is `len(getline('.')) - 1`
 190             call s:set_text(['foo', 'bar'])
 191
 192             call lsp#utils#text_edit#apply_text_edits(
 193                     \ expand('%'),
 194                     \ [{
 195                     \   'range': {
 196                     \       'start': {
 197                     \           'line': 1,
 198                     \           'character': 0
 199                     \       },
 200                     \       'end': {
 201                     \           'line': 1,
 202                     \           'character': 2
 203                     \       }
 204                     \   },
 205                     \   'newText': ''
 206                     \ }])
 207
 208             let l:buffer_text = s:get_text()
 209             Assert Equals(l:buffer_text, ['foo', 'r', ''])
 210         End
 211
 212         It single line end character is `len(getline('.'))`
 213             call s:set_text(['foo', 'bar'])
 214
 215             call lsp#utils#text_edit#apply_text_edits(
 216                     \ expand('%'),
 217                     \ [{
 218                     \   'range': {
 219                     \       'start': {
 220                     \           'line': 1,
 221                     \           'character': 0
 222                     \       },
 223                     \       'end': {
 224                     \           'line': 1,
 225                     \           'character': 3
 226                     \       }
 227                     \   },
 228                     \   'newText': ''
 229                     \ }])
 230
 231             let l:buffer_text = s:get_text()
 232             Assert Equals(l:buffer_text, ['foo', '', ''])
 233         End
 234
 235         It single line end character is `len(getline('.')) + 1`
 236             call s:set_text(['foo', 'bar'])
 237
 238             call lsp#utils#text_edit#apply_text_edits(
 239                     \ expand('%'),
 240                     \ [{
 241                     \   'range': {
 242                     \       'start': {
 243                     \           'line': 1,
 244                     \           'character': 0
 245                     \       },
 246                     \       'end': {
 247                     \           'line': 1,
 248                     \           'character': 4
 249                     \       }
 250                     \   },
 251                     \   'newText': ''
 252                     \ }])
 253
 254             " if newline character deleting, need end position is next line zero character.
 255             let l:buffer_text = s:get_text()
 256             Assert Equals(l:buffer_text, ['foo', '', ''])
 257         End
 258
 259         It replace range string to empty newText, multiline top to top
 260             call s:set_text(['foo', 'bar', 'baz'])
 261
 262             call lsp#utils#text_edit#apply_text_edits(
 263                     \ expand('%'),
 264                     \ [{
 265                     \   'range': {
 266                     \       'start': {
 267                     \           'line': 0,
 268                     \           'character': 0
 269                     \       },
 270                     \       'end': {
 271                     \           'line': 1,
 272                     \           'character': 0
 273                     \       }
 274                     \   },
 275                     \   'newText': ''
 276                     \ }])
 277
 278             let l:buffer_text = s:get_text()
 279             Assert Equals(l:buffer_text, ['bar', 'baz', ''])
 280         End
 281
 282         It replace range string to empty newText, multiline top to tail
 283             call s:set_text(['foo', 'bar', 'baz'])
 284
 285             call lsp#utils#text_edit#apply_text_edits(
 286                     \ expand('%'),
 287                     \ [{
 288                     \   'range': {
 289                     \       'start': {
 290                     \           'line': 0,
 291                     \           'character': 0
 292                     \       },
 293                     \       'end': {
 294                     \           'line': 1,
 295                     \           'character': 2
 296                     \       }
 297                     \   },
 298                     \   'newText': ''
 299                     \ }])
 300
 301             let l:buffer_text = s:get_text()
 302             Assert Equals(l:buffer_text, ['r', 'baz', ''])
 303
 304             call s:set_text(['foo', 'bar', 'baz'])
 305
 306             call lsp#utils#text_edit#apply_text_edits(
 307                     \ expand('%'),
 308                     \ [{
 309                     \   'range': {
 310                     \       'start': {
 311                     \           'line': 0,
 312                     \           'character': 0
 313                     \       },
 314                     \       'end': {
 315                     \           'line': 1,
 316                     \           'character': 3
 317                     \       }
 318                     \   },
 319                     \   'newText': ''
 320                     \ }])
 321
 322             let l:buffer_text = s:get_text()
 323             Assert Equals(l:buffer_text, ['', 'baz', ''])
 324
 325             call s:set_text(['foo', 'bar', 'baz'])
 326
 327             call lsp#utils#text_edit#apply_text_edits(
 328                     \ expand('%'),
 329                     \ [{
 330                     \   'range': {
 331                     \       'start': {
 332                     \           'line': 0,
 333                     \           'character': 0
 334                     \       },
 335                     \       'end': {
 336                     \           'line': 1,
 337                     \           'character': 4
 338                     \       }
 339                     \   },
 340                     \   'newText': ''
 341                     \ }])
 342
 343             " if newline character deleting, need end position is next line zero character.
 344             let l:buffer_text = s:get_text()
 345             Assert Equals(l:buffer_text, ['', 'baz', ''])
 346         End
 347
 348         It replace range string to empty newText, multiline middle to middle
 349             call s:set_text(['foo', 'bar', 'baz'])
 350
 351             call lsp#utils#text_edit#apply_text_edits(
 352                     \ expand('%'),
 353                     \ [{
 354                     \   'range': {
 355                     \       'start': {
 356                     \           'line': 0,
 357                     \           'character': 1
 358                     \       },
 359                     \       'end': {
 360                     \           'line': 1,
 361                     \           'character': 2
 362                     \       }
 363                     \   },
 364                     \   'newText': ''
 365                     \ }])
 366
 367             let l:buffer_text = s:get_text()
 368             Assert Equals(l:buffer_text, ['fr', 'baz', ''])
 369         End
 370
 371         It replaces entire buffer correctly
 372             call s:set_text(['foo', 'bar', 'baz'])
 373
 374             call lsp#utils#text_edit#apply_text_edits(
 375                     \ expand('%'),
 376                     \ [{
 377                     \   'range': {
 378                     \       'start': {
 379                     \           'line': 0,
 380                     \           'character': 0
 381                     \       },
 382                     \       'end': {
 383                     \           'line': 3,
 384                     \           'character': 0
 385                     \       }
 386                     \   },
 387                     \   'newText': "x\ny\nz\n"
 388                     \ }])
 389
 390             let l:buffer_text = s:get_text()
 391             Assert Equals(l:buffer_text, ['x', 'y', 'z', ''])
 392         End
 393
 394         It multiple textEdit with inserting \r.
 395             " Add some text to buffer
 396             call s:set_text(['class ABC {', '  private:', '  ', 'int a;};', ])
 397
 398             " Format
 399             call lsp#utils#text_edit#apply_text_edits(
 400                     \ expand('%'),
 401                     \ [
 402                     \   {
 403                     \     "range": {
 404                     \       "end": {
 405                     \         "character": 2,
 406                     \         "line": 1
 407                     \       },
 408                     \       "start": {
 409                     \         "character": 11,
 410                     \         "line": 0
 411                     \       }
 412                     \     },
 413                     \     "newText": "\n"
 414                     \   },
 415                     \   {
 416                     \     "range": {
 417                     \       "end": {
 418                     \         "character": 0,
 419                     \         "line": 3
 420                     \       },
 421                     \       "start": {
 422                     \         "character": 10,
 423                     \         "line": 1
 424                     \       }
 425                     \     },
 426                     \     "newText": "\n  "
 427                     \   },
 428                     \   {
 429                     \     "range": {
 430                     \       "end": {
 431                     \         "character": 6,
 432                     \         "line": 3
 433                     \       },
 434                     \       "start": {
 435                     \         "character": 6,
 436                     \         "line": 3
 437                     \       }
 438                     \     },
 439                     \     "newText": "\n"
 440                     \   }
 441                     \ ])
 442
 443             let l:buffer_text = s:get_text()
 444             Assert Equals(l:buffer_text, ['class ABC {', 'private:', '  int a;', '};', ''])
 445         End
 446
 447         It preserves v:completed_item
 448             " Add some text to buffer
 449             call s:set_text(['foo', 'bar'])
 450
 451             " Go to end of file and invoke completion
 452             execute "normal Gof\<C-p>\<Esc>"
 453
 454             " Make sure that v:completed_item is set
 455             Assert Equals(v:completed_item["word"], "foo")
 456             let l:old_completed_item = v:completed_item
 457
 458             " Perform some text edits
 459
 460             " Insert
 461             call lsp#utils#text_edit#apply_text_edits(
 462                     \ expand('%'),
 463                     \ [{
 464                     \   'range': {
 465                     \       'start': {
 466                     \           'line': 1,
 467                     \           'character': 1
 468                     \       },
 469                     \       'end': {
 470                     \           'line': 1,
 471                     \           'character': 1
 472                     \       }
 473                     \   },
 474                     \   'newText': 'baz'
 475                     \ }])
 476
 477             " Insert empty
 478             call lsp#utils#text_edit#apply_text_edits(
 479                     \ expand('%'),
 480                     \ [{
 481                     \   'range': {
 482                     \       'start': {
 483                     \           'line': 1,
 484                     \           'character': 1
 485                     \       },
 486                     \       'end': {
 487                     \           'line': 1,
 488                     \           'character': 1
 489                     \       }
 490                     \   },
 491                     \   'newText': ''
 492                     \ }])
 493
 494             " Replace
 495             call lsp#utils#text_edit#apply_text_edits(
 496                     \ expand('%'),
 497                     \ [{
 498                     \   'range': {
 499                     \       'start': {
 500                     \           'line': 1,
 501                     \           'character': 0
 502                     \       },
 503                     \       'end': {
 504                     \           'line': 1,
 505                     \           'character': 1
 506                     \       }
 507                     \   },
 508                     \   'newText': 'replaced'
 509                     \ }])
 510
 511             " Delete
 512             call lsp#utils#text_edit#apply_text_edits(
 513                     \ expand('%'),
 514                     \ [{
 515                     \   'range': {
 516                     \       'start': {
 517                     \           'line': 1,
 518                     \           'character': 0
 519                     \       },
 520                     \       'end': {
 521                     \           'line': 1,
 522                     \           'character': 1
 523                     \       }
 524                     \   },
 525                     \   'newText': ''
 526                     \ }])
 527
 528             " Make sure v:completed_item is not changed
 529             Assert Equals(v:completed_item, l:old_completed_item)
 530         End
 531
 532         It replaces entire buffer correctly when end column is 1
 533             call s:set_text(['foo', 'b'])
 534
 535             call lsp#utils#text_edit#apply_text_edits(
 536                     \ expand('%'),
 537                     \ [{
 538                     \   'range': {
 539                     \       'start': {
 540                     \           'line': 0,
 541                     \           'character': 0
 542                     \       },
 543                     \       'end': {
 544                     \           'line': 1,
 545                     \           'character': 1
 546                     \       }
 547                     \   },
 548                     \   'newText': "x\ny\nz\n"
 549                     \ }])
 550
 551             let l:buffer_text = s:get_text()
 552             Assert Equals(l:buffer_text, ['x', 'y', 'z', '', ''])
 553         End
 554
 555         It should apply edit that contains \r\n
 556             call s:set_text(['foo', 'b'])
 557
 558             call lsp#utils#text_edit#apply_text_edits(
 559                     \ expand('%'),
 560                     \ [{
 561                     \   'range': {
 562                     \       'start': {
 563                     \           'line': 0,
 564                     \           'character': 0
 565                     \       },
 566                     \       'end': {
 567                     \           'line': 1,
 568                     \           'character': 1
 569                     \       }
 570                     \   },
 571                     \   'newText': "x\r\ny\r\nz\r\n"
 572                     \ }])
 573
 574             let l:buffer_text = s:get_text()
 575             Assert Equals(l:buffer_text, ['x', 'y', 'z', '', ''])
 576         End
 577
 578         It adds imports correctly
 579             call s:set_text(['package main', '', 'import java.util.ArrayList;', '', 'public class Main {}'])
 580
 581             call lsp#utils#text_edit#apply_text_edits(
 582                 \ expand('%'),
 583                 \ [{
 584                 \     "range": {
 585                 \       "start": {
 586                 \         "character": 0,
 587                 \         "line": 2
 588                 \       },
 589                 \       "end": {
 590                 \         "character": 0,
 591                 \         "line": 3
 592                 \       }
 593                 \     },
 594                 \     "newText": ""
 595                 \   },
 596                 \   {
 597                 \     "range": {
 598                 \       "start": {
 599                 \         "character": 0,
 600                 \         "line": 2
 601                 \       },
 602                 \       "end": {
 603                 \         "character": 0,
 604                 \         "line": 2
 605                 \       }
 606                 \     },
 607                 \     "newText": "import java.util.ArrayList;\n"
 608                 \   }
 609                 \ ])
 610
 611             let l:buffer_text = s:get_text()
 612             Assert Equals(l:buffer_text, ['package main', '', 'import java.util.ArrayList;', '', 'public class Main {}', ''])
 613         End
 614
 615         It adds null
 616             let l:text = ['package main', '', 'import java.util.ArrayList;', '', 'public class Main {}']
 617             call s:set_text(l:text)
 618
 619             call lsp#utils#text_edit#apply_text_edits(
 620                 \ expand('%'),
 621                 \ v:null)
 622
 623             let l:buffer_text = s:get_text()
 624             Assert Equals(l:buffer_text, l:text + [''])
 625         End
 626
 627         It should apply edits to unloaded file
 628             let l:target = globpath(&runtimepath, 'test/lsp/utils/text_edit.vimspec')
 629             call themis#log(l:target)
 630             call lsp#utils#text_edit#apply_text_edits(lsp#utils#path_to_uri(l:target), [{
 631             \   'range': {
 632             \     'start': {
 633             \       'line': 0,
 634             \       'character': 0,
 635             \     },
 636             \     'end': {
 637             \       'line': 0,
 638             \       'character': 0,
 639             \     }
 640             \   },
 641             \   'newText': "aiueo\n"
 642             \ }])
 643
 644             Assert Equals(getbufline(l:target, 1), ['aiueo'])
 645         End
 646
 647         It should apply edits to buffer and unloaded file
 648             let l:text = ['plop']
 649             call s:set_text(l:text)
 650             let l:buffer_text = s:get_text()
 651             Assert Equals(l:buffer_text, ['plop', ''])
 652             let l:target = globpath(&runtimepath, 'test/lsp/utils/text_edit.vimspec')
 653             call lsp#utils#text_edit#apply_text_edits(
 654               \ lsp#utils#path_to_uri(expand('%')),
 655               \  [{
 656               \   'range': {
 657               \     'start': {
 658               \       'line': 0,
 659               \       'character': 0,
 660               \     },
 661               \     'end': {
 662               \       'line': 1,
 663               \       'character': 0,
 664               \     }
 665               \   },
 666               \   'newText': "buffer\n"
 667               \ }])
 668             call lsp#utils#text_edit#apply_text_edits(lsp#utils#path_to_uri(l:target), [{
 669               \   'range': {
 670               \     'start': {
 671               \       'line': 0,
 672               \       'character': 0,
 673               \     },
 674               \     'end': {
 675               \       'line': 1,
 676               \       'character': 0,
 677               \     }
 678               \   },
 679               \   'newText': "unloaded\n"
 680               \ }])
 681
 682             Assert Equals(getbufline(l:target, 1), ['unloaded'])
 683             Assert Equals(getbufline(expand('%'), 1), ['buffer'])
 684         End
 685     End
 686 End
 687