dry-cli-ui 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be9415991dfb76bcec0253194fd2964b2f3781ca06cfc36be0653a9dd70bbba4
-  data.tar.gz: c3cd053b4e9a8e49cb6b33ebf2b41df1f3ead240e0f4b74184695914c85850ec
+  metadata.gz: 6d1ad3344ddfd395caef9b2ec0128f05cda8248a98afa864b1b61ed1d1db0b5e
+  data.tar.gz: d55f3256373ec25c1201dd0c39525eeb49b50f16989806740f720ed3e59f0f13
 SHA512:
-  metadata.gz: c55ab258c17e0fc192e16995374190cafd81d0f493057af61e3b186bac96e12b7f5736f28f4ff8f19d551298de830637c7001d6f49f240bb1a9db5ace54e401d
-  data.tar.gz: 01ab36292c51f456c16c313a7fe45607b50ddc63906f0aa356eb98b4dd31b522ef1df064c147a6a57fdf6df3e95278abd9366e09762e5cfc5d6fab773e209dcc
+  metadata.gz: fe5bb8356f594b5a8670ee7c8b9a5cdc0ec87e2480bea892f0e98389a8d43218fd2de162f77de9444990e3d197e7679352995f1da3eb234094df68a5ea5c2d25
+  data.tar.gz: b982df4a36156203f92f39b3b3c8da0e9b5fe8672092333c09d7dd70e48759f0470fc82060dea4a16bdbc9daca3e219361ca0c7f95f114961b740b20354e2105

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.5.1]
+
+- `ui.stoppable { |stop| ... }` makes Ctrl-C ask for a stop instead of interrupting, and `ui.multi_spinner` and `ui.multi_progress` take `stop:`. Once it is set, the jobs running finish, the rest are skipped, and the headline says `stopping`, then ends skipped. A second Ctrl-C interrupts. `Dry::CLI::UI::Stop` is the object behind it.
+- `ui.multi_spinner` and `ui.multi_progress` stay animated when their rows do not fit on the screen. Only the running jobs are shown under the headline, as many as fit. Before, every row was printed one by one.
+- `m.progress` inside `ui.multi_progress` takes `total: nil` for a job that learns its size as it runs. Its bar is empty and counts `12/?` until the job sets `bar.total =`, which every progress handle now has.
+- `ui.multi_progress` takes `count: :jobs`, so the headline bar counts the jobs that ended, and `total:`, the headline's own total for bars that overlap.
+- `examples/bin/mycli download-urls` sends each URL's `HEAD` request when its turn comes, not all of them first, and writes each file as its body arrives. `find-hosts --progress` gives its headline a total of the addresses scanned, not twice that. Both take `-c/--concurrency`, from 1 to 100, 10 by default, and on Ctrl-C finish what is running and report how many URLs were downloaded or addresses scanned.
+
 ## [0.5.0]
 
 - The README documents every public method, option and error, with the plain output each widget prints when piped, and a section on testing a command with `StringIO`.

data/README.md

@@ -267,6 +267,7 @@ end
 ```
 
 - `advance(step = 1)` adds to `current` and returns the handle; `current` never passes `total`.
+- `total = n` sets the total once the work finds out, such as a download learning its size, and lowers `current` to fit. Anything but a non-negative Integer raises `ArgumentError`.
 - `total:` must be a non-negative Integer, or `progress` raises `ArgumentError`.
 - `total: 0` draws no bar, and ends `✓ Copying 0/0`.
 - `color:` paints this bar's finished part in any Pastel style, such as `color: :red`, instead of the configured `bar_color`. A style Pastel does not know raises `ArgumentError` before the block runs.
@@ -328,7 +329,13 @@ Fetching...
 𝘅 Fetching (0.1s)
 ```
 
-The rows are also printed one by one on a terminal that has fewer rows than the widget needs, since the cursor cannot move above the top of the screen.
+On a terminal with fewer rows than the widget needs, the cursor cannot reach them all, so only the jobs running are shown under the headline, as many as fit. Jobs leave the screen as they end, and the headline is all that remains:
+
+```text
+[⠋] Fetching
+├─ [⠋] video
+└─ [⠋] audio
+```
 
 ### Several progress bars at once
 
@@ -354,13 +361,43 @@ The same shape as `multi_spinner`, with a bar per job and a headline bar that co
 Each job is given the same handle as `ui.progress`, with `advance(step = 1)`, `current` and `total`. `m.progress` takes `color:` as `ui.progress` does, so bars side by side can differ:
 
 ```ruby
-ui.multi_progress("Probing #{hosts.size} hosts") do |m|
+ui.multi_progress("Probing #{hosts.size} hosts", total: hosts.size) do |m|
   m.progress("Answered", total: hosts.size, color: :green) { |bar| ... }
   m.progress("No answer", total: hosts.size, color: :red) { |bar| ... }
 end
 ```
 
-The headline bar keeps the configured colour. A finished job's row reads `[✓] fonts.zip 40/40 (0.1s)`, and the headline's `[✓] Downloading 240/240 (0.3s)`. It returns what each job returned, in declaration order, and takes `concurrent:` as `multi_spinner` does. Every `m.progress` needs a block and a non-negative Integer `total:`, or raises `ArgumentError`.
+The headline bar keeps the configured colour. A finished job's row reads `[✓] fonts.zip 40/40 (0.1s)`, and the headline's `[✓] Downloading 240/240 (0.3s)`. It returns what each job returned, in declaration order, and takes `concurrent:` as `multi_spinner` does. Every `m.progress` needs a block, and a `total:` that is nil or a non-negative Integer, or raises `ArgumentError`.
+
+A job that learns its size only as it runs declares `total: nil` and sets `bar.total =` once it knows. Until then its bar is empty and its count reads `12/?`.
+
+The headline bar adds up every job's bar. Two options change that:
+
+- `count: :jobs` counts the jobs that have ended, out of all of them, whatever each bar measures.
+- `total: n` sets the headline's total, for bars that overlap, such as two bars that each count some of the same hosts.
+
+```ruby
+ui.multi_progress("Downloading", concurrent: 2, count: :jobs) do |m|
+  files.each do |file|
+    m.progress(file.name, total: nil) do |bar|
+      bar.total = size_of(file)
+      download(file) { |bytes| bar.advance(bytes) }
+    end
+  end
+end
+```
+
+Piped, where `images.tar.gz` never learned its size:
+
+```text
+Downloading...
+  [✓] fonts.zip 40/40 (0.1s)
+  [✓] images.tar.gz 120/? (0.1s)
+  [✓] video.mp4 80/80 (0.1s)
+✓ Downloading 3/3 (0.1s)
+```
+
+Any other `count:`, or a `total:` that is not a non-negative Integer, raises `ArgumentError`.
 
 Piped:
 
