toys-core 0.3.6 → 0.3.7

data/lib/toys/utils/exec.rb

@@ -72,13 +72,13 @@ module Toys
     #    stream of the subprocess. If set to `:controller`, the controller
     #    will control the output stream. If set to `:capture`, the output will
     #    be captured in a string that is available in the
-    #    {Toys::Helpers::Exec::Result} object. If not set, the subprocess
+    #    {Toys::Utils::Exec::Result} object. If not set, the subprocess
     #    standard out is connected to STDOUT of the Toys process.
     # *  **:err_to** (`:controller`,`:capture`) Connects the standard error
     #    stream of the subprocess. If set to `:controller`, the controller
     #    will control the output stream. If set to `:capture`, the output will
     #    be captured in a string that is available in the
-    #    {Toys::Helpers::Exec::Result} object. If not set, the subprocess
+    #    {Toys::Utils::Exec::Result} object. If not set, the subprocess
     #    standard out is connected to STDERR of the Toys process.
     #
     # In addition, the following options recognized by `Process#spawn` are
@@ -134,8 +134,18 @@ module Toys
       #     exit code and any captured output.
       #
       def exec(cmd, opts = {}, &block)
+        spawn_cmd =
+          if cmd.is_a?(::Array)
+            if cmd.size == 1 && cmd.first.is_a?(::String)
+              [[cmd.first, opts[:argv0] || cmd.first]]
+            else
+              cmd
+            end
+          else
+            [cmd]
+          end
         exec_opts = Opts.new(@default_opts).add(opts)
-        executor = Executor.new(exec_opts, cmd)
+        executor = Executor.new(exec_opts, spawn_cmd)
         executor.execute(&block)
       end
 
@@ -155,13 +165,8 @@ module Toys
       #     exit code and any captured output.
       #
       def ruby(args, opts = {}, &block)
-        cmd =
-          if args.is_a?(::Array)
-            [[::RbConfig.ruby, "ruby"]] + args
-          else
-            "#{::RbConfig.ruby} #{args}"
-          end
-        exec(cmd, opts, &block)
+        cmd = args.is_a?(::Array) ? [::RbConfig.ruby] + args : "#{::RbConfig.ruby} #{args}"
+        exec(cmd, {argv0: "ruby"}.merge(opts), &block)
       end
 
       ##
@@ -170,8 +175,6 @@ module Toys
       # @param [String] cmd The shell command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
-      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
-      #     for the subprocess streams.
       #
       # @return [Integer] The exit code
       #
@@ -188,8 +191,6 @@ module Toys
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
-      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
-      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
@@ -384,8 +385,8 @@ module Toys
       # @private
       #
       class Executor
-        def initialize(exec_opts, cmd)
-          @cmd = Array(cmd)
+        def initialize(exec_opts, spawn_cmd)
+          @spawn_cmd = spawn_cmd
           @config_opts = exec_opts.config_opts
           @spawn_opts = exec_opts.spawn_opts
           @captures = {}
@@ -409,7 +410,7 @@ module Toys
         def log_command
           logger = @config_opts[:logger]
           if logger && @config_opts[:log_level] != false
-            cmd_str = @cmd.size == 1 ? @cmd.first : @cmd.inspect
+            cmd_str = @spawn_cmd.size == 1 ? @spawn_cmd.first : @spawn_cmd.inspect
             logger.add(@config_opts[:log_level] || ::Logger::INFO, cmd_str)
           end
         end
@@ -417,7 +418,7 @@ module Toys
         def start_process
           args = []
           args << @config_opts[:env] if @config_opts[:env]
-          args.concat(@cmd)
+          args.concat(@spawn_cmd)
           pid = ::Process.spawn(*args, @spawn_opts)
           @child_streams.each(&:close)
           ::Process.detach(pid)

data/lib/toys/utils/gems.rb

