tty-spinner 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c26cc2927383414d21521728ed1f422220ba6a6
-  data.tar.gz: 3249e7dbba98b16a202ab085bd686994d4abbbde
+  metadata.gz: 4fcc097a53cf0eecf886ee4784e264033b035e5f
+  data.tar.gz: 749c0703578a4f0fd260c930eee3f1adf7e6c502
 SHA512:
-  metadata.gz: 124f9ca4848567f0c79def88f9db19afd25a6844624867292c89013959a96cf31fa710f342b48248aa249e7e5484a8d30da71d919c9277cd162c78adff929e48
-  data.tar.gz: 58417c89c98f29482eca0b33cf1b285bab9d45260458284e00f934c57d8153a3be0baca2ad64622e5c730592cd15331ddd6827f26597daeac28d03c5a747ba57
+  metadata.gz: eb546b547b98b0630006660873fe0224ac839c82c67481d0b3711a453898bee0601f037fdbac596cbff54f1a33d62efb951f084c15a8100459a57ac08023aefb
+  data.tar.gz: c8b6121dccdbfbe8d3f0e1f04f662df51940d1ef2b3d42e227835e2c6394f95399bd9ed30db759be67bd615be19c81bbbb812781619f3db26ff5ee4dd0ac45a7

data/README.md

