spotify_cli 0.1.0

data/lib/dex/ui/frame.rb

@@ -0,0 +1,166 @@
+require 'dex/ui'
+
+module Dex
+  module UI
+    module Frame
+      class << self
+        DEFAULT_FRAME_COLOR = Dex::UI.resolve_color(:cyan)
+
+        # Can be invoked in two ways: block and blockless
+        # In block form, the frame is closed automatically when the block returns
+        # In blockless form, caller MUST call Frame.close when the frame is
+        #   logically done.
+        # blockless form is strongly discouraged in cases where block form can be
+        #   made to work.
+        def open(
+          text,
+          color: DEFAULT_FRAME_COLOR,
+          failure_text: nil,
+          success_text: nil,
+          timing:       nil
+        )
+          color = Dex::UI.resolve_color(color)
+
+          unless block_given?
+            if failure_text
+              raise ArgumentError, "failure_text is not compatible with blockless invocation"
+            elsif success_text
+              raise ArgumentError, "success_text is not compatible with blockless invocation"
+            elsif !timing.nil?
+              raise ArgumentError, "timing is not compatible with blockless invocation"
+            end
+          end
+
+          timing = true if timing.nil?
+
+          t_start = Time.now.to_f
+          Dex::UI.raw do
+            puts edge(text, color: color, first: Dex::UI::Box::Heavy::TL)
+          end
+          FrameStack.push(color)
+
+          return unless block_given?
+
+          begin
+            success = false
+            success = yield
+          rescue
+            t_diff = timing ? (Time.now.to_f - t_start) : nil
+            close(failure_text, color: :red, elapsed: t_diff)
+            raise
+          else
+            t_diff = timing ? (Time.now.to_f - t_start) : nil
+            if success != false
+              close(success_text, color: color, elapsed: t_diff)
+            else
+              close(failure_text, color: :red, elapsed: t_diff)
+            end
+            success
+          end
+        end
+
+        def close(text, color: DEFAULT_FRAME_COLOR, elapsed: nil)
+          color = Dex::UI.resolve_color(color)
+
+          FrameStack.pop
+          kwargs = {}
+          if elapsed
+            kwargs[:right_text] = "(#{elapsed.round(2)}s)"
+          end
+          Dex::UI.raw do
+            puts edge(text, color: color, first: Dex::UI::Box::Heavy::BL, **kwargs)
+          end
+        end
+
+        def divider(text, color: nil)
+          color = Dex::UI.resolve_color(color)
+          item  = Dex::UI.resolve_color(FrameStack.pop)
+
+          Dex::UI.raw do
+            puts edge(text, color: (color || item), first: Dex::UI::Box::Heavy::DIV)
+          end
+          FrameStack.push(item)
+        end
+
+        def prefix(color: nil)
+          pfx = String.new
+          items = FrameStack.items
+          items[0..-2].each do |item|
+            pfx << Dex::UI.resolve_color(item).code << Dex::UI::Box::Heavy::VERT
+          end
+          if item = items.last
+            c = Thread.current[:dexui_frame_color_override] || color || item
+            pfx << Dex::UI.resolve_color(c).code \
+              << Dex::UI::Box::Heavy::VERT << ' ' << Dex::UI::Color::RESET.code
+          end
+          pfx
+        end
+
+        def with_frame_color_override(color)
+          prev = Thread.current[:dexui_frame_color_override]
+          Thread.current[:dexui_frame_color_override] = color
+          yield
+        ensure
+          Thread.current[:dexui_frame_color_override] = prev
+        end
+
+        private
+
+        def edge(text, color: raise, first: raise, right_text: nil)
+          color = Dex::UI.resolve_color(color)
+          text  = Dex::UI.resolve_text("{{#{color.name}:#{text}}}")
+
+          prefix = String.new
+          FrameStack.items.each do |item|
+            prefix << Dex::UI.resolve_color(item).code << Dex::UI::Box::Heavy::VERT
+          end
+          prefix << color.code << first << (Dex::UI::Box::Heavy::HORZ * 2)
+          text ||= ''
+          unless text.empty?
+            prefix << ' ' << text << ' '
+          end
+
+          suffix = String.new
+          if right_text
+            suffix << ' ' << right_text << ' ' << color.code << (Dex::UI::Box::Heavy::HORZ * 2)
+          end
+
+          textwidth = Dex::UI::ANSI.printing_width(prefix + suffix)
+          termwidth = Dex::UI::Terminal.width
+          termwidth = 30 if termwidth < 30
+
+          if textwidth > termwidth
+            suffix = ''
+            prefix = prefix[0...termwidth]
+            textwidth = termwidth
+          end
+          padwidth = termwidth - textwidth
+          pad = Dex::UI::Box::Heavy::HORZ * padwidth
+
+          prefix + color.code + pad + suffix + Dex::UI::Color::RESET.code + "\n"
+        end
+
+        module FrameStack
+          ENVVAR = 'DEX_FRAME_STACK'
+
+          def self.items
+            ENV.fetch(ENVVAR, '').split(':').map(&:to_sym)
+          end
+
+          def self.push(item)
+            curr = items
+            curr << item.name
+            ENV[ENVVAR] = curr.join(':')
+          end
+
+          def self.pop
+            curr = items
+            ret = curr.pop
+            ENV[ENVVAR] = curr.join(':')
+            ret.nil? ? nil : ret.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dex/ui/glyph.rb

@@ -0,0 +1,49 @@
+require 'dex/ui'
+
+module Dex
+  module UI
+    class Glyph
+      MAP = {}
+
+      attr_reader :handle, :codepoint, :color, :char, :to_s, :fmt
+      def initialize(handle, codepoint, color)
+        @handle    = handle
+        @codepoint = codepoint
+        @color     = color
+        @char      = [codepoint].pack('U')
+        @to_s      = color.code + char + Color::RESET.code
+        @fmt       = "{{#{color.name}:#{char}}}"
+
+        MAP[handle] = self
+      end
+
+      STAR     = new('*', 0x2b51,  Color::YELLOW) # BLACK SMALL STAR
+      INFO     = new('i', 0x1d4be, Color::BLUE)   # MATHEMATICAL SCRIPT SMALL I
+      QUESTION = new('?', 0x003f,  Color::BLUE)   # QUESTION MARK
+      CHECK    = new('v', 0x2713,  Color::GREEN)  # CHECK MARK
+      X        = new('x', 0x2717,  Color::RED)    # BALLOT X
+
+      class InvalidGlyphHandle < ArgumentError
+        def initialize(handle)
+          @handle = handle
+        end
+
+        def message
+          keys = Glyph.available.join(',')
+          "invalid glyph handle: #{@handle} " \
+            "-- must be one of Dex::UI::Glyph.available (#{keys})"
+        end
+      end
+
+      def self.lookup(name)
+        MAP.fetch(name.to_s)
+      rescue KeyError
+        raise InvalidGlyphHandle, name
+      end
+
+      def self.available
+        MAP.keys
+      end
+    end
+  end
+end

data/lib/dex/ui/progress.rb

@@ -0,0 +1,19 @@
+require 'dex/ui'
+
+module Dex
+  module UI
+    module Progress
+      FILLED_BAR = Dex::UI::Glyph.new("◾", 0x2588,  Color::CYAN)
+      UNFILLED_BAR = Dex::UI::Glyph.new("◽", 0x2588,  Color::WHITE)
+
+      def self.progress(percent, width)
+        filled = (percent * width).ceil
+        unfilled = width - filled
+        Dex::UI.resolve_text [
+          (FILLED_BAR.to_s * filled),
+          (UNFILLED_BAR.to_s * unfilled)
+        ].join
+      end
+    end
+  end
+end

data/lib/dex/ui/prompt.rb

@@ -0,0 +1,121 @@
+require 'dex/ui'
+require 'readline'
+
+module Dex
+  module UI
+    module Prompt
+      class << self
+        def ask(question, options: nil, default: nil, is_file: nil, allow_empty: true)
+          if (default && !allow_empty) || (options && (default || is_file))
+            raise(ArgumentError, 'conflicting arguments')
+          end
+
+          if default
+            puts_question("#{question} (empty = #{default})")
+          else
+            puts_question(question)
+          end
+
+          if options
+            return ask_options(options)
+          end
+
+          loop do
+            line = readline(is_file: is_file)
+
+            if line.empty? && default
+              write_default_over_empty_input(default)
+              return default
+            end
+
+            if !line.empty? || allow_empty
+              return line
+            end
+          end
+        end
+
+        def confirm(question)
+          puts_question(question + ' {{yellow:[y/n]}}')
+
+          loop do
+            line = readline(is_file: false)
+            char = line[0].downcase
+            return true  if char == 'y'
+            return false if char == 'n'
+          end
+        end
+
+        private
+
+        def write_default_over_empty_input(default)
+          Dex::UI.raw do
+            STDERR.puts(
+              Dex::UI::ANSI.cursor_up(1) +
+              "\r" +
+              Dex::UI::ANSI.cursor_forward(4) + # TODO: width
+              default +
+              Dex::UI::Color::RESET.code
+            )
+          end
+        end
+
+        def puts_question(str)
+          Dex::UI.with_frame_color(:blue) do
+            STDOUT.puts(Dex::UI.fmt('{{?}} ' + str))
+          end
+        end
+
+        def ask_options(options)
+          puts_question("Your options are:")
+          options.each_with_index do |v, idx|
+            puts_question("#{idx + 1}) #{v}")
+          end
+          puts_question("Choose a number between 1 and #{options.length}")
+
+          buf = -1
+          available = (1..options.length).to_a
+          until available.include?(buf.to_i)
+            buf = readline(is_file: false)
+
+            if buf.nil?
+              STDERR.puts
+              next
+            end
+
+            if buf.is_a?(String)
+              buf = buf.chomp
+            end
+            buf = -1 if buf.empty?
+            buf = -1 if buf.to_i.to_s != buf
+          end
+
+          options[buf.to_i - 1]
+        end
+
+        def readline(is_file: false)
+          if is_file
+            Readline.completion_proc = Readline::FILENAME_COMPLETION_PROC
+            Readline.completion_append_character = ""
+          else
+            Readline.completion_proc = proc { |*| nil }
+            Readline.completion_append_character = " "
+          end
+
+          # because Readline is a C library, Dex::UI's hooks into $stdout don't
+          # work. We could work around this by having Dex::UI use a pipe and a
+          # thread to manage output, but the current strategy feels like a
+          # better tradeoff.
+          prefix = Dex::UI.with_frame_color(:blue) { Dex::UI::Frame.prefix }
+          prompt = prefix + Dex::UI.fmt('{{blue:> }}{{yellow:')
+
+          begin
+            Readline.readline(prompt, true).chomp
+          rescue Interrupt
+            Dex::UI.raw { STDERR.puts('^C' + Dex::UI::Color::RESET.code) }
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dex/ui/spinner.rb

@@ -0,0 +1,168 @@
+require 'dex/ui'
+
+module Dex
+  module UI
+    module Spinner
+      PERIOD = 0.1 # seconds
+
+      begin
+        runes = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+        colors = [Dex::UI::Color::CYAN.code] * 5 + [Dex::UI::Color::MAGENTA.code] * 5
+        raise unless runes.size == colors.size
+        GLYPHS = colors.zip(runes).map(&:join)
+      end
+
+      def self.spin(title, &block)
+        sg = SpinGroup.new
+        sg.add(title, &block)
+        sg.wait
+      end
+
+      class SpinGroup
+        def initialize
+          @m = Mutex.new
+          @consumed_lines = 0
+          @tasks = []
+        end
+
+        class Task
+          attr_reader :title, :exception, :success, :stdout, :stderr
+
+          def initialize(title, &block)
+            @title = title
+            @thread = Thread.new do
+              cap = Dex::UI::StdoutRouter::Capture.new(with_frame_inset: false, &block)
+              begin
+                cap.run
+              ensure
+                @stdout = cap.stdout
+                @stderr = cap.stderr
+              end
+            end
+
+            @done      = false
+            @exception = nil
+            @success   = false
+          end
+
+          def check
+            return true if @done
+            return false if @thread.alive?
+
+            @done = true
+            begin
+              status = @thread.join.status
+              @success = (status == false)
+            rescue => exc
+              @exception = exc
+              @success = false
+            end
+
+            @done
+          end
+
+          def render(index, force = true)
+            return full_render(index) if force
+            partial_render(index)
+          end
+
+          private
+
+          def full_render(index)
+            inset + glyph(index) + Dex::UI::Color::RESET.code + ' ' + Dex::UI.resolve_text(title)
+          end
+
+          def partial_render(index)
+            Dex::UI::ANSI.cursor_forward(inset_width) + glyph(index) + Dex::UI::Color::RESET.code
+          end
+
+          def glyph(index)
+            if @done
+              @success ? Dex::UI::Glyph::CHECK.to_s : Dex::UI::Glyph::X.to_s
+            else
+              GLYPHS[index]
+            end
+          end
+
+          def inset
+            @inset ||= Dex::UI::Frame.prefix
+          end
+
+          def inset_width
+            @inset_width ||= Dex::UI::ANSI.printing_width(inset)
+          end
+        end
+
+        def add(title, &block)
+          @m.synchronize do
+            @tasks << Task.new(title, &block)
+          end
+        end
+
+        def wait
+          idx = 0
+
+          loop do
+            all_done = true
+
+            @m.synchronize do
+              Dex::UI.raw do
+                @tasks.each.with_index do |task, int_index|
+                  nat_index = int_index + 1
+                  task_done = task.check
+                  all_done = false unless task_done
+
+                  if nat_index > @consumed_lines
+                    print(task.render(idx, true) + "\n")
+                    @consumed_lines += 1
+                  else
+                    offset = @consumed_lines - int_index
+                    move_to   = Dex::UI::ANSI.cursor_up(offset) + "\r"
+                    move_from = "\r" + Dex::UI::ANSI.cursor_down(offset)
+
+                    print(move_to + task.render(idx, idx.zero?) + move_from)
+                  end
+                end
+              end
+            end
+
+            break if all_done
+
+            idx = (idx + 1) % GLYPHS.size
+            sleep(PERIOD)
+          end
+
+          debrief
+        end
+
+        def debrief
+          @m.synchronize do
+            @tasks.each do |task|
+              next if task.success
+
+              e = task.exception
+              out = task.stdout
+              err = task.stderr
+
+              Dex::UI::Frame.open('Task Failed: ' + task.title, color: :red) do
+                if e
+                  puts"#{e.class}: #{e.message}"
+                  puts "\tfrom #{e.backtrace.join("\n\tfrom ")}"
+                end
+
+                Dex::UI::Frame.divider('STDOUT')
+                out = "(empty)" if out.strip.empty?
+                puts out
+
+                Dex::UI::Frame.divider('STDERR')
+                err = "(empty)" if err.strip.empty?
+                puts err
+              end
+            end
+            @tasks.all?(&:success)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dex/ui/stdout_router.rb