@@ -0,0 +1,140 @@
+# Copyright 2018 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+;
+
+module Toys
+  module Utils
+    ##
+    # A helper module that activates and installs gems
+    #
+    class Gems
+      ##
+      # Failed to activate a gem.
+      #
+      class ActivationFailedError < ::StandardError
+      end
+
+      ##
+      # Failed to install a gem.
+      #
+      class InstallFailedError < ActivationFailedError
+      end
+
+      ##
+      # Need to add a gem to the bundle.
+      #
+      class GemfileUpdateNeededError < ActivationFailedError
+        def initialize(requirements_text, gemfile_path)
+          super("Required gem not available in the bundle: #{requirements_text}.\n" \
+                "Please update your Gemfile #{gemfile_path.inspect}.")
+        end
+      end
+
+      ##
+      # Activate the given gem.
+      #
+      # @param [String] name Name of the gem
+      # @param [String...] requirements Version requirements
+      #
+      def self.activate(name, *requirements)
+        new.activate(name, *requirements)
+      end
+
+      ##
+      # Create a new gem activator.
+      #
+      def initialize
+        @terminal = Terminal.new(output: $stderr)
+        @exec = Exec.new
+      end
+
+      ##
+      # Activate the given gem.
+      #
+      # @param [String] name Name of the gem
+      # @param [String...] requirements Version requirements
+      #
+      def activate(name, *requirements)
+        gem(name, *requirements)
+      rescue ::Gem::MissingSpecError
+        install_gem(name, requirements)
+      rescue ::Gem::LoadError => e
+        if ::ENV["BUNDLE_GEMFILE"]
+          raise GemfileUpdateNeededError.new(gem_requirements_text(name, requirements),
+                                             ::ENV["BUNDLE_GEMFILE"])
+        end
+        raise ActivationFailedError, e.message
+      end
+
+      private
+
+      def gem_requirements_text(name, requirements)
+        "#{name.inspect}, #{requirements.map(&:inspect).join(', ')}"
+      end
+
+      def install_gem(name, requirements)
+        requirements_text = gem_requirements_text(name, requirements)
+        response = @terminal.confirm("Gem needed: #{requirements_text}. Install?")
+        unless response
+          raise InstallFailedError, "Canceled installation of needed gem: #{requirements_text}"
+        end
+        version = find_best_version(name, requirements)
+        raise InstallFailedError, "No gem found matching #{requirements_text}." unless version
+        perform_install(name, version)
+        activate(name, *requirements)
+      end
+
+      def find_best_version(name, requirements)
+        @terminal.spinner(leading_text: "Getting info on gem #{name.inspect}... ",
+                          final_text: "Done.\n") do
+          req = ::Gem::Requirement.new(*requirements)
+          result = @exec.exec(["gem", "query", "-q", "-r", "-a", "-e", name], out_to: :capture)
+          if result.captured_out =~ /\(([\w\.,\s]+)\)/
+            $1.split(", ")
+              .map { |v| ::Gem::Version.new(v) }
+              .find { |v| !v.prerelease? && req.satisfied_by?(v) }
+          else
+            raise InstallFailedError, "Unable to determine existing versions of gem #{name.inspect}"
+          end
+        end
+      end
+
+      def perform_install(name, version)
+        @terminal.spinner(leading_text: "Installing gem #{name} #{version}... ",
+                          final_text: "Done.\n") do
+          result = @exec.exec(["gem", "install", name, "--version", version.to_s],
+                              out_to: :capture, err_to: :capture)
+          if result.error?
+            @terminal.puts(result.captured_out + result.captured_err)
+            raise InstallFailedError, "Failed to install gem #{name} #{version}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/toys/utils/help_text.rb

@@ -27,7 +27,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
-require "highline"
+require "toys/utils/terminal"
 
 module Toys
   module Utils
@@ -52,13 +52,14 @@ module Toys
       DEFAULT_INDENT = 4
 
       ##
-      # Create a usage helper given an execution context.
+      # Create a usage helper given an executable tool.
       #