@@ -384,21 +421,16 @@ end
 File.write("urls.txt", bodies.join("\n"))
 ```
 
-With `multi_progress`, each URL gets a bar that fills one byte at a time as the body arrives. A bar's `total` is fixed when it is declared, so a `HEAD` request asks each URL for its size first:
+With `multi_progress`, each URL gets a bar that fills as the body arrives, and the headline counts URLs. When a URL's turn comes, a `HEAD` request asks for its size, which becomes the bar's total:
 
 ```ruby
-found = urls.filter_map do |url|
-  [url, content_length(url)]
-rescue StandardError => e
-  ui.status "#{url}: #{e.message}", level: :warn
-  nil
-end
-
-bodies = ui.multi_progress("Fetching #{found.size} URLs", concurrent: 8) do |m|
-  found.each do |url, size|
-    m.progress(url, total: size || 1) do |bar|
-      body = download(url) { |bytes| bytes.times { bar.advance } if size }
-      bar.advance unless size # no Content-Length: done in one step
+bodies = ui.multi_progress("Fetching #{urls.size} URLs", concurrent: 8, count: :jobs) do |m|
+  urls.each do |url|
+    m.progress(url, total: nil) do |bar|
+      size = content_length(url)
+      bar.total = size if size
+      body = download(url) { |bytes| bar.advance(bytes) }
+      bar.total = bar.current unless size # no Content-Length: full once done
       body
     end
   end
