howl.Completer

buffer = nil
before_each ->
  buffer = Buffer {}

.start_pos holds the start position for completing

buffer.text = 'oh cruel word'
assert.equal 4, Completer(buffer, 9).start_pos

.complete(pos [, limit])

instantiates completers once with (buffer, context)

buffer.text = 'mr.cat'
factory = spy.new -> nil
append buffer.completers, factory
completer = Completer(buffer, 6)
completer\complete 6
assert.spy(factory).was.called_with buffer, buffer\context_at 6
completer\complete 6
assert.spy(factory).was.called(1)

lookups completers in completion when they are specified as strings

buffer.text = 'yowser'
factory = spy.new -> nil
completion.register name: 'comp-name', :factory
append buffer.completers, 'comp-name'
completer = Completer(buffer, 3)
assert.spy(factory).was.called

returns completions for completers in buffer and mode

mode = completers: { -> complete: -> { 'mode' } }
buffer.mode = mode
append buffer.completers,  -> complete: -> { 'buffer' }
completions = Completer(buffer, 1)\complete 1
assert.same completions, { 'buffer', 'mode' }

returns completions for mode even if buffer has no completers

mode = completers: { -> complete: -> { 'mode' } }
buffer.mode = mode
assert.same Completer(buffer, 1)\complete(1), { 'mode' }

returns the search string after the completions

mode = completers: { -> complete: -> { 'prefix' } }
buffer.text = 'pre'
buffer.mode = mode
append buffer.completers,  -> complete: -> { 'buffer' }
_, search = Completer(buffer, 4)\complete 4
assert.same search, 'pre'

calls <completer.complete()> with (completer, context)

buffer.text = 'mr.cat'
comp = complete: spy.new -> {}
append buffer.completers, -> comp
completer = Completer(buffer, 6)

completer\complete 6
assert.spy(comp.complete).was.called_with comp, buffer\context_at 6

completer\complete 7
assert.spy(comp.complete).was.called_with comp, buffer\context_at 7

returns completions from just one completer if completions.authoritive is set

append buffer.completers, -> complete: -> { 'one', authoritive: true }
append buffer.completers, -> complete: -> { 'two' }
completions = Completer(buffer, 1)\complete 1
assert.same { 'one' }, completions

merges duplicate completions from different completers

append buffer.completers, -> complete: -> { 'yes'}
append buffer.completers, -> complete: -> { 'yes' }
completions = Completer(buffer, 1)\complete 1
assert.same { 'yes' }, completions

(limiting completions)

returns at most `completion_max_shown` completions

completions = ["cand-#{i}" for i = 1,15]
append buffer.completers, -> complete: -> completions
buffer.config.completion_max_shown = 3
actual = Completer(buffer, 1)\complete 1
assert.equal 3, #actual

returns at most <limit> completions if specified

completions = ["cand-#{i}" for i = 1,15]
append buffer.completers, -> complete: -> completions
actual = Completer(buffer, 1)\complete 1, 4
assert.equal 4, #actual

accept(completion)

returns the position after the accepted completion

buffer.text = 'hello there'
  assert.equal 5, Completer(buffer, 4)\accept 'hƏlp', 4

(when hungry_completion is true)

replaces the current word with <completion>

buffer.text = 'hello there'
buffer.config.hungry_completion = true
completer = Completer(buffer, 3)
completer\accept 'hey', 3
assert.equal 'hey there', buffer.text

(when hungry_completion is false)

inserts <completion> at the start position

buffer.text = 'hello there'
buffer.config.hungry_completion = false
completer = Completer(buffer, 7)
completer\accept 'over', 7
assert.equal 'hello overthere', buffer.text

(interacting with mode's .on_completion_accepted)

invokes it with (mode, completion, context) if present

mode = on_completion_accepted: spy.new -> nil
buffer.mode = mode
buffer.text = 'hello there'
Completer(buffer, 4)\accept 'help', 4
assert.spy(mode.on_completion_accepted).was_called_with mode, 'help', buffer\context_at(5)

uses it's return value as the position returned if it's a number

mode = on_completion_accepted: -> 6
buffer.mode = mode
buffer.text = 'hello there'
assert.equal 6, Completer(buffer, 4)\accept 'help', 4