-      # @param [Toys::Context] context The current execution context.
+      # @param [Toys::Tool] tool The current tool.
       # @return [Toys::Utils::HelpText]
       #
-      def self.from_context(context)
-        new(context[Context::TOOL], context[Context::LOADER], context[Context::BINARY_NAME])
+      def self.from_tool(tool)
+        new(tool[Tool::Keys::TOOL_DEFINITION], tool[Tool::Keys::LOADER],
+            tool[Tool::Keys::BINARY_NAME])
       end
 
       ##
@@ -133,7 +134,7 @@ module Toys
       def find_subtools(recursive, search)
         subtools = @loader.list_subtools(@tool.full_name, recursive: recursive)
         return subtools if search.nil? || search.empty?
-        regex = Regexp.new(search, Regexp::IGNORECASE)
+        regex = ::Regexp.new(search, ::Regexp::IGNORECASE)
         subtools.find_all do |tool|
           regex =~ tool.display_name || regex =~ tool.desc.to_s
         end
@@ -161,16 +162,16 @@ module Toys
         def assemble
           add_synopsis_section
           add_flags_section
-          add_positional_arguments_section if @tool.includes_script?
+          add_positional_arguments_section if @tool.runnable?
           add_subtool_list_section
           @result = @lines.join("\n") + "\n"
         end
 
         def add_synopsis_section
           synopses = []
-          synopses << namespace_synopsis if !@subtools.empty? && !@tool.includes_script?
+          synopses << namespace_synopsis if !@subtools.empty? && !@tool.runnable?
           synopses << tool_synopsis
-          synopses << namespace_synopsis if !@subtools.empty? && @tool.includes_script?
+          synopses << namespace_synopsis if !@subtools.empty? && @tool.runnable?
           first = true
           synopses.each do |synopsis|
             @lines << (first ? "Usage:  #{synopsis}" : "        #{synopsis}")
@@ -228,7 +229,7 @@ module Toys
           @subtools.each do |subtool|
             tool_name = subtool.full_name.slice(name_len..-1).join(" ")
             desc =
-              if subtool.is_a?(Alias)
+              if subtool.is_a?(Definition::Alias)
                 ["(Alias of #{subtool.display_target})"]
               else
                 wrap_desc(subtool.desc)
@@ -283,8 +284,7 @@ module Toys
           @indent = indent
           @indent2 = indent2
           @wrap_width = wrap_width
-          @styled = styled
-          @lines = []
+          @lines = Utils::Terminal.new(output: ::StringIO.new, styled: styled)
           assemble
         end
 
@@ -300,7 +300,7 @@ module Toys
           add_positional_arguments_section
           add_subtool_list_section
           add_source_section
-          @result = @lines.join("\n") + "\n"
+          @result = @lines.output.string
         end
 
         def add_name_section
@@ -326,11 +326,11 @@ module Toys
         def add_synopsis_section
           @lines << ""
           @lines << bold("SYNOPSIS")
-          if !@subtools.empty? && !@tool.includes_script?
+          if !@subtools.empty? && !@tool.runnable?
             add_synopsis_clause(namespace_synopsis)
           end
           add_synopsis_clause(tool_synopsis)
-          if !@subtools.empty? && @tool.includes_script?
+          if !@subtools.empty? && @tool.runnable?
             add_synopsis_clause(namespace_synopsis)
           end
         end
@@ -364,10 +364,10 @@ module Toys
         end
 
         def add_source_section
-          return unless @tool.definition_path && @show_source_path
+          return unless @tool.source_path && @show_source_path
           @lines << ""
           @lines << bold("SOURCE")
-          @lines << indent_str("Defined in #{@tool.definition_path}")
+          @lines << indent_str("Defined in #{@tool.source_path}")
         end
 
         def add_description_section
@@ -427,7 +427,12 @@ module Toys
           name_len = @tool.full_name.length
           @subtools.each do |subtool|
             tool_name = subtool.full_name.slice(name_len..-1).join(" ")
-            desc = subtool.is_a?(Alias) ? "(Alias of #{subtool.display_target})" : subtool.desc
+            desc =
+              if subtool.is_a?(Definition::Alias)
+                "(Alias of #{subtool.display_target})"
+              else
+                subtool.desc
+              end
             add_prefix_with_desc(bold(tool_name), desc)
           end
         end
@@ -473,11 +478,11 @@ module Toys
         end
 
         def bold(str)
-          @styled ? ::HighLine.color(str, :bold) : str
+          @lines.apply_styles(str, :bold)
         end
 
         def underline(str)
-          @styled ? ::HighLine.color(str, :underline) : str
+          @lines.apply_styles(str, :underline)
         end
 
         def indent_str(str)

data/lib/toys/utils/terminal.rb

@@ -0,0 +1,412 @@
+# Copyright 2018 Daniel Azuma
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+;
+
+require "stringio"
+require "monitor"
+
+begin
+  require "io/console"
+rescue ::LoadError # rubocop:disable Lint/HandleExceptions
+  # TODO: use stty to get terminal size
+end
+
+module Toys
+  module Utils
+    ##
+    # A simple terminal class.
+    #
+    # ## Styles
+    #
+    # This class supports ANSI styled output where supported.
+    #
+    # Styles may be specified in any of the following forms:
+    # *   A symbol indicating the name of a well-known style, or the name of
+    #     a defined style.
+    # *   An rgb string in hex "rgb" or "rrggbb" form.
+    # *   An ANSI code string in `\e[XXm` form.
+    # *   An array of ANSI codes as integers.
+    #
+    class Terminal
+      ## ANSI style code to clear styles
+      CLEAR_CODE = "\e[0m".freeze
+
+      ## Standard ANSI style codes
+      BUILTIN_STYLE_NAMES = {
+        clear: [0],
+        reset: [0],
+        bold: [1],
+        faint: [2],
+        italic: [3],
+        underline: [4],
+        blink: [5],
+        reverse: [7],
+        black: [30],
+        red: [31],
+        green: [32],
+        yellow: [33],
+        blue: [34],
+        magenta: [35],
+        cyan: [36],
+        white: [37],
+        on_black: [30],
+        on_red: [31],
+        on_green: [32],
+        on_yellow: [33],
+        on_blue: [34],
+        on_magenta: [35],
+        on_cyan: [36],
+        on_white: [37],
+        bright_black: [90],
+        bright_red: [91],
+        bright_green: [92],
+        bright_yellow: [93],
+        bright_blue: [94],
+        bright_magenta: [95],
+        bright_cyan: [96],
+        bright_white: [97],
+        on_bright_black: [100],
+        on_bright_red: [101],
+        on_bright_green: [102],
+        on_bright_yellow: [103],
+        on_bright_blue: [104],
+        on_bright_magenta: [105],
+        on_bright_cyan: [106],
+        on_bright_white: [107]
+      }.freeze
+
+      ##
+      # Default length of a single spinner frame, in seconds.
+      # @return [Float]
+      #
+      DEFAULT_SPINNER_FRAME_LENGTH = 0.1
+
+      ##
+      # Default set of spinner frames.
+      # @return [Array<String>]
+      #
+      DEFAULT_SPINNER_FRAMES = ["-", "\\", "|", "/"].freeze
+
+      ##
+      # Returns a copy of the given string with all ANSI style codes removed.
+      #
+      # @param [String] str Input string
+      # @return [String] String with styles removed
+      #
+      def self.remove_style_escapes(str)
+        str.gsub(/\e\[\d+(;\d+)*m/, "")
+      end
+
+      ##
+      # Create a terminal.
+      #
+      # @param [IO,Logger,nil] output Output stream or logger.
+      # @param [IO,nil] input Input stream.
+      #
+      def initialize(input: $stdin,
+                     output: $stdout,
+                     styled: nil)
+        @input = input
+        @output = output
+        @styled =
+          if styled.nil?
+            output.respond_to?(:tty?) && output.tty?
+          else
+            styled ? true : false
+          end
+        @named_styles = BUILTIN_STYLE_NAMES.dup
+      end
+
+      ##
+      # Output stream or logger
+      # @return [IO,Logger,nil]
+      #
+      attr_reader :output
+
+      ##
+      # Input stream
+      # @return [IO,nil]
+      #
+      attr_reader :input
+
+      ##
+      # Whether output is styled
+      # @return [Boolean]
+      #
+      attr_accessor :styled
+
+      ##
+      # Write a partial line without appending a newline.
+      #
+      # @param [String] str The line to write
+      # @param [Symbol,String,Array<Integer>...] styles Styles to apply to the
+      #     partial line.
+      #
+      def write(str = "", *styles)
+        output.write(apply_styles(str, *styles))
+        output.flush
+        self
+      end
+
+      ##
+      # Write a line, appending a newline if one is not already present.
+      #
+      # @param [String] str The line to write
+      # @param [Symbol,String,Array<Integer>...] styles Styles to apply to the
+      #     entire line.
+      #
+      def puts(str = "", *styles)
+        str = "#{str}\n" unless str.end_with?("\n")
+        write(str, *styles)
+      end
+
+      ##
+      # Write a line, appending a newline if one is not already present.
+      #
+      # @param [String] str The line to write
+      #
+      def <<(str)
+        puts(str)
+      end
+
+      ##
+      # Write a newline and flush the current line.
+      #
+      def newline
+        puts
+      end
+
+      ##
+      # Confirm with the user.
+      #
+      # @param [String] prompt Prompt string. Defaults to `"Proceed?"`.
+      # @return [Boolean]
+      #
+      def confirm(prompt = "Proceed?")
+        write("#{prompt} (y/n) ")
+        resp = input.gets
+        if resp =~ /^y/i
+          true
+        elsif resp =~ /^n/i
+          false
+        else
+          confirm("Please answer \"y\" or \"n\"")
+        end
+      end
+
+      ##
+      # Display a spinner during a task. You should provide a block that
+      # performs the long-running task. While the block is executing, a
+      # spinner will be displayed.
+      #
+      # @param [String] leading_text Optional leading string to display to the
+      #     left of the spinner. Default is the empty string.
+      # @param [Float] frame_length Length of a single frame, in seconds.
+      #     Defaults to {DEFAULT_SPINNER_FRAME_LENGTH}.
+      # @param [Array<String>] frames An array of frames. Defaults to
+      #     {DEFAULT_SPINNER_FRAMES}.
+      # @param [Symbol,Array<Symbol>] style A terminal style or array of styles
+      #     to apply to all frames in the spinner. Defaults to empty,
+      # @param [String] final_text Optional final string to display when the
+      #     spinner is complete. Default is the empty string. A common practice
+      #     is to set this to newline.
+      #
+      def spinner(leading_text: "", final_text: "",
+                  frame_length: nil, frames: nil, style: nil)
+        return nil unless block_given?
+        frame_length ||= DEFAULT_SPINNER_FRAME_LENGTH
+        frames ||= DEFAULT_SPINNER_FRAMES
+        output.write(leading_text) unless leading_text.empty?
+        spin = SpinDriver.new(self, frames, Array(style), frame_length)
+        begin
+          yield
+        ensure
+          spin.stop
+          output.write(final_text) unless final_text.empty?
+        end
+      end
+
+      ##
+      # Return the terminal size as an array of width, height.
+      #
+      # @return [Array(Integer,Integer)]
+      #
+      def size
+        if @output.respond_to?(:tty?) && @output.tty? && @output.respond_to?(:winsize)
+          @output.winsize.reverse
+        else
+          [80, 25]
+        end
+      end
+
+      ##
+      # Return the terminal width
+      #
+      # @return [Integer]
+      #
+      def width
+        size[0]
+      end
+
+      ##
+      # Return the terminal height
+      #
+      # @return [Integer]
+      #
+      def height
+        size[1]
+      end
+
+      ##
+      # Define a named style.
+      #
+      # Style names must be symbols.
+      # The definition of a style may include any valid style specification,
+      # including the symbol names of existing defined styles.
+      #
+      # @param [Symbol] name The name for the style
+      # @param [Symbol,String,Array<Integer>...] styles
+      #
+      def define_style(name, *styles)
+        @named_styles[name] = resolve_styles(*styles)
+        self
+      end
+
+      ##
+      # Apply the given styles to the given string, returning the styled
+      # string. Honors the styled setting; if styling is disabled, does not
+      # add any ANSI style codes and in fact removes any existing codes. If
+      # styles were added, ensures that the string ends with a clear code.
+      #
+      # @param [String] str String to style
+      # @param [Symbol,String,Array<Integer>...] styles Styles to apply
+      # @return [String] The styled string
+      #
+      def apply_styles(str, *styles)
+        if styled
+          prefix = escape_styles(*styles)
+          suffix = prefix.empty? || str.end_with?(CLEAR_CODE) ? "" : CLEAR_CODE
+          "#{prefix}#{str}#{suffix}"
+        else
+          Terminal.remove_style_escapes(str)
+        end
+      end
+
+      private
+
+      ##
+      # Resolve a style to an ANSI style escape sequence.
+      #
+      def escape_styles(*styles)
+        codes = resolve_styles(*styles)
+        codes.empty? ? "" : "\e[#{codes.join(';')}m"
+      end
+
+      ##
+      # Resolve a style to an array of ANSI style codes (integers).
+      #
+      def resolve_styles(*styles)
+        result = []
+        styles.each do |style|
+          codes =
+            case style
+            when ::Array
+              style
+            when ::String
+              interpret_style_string(style)
+            when ::Symbol
+              @named_styles[style]
+            end
+          raise ::ArgumentError, "Unknown style code: #{s.inspect}" unless codes
+          result.concat(codes)
+        end
+        result
+      end
+
+      ##
+      # Transform various style string formats into a list of style codes.
+      #
+      def interpret_style_string(style)
+        case style
+        when /^[0-9a-fA-F]{6}$/
+          rgb = style.to_i(16)
+          [38, 2, rgb >> 16, (rgb & 0xff00) >> 8, rgb & 0xff]
+        when /^[0-9a-fA-F]{3}$/
+          rgb = style.to_i(16)
+          [38, 2, (rgb >> 8) * 0x11, ((rgb & 0xf0) >> 4) * 0x11, (rgb & 0xf) * 0x11]
+        when /^\e\[([\d;]+)m$/
+          $1.split(";").map(&:to_i)
+        end
+      end
+
+      ## @private
+      class SpinDriver
+        include ::MonitorMixin
+
+        def initialize(terminal, frames, style, frame_length)
+          @terminal = terminal
+          @frames = frames.map do |f|
+            [@terminal.apply_styles(f, *style), Terminal.remove_style_escapes(f).size]
+          end
+          @frame_length = frame_length
+          @cur_frame = 0
+          @stopping = false
+          @cond = new_cond
+          super()
+          @thread = @terminal.output.tty? ? start_thread : nil
+        end
+
+        def stop
+          synchronize do
+            @stopping = true
+            @cond.broadcast
+          end
+          @thread.join if @thread
+          self
+        end
+
+        private
+
+        def start_thread
+          ::Thread.new do
+            synchronize do
+              until @stopping
+                @terminal.output.write(@frames[@cur_frame][0])
+                @cond.wait(@frame_length)
+                size = @frames[@cur_frame][1]
+                @terminal.output.write("\b" * size + " " * size + "\b" * size)
+                @cur_frame += 1
+                @cur_frame = 0 if @cur_frame >= @frames.size
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end