@@ -434,7 +466,34 @@ def download(url)
 end
 ```
 
-In both, at most eight requests run at once and the rest wait as `[ ]` rows. The headline counts every URL, and in `multi_progress` every byte. A server that sends no `Content-Length` gets a bar of one unit, which sits at 0% and fills when its download ends. These helpers are kept short: a real one follows redirects, and sends `Accept-Encoding: identity` so the bytes counted match `Content-Length`. With more URLs than the screen has rows, each finished URL prints one line instead.
+In both, at most eight requests run at once, in the order of `urls`, and the rest wait as `[ ]` rows. A server that sends no `Content-Length` leaves its bar empty, counting `12/?`, until its download ends. These helpers are kept short: a real one follows redirects, sends `Accept-Encoding: identity` so the bytes counted match `Content-Length`, and writes each body to its file as it arrives rather than holding it in memory; `examples/bin/mycli download-urls` does all three. With more URLs than the screen has rows, only the URLs downloading are shown.
+
+### Stopping on Ctrl-C
+
+`ui.stoppable` runs its block with Ctrl-C asking for a stop instead of killing the command. Hand the `stop` it yields to `multi_spinner` or `multi_progress` as `stop:`: once Ctrl-C is pressed, the jobs running finish, no more start, and the command carries on to report what it did. A second Ctrl-C interrupts as usual.
+
+```ruby
+ui.stoppable do |stop|
+  files = ui.multi_spinner("Downloading #{urls.size} URLs", concurrent: 10, stop: stop) do |m|
+    urls.each { |url| m.spinner(url) { download(url) } }
+  end
+  next ui.success("Downloaded #{files.size} URLs") unless stop.stopped?
+
+  ui.info "Stopped", "Downloaded #{files.compact.size} of #{urls.size} URLs"
+end
+```
+
+While the running jobs finish, the headline reads `[⠋] Downloading 1628 URLs stopping`. Jobs that never started are marked skipped and return `nil`, and the headline ends skipped too, unless a job failed. Piped:
+
+```text
+Fetching...
+  [✓] fonts (0.1s)
+  [—] images
+  [—] video
+— Fetching (0.1s)
+```
+
+`stop.stopped?` says whether a stop was asked for, and `stop.stop!` asks for one from code, from any thread. `Dry::CLI::UI::Stop.new.trap(signal)` traps a signal other than `INT`. Your own worker threads can check `stop.stopped?` before taking the next item, as `examples/bin/mycli find-hosts` does. With `concurrent: true` every job has started already, so there is nothing left to skip.
 
 ### Task trees
 

data/examples/bin/mycli

@@ -28,6 +28,23 @@ module Foo
         end
       end
 
+      # Adds -c/--concurrency, how many items a command works on at once.
+      module Concurrency
+        DEFAULT = 10
+        MAX = 100
+
+        def self.included(command)
+          command.option :concurrency, aliases: ["-c"], type: :integer, default: DEFAULT, desc: "How many at once, from 1 to #{MAX}"
+        end
+
+        private
+
+        # @return [Integer, nil] the value as an Integer; nil when out of range
+        def concurrency(value)
+          Integer(value, exception: false)&.then { |count| count if count.between?(1, MAX) }
+        end
+      end
+
       # Used by download-urls: follows up to REDIRECTS redirects on every
       # request, and asks for the body as it is stored, so the bytes counted
       # match Content-Length.
@@ -52,28 +69,24 @@ module Foo
           [uri, response.content_length]
         end
 
-        # @yieldparam bytes [Integer] the size of each chunk as it arrives
-        # @return [Array(String, String, nil)] the body, and its media type when the server says
+        # @yieldparam response [Net::HTTPSuccess] the response, whose body is
+        #   read in the block
+        # @return [Object] what the block returned
         # @raise [RuntimeError] for a response that is not a success
-        def download(uri, hops = REDIRECTS, &)
-          body = +""
-          type = nil
+        def get(uri, hops = REDIRECTS, &)
+          result = nil
           location = nil
           start(uri) do |http|
             http.request_get(uri.request_uri, HEADERS) do |response|
               next location = redirect(uri, response, hops) if response.is_a?(Net::HTTPRedirection)
               raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
 
-              type = response.content_type
-              response.read_body do |chunk|
-                body << chunk
-                yield chunk.bytesize if block_given?
-              end
+              result = yield response
             end
           end
-          return download(URI(location), hops - 1, &) if location
+          return get(URI(location), hops - 1, &) if location
 
-          [body, type]
+          result
         end
 
         # @return [String] the absolute URL a redirect points to
@@ -90,7 +103,9 @@ module Foo
         end
       end
 
-      # Downloads URLs, each to its own file, under a spinner or a progress bar.
+      # Downloads URLs, each to its own file as its body arrives, at most
+      # --concurrency at once and in the order given, under a spinner or a
+      # progress bar.
       class DownloadUrls < Dry::CLI::Command
         include Dry::CLI::UI
 
@@ -116,21 +131,21 @@ module Foo
           "text/xml" => ".xml"
         }.freeze
 
-        # The most URLs downloaded at once.
-        CONCURRENCY = 10
-
         desc "Download URLs, each to its own file"
         argument :urls, type: :array, required: false, desc: "URLs to download, separated by spaces"
         option :'urls-file', aliases: ["-u"], desc: "A file with one URL per line; blank lines and # comments are skipped"
-        option :'save-to', default: ".", desc: "Directory to save the files in, created when missing"
-        option :progress, type: :flag, default: false, desc: "Show a progress bar per URL"
-        option :spinner, type: :flag, default: false, desc: "Show a spinner per URL; used when neither flag is given"
+        option :output, aliases: ["-o"], default: ".", desc: "A directory to save the files in, created when missing"
+        option :progress, aliases: ["-p"], type: :flag, default: true, desc: "Show a progress bar per URL"
+        option :spinner, aliases: ["-s"], type: :flag, default: false, desc: "Show a spinner per URL; used when neither flag is given"
+        include Concurrency
 
         def call(urls: [], progress: false, spinner: false, **options)
-          return ui.error("Pick one of --progress and --spinner, not both") if progress && spinner
+          progress = false if spinner
+          @concurrency = concurrency(options[:concurrency]) or
+            return ui.error("--concurrency must be from 1 to #{Concurrency::MAX}, got #{options[:concurrency]}")
 
           urls_file = options[:'urls-file']
-          save_to = options.fetch(:'save-to', ".")
+          save_to = options.fetch(:output, ".")
 
           begin
             urls += read_urls(urls_file) if urls_file
@@ -153,16 +168,18 @@ module Foo
             return ui.error("Cannot create #{save_to}", e.message)
           end
 
-          downloads = progress ? with_progress(urls) : with_spinner(urls)
-          files = urls.zip(downloads).filter_map do |url, (body, type)|
-            next unless body
-
-            File.join(save_to, filename(url, type)).tap { |file| File.write(file, body) }
+          # Ctrl-C lets the downloads running finish, and starts no more.
+          files = ui.stoppable do |stop|
+            @stop = stop
+            (progress ? with_progress(urls, save_to) : with_spinner(urls, save_to)).compact
           end
+          return ui.info("Stopped", "Downloaded #{files.size} of #{urls.size} URLs into #{save_to}") if @stop.stopped?
+
           ui.success "Wrote #{files.size} of #{urls.size} URLs", files.join("\n")
         end
 
         # An http or https URL with a host.
+
         def valid?(url)
           uri = URI.parse(url)
           uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
@@ -170,14 +187,15 @@ module Foo
           false
         end
 
-        def with_spinner(urls)
-          ui.multi_spinner("Downloading #{urls.size} URLs", concurrent: CONCURRENCY) do |m|
+        # A spinner per URL; a URL that fails is marked failed.
+        #
+        # @return [Array<String, nil>] the file written for each URL
+        def with_spinner(urls, save_to)
+          ui.multi_spinner("Downloading #{urls.size} URLs", concurrent: @concurrency, stop: @stop) do |m|
             urls.each do |url|
               m.spinner(url) do |line|
-                line.detail = "resolving"
-                uri, = HTTP.resolve(url)
-                line.detail = "downloading #{uri.host}"
-                HTTP.download(uri)
+                received = 0
+                save(url, URI(url), save_to) { |bytes| line.detail = "#{received += bytes} bytes" }
               rescue StandardError => e
                 line.fail(e.message)
                 nil
@@ -186,36 +204,53 @@ module Foo
           end
         end
 
-        # A bar's total is fixed when it is declared, so ask each URL for its
-        # size first, with a HEAD request. A URL that fails here is left out.
-        def with_progress(urls)
-          found = urls.to_h do |url|
-            [url, HTTP.resolve(url)]
-          rescue StandardError => e
-            ui.status "#{url}: #{e.message}", level: :warn
-            [url, nil]
-          end
-          ready = found.select { |_, (uri, _)| uri }
-          return urls.map { nil } if ready.empty?
-
+        # A bar per URL, and a headline bar counting the URLs done. When a
+        # URL's turn comes, a HEAD request finds its size for the bar's total,
+        # then the file is downloaded.
+        #
+        # @return [Array<String, nil>] the file written for each URL
+        def with_progress(urls, save_to)
           # A bar cannot be marked failed, so a download that fails is
           # reported once every bar has finished.
           errors = Concurrent::Array.new
-          bodies = ui.multi_progress("Downloading #{ready.size} URLs", concurrent: CONCURRENCY) do |m|
-            ready.each do |url, (uri, size)|
-              m.progress(url, total: size || 1) do |bar|
-                download = HTTP.download(uri) { |bytes| bar.advance(bytes) if size }
-                bar.advance unless size # no Content-Length: done in one step
-                download
+          files = ui.multi_progress("Downloading #{urls.size} URLs", concurrent: @concurrency, count: :jobs, stop: @stop) do |m|
+            urls.each do |url|
+              m.progress(url, total: nil) do |bar|
+                uri, size = HTTP.resolve(url)
+                bar.total = size if size
+                save(url, uri, save_to) { |bytes| bar.advance(bytes) }.tap { bar.total = bar.current unless size }
               rescue StandardError => e
                 errors << "#{url}: #{e.message}"
                 nil
               end
             end
           end
-          errors.each { |error| ui.status error, level: :warn }
-          downloads = ready.keys.zip(bodies).to_h
-          urls.map { |url| downloads[url] }
+          ui.warn "#{errors.size} URLs failed", errors.join("\n") if errors.any?
+          files
+        end
+
+        # Downloads a URL straight into its file, removing what was written
+        # when the download fails.
+        #
+        # @param url [String] what the file is named after
+        # @param uri [URI] where to download it from
+        # @yieldparam bytes [Integer] the size of each chunk as it is written
+        # @return [String] the file written
+        def save(url, uri, save_to)
+          file = nil
+          HTTP.get(uri) do |response|
+            file = File.join(save_to, filename(url, response.content_type))
+            File.open(file, "wb") do |io|
+              response.read_body do |chunk|
+                io.write(chunk)
+                yield chunk.bytesize
+              end
+            end
+          end
+          file
+        rescue StandardError
+          FileUtils.rm_f(file) if file
+          raise
         end
 
         def read_urls(file)
@@ -243,19 +278,19 @@ module Foo
         # RDP, and the two AirPlay and Synology use.
         COMMON_PORTS = [22, 53, 80, 123, 139, 443, 445, 631, 3389, 5000, 7000].freeze
 
-        # How many addresses are probed at once. Each probes its ports all at
-        # once, so this keeps open sockets well under the default limit of 256.
-        CONCURRENCY = 10
-
         desc "Find hosts on the local network that answer on TCP ports"
         option :port, type: :integer, desc: "Probe only this TCP port, instead of #{COMMON_PORTS.join(', ')}"
         option :timeout, type: :float, default: 0.5, aliases: ["-t"], desc: "Seconds to wait for each port"
         option :output, aliases: ["-o"], desc: "Also write the hosts to this file"
-        option :progress, type: :flag, default: false, aliases: ["-p"], desc: "Show progress bars; the default with --port"
-        option :spinner, type: :flag, default: false, aliases: ["-s"], desc: "Show spinners; the default without --port"
+        option :progress, aliases: ["-p"], type: :flag, default: true, desc: "Show progress bars"
+        option :spinner, aliases: ["-s"], type: :flag, default: false, desc: "Show spinners"
+        include Concurrency
+
+        def call(timeout:, port: nil, output: nil, progress: false, spinner: false, concurrency: Concurrency::DEFAULT, **)
+          progress = false if spinner
+          @concurrency = concurrency(concurrency) or return ui.error("--concurrency must be from 1 to #{Concurrency::MAX}, got #{concurrency}")
 
-        def call(timeout:, port: nil, output: nil, progress: false, spinner: false, **)
-          return ui.error("Pick one of --progress and --spinner, not both") if progress && spinner
+          open_files_for(@concurrency * COMMON_PORTS.size)
 
           ip = local_ip or return ui.error("No local IPv4 address found")
           subnet = ip.split(".").first(3).join(".")
@@ -264,17 +299,36 @@ module Foo
           ui.info "Local IP: #{ip}, scanning #{subnet}.1-254 on #{ports.size == 1 ? 'port' : 'ports'} #{ports.join(', ')}"
 
           progress ||= port && !spinner
-          results = progress ? with_progress(ips, ports, timeout.to_f) : with_spinner(ips, ports, timeout.to_f)
+          @scanned = Concurrent::AtomicFixnum.new
+          # Ctrl-C lets the addresses being probed finish, and probes no more.
+          results = ui.stoppable do |stop|
+            @stop = stop
+            progress ? with_progress(ips, ports, timeout.to_f) : with_spinner(ips, ports, timeout.to_f)
+          end
           hosts = ips.zip(results).select { |_, open| open }
+          lines = hosts.map { |host, open| "#{host}: #{open.empty? ? 'no open ports' : open.join(', ')}" }
+          File.write(output, lines.join("\n") << "\n") if output && hosts.any?
+          if @stop.stopped?
+            return ui.info("Stopped", "Scanned #{@scanned.value} of #{ips.size} addresses, and found #{hosts.size} hosts", *lines)
+          end
           return ui.warn("No hosts answered on #{ports.join(', ')}") if hosts.empty?
 
-          lines = hosts.map { |host, open| "#{host}: #{open.empty? ? 'no open ports' : open.join(', ')}" }
-          File.write(output, lines.join("\n") << "\n") if output
           ui.success "Found #{hosts.size} hosts", lines.join("\n"), *("Written to #{output}" if output)
         end
 
         private
 
+        # Each address probes its ports all at once, so raise the open file limit
+        # when the default, often 256, is too low; a probe that cannot open a
+        # socket would read as no answer.
+        def open_files_for(sockets)
+          soft, hard = Process.getrlimit(:NOFILE)
+          wanted = sockets + 64
+          Process.setrlimit(:NOFILE, [wanted, hard].min, hard) if soft < wanted
+        rescue SystemCallError
+          nil
+        end
+
         def local_ip
           Socket.getifaddrs
                 .map(&:addr)
@@ -285,7 +339,7 @@ module Foo
         # A spinner per address, counting the ports answered so far. An
         # address where nothing answered is marked failed.
         def with_spinner(ips, ports, timeout)
-          ui.multi_spinner("Probing #{ips.size} addresses", concurrent: CONCURRENCY) do |m|
+          ui.multi_spinner("Probing #{ips.size} addresses", concurrent: @concurrency, stop: @stop) do |m|
             ips.each do |ip|
               m.spinner(ip) do |line|
                 answered = Concurrent::AtomicFixnum.new
@@ -306,7 +360,7 @@ module Foo
           silent_bar = Concurrent::Promises.resolvable_future
           scanned = Concurrent::Promises.resolvable_future
           results = nil
-          ui.multi_progress("Probing #{ips.size} addresses") do |m|
+          ui.multi_progress("Probing #{ips.size} addresses", total: ips.size) do |m|
             m.progress("Answered", total: ips.size, color: :green) do |answered|
               silent = silent_bar.value!
               results = in_parallel(ips) do |ip|
@@ -323,7 +377,7 @@ module Foo
           results
         end
 
-        # Runs the block for each item, at most CONCURRENCY at once.
+        # Runs the block for each item, at most --concurrency at once.
         #
         # @return [Array] what the block returned for each item, in order
         def in_parallel(items)
@@ -331,9 +385,9 @@ module Foo
           items.each_with_index { |item, index| queue << [item, index] }
           queue.close
           results = Array.new(items.size)
-          Array.new(CONCURRENCY) do
+          Array.new(@concurrency) do
             Thread.new do
-              while (pair = queue.pop)
+              while !@stop.stopped? && (pair = queue.pop)
                 item, index = pair
                 results[index] = yield item
               end
@@ -353,6 +407,7 @@ module Foo
               probe(ip, port, timeout).tap(&)
             end
           end.map(&:value)
+          @scanned.increment
           return if states.all?(:silent)
 
           ports.zip(states).filter_map { |port, state| port if state == :open }

data/lib/dry/cli/ui/console.rb

@@ -158,13 +158,14 @@ module Dry
         # @param title [String] the headline
         # @param concurrent [Boolean, Integer] all at once (the default), one at
         #   a time, or at most this many at once
+        # @param stop [Stop, nil] once set, no more jobs start; see {#stoppable}
         # @yieldparam spinners [Widgets::MultiSpinner::Builder] declares each `spinner`
         # @return [Array<Object>] what each job returned, in declaration order
         # @raise [ArgumentError] without a block, or with an invalid concurrent
-        def multi_spinner(title, concurrent: true, &)
+        def multi_spinner(title, concurrent: true, stop: nil, &)
           raise ArgumentError, "multi_spinner needs a block" unless block_given?
 
-          Widgets::MultiSpinner.new(err, clock: clock, config: config).run(title, concurrent: concurrent, &)
+          Widgets::MultiSpinner.new(err, clock: clock, config: config).run(title, concurrent: concurrent, stop: stop, &)
         end
 
         # Runs a block with a progress bar showing percent, count and ETA.
@@ -197,13 +198,18 @@ module Dry
         # @param title [String] the headline
         # @param concurrent [Boolean, Integer] all at once (the default), one at
         #   a time, or at most this many at once
+        # @param count [Symbol] what the headline bar counts: `:units`, the sum
+        #   of every bar (the default), or `:jobs`, how many jobs have ended
+        # @param total [Integer, nil] the headline bar's total, when the jobs'
+        #   totals do not add up to it; nil to work it out
+        # @param stop [Stop, nil] once set, no more jobs start; see {#stoppable}
         # @yieldparam bars [Widgets::MultiProgress::Builder] declares each `progress`
         # @return [Array<Object>] what each job returned, in declaration order
-        # @raise [ArgumentError] without a block, or with an invalid concurrent
-        def multi_progress(title, concurrent: true, &)
+        # @raise [ArgumentError] without a block, or with an invalid concurrent, count or total
+        def multi_progress(title, concurrent: true, count: :units, total: nil, stop: nil, &)
           raise ArgumentError, "multi_progress needs a block" unless block_given?
 
-          Widgets::MultiProgress.new(err, clock: clock, config: config).run(title, concurrent: concurrent, &)
+          Widgets::MultiProgress.new(err, clock: clock, config: config).run(title, concurrent: concurrent, count: count, total: total, stop: stop, &)
         end
 
         # Declares a tree of tasks, then runs it, showing each task's state
@@ -256,6 +262,26 @@ module Dry
           StatusBar.new(err, others: others, title: title, hints: Array(hints), clock: clock, config: config).run(&)
         end
 
+        # Runs the block with Ctrl-C asking for a stop instead of interrupting.
+        # Hand the stop to `multi_spinner` or `multi_progress` as `stop:`, and
+        # the jobs running finish while the rest are skipped. A second Ctrl-C
+        # interrupts as usual. See {Stop}.
+        #
+        # @example
+        #   ui.stoppable do |stop|
+        #     done = ui.multi_spinner("Fetching", concurrent: 4, stop: stop) { |m| ... }
+        #     ui.info "Stopped after #{done.compact.size}" if stop.stopped?
+        #   end
+        #
+        # @yieldparam stop [Stop]
+        # @return [Object] whatever the block returns
+        # @raise [ArgumentError] without a block
+        def stoppable(&)
+          raise ArgumentError, "stoppable needs a block" unless block_given?
+
+          Stop.new.trap(&)
+        end
+
         # Prints a table to `out`.
         #
         # @example

data/lib/dry/cli/ui/status_bar.rb

@@ -284,7 +284,7 @@ module Dry
         # @return [String, nil] a bar over every progress reported so far
         def meter
           progress = @finished + @running.values.filter_map(&:last)
-          total = progress.sum(&:total)
+          total = progress.sum { |item| item.total || item.current }
           return if total.zero?
 
           ratio = progress.sum(&:current).fdiv(total)

data/lib/dry/cli/ui/stop.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Dry
+  class CLI
+    module UI
+      # A request to stop starting new work, which any thread may make or
+      # check. The multi widgets take one as `stop:`: once it is set, jobs
+      # already running finish, and jobs not yet started are skipped.
+      #
+      # {#trap} sets it on Ctrl-C, so a command can end early and still report
+      # what it did. A second Ctrl-C interrupts as usual.
+      #
+      # @example
+      #   ui.stoppable do |stop|
+      #     files = ui.multi_spinner("Downloading", concurrent: 10, stop: stop) { |m| ... }
+      #     ui.info "Stopped after #{files.compact.size} files" if stop.stopped?
+      #   end
+      class Stop
+        # A plain flag rather than an atomic one, which takes a lock, and a
+        # trap handler may not. Setting it once, to true, is safe to race.
+        def initialize
+          @stopped = false
+        end
+
+        # @return [Boolean] whether a stop was asked for
+        def stopped? = @stopped
+
+        # Asks for a stop.
+        #
+        # @return [self]
+        def stop!
+          @stopped = true
+          self
+        end
+
+        # Runs the block with the signal trapped: the first one asks for a
+        # stop, and the next raises `Interrupt`. The previous handler is put
+        # back when the block ends.
+        #
+        # @param signal [String]
+        # @yieldparam stop [Stop] this stop
+        # @return [Object] whatever the block returns
+        def trap(signal = "INT")
+          previous = Signal.trap(signal) { stopped? ? raise(Interrupt) : stop! }
+          yield self
+        ensure
+          Signal.trap(signal, previous || "DEFAULT")
+        end
+      end
+    end
+  end
+end

data/lib/dry/cli/ui/version.rb

@@ -11,7 +11,7 @@ module Dry
     # Presentation helpers for Dry::CLI commands.
     module UI
       # The gem version.
-      VERSION = "0.5.0"
+      VERSION = "0.5.1"
     end
   end
 end

data/lib/dry/cli/ui/widgets/multi.rb

@@ -16,8 +16,13 @@ module Dry
         # limit, is drawn before the first job starts.
         #
         # On an animated terminal the rows are drawn once and redrawn in place.
-        # Otherwise, or when there are more rows than the screen has, it prints
-        # `Title...`, then each job's outcome as it ends, then the headline's.
+        # When there are more rows than the screen has, only the jobs running
+        # are shown under the headline, as many as fit. Without animation it
+        # prints `Title...`, then each job's outcome as it ends, then the headline's.
+        #
+        # Given a {Stop} that is set, jobs already running finish, jobs not yet
+        # started are marked skipped, and so is the headline; while the running
+        # jobs finish, the headline says `stopping`.
         #
         # When a job raises, jobs already running finish, jobs not yet started
         # are marked skipped, the headline is marked failed, and the first error
@@ -72,6 +77,7 @@ module Dry
             @live = nil
             @lock = Mutex.new
             @frame = 0
+            @drawn = 0
           end
 
           # Declares the jobs with the block, then runs them.
@@ -79,19 +85,21 @@ module Dry
           # @param title [String] the headline above the jobs
           # @param concurrent [Boolean, Integer] all at once, one at a time, or
           #   at most this many at once
+          # @param stop [Stop, nil] once set, no more jobs start
           # @yieldparam builder [Object] declares the jobs
           # @return [Array<Object>] what each job returned, in declaration
           #   order; nil for a job that never ran
           # @raise [ArgumentError] with an invalid concurrent
           # @raise [Exception] the first error a job raised
-          def run(title, concurrent: true)
+          def run(title, concurrent: true, stop: nil)
             Pool.concurrency(concurrent)
             yield builder
             @title = title
+            @stop = stop
             @started = clock.call
             ticker = start
             begin
-              Pool.run(jobs, concurrent) { |job| execute(job) }
+              Pool.run(jobs, concurrent, stop: stop) { |job| execute(job) }
             ensure
               ticker&.shutdown
               ticker&.wait_for_termination(1)
@@ -117,6 +125,9 @@ module Dry
           # @return [String]
           attr_reader :title
 
+          # @return [Stop, nil]
+          attr_reader :stop
+
           # @return [Float] when the headline started, by the clock
           attr_reader :started
 
@@ -182,7 +193,9 @@ module Dry
               return
             end
 
-            rows.each { |row| terminal.puts(row) }
+            drawn = rows
+            drawn.each { |row| terminal.puts(row) }
+            @drawn = drawn.size
             Concurrent::TimerTask.new(execution_interval: config.spinner_frame_seconds) { tick }.tap(&:execute)
           end
 
@@ -206,12 +219,21 @@ module Dry
           def finish
             jobs.each { |job| change(job, :skipped) if job.state == :pending }
             lock.synchronize do
-              self.state = jobs.all? { |job| job.state == :done } ? :done : :failed
+              self.state = outcome
               @seconds = clock.call - started
               live? ? redraw : terminal.puts(Outcome.line(terminal, state, headline_summary, @seconds))
             end
           end
 
+          # @return [Symbol] the headline's state once every job has ended:
+          #   failed when any job failed, skipped when any was skipped
+          def outcome
+            states = jobs.map(&:state)
+            return :failed if states.include?(:failed)
+
+            states.include?(:skipped) ? :skipped : :done
+          end
+
           # @param job [Job]
           # @param state [Symbol]
           # @param seconds [Float, nil]
@@ -228,15 +250,23 @@ module Dry
             end
           end
 
-          # Whether to redraw in place: needs cursor movement, and every row on
-          # the screen, since the cursor cannot move above the top row.
+          # Whether to redraw in place, which needs cursor movement.
           #
           # @return [Boolean]
           def live?
-            @live = terminal.animated? && jobs.size + 1 < terminal.height if @live.nil?
+            @live = terminal.animated? if @live.nil?
             @live
           end
 
+          # Whether some rows must be left out, since the cursor cannot move
+          # above the top row of the screen.
+          #
+          # @return [Boolean]
+          def crowded?
+            @crowded = jobs.size + 1 >= terminal.height if @crowded.nil?
+            @crowded
+          end
+
           # @return [void]
           def tick
             lock.synchronize do
@@ -245,18 +275,34 @@ module Dry
             end
           end
 
+          # Draws the rows over the ones drawn last, clearing the screen below
+          # first, since there may be fewer rows than before.
+          #
           # @return [void]
           def redraw
-            terminal.print(terminal.cursor.up(jobs.size + 1) + rows.map { |row| "#{terminal.cursor.clear_line}#{row}\n" }.join)
+            drawn = rows
+            terminal.print(terminal.cursor.up(@drawn) + terminal.cursor.clear_screen_down + drawn.map { |row| "#{terminal.cursor.clear_line}#{row}\n" }.join)
+            @drawn = drawn.size
           end
 
-          # The headline, then one row per job with its tree branch.
+          # The headline, then one row per job shown, with its tree branch.
           #
           # @return [Array<String>]
           def rows
             width = label_width
-            branches = jobs.each_with_index.map { |_, index| index == jobs.size - 1 ? "└─ " : "├─ " }
-            [headline(width), *jobs.zip(branches).map { |job, branch| terminal.pastel.bright_black(branch) + row(job, width - branch.length) }]
+            shown = visible
+            branches = shown.each_index.map { |index| index == shown.size - 1 ? "└─ " : "├─ " }
+            [headline(width), *shown.zip(branches).map { |job, branch| terminal.pastel.bright_black(branch) + row(job, width - branch.length) }]
+          end
+
+          # Every job; when crowded, only the running ones, as many as leave
+          # the bottom row free.
+          #
+          # @return [Array<Job>]
+          def visible
+            return jobs unless crowded?
+
+            jobs.select { |job| job.state == :running }.first([terminal.height - 2, 0].max)
           end
 
           # The columns every label is padded to, so what follows lines up.
@@ -269,12 +315,15 @@ module Dry
           # @param width [Integer]
           # @return [String]
           def headline(width)
-            return "#{glyph(state)} #{running_headline(width)}" if state == :running
+            return "#{glyph(state)} #{running_headline(width)}#{stopping}" if state == :running
 
             elapsed = " #{terminal.pastel.bright_black("(#{Duration.format(@seconds)})")}"
             "#{glyph(state)} #{headline_summary}#{elapsed}"
           end
 
+          # @return [String] ` stopping` once a stop is asked for, or nothing
+          def stopping = stop&.stopped? ? " #{terminal.pastel.yellow('stopping')}" : ""
+
           # @param job [Job]
           # @param width [Integer] the columns its label is padded to
           # @return [String]

data/lib/dry/cli/ui/widgets/multi_progress.rb

@@ -32,22 +32,49 @@ module Dry
             # Declares a job with a progress bar of its own.
             #
             # @param label [String]
-            # @param total [Integer] units of work
+            # @param total [Integer, nil] units of work; nil when the job finds
+            #   out as it runs, and sets `total=` on its handle
             # @param color [Symbol, nil] the finished part's Pastel style; nil for
             #   {Configuration#bar_color}
             # @yieldparam progress [Progress::Handle] call `advance` as units complete
             # @return [self]
-            # @raise [ArgumentError] without a block, when total is not a
-            #   non-negative Integer, or when color is not a Pastel style
+            # @raise [ArgumentError] without a block, when total is neither nil
+            #   nor a non-negative Integer, or when color is not a Pastel style
             def progress(label, total:, color: nil, &work)
               raise ArgumentError, "progress #{label.inspect} needs a block" unless work
-              raise ArgumentError, "total must be a non-negative Integer, got #{total.inspect}" unless total.is_a?(Integer) && total >= 0
+
+              Progress.total(total) unless total.nil?
 
               @jobs << Multi::Job.new(label, work, Progress::Handle.new(total, nil, color: Progress.color(color)))
               self
             end
           end
 
+          # What the headline bar can count.
+          COUNTS = %i[units jobs].freeze
+
+          # Declares the jobs with the block, then runs them.
+          #
+          # @param title [String] the headline above the jobs
+          # @param concurrent [Boolean, Integer] see {Multi#run}
+          # @param count [Symbol] what the headline bar counts: `:units`, the
+          #   sum of every bar, or `:jobs`, how many jobs have ended
+          # @param total [Integer, nil] the headline bar's total; nil for the
+          #   sum of every bar's, or the number of jobs when counting jobs
+          # @param stop [Stop, nil] see {Multi#run}
+          # @yieldparam builder [Builder] declares the jobs
+          # @return [Array<Object>] what each job returned, in declaration order
+          # @raise [ArgumentError] with an invalid concurrent, count or total
+          # @raise [Exception] the first error a job raised
+          def run(title, concurrent: true, count: :units, total: nil, stop: nil, &)
+            raise ArgumentError, "count must be one of #{COUNTS.inspect}, got #{count.inspect}" unless COUNTS.include?(count)
+
+            Progress.total(total) unless total.nil?
+            @count = count
+            @total = total
+            super(title, concurrent: concurrent, stop: stop, &)
+          end
+
           private
 
           # @param job [Job]
@@ -63,7 +90,7 @@ module Dry
 
           # @param job [Job]
           # @return [String]
-          def summary(job) = "#{job.label} #{job.handle.current}/#{job.handle.total}"
+          def summary(job) = "#{job.label} #{job.handle.current}/#{job.handle.total || '?'}"
 
           # @param width [Integer]
           # @return [String]
@@ -74,25 +101,40 @@ module Dry
           # @return [String]
           def headline_summary = "#{title} #{current}/#{total}"
 
-          # @return [Integer] units completed across every job
-          def current = jobs.sum { |job| job.handle.current }
+          # @return [Integer] units completed across every job, or jobs ended
+          def current
+            return jobs.count(&:seconds) if @count == :jobs
 
-          # @return [Integer] units across every job
-          def total = jobs.sum { |job| job.handle.total }
+            jobs.sum { |job| job.handle.current }
+          end
+
+          # @return [Integer] the total given; or units across every job,
+          #   counting what a job without a total has done so far; or every job
+          def total
+            return @total if @total
+            return jobs.size if @count == :jobs
+
+            jobs.sum { |job| job.handle.total || job.handle.current }
+          end
 
           # `[◼◼◼   ] 48%  96/200  ETA 3.1s`, with the count right-aligned to
           # the widest any row can show, so every count ends in one column.
           #
+          # A bar whose total is not known yet is drawn empty, counting `12/?`.
+          #
           # @param done [Integer]
-          # @param all [Integer]
+          # @param all [Integer, nil]
           # @param since [Float, nil] when the work started, by the clock
           # @param color [Symbol, nil] the bar's own colour, if any
           # @return [String]
           def meter(done, all, since, color = nil)
-            ratio = all.zero? ? 1.0 : done.fdiv(all)
+            ratio = if all.nil? then 0.0
+                    elsif all.zero? then 1.0
+                    else done.fdiv(all)
+                    end
             bar = Progress.bar(terminal.pastel, config, ratio, bar_columns, color: color)
             format("%<bar>s %<percent>3d%%  %<count>s  ETA %<eta>s",
-                   bar: bar, percent: (ratio * 100).floor, count: "#{done}/#{all}".rjust(count_width), eta: eta(done, all, since))
+                   bar: bar, percent: (ratio * 100).floor, count: "#{done}/#{all || '?'}".rjust(count_width), eta: eta(done, all, since))
           end
 
           # The widest count any row shows: the headline's, once every job is done.
@@ -108,11 +150,12 @@ module Dry
           end
 
           # @param done [Integer]
-          # @param all [Integer]
+          # @param all [Integer, nil]
           # @param since [Float, nil]
-          # @return [String] the time left at the rate so far, or `--` before any progress
+          # @return [String] the time left at the rate so far, or `--` before
+          #   any progress or while the total is not known
           def eta(done, all, since)
-            return "--" if since.nil? || done.zero?
+            return "--" if since.nil? || done.zero? || all.nil?
 
             Duration.format((clock.call - since) / done * (all - done))
           end

data/lib/dry/cli/ui/widgets/pool.rb

@@ -11,7 +11,8 @@ module Dry
         #
         # When one raises, items already running finish, items not yet
         # started are never started, and the first error is re-raised once
-        # everything running has stopped.
+        # everything running has stopped. Once a {Stop} is set, items not yet
+        # started are never started either.
         module Pool
           # Checks a `concurrent:` setting.
           #
@@ -29,13 +30,14 @@ module Dry
           #
           # @param items [Array]
           # @param concurrent [Boolean, Integer] see {.concurrency}
+          # @param stop [Stop, nil] checked before each item starts
           # @yieldparam item [Object] one of the items
           # @return [void]
           # @raise [Exception] the first error any block raised
-          def self.run(items, concurrent, &)
-            return items.each(&) unless concurrent
+          def self.run(items, concurrent, stop: nil, &each)
+            return items.each { |item| stop&.stopped? ? break : each.call(item) } unless concurrent
 
-            futures = concurrent == true ? all_at_once(items, &) : at_most(concurrent, items, &)
+            futures = concurrent == true ? all_at_once(items, &each) : at_most(concurrent, items, stop, &each)
             futures.each(&:wait)
             failed = futures.find(&:rejected?)
             raise failed.reason if failed
@@ -52,26 +54,28 @@ module Dry
           #
           # @param limit [Integer]
           # @param items [Array]
+          # @param stop [Stop, nil]
           # @return [Array<Concurrent::Promises::Future>] one per worker
-          def self.at_most(limit, items, &)
+          def self.at_most(limit, items, stop, &)
             queue = Queue.new
             items.each { |item| queue << item }
             queue.close
-            stop = Concurrent::AtomicBoolean.new
-            Array.new([limit, items.size].min) { Concurrent::Promises.future { work(queue, stop, &) } }
+            failed = Concurrent::AtomicBoolean.new
+            Array.new([limit, items.size].min) { Concurrent::Promises.future { work(queue, failed, stop, &) } }
           end
 
           # @param queue [Queue] closed, so `pop` returns nil once it is empty
-          # @param stop [Concurrent::AtomicBoolean] set once any worker raises
+          # @param failed [Concurrent::AtomicBoolean] set once any worker raises
+          # @param stop [Stop, nil]
           # @return [void]
-          def self.work(queue, stop, &each)
+          def self.work(queue, failed, stop, &each)
             ok = false
-            while (item = queue.pop) && stop.false?
+            while !stop&.stopped? && (item = queue.pop) && failed.false?
               each.call(item)
             end
             ok = true
           ensure
-            stop.make_true unless ok
+            failed.make_true unless ok
           end
 
           private_class_method :all_at_once, :at_most, :work

data/lib/dry/cli/ui/widgets/progress.rb

@@ -14,7 +14,7 @@ module Dry
         class Progress
           # What the block is given to report progress through.
           class Handle
-            # @param total [Integer]
+            # @param total [Integer, nil] nil until the work finds out
             # @param bar [TTY::ProgressBar, nil]
             # @param color [Symbol, nil] see {Progress.color}
             def initialize(total, bar, color: nil)
@@ -24,7 +24,8 @@ module Dry
               @current = 0
             end
 
-            # @return [Integer] the number of units the operation has
+            # @return [Integer, nil] the number of units the operation has; nil
+            #   while it is not known
             attr_reader :total
 
             # @return [Symbol, nil] the Pastel style of the bar's finished part;
@@ -34,7 +35,18 @@ module Dry
             # @return [Integer] the number of units completed so far
             attr_reader :current
 
-            # Marks units as complete. Progress never passes {#total}.
+            # Sets the number of units once the work finds out, such as a download
+            # learning its size. {#current} is lowered to fit.
+            #
+            # @param value [Integer]
+            # @raise [ArgumentError] when value is not a non-negative Integer
+            def total=(value)
+              @total = Progress.total(value)
+              self.current = current.clamp(0, value)
+              bar&.update(total: value)
+            end
+
+            # Marks units as complete. Progress never passes {#total} once it is known.
             #
             # @param step [Integer]
             # @return [self]
@@ -58,6 +70,17 @@ module Dry
           # Narrowest bar drawn.
           MIN_BAR = 10
 
+          # Checks a bar's total.
+          #
+          # @param value [Integer]
+          # @return [Integer] the value
+          # @raise [ArgumentError] for anything but a non-negative Integer
+          def self.total(value)
+            return value if value.is_a?(Integer) && value >= 0
+
+            raise ArgumentError, "total must be a non-negative Integer, got #{value.inspect}"
+          end
+
           # Checks a bar's own colour.
           #
           # @param value [Symbol, nil] any Pastel style, or nil for {Configuration#bar_color}
@@ -119,8 +142,7 @@ module Dry
           # @raise [ArgumentError] when total is not a non-negative Integer, or
           #   color is not a Pastel style
           def run(label, total:, color: nil)
-            raise ArgumentError, "total must be a non-negative Integer, got #{total.inspect}" unless total.is_a?(Integer) && total >= 0
-
+            Progress.total(total)
             Progress.color(color)
             started = clock.call
             bar = start(label, total, color)
@@ -134,7 +156,7 @@ module Dry
             if handle
               bar&.stop
               terminal.finished(handle, ok)
-              summary = "#{label} #{handle.current}/#{total}"
+              summary = "#{label} #{handle.current}/#{handle.total}"
               terminal.puts(Outcome.line(terminal, ok ? :done : :failed, summary, clock.call - started))
             end
           end

data/lib/dry/cli/ui.rb

@@ -35,6 +35,7 @@ module Dry
       autoload :Console, File.expand_path("ui/console", __dir__)
       autoload :Duration, File.expand_path("ui/duration", __dir__)
       autoload :Line, File.expand_path("ui/line", __dir__)
+      autoload :Stop, File.expand_path("ui/stop", __dir__)
       autoload :StatusBar, File.expand_path("ui/status_bar", __dir__)
       autoload :Terminal, File.expand_path("ui/terminal", __dir__)
       autoload :Theme, File.expand_path("ui/theme", __dir__)

data/sig/dry/cli/ui.rbs

@@ -44,6 +44,12 @@ module Dry
         def summary: (String label) -> String
       end
 
+      class Stop
+        def stopped?: () -> bool
+        def stop!: () -> self
+        def trap: [T] (?String signal) { (Stop stop) -> T } -> T
+      end
+
       class Console
         def debug: (*_ToS paragraphs, ?width: Integer?) -> nil
         def info: (*_ToS paragraphs, ?width: Integer?) -> nil
@@ -55,9 +61,10 @@ module Dry
         def status: (*_ToS words, ?level: Symbol) -> nil
         def popup: (*_ToS paragraphs, ?title: String?, ?width: Integer?) -> nil
         def spinner: [T] (String label) { (Line line) -> T } -> T
-        def multi_spinner: (String title, ?concurrent: (bool | Integer)) { (untyped spinners) -> void } -> Array[untyped]
+        def multi_spinner: (String title, ?concurrent: (bool | Integer), ?stop: Stop?) { (untyped spinners) -> void } -> Array[untyped]
         def progress: [T] (String label, total: Integer, ?color: Symbol?) { (untyped progress) -> T } -> T
-        def multi_progress: (String title, ?concurrent: (bool | Integer)) { (untyped bars) -> void } -> Array[untyped]
+        def multi_progress: (String title, ?concurrent: (bool | Integer), ?count: (:units | :jobs), ?total: Integer?, ?stop: Stop?) { (untyped bars) -> void } -> Array[untyped]
+        def stoppable: [T] () { (Stop stop) -> T } -> T
         def status_bar: [T] (?String? title, ?hints: Array[String] | String) { () -> T } -> T
         def tasks: (?String? title, ?concurrent: (bool | Integer)) { (untyped tasks) -> void } -> nil
         def table: (Array[Array[_ToS]] rows, ?header: Array[_ToS]?) -> nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-cli-ui
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Konstantin Gredeskoul
@@ -189,6 +189,7 @@ files:
 - lib/dry/cli/ui/duration.rb
 - lib/dry/cli/ui/line.rb
 - lib/dry/cli/ui/status_bar.rb
+- lib/dry/cli/ui/stop.rb
 - lib/dry/cli/ui/terminal.rb
 - lib/dry/cli/ui/theme.rb
 - lib/dry/cli/ui/version.rb