@@ -0,0 +1,186 @@
+require 'dex/ui'
+
+module Dex
+  module UI
+    module StdoutRouter
+      class << self
+        attr_accessor :duplicate_output_to
+      end
+
+      class Writer
+        def initialize(stream, name)
+          @stream = stream
+          @name = name
+        end
+
+        def write(*args)
+          if auto_frame_inset?
+            str = args[0].dup # unfreeze
+            str = str.force_encoding(Encoding::UTF_8)
+            str = apply_line_prefix(str, Dex::UI::Frame.prefix)
+            args[0] = str
+          else
+            @pending_newline = false
+          end
+
+          hook = Thread.current[:dexui_output_hook]
+          # hook return of false suppresses output.
+          if !hook || hook.call(args.first, @name) != false
+            args.first
+            @stream.write_without_dex_ui(*args)
+            if dup = StdoutRouter.duplicate_output_to
+              dup.write(*args)
+            end
+          end
+        end
+
+        private
+
+        def auto_frame_inset?
+          !Thread.current[:no_dexui_frame_inset]
+        end
+
+        def apply_line_prefix(str, prefix)
+          return '' if str.empty?
+          prefixed = String.new
+          str.force_encoding(Encoding::UTF_8).lines.each do |line|
+            if @pending_newline
+              prefixed << line
+              @pending_newline = false
+            else
+              prefixed << prefix << line
+            end
+          end
+          @pending_newline = !str.end_with?("\n")
+          prefixed
+        end
+      end
+
+      class Capture
+        @m = Mutex.new
+        @active_captures = 0
+        @saved_stdin = nil
+
+        def self.with_stdin_masked
+          @m.synchronize do
+            if @active_captures.zero?
+              @saved_stdin = $stdin
+              $stdin, w = IO.pipe
+              $stdin.close
+              w.close
+            end
+            @active_captures += 1
+          end
+
+          yield
+        ensure
+          @m.synchronize do
+            @active_captures -= 1
+            if @active_captures.zero?
+              $stdin = @saved_stdin
+            end
+          end
+        end
+
+        def initialize(with_frame_inset: true, &block)
+          @with_frame_inset = with_frame_inset
+          @block = block
+        end
+
+        attr_reader :stdout, :stderr
+
+        def run
+          StdoutRouter.assert_enabled!
+
+          out = StringIO.new
+          err = StringIO.new
+
+          prev_frame_inset = Thread.current[:no_dexui_frame_inset]
+          prev_hook = Thread.current[:dexui_output_hook]
+
+          self.class.with_stdin_masked do
+            Thread.current[:no_dexui_frame_inset] = !@with_frame_inset
+            Thread.current[:dexui_output_hook] = ->(data, stream) do
+              case stream
+              when :stdout then out.write(data)
+              when :stderr then err.write(data)
+              else raise
+              end
+              false # suppress writing to terminal
+            end
+
+            begin
+              @block.call
+            ensure
+              @stdout = out.string
+              @stderr = err.string
+            end
+          end
+        ensure
+          Thread.current[:dexui_output_hook] = prev_hook
+          Thread.current[:no_dexui_frame_inset] = prev_frame_inset
+        end
+      end
+
+      class << self
+        WRITE_WITHOUT_DEX_UI = :write_without_dex_ui
+
+        NotEnabled = Class.new(StandardError)
+
+        def assert_enabled!
+          raise NotEnabled unless enabled?
+        end
+
+        def with_enabled
+          enable
+          yield
+        ensure
+          disable
+        end
+
+        # TODO: remove this
+        def ensure_activated
+          enable unless enabled?
+        end
+
+        def enable
+          return false if enabled?($stdout) || enabled?($stderr)
+          activate($stdout, :stdout)
+          activate($stderr, :stderr)
+          true
+        end
+
+        def enabled?(stream = $stdout)
+          stream.respond_to?(WRITE_WITHOUT_DEX_UI)
+        end
+
+        def disable
+          return false unless enabled?($stdout) && enabled?($stderr)
+          deactivate($stdout)
+          deactivate($stderr)
+          true
+        end
+
+        private
+
+        def deactivate(stream)
+          sc = stream.singleton_class
+          sc.send(:remove_method, :write)
+          sc.send(:alias_method, :write, WRITE_WITHOUT_DEX_UI)
+        end
+
+        def activate(stream, streamname)
+          writer = StdoutRouter::Writer.new(stream, streamname)
+
+          raise if stream.respond_to?(WRITE_WITHOUT_DEX_UI)
+          stream.singleton_class.send(:alias_method, WRITE_WITHOUT_DEX_UI, :write)
+          stream.define_singleton_method(:write) do |*args|
+            writer.write(*args)
+          end
+        end
+      end
+    end
+  end
+end
+
+Dex::UI::StdoutRouter.enable