Fixes for Terminal code to work with new comma syntax.

[cslatevm.git] / src / lib / terminal.slate

prototypes ensureNamespace: #terminals &delegate: True.

terminals define: #Backend &parents: {PrettyPrinterMixin. Stream WrapperStream}.
"The device object/handle used for the terminal."

_@(Backend traits) defaultColumns [80].
_@(Backend traits) defaultRows [24].

_@(Backend traits) display: lineString cursorAt: index
"The basic method for line-oriented display and interaction."
[overrideThis].

b@(Backend traits) events
"Return a stream of events"
[overrideThis].

terminals define: #Terminal &parents: {Backend}
  &slots: {#console "The underlying console object"}.
"The abstract terminal type."
Terminal addLazySlot: #commandEditor initializer: [| :t | t LineEditor newOn: t]. "A line editor instance on demand"

Terminal traits define: #KeyboardInterrupt &parents: {Condition}
 &slots: {#terminal}.

c@(Terminal KeyboardInterrupt traits) newFor: t
[
  c new `>> [terminal: t. ]
].

t@(Terminal traits) interrupted
[(t KeyboardInterrupt newFor: t) signal].

_@(Terminal traits) newBasedOn: console@(ExternalResource traits)
[
  (DumbTerminal newOn: console interactor) `>> [
    console: console.
  ]
].

_@(Terminal traits) newBasedOn: console@(SmartConsole traits)
[
  (SmartTerminal newOn: console interactor) `>> [
    console: console.
  ]
].

t@(Terminal traits) events [t console events].

t@(Terminal traits) sessionDo: block
[
  t resource sessionDo: [| :r | block applyWith: t]
].

t@(Terminal traits) isSmart
"Answer whether all of certain cursor movement signals are defined."
[False].

t@(Terminal traits) echoes
[True].

t@(Terminal traits) columnLast
[t columns - 1].

t@(Terminal traits) columns
[t defaultColumns].

t@(Terminal traits) rowLast
[t rows - 1].

t@(Terminal traits) rows
[t defaultRows].

t@(Terminal traits) flush
[t console flush].

t@(Terminal traits) beep
"Send the beep/BEL character."
[
  "TODO: on cygwin it doesn't work in raw mode, only prints ^G"
  "Terminal traits define: #bell -> ({$\a code} as: ByteArray).
  t console write: 1 from: t bell."
  t flush.
].

t@(Terminal traits) page
"Display a simple header and page-down; exit if Q is pressed."
[| chord |
  t writer ; '--More--'.
  t flush.
  chord: t nextChord.
  t newLine.
  (chord = $q \/ [chord = $Q]) not
].

t@(Terminal traits) newLine
"Terminate the current line."
[t nextPut: $\n].

t@(Terminal traits) newColumn
[t nextPut: $\s].

terminals define: #DumbTerminal &parents: {Terminal}.
"The simple terminal type, not even VT100."

t@(DumbTerminal traits) display: line cursorAt: index
[
  "That's all we can do..."
].

terminals define: #SmartTerminal &parents: {Terminal}
  &slots: {#basePosition -> Tuple new*, 0, 0 "The screen coordinate where line editing started"}.
"The terminal type that understands control- and escape-sequences for redraws, etc."

t@(SmartTerminal traits) isSmart
"Answer whether all of certain cursor movement signals are defined."
[True].

t@(SmartTerminal traits) echoes
[False].

t@(SmartTerminal traits) newLine
[| console |
  console: t console.
  console isCursorAtLastRow
    ifTrue: [console scroll].
  console moveCursorToBONL.
  t
].

t@(SmartTerminal traits) columns
[t console columns].

t@(SmartTerminal traits) rows
[t console rows].

t@(SmartTerminal traits) display: cmd cursorAt: cursorPos &incremental: incremental
[| console scroll |
  console: t console.
  incremental ifNil: [incremental: False].
  incremental ifFalse: [
    console moveCursorTo: t basePosition. "TODO more then a page long lines (baseline < 0)"
    t nextPutAll: cmd].
  "Ideally basePosition update should be done with scroll callbacks. It does not handle
  newlines in the command this way, and the console already keeps track of its state."
  scroll: t basePosition second + ((t basePosition first + cmd size) // console width) - console rowLast.
  scroll > 0 ifTrue: [t basePosition at: 1 put: t basePosition second - scroll].
  incremental ifFalse: [console clearToEOS].
  t moveCursorTo: cursorPos inCommand: cmd.
].

"TODO take control chars like \n's in cmd into account? generalize into SmartConsole"
t@(SmartTerminal traits) moveCursorTo: pos inCommand: cmd
[| cols |
  cols: t columns.
  pos: pos + t basePosition first.
  t console moveCursorTo: (Tuple new*, (pos rem: cols), t basePosition second + (pos // cols)).
].

terminals define: #ConsoleLineEditor &parents: {Cloneable} &slots:
 {#terminal.
  #position -> 0. "Cursor position"
  #currentHistoryIndex -> 0.
  #killRing -> LinkedList new.
  #insertMode -> True.
  #mark.
  #currentYank.
  #lastYank.
  #prompt -> Nil.
  #currentWord -> Nil.
  #currentCompletions -> {}.
  #history -> ({ExtensibleArray new} as: ExtensibleArray new)}.
"A line editor, used to manage some terminal interactions, and having editing
state and behavior."
ConsoleLineEditor addLazySlot: #reader initializer: [| :e | e ReadStream newOn: e].
ConsoleLineEditor traits `>> [
  define: #keymap &builder: [Dictionary new].
  define: #controlKeymap &builder: [Dictionary new].
  define: #modifierKeymap &builder: [Dictionary new].
  define: #maxHistorySize -> 50.
].

e@(ConsoleLineEditor traits) newOn: terminal
[
  e clone `>> [
    history: [ExtensibleArray new `>> [addFirst: ExtensibleArray new. ]] do.
    on: terminal.
  ]
].

e@(ConsoleLineEditor traits) on: terminal
[
  e terminal: terminal.
  e
].

e@(ConsoleLineEditor traits) lineString
[
  e history at: e currentHistoryIndex
].

e@(ConsoleLineEditor traits) prepareToEditLine
"Take the current history item, duplicate it, and addFirst:
to edit a copy rather then the item in the history."
[
  e currentHistoryIndex > 0 ifTrue: [| current |
    current: (e history at: e currentHistoryIndex).
    e history first size = 0 ifTrue: [e history removeFirst].
    e history addFirst: (ExtensibleArray newWithAll: current).
    [e history size > e maxHistorySize]
      whileTrue: [e history removeLast].
    e currentHistoryIndex: 0].
].

e@(ConsoleLineEditor traits) markCursorAsBasePosition
[
  e terminal basePosition: e terminal console cursorPosition
].

e@(ConsoleLineEditor traits) readLine &echoNewLine: echoNewLine &showPrompt: prompt
[
  prompt ifNil: [prompt: True].
  e history first size > 0
    ifTrue: [
      e history at: 0 infect: [| :value | value as: String].
      e history addFirst: ExtensibleArray new.
      [e history size > e maxHistorySize]
        whileTrue: [e history removeLast]].
  e currentHistoryIndex: 0.
  e position: 0.
  prompt /\ [e prompt isNotNil] ifTrue: [e terminal ; e prompt].
  e markCursorAsBasePosition.
  e redrawLine.
  e continue &echoNewLine: echoNewLine
].

e@(ConsoleLineEditor traits) moveCursorTo: pos
[
  e position: pos.
  e updateCursor.
].

e@(ConsoleLineEditor traits) hasInput
"Answer if the editor has events waiting to be processed"
[
  e terminal events hasNext
].

e@(ConsoleLineEditor traits) continue &echoNewLine: echoNewLine
[| terminal |
  echoNewLine ifNil: [echoNewLine: False].
  terminal: e terminal.
  terminal events do: [| :event |
    [
      (event is: SmartConsole KeyDownEvent) ifTrue: [
        event keyName = #Enter ifTrue: [
          echoNewLine ifTrue: [terminal newLine].
          ^ (e lineString as: terminal collectionType)]].
      (e processEvent: event) ifTrue: [e redrawLine].
      terminal flush.
    ] on: Terminal KeyboardInterrupt do: [| :_ | e clear]].
].

