Accept RefValue cursor as TerminalMenu request argument. (#38393)

stdlib/REPL/src/TerminalMenus/AbstractMenu.jl

@@ -64,6 +64,8 @@ end
 # TODO Julia2.0: get rid of parametric intermediate, making it just
 #   abstract type ConfiguredMenu <: AbstractMenu end
 # Or perhaps just make all menus ConfiguredMenus
+# Also consider making `cursor` a mandatory field in the Menu structs
+# instead of going via the RefValue in `request`.
 abstract type _ConfiguredMenu{C} <: AbstractMenu end
 const ConfiguredMenu = _ConfiguredMenu{<:AbstractConfig}
 
@@ -162,19 +164,24 @@ selected(m::AbstractMenu) = m.selected
     request(m::AbstractMenu; cursor=1)
 
 Display the menu and enter interactive mode. `cursor` indicates the item
-number used for the initial cursor position.
+number used for the initial cursor position. `cursor` can be either an
+`Int` or a `RefValue{Int}`. The latter is useful for observation and
+control of the cursor position from the outside.
 
 Returns `selected(m)`.
 """
 request(m::AbstractMenu; kwargs...) = request(terminal, m; kwargs...)
 
-function request(term::REPL.Terminals.TTYTerminal, m::AbstractMenu; cursor::Int=1, suppress_output=false)
+function request(term::REPL.Terminals.TTYTerminal, m::AbstractMenu; cursor::Union{Int, Base.RefValue{Int}}=1, suppress_output=false)
+    if cursor isa Int
+        cursor = Ref(cursor)
+    end
     menu_header = header(m)
     !suppress_output && !isempty(menu_header) && println(term.out_stream, menu_header)
 
     state = nothing
     if !suppress_output
-        state = printmenu(term.out_stream, m, cursor, init=true)
+        state = printmenu(term.out_stream, m, cursor[], init=true)
     end
 
     raw_mode_enabled = try
@@ -193,22 +200,22 @@ function request(term::REPL.Terminals.TTYTerminal, m::AbstractMenu; cursor::Int=
             c = readkey(term.in_stream)
 
             if c == Int(ARROW_UP)
-                cursor = move_up!(m, cursor, lastoption)
+                cursor[] = move_up!(m, cursor[], lastoption)
             elseif c == Int(ARROW_DOWN)
-                cursor = move_down!(m, cursor, lastoption)
+                cursor[] = move_down!(m, cursor[], lastoption)
             elseif c == Int(PAGE_UP)
-                cursor = page_up!(m, cursor, lastoption)
+                cursor[] = page_up!(m, cursor[], lastoption)
             elseif c == Int(PAGE_DOWN)
-                cursor = page_down!(m, cursor, lastoption)
+                cursor[] = page_down!(m, cursor[], lastoption)
             elseif c == Int(HOME_KEY)
-                cursor = 1
+                cursor[] = 1
                 m.pageoffset = 0
             elseif c == Int(END_KEY)
-                cursor = lastoption
+                cursor[] = lastoption
                 m.pageoffset = lastoption - m.pagesize
             elseif c == 13 # <enter>
                 # will break if pick returns true
-                pick(m, cursor) && break
+                pick(m, cursor[]) && break
             elseif c == UInt32('q')
                 cancel(m)
                 break
@@ -221,7 +228,7 @@ function request(term::REPL.Terminals.TTYTerminal, m::AbstractMenu; cursor::Int=
             end
 
             if !suppress_output
-                state = printmenu(term.out_stream, m, cursor, oldstate=state)
+                state = printmenu(term.out_stream, m, cursor[], oldstate=state)
             end
         end
     finally # always disable raw mode

stdlib/REPL/src/TerminalMenus/MultiSelectMenu.jl

@@ -59,7 +59,7 @@ function MultiSelectMenu(options::Array{String,1}; pagesize::Int=10, selected=In
     pagesize = pagesize == -1 ? length(options) : pagesize
     # pagesize shouldn't be bigger than options
     pagesize = min(length(options), pagesize)
-    # after other checks, pagesize must be greater than 2
+    # after other checks, pagesize must be at least 1
     pagesize < 1 && error("pagesize must be >= 1")
 
     pageoffset = 0

stdlib/REPL/test/TerminalMenus/multiselect_with_skip_menu.jl

@@ -0,0 +1,124 @@
+# This file is a part of Julia. License is MIT: https://julialang.org/license
+
+# Like MultiSelect but adds `n`/`p` to move to next/previous
+# unselected item and `N`/`P` to move to next/previous selected item.
+mutable struct MultiSelectWithSkipMenu <: TerminalMenus._ConfiguredMenu{TerminalMenus.Config}
+    options::Array{String,1}
+    pagesize::Int
+    pageoffset::Int
+    selected::Set{Int}
+    cursor::Base.RefValue{Int}
+    config::TerminalMenus.MultiSelectConfig
+end
+
+function MultiSelectWithSkipMenu(options::Array{String,1}; pagesize::Int=10,
+                                 selected=Int[], kwargs...)
+    length(options) < 1 && error("MultiSelectWithSkipMenu must have at least one option")
+
+    pagesize = pagesize == -1 ? length(options) : pagesize
+    pagesize = min(length(options), pagesize)
+    pagesize < 1 && error("pagesize must be >= 1")
+
+    pageoffset = 0
+    _selected = Set{Int}()
+    for item in selected
+        push!(_selected, item)
+    end
+
+    MultiSelectWithSkipMenu(options, pagesize, pageoffset, _selected,
+                            Ref{Int}(1),
+                            TerminalMenus.MultiSelectConfig(; kwargs...))
+end
+
+TerminalMenus.header(m::MultiSelectWithSkipMenu) = "[press: d=done, a=all, c=none, npNP=move with skip]"
+
+TerminalMenus.options(m::MultiSelectWithSkipMenu) = m.options
+
+TerminalMenus.cancel(m::MultiSelectWithSkipMenu) = m.selected = Set{Int}()
+
+# Do not exit menu when a user selects one of the options
+function TerminalMenus.pick(menu::MultiSelectWithSkipMenu, cursor::Int)
+    if cursor in menu.selected
+        delete!(menu.selected, cursor)
+    else
+        push!(menu.selected, cursor)
+    end
+
+    return false
+end
+
+function TerminalMenus.writeline(buf::IOBuffer,
+                                 menu::MultiSelectWithSkipMenu,
+                                 idx::Int, iscursor::Bool)
+    if idx in menu.selected
+        print(buf, menu.config.checked, " ")
+    else
+        print(buf, menu.config.unchecked, " ")
+    end
+
+    print(buf, replace(menu.options[idx], "\n" => "\\n"))
+end
+
+# d: Done, return from request
+# a: Select all
+# c: Deselect all
+# n: Move to next unselected
+# p: Move to previous unselected
+# N: Move to next selected
+# P: Move to previous selected
+function TerminalMenus.keypress(menu::MultiSelectWithSkipMenu, key::UInt32)
+    if key == UInt32('d') || key == UInt32('D')
+        return true # break
+    elseif key == UInt32('a') || key == UInt32('A')
+        menu.selected = Set(1:length(menu.options))
+    elseif key == UInt32('c') || key == UInt32('C')
+        menu.selected = Set{Int}()
+    elseif key == UInt32('n')
+        move_cursor!(menu, 1, false)
+    elseif key == UInt32('p')
+        move_cursor!(menu, -1, false)
+    elseif key == UInt32('N')
+        move_cursor!(menu, 1, true)
+    elseif key == UInt32('P')
+        move_cursor!(menu, -1, true)
+    end
+    false # don't break
+end
+
+function move_cursor!(menu, direction, selected)
+    c = menu.cursor[]
+    while true
+        c += direction
+        if !(1 <= c <= length(menu.options))
+            return
+        end
+        if (c in menu.selected) == selected
+            break
+        end
+    end
+    menu.cursor[] = c
+    if menu.pageoffset >= c - 1
+        menu.pageoffset = max(c - 2, 0)
+    end
+    if menu.pageoffset + menu.pagesize <= c
+        menu.pageoffset = min(c + 1, length(menu.options)) - menu.pagesize
+    end
+end
+
+# Intercept the `request` call to insert the cursor field.
+function TerminalMenus.request(term::REPL.Terminals.TTYTerminal,
+                               m::MultiSelectWithSkipMenu;
+                               cursor::Int=1, kwargs...)
+    m.cursor[] = cursor
+    invoke(TerminalMenus.request, Tuple{REPL.Terminals.TTYTerminal,
+                                        TerminalMenus.AbstractMenu},
+           term, m; cursor=m.cursor, kwargs...)
+end
+
+# These tests are specifically designed to verify that a `RefValue`
+# input to the AbstractMenu `request` function works as intended.
+menu = MultiSelectWithSkipMenu(string.(1:5), selected=[2, 3])
+@test simulate_input(Set([2, 3, 4]), menu, 'n', :enter, 'd')
+
+menu = MultiSelectWithSkipMenu(string.(1:5), selected=[2, 3])
+@test simulate_input(Set([2]), menu, 'P', :enter, 'd', cursor=5)

stdlib/REPL/test/TerminalMenus/runtests.jl

@@ -4,7 +4,8 @@ import REPL
 using REPL.TerminalMenus
 using Test
 
-function simulate_input(expected, menu::TerminalMenus.AbstractMenu, keys...)
+function simulate_input(expected, menu::TerminalMenus.AbstractMenu, keys...;
+                        kwargs...)
     keydict =  Dict(:up => "\e[A",
                     :down => "\e[B",
                     :enter => "\r")
@@ -17,12 +18,13 @@ function simulate_input(expected, menu::TerminalMenus.AbstractMenu, keys...)
         end
     end
 
-    request(menu; suppress_output=true) == expected
+    request(menu; suppress_output=true, kwargs...) == expected
 end
 
 include("radio_menu.jl")
 include("multiselect_menu.jl")
 include("dynamic_menu.jl")
+include("multiselect_with_skip_menu.jl")
 
 # Legacy tests
 include("legacytests/old_radio_menu.jl")