@@ -1,6 +1,7 @@
 # TTY::Spinner [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 [![Gem Version](https://badge.fury.io/rb/tty-spinner.svg)][gem]
 [![Build Status](https://secure.travis-ci.org/piotrmurach/tty-spinner.svg?branch=master)][travis]
+[![Build status](https://ci.appveyor.com/api/projects/status/2i5lx3tvyi5l8x3j?svg=true)][appveyor]
 [![Code Climate](https://codeclimate.com/github/piotrmurach/tty-spinner/badges/gpa.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/piotrmurach/tty-spinner/badge.svg)][coverage]
 [![Inline docs](http://inch-ci.org/github/piotrmurach/tty-spinner.svg?branch=master)][inchpages]
@@ -8,6 +9,7 @@
 [gitter]: https://gitter.im/piotrmurach/tty
 [gem]: http://badge.fury.io/rb/tty-spinner
 [travis]: http://travis-ci.org/piotrmurach/tty-spinner
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-spinner
 [codeclimate]: https://codeclimate.com/github/piotrmurach/tty-spinner
 [coverage]: https://coveralls.io/r/piotrmurach/tty-spinner
 [inchpages]: http://inch-ci.org/github/piotrmurach/tty-spinner
@@ -37,9 +39,11 @@ Or install it yourself as:
 ## Contents
 
 * [1. Usage](#1-usage)
-* [2. API](#2-api)
+* [2. TTY::Spinner API](#2-ttyspinner-api)
   * [2.1 spin](#21-spin)
   * [2.2 auto_spin](#22-auto_spin)
+    * [2.2.1 pause](#221-pause)
+    * [2.2.2 resume](#222-resume)
   * [2.3 run](#23-run)
   * [2.4 start](#24-start)
   * [2.5 stop](#25-stop)
@@ -61,6 +65,15 @@ Or install it yourself as:
   * [4.1 done](#41-done)
   * [4.2 success](#42-success)
   * [4.3 error](#43-error)
+* [5. TTY::Spinner::Multi API](#5-ttyspinnermulti-api)
+  * [5.1 reigster](#51-register)
+  * [5.2 auto_spin](#52-auto_spin)
+    * [5.2.1 manual async](#521-manual-async)
+    * [5.2.2 auto async tasks](#522-auto-async-tasks)
+  * [5.3 stop](#53-stop)
+    * [5.3.1 success](#531-success)
+    * [5.3.2 error](#532-error)
+  * [5.4 :style](#54-style)
 
 ## 1. Usage
 
@@ -74,11 +87,12 @@ In addition you can provide a message with `:spinner` token and format type you
 
 ```ruby
 spinner = TTY::Spinner.new("[:spinner] Loading ...", format: :pulse_2)
-30.times do
-  spinner.spin
-  sleep(0.1)
-end
-spinner.stop('Done!')
+
+spinner.auto_spin # Automatic animation with default interval
+
+sleep(2) # Perform task
+
+spinner.stop('Done!') # Stop animation
 ```
 
 This would produce animation in your terminal:
@@ -93,9 +107,34 @@ and when finished output:
 _ Loading ... Done!
 ```
 
+Use **TTY::Spinner::Multi** to synchornize multiple spinners:
+
+```ruby
+spinners = TTY::Spinner::Multi.new("[:spinner] top")
+
+sp1 = spinners.register "[:spinner] one"
+sp2 = spinners.register "[:spinner] two"
+
+sp1.auto_spin
+sp2.auto_spin
+
+sleep(2) # Perform work
+
+sp1.success
+sp2.success
+```
+
+which when done will display:
+
+```ruby
+┌[✔]] top
+├──[✔] one
+└──[✔] two
+```
+
 For more usage examples please see [examples directory](https://github.com/piotrmurach/tty-spinner/tree/master/examples)
 
-## 2. API
+## 2. TTY::Spinner API
 
 ### 2.1 spin
 
@@ -119,6 +158,22 @@ spinner.auto_spin
 
 The speed with which the spinning happens is determined by the `:interval` parameter. All the spinner formats have their default intervals specified ([see](https://github.com/piotrmurach/tty-spinner/blob/master/lib/tty/spinner/formats.rb)).
 
+### 2.2.1 pause
+
+After calling `auto_spin` you can pause spinner execution:
+
+```ruby
+spinner.pause
+```
+
+### 2.2.2 resume
+
+You can continue any paused spinner:
+
+```ruby
+spinner.resume
+```
+
 ### 2.3 run
 
 Use `run` with a code block that will automatically display spinning animation while the block executes and finish animation when the block terminates. Optionally you can provide a stop message to display when animation is finished.
@@ -179,7 +234,6 @@ This will produce:
 [✖] Task name (error)
 ```
 
-
 ### 2.6 update
 
 Use `update` call to dynamically change label name(s).
@@ -338,6 +392,131 @@ This event is fired when `error` completion is called. In order to respond to th
 spinner.on(:error) { ... }
 ```
 
+## 5. TTY::Spinner::Multi API
+
+### 5.1 register
+
+Create and register a `TTY::Spinner` under the multispinner
+
+```ruby
+new_spinner = multi_spinner.register("[:spinner] Task 1 name", options)
+```
+
+If no options are given it will use the options given to the multi_spinner when it was initialized to create the new spinner.
+If options are passed, they will override any options given to the multi spinner.
+
+### 5.2 auto_spin
+
+The multispinner has to have been given a message on initialization.
+To perform automatic spinning animation use `auto_spin` method like so:
+
+```ruby
+multi_spinner = TTY::Spinner::Multi.new("[:spinner] Top level spinner")
+multi_spinner.auto_spin
+```
+
+If you register spinners without any tasks then you will have to manually control when the `multi_spinner` finishes by calling `stop`, `success` or `error` (see [manual](#521-manual-async)).
+
+Alternatively, you can register spinners with tasks that will automatically animate and finish spinners when respective tasks are done (see [async tasks](#522-auto-async-tasks)).
+
+The speed with which the spinning happens is determined by the `:interval` parameter. All the spinner formats have their default intervals specified ([see](https://github.com/piotrmurach/tty-spinner/blob/master/lib/tty/spinner/formats.rb)).
+
+#### 5.2.1 manual async
+
+In case when you wish to have full control over multiple spinners, you will need to perform all actions manually.
+
+For example, create a multi spinner that will track status of all registered spinners:
+
+```ruby
+multi_spinner = TTY::Spinner::Multi.new("[:spinner] top")
+```
+
+and then register spinners with their formats:
+
+```
+spinner_1 = spinners.register "[:spinner] one"
+spinner_2 = spinners.register "[:spinner] two"
+```
+
+Once registered, you can set spinners running in separate threads:
+
+```ruby
+multi_spinner.auto_spin
+spinner_1.auto_spin
+spinner_2.auto_spin
+```
+
+Finnally, you need to stop each spinner manually, in our case we mark the multi spinner as failure as one of its children has been marked as failure:
+
+```ruby
+spinner_1.success
+spinner_2.error
+multi_spinner.error
+```
+
+#### 5.2.2 auto async tasks
+
+In case when you wish to execute async tasks and update individual spinners automatically, in any order, about their task status use `#register` and pass additional block parameter with the job to be executed.
+
+For example, create a multi spinner that will track status of all registered spinners:
+
+```ruby
+multi_spinner = TTY::Spinner::Multi.new("[:spinner] top")
+```
+
+and then register spinners with their respective tasks:
+
+```ruby
+multi_spinner.register("[:spinner] one") { |sp| sleep(2); sp.success('yes 2') }
+multi_spinner.register("[:spinner] two") { |sp| sleep(3); sp.error('no 2') }
+```
+
+Finally, call `#auto_spin` to kick things off:
+
+```ruby
+multi_spinner.auto_spin
+```
+
+If any of the child spinner stops with error then the top level spinner will be marked as failure.
+
+### 5.3 stop
+
+In order to stop the multi spinner call `stop`. This will stop the top level spinner, if it exists, and any sub-spinners still spinning.
+
+```ruby
+multi_spinner.stop
+```
+
+#### 5.3.1 success
+
+Use `success` call to stop the spinning animation and replace the spinning symbol with checkmark character to indicate successful completion.
+This will also call `#success` on any sub-spinners that are still spinning.
+
+```ruby
+multi_spinner.success
+```
+
+#### 5.3.2 error
+
+Use `error` call to stop the spining animation and replace the spinning symbol with cross character to indicate error completion.
+This will also call `#error` on any sub-spinners that are still spinning.
+
+```ruby
+multi_spinner.error
+```
+
+### 5.4 :style
+
+In addition to all [configuration options](#3-configuration) you can style multi spinner like so:
+
+```ruby
+multi_spinner = TTY::Spinner::Multi.new("[:spinner] parent", style: {
+  top: '. '
+  middle: '|-> '
+  bottom: '|__ '
+})
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/piotrmurach/tty-spinner/fork )
@@ -348,4 +527,4 @@ spinner.on(:error) { ... }
 
 ## Copyright
 
-Copyright (c) 2014-2016 Piotr Murach. See LICENSE for further details.
+Copyright (c) 2014-2017 Piotr Murach. See LICENSE for further details.

data/lib/tty-spinner.rb

@@ -1 +1,4 @@
-require 'tty/spinner'
+# encoding: utf-8
+
+require_relative 'tty/spinner'
+require_relative 'tty/spinner/multi'

data/lib/tty/spinner.rb

@@ -1,7 +1,11 @@
-# coding: utf-8
+# encoding: utf-8
+# frozen_string_literal: true
 
-require 'tty/spinner/version'
-require 'tty/spinner/formats'
+require 'monitor'
+require 'tty-cursor'
+
+require_relative 'spinner/version'
+require_relative 'spinner/formats'
 
 module TTY
   # Used for creating terminal spinner
@@ -9,23 +13,19 @@ module TTY
   # @api public
   class Spinner
     include Formats
+    include MonitorMixin
 
     # @raised when attempting to join dead thread
     NotSpinningError = Class.new(StandardError)
 
-    ECMA_ESC = "\x1b".freeze
     ECMA_CSI = "\x1b[".freeze
-    ECMA_CHA = 'G'.freeze
-    ECMA_CLR = 'K'.freeze
-
-    DEC_RST = 'l'.freeze
-    DEC_SET = 'h'.freeze
-    DEC_TCEM = '?25'.freeze
 
     MATCHER = /:spinner/
     TICK = '✔'.freeze
     CROSS = '✖'.freeze
 
+    CURSOR_USAGE_LOCK = Monitor.new
+
     # The object that responds to print call defaulting to stderr
     #
     # @api public
@@ -83,6 +83,7 @@ module TTY
     #
     # @api public
     def initialize(*args)
+      super()
       options  = args.last.is_a?(::Hash) ? args.pop : {}
       @message = args.empty? ? ':spinner' : args.pop
       @tokens  = {}
@@ -106,25 +107,69 @@ module TTY
       @done        = false
       @state       = :stopped
       @thread      = nil
+      @job         = nil
+      @multispinner= nil
+      @index       = nil
+      @succeeded   = false
+      @first_run  = true
+    end
+
+    # Notifies the TTY::Spinner that it is running under a multispinner
+    #
+    # @param [TTY::Spinner::Multi] the multispinner that it is running under
+    # @param [Integer] the index of this spinner in the multispinner
+    #
+    # @api private
+    def add_multispinner(multispinner, index)
+      @multispinner = multispinner
+      @index = index
+    end
+
+    # Whether the spinner has completed spinning
+    #
+    # @return [Boolean] whether or not the spinner has finished
+    #
+    # @api public
+    def done?
+      @done
     end
 
+    # Whether the spinner is spinning
+    #
+    # @return [Boolean] whether or not the spinner is spinning
+    #
+    # @api public
     def spinning?
       @state == :spinning
     end
 
+    # Whether the spinner is in the success state.
+    # When true the spinner is marked with a success mark.
+    #
+    # @return [Boolean] whether or not the spinner succeeded
+    #
+    # @api public
     def success?
-      @state == :success
+      @succeeded == :success
     end
 
+    # Whether the spinner is in the error state. This is only true
+    # temporarily while it is being marked with a failure mark.
+    #
+    # @return [Boolean] whether or not the spinner is erroring
+    #
+    # @api public
     def error?
-      @state == :error
+      @succeeded == :error
     end
 
     # Register callback
     #
     # @api public
     def on(name, &block)
-      @callbacks[name] << block
+      synchronize do
+        @callbacks[name] << block
+      end
       self
     end
 
@@ -137,21 +182,91 @@ module TTY
       reset
     end
 
+    # Add job to this spinner
+    #
+    # @api public
+    def job(&work)
+      synchronize do
+        if block_given?
+          @job = work
+        else
+          @job
+        end
+      end
+    end
+
+    # Execute this spinner job
+    #
+    # @api public
+    def execute_job
+      if job.arity.zero?
+        instance_eval(&job)
+      else
+        job.(self)
+      end
+    end
+
+    # Check if this spinner has a scheduled job
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def job?
+      !@job.nil?
+    end
+
     # Start automatic spinning animation
     #
     # @api public
     def auto_spin
-      start
-      sleep_time = 1.0 / @interval
+      CURSOR_USAGE_LOCK.synchronize do
+        start
+        sleep_time = 1.0 / @interval
 
-      @thread = Thread.new do
-        while @started_at
-          spin
+        spin
+        @thread = Thread.new do
           sleep(sleep_time)
+          while @started_at
+            if Thread.current['pause']
+              Thread.stop
+              Thread.current['pause'] = false
+            end
+            spin
+            sleep(sleep_time)
+          end
         end
       end
     end
 
+    # Checked if current spinner is paused
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def paused?
+      !!(@thread && @thread['pause'])
+    end
+
+    # Pause spinner automatic animation
+    #
+    # @api public
+    def pause
+      return if paused?
+
+      synchronize do
+        @thread['pause'] = true if @thread
+      end
+    end
+
+    # Resume spinner automatic animation
+    #
+    # @api public
+    def resume
+      return unless paused?
+
+      @thread.wakeup if @thread
+    end
+
     # Run spinner while executing job
     #
     # @param [String] stop_message
@@ -164,9 +279,10 @@ module TTY
     #
     # @api public
     def run(stop_message = '', &block)
+      job(&block)
       auto_spin
 
-      @work = Thread.new(&block)
+      @work = Thread.new { execute_job }
       @work.join
     ensure
       stop(stop_message)
@@ -199,7 +315,9 @@ module TTY
     #
     # @api public
     def kill
-      @thread.kill if @thread
+      synchronize do
+        @thread.kill if @thread
+      end
     end
 
     # Perform a spin
@@ -209,18 +327,31 @@ module TTY
     #
     # @api public
     def spin
-      return if @done
+      synchronize do
+        return if @done
+
+        if @hide_cursor && !spinning?
+          write(TTY::Cursor.hide)
+        end
 
+        data = message.gsub(MATCHER, @frames[@current])
+        data = replace_tokens(data)
+        write(data, true)
+        @current = (@current + 1) % @length
+        @state = :spinning
+        data
+      end
+    end
+
+    # Redraw the indent for this spinner, if it exists
+    #
+    # @api private
+    def redraw_indent
       if @hide_cursor && !spinning?
         write(ECMA_CSI + DEC_TCEM + DEC_RST)
       end
 
-      data = message.gsub(MATCHER, @frames[@current])
-      data = replace_tokens(data)
-      write(data, true)
-      @current = (@current + 1) % @length
-      @state = :spinning
-      data
+      write("", false)
     end
 
     # Finish spining
@@ -230,10 +361,11 @@ module TTY
     #
     # @api public
     def stop(stop_message = '')
-      return if @done
+      mon_enter
+      return if done?
 
       if @hide_cursor
-        write(ECMA_CSI + DEC_TCEM + DEC_SET, false)
+        write(TTY::Cursor.show, false)
       end
       return clear_line if @clear
 
@@ -244,13 +376,14 @@ module TTY
       end
 
       write(data, true)
-      write("\n", false) unless @clear
+      write("\n", false) unless @clear || @multispinner
     ensure
       @state      = :stopped
       @done       = true
       @started_at = nil
       emit(:done)
       kill
+      mon_exit
     end
 
     # Retrieve next character
@@ -272,25 +405,33 @@ module TTY
     #
     # @api public
     def success(stop_message = '')
-      @state = :success
-      stop(stop_message)
-      emit(:success)
+      return if done?
+
+      synchronize do
+        @succeeded = :success
+        stop(stop_message)
+        emit(:success)
+      end
     end
 
     # Finish spinning and set state to :error
     #
     # @api public
     def error(stop_message = '')
-      @state = :error
-      stop(stop_message)
-      emit(:error)
+      return if done?
+
+      synchronize do
+        @succeeded = :error
+        stop(stop_message)
+        emit(:error)
+      end
     end
 
     # Clear current line
     #
     # @api public
     def clear_line
-      output.print(ECMA_CSI + '0m' + ECMA_CSI + '1000D' + ECMA_CSI + ECMA_CLR)
+      write(ECMA_CSI + '0m' + TTY::Cursor.clear_line)
     end
 
     # Update string formatting tokens
@@ -300,28 +441,64 @@ module TTY
     #
     # @api public
     def update(tokens)
-      clear_line if spinning?
-      @tokens.merge!(tokens)
+      synchronize do
+        clear_line if spinning?
+        @tokens.merge!(tokens)
+      end
     end
 
     # Reset the spinner to initial frame
     #
     # @api public
     def reset
-      @current = 0
+      synchronize do
+        @current = 0
+        @first_run = true
+      end
     end
 
     private
 
+    # Execute a block on the proper terminal line if the spinner is running
+    # under a multispinner. Otherwise, execute the block on the current line.
+    #
+    # @api private
+    def execute_on_line
+      if @multispinner
+        CURSOR_USAGE_LOCK.synchronize do
+          lines_up = @multispinner.count_line_offset(@index)
+
+          if @first_run
+            yield if block_given?
+            output.print "\n"
+            @first_run = false
+          else
+            output.print TTY::Cursor.save
+            output.print TTY::Cursor.up(lines_up)
+            yield if block_given?
+            output.print TTY::Cursor.restore
+          end
+        end
+      else
+        yield if block_given?
+      end
+    end
+
     # Write data out to output
     #
     # @return [nil]
     #
     # @api private
     def write(data, clear_first = false)
-      output.print(ECMA_CSI + '1' + ECMA_CHA) if clear_first
-      output.print(data)
-      output.flush
+      execute_on_line do
+        output.print(TTY::Cursor.column(1)) if clear_first
+
+        # If there's a top level spinner, print with inset
+        characters_in = @multispinner.nil? ? "" : @multispinner.line_inset(self)
+
+        output.print(characters_in + data)
+        output.flush
+      end
     end
 
     # Emit callback

data/lib/tty/spinner/multi.rb

@@ -0,0 +1,259 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative '../spinner'
+
+module TTY
+  class Spinner
+    # Used for managing multiple terminal spinners
+    #
+    # @api public
+    class Multi
+      include Enumerable
+
+      extend Forwardable
+
+      def_delegators :@spinners, :each, :empty?, :length
+
+      DEFAULT_INSET = {
+        top:    Gem.win_platform? ? '+ '   : "\u250c ",
+        middle: Gem.win_platform? ? '|-- ' : "\u251c\u2500\u2500",
+        bottom: Gem.win_platform? ? '|__ ' : "\u2514\u2500\u2500"
+      }.freeze
+
+      # Initialize a multispinner
+      #
+      # @example
+      #   spinner = TTY::Spinner::Multi.new
+      #
+      # @param [String] message
+      #   the optional message to print in front of the top level spinner
+      #
+      # @param [Hash] options
+      # @option options [Hash] :style
+      #   keys :top :middle and :bottom can contain Strings that are used to
+      #   indent the spinners. Ignored if message is blank
+      # @option options [Object] :output
+      #   the object that responds to print call defaulting to stderr
+      # @option options [Boolean] :hide_cursor
+      #   display or hide cursor
+      # @option options [Boolean] :clear
+      #   clear ouptut when finished
+      # @option options [Float] :interval
+      #   the interval for auto spinning
+      #
+      # @api public
+      def initialize(*args)
+        @options = args.last.is_a?(::Hash) ? args.pop : {}
+        message = args.empty? ? nil : args.pop
+        @inset_opts = @options.delete(:style) { DEFAULT_INSET }
+        @create_spinner_lock = Mutex.new
+        @spinners    = []
+        @top_spinner = nil
+        @top_spinner = register(message) unless message.nil?
+
+        @callbacks = {
+          success: [],
+          error:   [],
+          done:    []
+        }
+      end
+
+      # Register a new spinner
+      #
+      # @param [String] pattern
+      #   the pattern used for creating spinner
+      #
+      # @api public
+      def register(pattern, options = {}, &job)
+        spinner = TTY::Spinner.new(pattern, @options.merge(options))
+
+        @create_spinner_lock.synchronize do
+          spinner.add_multispinner(self, @spinners.length)
+          spinner.job(&job) if block_given?
+          observe_events(spinner) if @top_spinner
+          @spinners << spinner
+          if @top_spinner
+            @spinners.each { |sp| sp.redraw_indent if sp.spinning? || sp.done? }
+          end
+        end
+
+        spinner
+      end
+
+      # Observe all child events to notify top spinner of current state
+      #
+      # @param [TTY::Spinner] spinner
+      #   the spinner to listen to for events
+      #
+      # @api private
+      def observe_events(spinner)
+        spinner.on(:success) { @top_spinner.success if success? }
+               .on(:error)   { @top_spinner.error if error? }
+               .on(:done)    { @top_spinner.stop if done? && !success? && !error? }
+      end
+
+      # Get the top level spinner if it exists
+      #
+      # @return [TTY::Spinner] the top level spinner
+      #
+      # @api public
+      def top_spinner
+        raise "No top level spinner" if @top_spinner.nil?
+
+        @top_spinner
+      end
+
+      # Auto spin the top level spinner & all child spinners
+      # that have scheduled jobs
+      #
+      # @api public
+      def auto_spin
+        raise "No top level spinner" if @top_spinner.nil?
+
+        @top_spinner.auto_spin
+        jobs = []
+        @spinners.each do |spinner|
+          if spinner.job?
+            spinner.auto_spin
+            jobs << Thread.new { spinner.execute_job }
+          end
+        end
+        jobs.each(&:join)
+      end
+
+      # Pause all spinners
+      #
+      # @api public
+      def pause
+        @spinners.dup.each(&:pause)
+      end
+
+      # Resume all spinners
+      #
+      # @api public
+      def resume
+        @spinners.dup.each(&:resume)
+      end
+
+      # Find relative offset position to which to move the current cursor
+      #
+      # The position is found among the registered spinners given the current
+      # position the spinner is at provided its index
+      #
+      # @param [Integer] index
+      #   the position to search from
+      #
+      # @return [Integer]
+      #   the current position
+      #
+      # @api public
+      def count_line_offset(index)
+        Array(@spinners[index..-1]).reduce(0) do |acc, spinner|
+          if spinner.spinning? || spinner.done?
+            acc += 1
+          end
+          acc
+        end
+      end
+
+      # Find the number of characters to move into the line
+      # before printing the spinner
+      #
+      # @param [TTY::Spinner] spinner
+      #   the spinner for which line inset is calculated
+      #
+      # @return [String]
+      #   the inset
+      #
+      # @api public
+      def line_inset(spinner)
+        return '' if @top_spinner.nil?
+
+        case spinner
+        when @top_spinner
+          @inset_opts[:top]
+        when @spinners.last
+          @inset_opts[:bottom]
+        else
+          @inset_opts[:middle]
+        end
+      end
+
+      # Check if all spinners are done
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def done?
+        (@spinners - [@top_spinner]).all?(&:done?)
+      end
+
+      # Check if all spinners succeeded
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def success?
+        (@spinners - [@top_spinner]).all?(&:success?)
+      end
+
+      # Check if any spinner errored
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def error?
+        (@spinners - [@top_spinner]).any?(&:error?)
+      end
+
+      # Stop all spinners
+      #
+      # @api public
+      def stop
+        @spinners.dup.each(&:stop)
+        emit :done
+      end
+
+      # Stop all spinners with success status
+      #
+      # @api public
+      def success
+        @top_spinner.success if @top_spinner
+        @spinners.dup.each(&:success)
+        emit :success
+      end
+
+      # Stop all spinners with error status
+      #
+      # @api public
+      def error
+        @top_spinner.error if @top_spinner
+        @spinners.dup.each(&:error)
+        emit :error
+      end
+
+      # Listen on event
+      #
+      # @api public
+      def on(key, &callback)
+        unless @callbacks.key?(key)
+          raise ArgumentError, "The event #{key} does not exist. "\
+                               " Use :success, :error, or :done instead"
+        end
+        @callbacks[key] << callback
+        self
+      end
+
+      private
+
+      def emit(key, *args)
+        @callbacks[key].each do |block|
+          block.call(*args)
+        end
+      end
+    end # MultiSpinner
+  end # Spinner
+end # TTY

data/lib/tty/spinner/version.rb

@@ -2,6 +2,6 @@
 
 module TTY
   class Spinner
-    VERSION = "0.4.1"
+    VERSION = "0.5.0"
   end # Spinner
 end # TTY

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: tty-spinner
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-07 00:00:00.000000000 Z
+date: 2017-08-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-cursor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,6 +70,7 @@ files:
 - lib/tty-spinner.rb
 - lib/tty/spinner.rb
 - lib/tty/spinner/formats.rb
+- lib/tty/spinner/multi.rb
 - lib/tty/spinner/version.rb
 homepage: https://github.com/piotrmurach/tty-spinner
 licenses: