planter-cli 3.0.1 → 3.0.2

data/lib/tty-spinner/lib/tty/spinner/multi.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "forwardable"
+
+require_relative "../spinner"
+
+module TTY
+  class Spinner
+    # Used for managing multiple terminal spinners
+    #
+    # @api public
+    class Multi
+      include Enumerable
+      include MonitorMixin
+
+      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
+
+      # The current count of all rendered rows
+      #
+      # @api public
+      attr_reader :rows
+
+      # 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)
+        super()
+        @options = args.last.is_a?(::Hash) ? args.pop : {}
+        message = args.empty? ? nil : args.pop
+        @inset_opts = @options.delete(:style) { DEFAULT_INSET }
+        @rows = 0
+        @spinners = []
+        @spinners_count = 0
+        @top_spinner = nil
+        @last_spin_at = nil
+        unless message.nil?
+          @top_spinner = register(message, observable: false, row: next_row)
+        end
+
+        @callbacks = {
+          success: [],
+          error: [],
+          done: [],
+          spin: []
+        }
+      end
+
+      # Register a new spinner
+      #
+      # @param [String, TTY::Spinner] pattern_or_spinner
+      #   the pattern used for creating spinner, or a spinner instance
+      #
+      # @api public
+      def register(pattern_or_spinner, **options, &job)
+        observable = options.delete(:observable) { true }
+        spinner = nil
+
+        synchronize do
+          spinner = create_spinner(pattern_or_spinner, options)
+          spinner.attach_to(self)
+          spinner.job(&job) if block_given?
+          observe(spinner) if observable
+          @spinners << spinner
+          @spinners_count += 1
+          if @top_spinner
+            @spinners.each { |sp| sp.redraw_indent if sp.spinning? || sp.done? }
+          end
+        end
+
+        spinner
+      end
+
+      # Create a spinner instance
+      #
+      # @api private
+      def create_spinner(pattern_or_spinner, options)
+        case pattern_or_spinner
+        when ::String
+          TTY::Spinner.new(
+            pattern_or_spinner,
+            @options.merge(options)
+          )
+        when ::TTY::Spinner
+          pattern_or_spinner
+        else
+          raise ArgumentError, "Expected a pattern or spinner, " \
+            "got: #{pattern_or_spinner.class}"
+        end
+      end
+
+      # Increase a row count
+      #
+      # @api public
+      def next_row
+        synchronize do
+          @rows += 1
+        end
+      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?
+
+        jobs = []
+        @spinners.each do |spinner|
+          if spinner.job?
+            spinner.auto_spin
+            jobs << Thread.new { spinner.execute_job }
+          end
+        end
+        jobs.each(&:join)
+      end
+
+      # Perform a single spin animation
+      #
+      # @api public
+      def spin
+        raise "No top level spinner" if @top_spinner.nil?
+
+        synchronize do
+          throttle { @top_spinner.spin }
+        end
+      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 the number of characters to move into the line
+      # before printing the spinner
+      #
+      # @param [Integer] line_no
+      #   the current spinner line number for which line inset is calculated
+      #
+      # @return [String]
+      #   the inset
+      #
+      # @api public
+      def line_inset(line_no)
+        return "" if @top_spinner.nil?
+
+        if line_no == 1
+          @inset_opts[:top]
+        elsif line_no == @spinners_count
+          @inset_opts[:bottom]
+        else
+          @inset_opts[:middle]
+        end
+      end
+
+      # Check if all spinners are done
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def done?
+        synchronize do
+          (@spinners - [@top_spinner]).all?(&:done?)
+        end
+      end
+
+      # Check if all spinners succeeded
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def success?
+        synchronize do
+          (@spinners - [@top_spinner]).all?(&:success?)
+        end
+      end
+
+      # Check if any spinner errored
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def error?
+        synchronize do
+          (@spinners - [@top_spinner]).any?(&:error?)
+        end
+      end
+
+      # Stop all spinners
+      #
+      # @api public
+      def stop
+        @spinners.dup.each(&:stop)
+      end
+
+      # Stop all spinners with success status
+      #
+      # @api public
+      def success
+        @spinners.dup.each(&:success)
+      end
+
+      # Stop all spinners with error status
+      #
+      # @api public
+      def error
+        @spinners.dup.each(&:error)
+      end
+
+      # Listen on event
+      #
+      # @api public
+      def on(key, &callback)
+        unless @callbacks.key?(key)
+          raise ArgumentError, "The event #{key} does not exist. " \
+                               " Use :spin, :success, :error, or :done instead"
+        end
+        @callbacks[key] << callback
+        self
+      end
+
+      private
+
+      # Check if this spinner should revolve to keep constant speed
+      # matching top spinner interval
+      #
+      # @api private
+      def throttle
+        sleep_time = 1.0 / @top_spinner.interval
+        return if @last_spin_at && Time.now - @last_spin_at < sleep_time
+
+        yield if block_given?
+        @last_spin_at = Time.now
+      end
+
+      # Fire an event
+      #
+      # @api private
+      def emit(key, *args)
+        @callbacks[key].each do |block|
+          block.call(*args)
+        end
+      end
+
+      # Observe spinner for events to notify top spinner of current state
+      #
+      # @param [TTY::Spinner] spinner
+      #   the spinner to listen to for events
+      #
+      # @api private
+      def observe(spinner)
+        spinner.on(:spin, &spin_handler)
+               .on(:success, &success_handler)
+               .on(:error, &error_handler)
+               .on(:done, &done_handler)
+      end
+
+      # Handle spin event
+      #
+      # @api private
+      def spin_handler
+        proc do
+          spin if @top_spinner
+          emit(:spin)
+        end
+      end
+
+      # Handle the success state
+      #
+      # @api private
+      def success_handler
+        proc do
+          if success?
+            @top_spinner.success if @top_spinner
+            emit(:success)
+          end
+        end
+      end
+
+      # Handle the error state
+      #
+      # @api private
+      def error_handler
+        proc do
+          if error?
+            @top_spinner.error if @top_spinner
+            @fired ||= emit(:error) # fire once
+          end
+        end
+      end
+
+      # Handle the done state
+      #
+      # @api private
+      def done_handler
+        proc do
+          if done?
+            @top_spinner.stop if @top_spinner && !error? && !success?
+            emit(:done)
+          end
+        end
+      end
+    end # MultiSpinner
+  end # Spinner
+end # TTY

data/lib/tty-spinner/lib/tty/spinner/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TTY
+  class Spinner
+    VERSION = "0.9.3"
+  end # Spinner
+end # TTY