e@(ConsoleLineEditor traits) clear
[
  e lineString clear.
  e position: 0.
  e redrawLine.
].

e@(ConsoleLineEditor traits) processEvent: event@(SmartConsole ResizeEvent traits)
[
  True "Simply force a redraw"
].

e@(ConsoleLineEditor traits) processEvent: event
"Process the event and return True if redraw is needed"
[| skipRedraw keymap value |
  skipRedraw: False.

  "Choose value between keyName and char"
  event keyName
    ifNil: [event char ifNotNil: [value: event char]]
    ifNotNil: [value: event keyName].

  "Select keymap based on modifier keys"
  event controlState
    ifTrue: [keymap: e controlKeymap]
    ifFalse: [event altState
               ifTrue: [keymap: e modifierKeymap]
               ifFalse: [keymap: e keymap]].

  "Look for a mapping and execute handler if found"
  keymap at: value
    ifPresent: [| :handler |
      handler edits ifTrue: [e prepareToEditLine].
      skipRedraw: (e handle: handler)]
    ifAbsent: [
      event char ifNotNil: [
        e prepareToEditLine.
        skipRedraw: (e handle: (e AddCharacter newFor: event char))]].

  skipRedraw = Nil \/ [skipRedraw = False]
].

e@(ConsoleLineEditor traits) redrawLine &incremental: incremental
"Re-run the display sequence for the current line."
[
  e terminal display: e lineString cursorAt: e position &incremental: incremental
].

e@(ConsoleLineEditor traits) updateCursor
[
  e terminal moveCursorTo: e position inCommand: e lineString
].

e@(ConsoleLineEditor traits) toggleInsert
"Toggle insert mode."
[
  e insertMode: e insertMode not
].

e@(ConsoleLineEditor traits) wordStart &dynamic: dynamic
"Answer the position of the start of the nearest word (right under the cursor).
Dynamic means that if the cursor is already on the start of a word then it leaves that
word and goes one word back."
[| line pos |
  line: e lineString.
  pos: e position.
  dynamic ifNil: [dynamic: False].

  pos > line indexLast
    ifTrue: [pos: line indexLast]
    ifFalse: [dynamic ifTrue: [pos: pos - 1. pos < 0 ifTrue: [^ 0]]].
  [pos > 0 /\
    [(line at: pos) isDelimiter]]
      whileTrue: [pos: pos - 1].
  [pos >= 0 /\
    [(line at: pos) isDelimiter not]]
      whileTrue: [pos: pos - 1].
  (line includesKey: pos + 1)
    ifTrue: [pos + 1]
    ifFalse: [pos]
].

e@(ConsoleLineEditor traits) wordEnd &dynamic: dynamic
"Answer the position of the end of the nearest word (right under the cursor).
Dynamic means that if the cursor is already on the end of a word then it leaves that
word and goes one word forward."
[| line size pos |
  line: e lineString.
  pos: e position.
  size: line size.
  dynamic ifNil: [dynamic: False].

  pos > line indexLast
    ifTrue: [pos: line indexLast]
    ifFalse: [dynamic ifTrue: [pos: pos + 1. pos >= size ifTrue: [^ size]]].
  (line at: pos) isDelimiter ifTrue: [^ pos].
  [pos < line indexLast /\
    [(line at: pos) isDelimiter]]
      whileTrue: [pos: pos + 1].
  [pos < size /\
    [(line at: pos) isDelimiter not]]
      whileTrue: [pos: pos + 1].
  pos
].

e@(ConsoleLineEditor traits) word
"Answer the word under the cursor, relying on wordStart and wordEnd."
[
  e lineString copyFrom: e wordStart to: e wordEnd - 1
].

e@(ConsoleLineEditor traits) completionsFor: word
"Answer the completions for the given word."
[overrideThis].

e@(ConsoleLineEditor traits) flushCompletions
[e currentCompletions: e currentCompletions new].

e@(ConsoleLineEditor traits) complete: word
"Answer a collection of the valid completions for a given word; this should
allow for varying strategies per context."
[
  word = e currentWord
    ifTrue: [e currentCompletions isEmpty
              ifTrue: [e currentCompletions: (e completionsFor: word)]]
    ifFalse: [e currentWord: word.
              e currentCompletions: (e completionsFor: word)].
  e currentCompletions
].

e@(ConsoleLineEditor traits) complete
"Answer a collection of valid completions for the word under the cursor."
[
  e complete: e word
].

e@(ConsoleLineEditor traits) rememberYank
[
  e currentYank: e position
].

e@(ConsoleLineEditor traits) forgetYank
[
  e lastYank: e yank.
  e currentYank: Nil
].

e@(ConsoleLineEditor traits) tryYank
[
  e currentYank: e lastYank
].

e@(ConsoleLineEditor traits) yank
[
  e rememberYank.
  e killRing next
    ifNil: [e terminal beep. e position]
    ifNotNilDo:
      [| :kill |
       e lineString: (e lineString copyFrom: 0 to: e currentYank)
         ; kill ; (e lineString copyFrom: e position).
       e position: e currentYank + kill size]
].

e@(ConsoleLineEditor traits) replaceWordWith: word
"Replace the word under the cursor with the given word.
Move cursor to end of the new word."
[| start end |
  start: e wordStart.
  end: e wordEnd.
  end >= start ifTrue: [e lineString at: start remove: end - start].
  e lineString at: start insertAll: word.
  e position: start.
  e position: e wordEnd.
].

e@(ConsoleLineEditor traits) isCursorInQuotedString
"A simple test to see if the cursor is between quotes."
[| start |
  start: e wordStart.
  start isNotNil
    /\ [start isPositive]
    /\ [(e lineString at: start - 1) isQuote]
].

"Commands"
"TODO: refactor to re-use the UI Command abstraction?"

ConsoleLineEditor define: #Command &parents: {Cloneable}
  &slots: {#edits -> False}.

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor Command traits)
[overrideThis].

e@(ConsoleLineEditor traits) addCommand: name
"Defines and returns a new attribute-named command object, with no slots.
If one already exists, this re-uses it and ensures the slot properties."
[| command |
  command: ((e traits hasSlotNamed: name)
   ifTrue: [e traits atSlotNamed: name]
   ifFalse: [e Command clone]).
  e traits addImmutableSlot: name valued: command.
  command
].

e@(ConsoleLineEditor traits) addEditingCommand: name
[| result |
  result: (e addCommand: name).
  result edits: True.
  result
].

ConsoleLineEditor define: #AddCharacter
                  &parents: {ConsoleLineEditor Command} &slots:
  {#char -> $\0. #edits -> True}.

c@(ConsoleLineEditor AddCharacter traits) newFor: char
[c clone `setting: #(char) to: {char}].

e@(ConsoleLineEditor traits) handle: c@(ConsoleLineEditor AddCharacter traits)
[| result |
  e insertMode 
    ifTrue: [e lineString at: e position insert: c char]
    ifFalse: [
      e position = e lineString size
        ifTrue: [e lineString addLast: c char]
        ifFalse: [e lineString at: e position put: c char]].
  e position: e position + 1.
  e position = e lineString size /\ [e terminal console autoScrollsAtBottom]
    ifTrue: [e terminal nextPut: c char.
             e redrawLine &incremental: True. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteCharBackwards)
[
  e position = 0 ifTrue: [^ True].
  e position: e position - 1.
  e lineString removeAt: e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteCharForwards)
[
  e position >= e lineString size ifTrue: [^ True].
  e lineString removeAt: e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #EOF)
[
  e lineString isEmpty
    ifTrue: [e reader exhausted]
    ifFalse: [e terminal beep].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #KeyboardInterrupt)
[
  e terminal interrupted.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteWordBackwards)
[| start |
  start: e wordStart.
  start > 0 ifTrue: [start: start - 1].
  e lineString at: start remove: e position - start.
  e position: start.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DeleteWordForwards)
[| end |
  end: e wordEnd.
  end < e lineString size ifTrue: [end: end + 1].
  e lineString at: e position remove: end - e position.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #UpcaseWord)
[| end |
  end: e wordEnd.
  (e lineString sliceFrom: e position below: end)
    infect: [| :char | char toUppercase].
  e position: end.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #DowncaseWord)
[| end |
  end: e wordEnd.
  (e lineString sliceFrom: e position below: end)
    infect: [| :char | char toLowercase].
  e position: end.
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorToBOL)
[
  e moveCursorTo: 0.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorToEOL)
[
  e moveCursorTo: e lineString size.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorCharForwards)
[
  e position < e lineString size ifTrue: [
    e moveCursorTo: e position + 1.
  ].
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorCharBackwards)
[
  e position > 0 ifTrue: [
    e moveCursorTo: e position - 1.
  ].
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorWordForwards)
[
  e moveCursorTo: e wordEnd.
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #CursorWordBackwards)
[
  e moveCursorTo: (e wordStart &dynamic: True).
  True
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #Undo)
[e rewindState]. "FIX"

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #ToggleInsert)
[e toggleInsert].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #HistoryPrevious)
[
  e currentHistoryIndex < e history indexLast
    ifTrue: [e currentHistoryIndex: e currentHistoryIndex + 1.
      e position: e lineString size]
    ifFalse: [e terminal beep. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addCommand: #HistoryNext)
[
  e currentHistoryIndex > 0
    ifTrue: [e currentHistoryIndex: e currentHistoryIndex - 1.
      e position: e lineString size]
    ifFalse: [e terminal beep. ^ True].
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #KillToEOL)
[
  e killRing addLast: (e lineString copyFrom: e position).
  e lineString: (e lineString copyFrom: 0 to: e position).
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #KillToBOL)
[
  e killRing addLast: (e lineString copyFrom: 0 to: e position).
  e lineString: (e lineString copyFrom: e position).
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #Yank)
[
  e tryYank
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #CopyRegion)
[| start end |
  e mark ifNil: [^ e position].
  start: (e mark min: e position).
  end: (e mark max: e position).
  e killRing addLast: (e lineString copyFrom: start to: end).
  e mark: Nil.
  e position
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #CutRegion)
[| start end |
  e mark ifNil: [^ e position].
  start: (e mark min: e position).
  end: (e mark max: e position).
  e killRing addLast: (e lineString copyFrom: start to: end).
  e mark: Nil.
  e lineString: (e lineString copyFrom: 0 to: start)
    ; (e lineString copyFrom: end).
  e position: start
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #SetMark)
[
  e mark: e position.
].

e@(ConsoleLineEditor traits) handle: _@(ConsoleLineEditor addCommand: #Help)
[
].

e@(ConsoleLineEditor traits)
  handle: _@(ConsoleLineEditor addEditingCommand: #Complete)
[| completions |
  completions: e complete.
  completions isEmpty ifTrue: [e terminal beep. ^ Nil].
  completions size = 1 ifTrue: [^ (e replaceWordWith: completions first)].
  e printInColumns: completions.
  e terminal newLine.
  e prompt ifNotNil: [e terminal ; e prompt].
  e markCursorAsBasePosition.
  e redrawLine.
].

e@(ConsoleLineEditor traits) printInColumns: col
"TODO: Oly prints one column for now.
Could reuse some UI layouting algorithm"
[| term |
  term: e terminal.
  term newLine.
  col
    do: [| :each | term ; '  ' ; each]
    separatedBy: [e terminal newLine].
].

{
 $a -> ConsoleLineEditor CursorToBOL.
 $b -> ConsoleLineEditor CursorCharBackwards.
 $d -> ConsoleLineEditor EOF.
 $e -> ConsoleLineEditor CursorToEOL.
 $f -> ConsoleLineEditor CursorCharForwards.
 $k -> ConsoleLineEditor KillToEOL.
 $n -> ConsoleLineEditor HistoryNext.
 $p -> ConsoleLineEditor HistoryPrevious.
 $u -> ConsoleLineEditor CutRegion.
 $y -> ConsoleLineEditor Yank.
 $c -> ConsoleLineEditor KeyboardInterrupt.
 $- -> ConsoleLineEditor Undo.
 #Backspace -> ConsoleLineEditor DeleteWordBackwards.
 #Delete -> ConsoleLineEditor DeleteWordForwards.
 "Ctrl+Space can't be detected with ncurses (or with unix terminals in general?)"
 #Space     -> ConsoleLineEditor SetMark.
} do: [| :assoc | ConsoleLineEditor controlKeymap add: assoc].

{
 $b -> ConsoleLineEditor CursorWordBackwards.
 $f -> ConsoleLineEditor CursorWordForwards.
 $l -> ConsoleLineEditor DowncaseWord.
 $u -> ConsoleLineEditor UpcaseWord.
 $w -> ConsoleLineEditor CopyRegion.
} do: [| :assoc | ConsoleLineEditor modifierKeymap add: assoc].

{
 #Tab         -> ConsoleLineEditor Complete.
 #Backspace   -> ConsoleLineEditor DeleteCharBackwards.
"It must be special-cased because we can't easily return from a non-toplevel method"
"#Return      -> ConsoleLineEditor FinishInput."
 #UpArrow     -> ConsoleLineEditor HistoryPrevious.
 #DownArrow   -> ConsoleLineEditor HistoryNext.
 #RightArrow  -> ConsoleLineEditor CursorCharForwards.
 #LeftArrow   -> ConsoleLineEditor CursorCharBackwards.
 #Insert      -> ConsoleLineEditor ToggleInsert.
 #Delete      -> ConsoleLineEditor DeleteCharForwards.
 #Home        -> ConsoleLineEditor CursorToBOL.
 #End         -> ConsoleLineEditor CursorToEOL
} do: [| :assoc | ConsoleLineEditor keymap add: assoc].

ConsoleLineEditor traits define: #ReadStream &parents: {ReadStream}
  &slots: {#editor. #line. #position. #closed -> False}.

s@(ConsoleLineEditor ReadStream traits) on: editor
[
  s editor: editor.
  s
].

s@(ConsoleLineEditor ReadStream traits) isAtEnd [s closed].
s@(ConsoleLineEditor ReadStream traits) elementType [s terminal elementType].
s@(ConsoleLineEditor ReadStream traits) collectionType [s terminal collectionType].

s@(ConsoleLineEditor ReadStream traits) next
[| result |
  [s line isNil \/ [s line isEmpty]]
    whileTrue: [
      s line: (s editor readLine &echoNewLine: True).
      s line ifNil: [
        s closed: True.
        s exhausted.
        ^ Nil].
      s line: (s line ; '\n').
      s position: 0].
  result: (s line at: s position).
  s position: s position + 1.
  s position = s line size ifTrue:
    [s line: Nil].
  result
].

"This is the default LineEditor that can be overridden by
adding a slot to terminal instances."
SmartTerminal traits define: #LineEditor -> ConsoleLineEditor.