shopify-cli 0.9.1 → 1.0.2

data/lib/shopify-cli/tunnel.rb

@@ -11,7 +11,7 @@ module ShopifyCli
   class Tunnel
     extend SingleForwardable
 
-    def_delegators :new, :start, :stop, :auth
+    def_delegators :new, :start, :stop, :auth, :stats, :urls
 
     class FetchUrlError < RuntimeError; end
     class NgrokError < RuntimeError; end
@@ -23,6 +23,10 @@ module ShopifyCli
       linux: 'https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip',
     }
 
+    NGROK_TUNNELS_URI = URI.parse('http://localhost:4040/api/tunnels')
+    TUNNELS_FIELD = 'tunnels'
+    PUBLIC_URL_FIELD = 'public_url'
+
     ##
     # will find and stop a running tunnel process. It will also output if the
     # operation was successful or not
@@ -82,6 +86,34 @@ module ShopifyCli
       ctx.system(File.join(ShopifyCli::CACHE_DIR, 'ngrok'), 'authtoken', token)
     end
 
+    ##
+    # will return the statistics of the current running tunnels
+    #
+    # #### Returns
+    #
+    # * `stats` - the hash of running statistics returning from the ngrok api
+    #
+    def stats
+      response = Net::HTTP.get_response(NGROK_TUNNELS_URI)
+      JSON.parse(response.body)
+    rescue
+      {}
+    end
+
+    ##
+    # will return the urls of the current running tunnels
+    #
+    # #### Returns
+    #
+    # * `stats` - the array of urls
+    #
+    def urls
+      tunnels = stats.dig(TUNNELS_FIELD)
+      tunnels.map { |tunnel| tunnel.dig(PUBLIC_URL_FIELD) }
+    rescue
+      []
+    end
+
     private
 
     def install(ctx)

data/lib/shopify-cli/version.rb

@@ -1,3 +1,3 @@
 module ShopifyCli
-  VERSION = '0.9.1'
+  VERSION = '1.0.2'
 end

data/vendor/deps/cli-ui/REVISION

@@ -1 +1 @@
-35e1b188f19b2ba0ab85bbf48ab983b1f72a361b
+c59f601fe271432dfe304f30f08a48b2a343606e

data/vendor/deps/cli-ui/lib/cli/ui.rb

@@ -3,14 +3,15 @@ module CLI
     autoload :ANSI,               'cli/ui/ansi'
     autoload :Glyph,              'cli/ui/glyph'
     autoload :Color,              'cli/ui/color'
-    autoload :Box,                'cli/ui/box'
     autoload :Frame,              'cli/ui/frame'
+    autoload :Printer,            'cli/ui/printer'
     autoload :Progress,           'cli/ui/progress'
     autoload :Prompt,             'cli/ui/prompt'
     autoload :Terminal,           'cli/ui/terminal'
     autoload :Truncater,          'cli/ui/truncater'
     autoload :Formatter,          'cli/ui/formatter'
     autoload :Spinner,            'cli/ui/spinner'
+    autoload :Widgets,            'cli/ui/widgets'
 
     # Convenience accessor to +CLI::UI::Spinner::SpinGroup+
     SpinGroup = Spinner::SpinGroup
@@ -42,7 +43,23 @@ module CLI
       end
     end
 
-    # Conviencence Method for +CLI::UI::Prompt.confirm+
+    # Frame style resolution using +CLI::UI::Frame::FrameStyle.lookup+.
+    # Will lookup using +FrameStyle.lookup+ if the input is a symbol.  Otherwise,
+    # we assume it's a valid FrameStyle
+    #
+    # ==== Attributes
+    #
+    # * +input+ - frame style to resolve
+    def self.resolve_style(input)
+      case input
+      when Symbol
+        CLI::UI::Frame::FrameStyle.lookup(input)
+      else
+        input
+      end
+    end
+
+    # Convenience Method for +CLI::UI::Prompt.confirm+
     #
     # ==== Attributes
     #
@@ -52,18 +69,18 @@ module CLI
       CLI::UI::Prompt.confirm(question, **kwargs)
     end
 
-    # Conviencence Method for +CLI::UI::Prompt.ask+
+    # Convenience Method for +CLI::UI::Prompt.ask+
     #
     # ==== Attributes
     #
     # * +question+ - question to ask
-    # * +kwargs+ - arugments for +Prompt.ask+
+    # * +kwargs+ - arguments for +Prompt.ask+
     #
     def self.ask(question, **kwargs)
       CLI::UI::Prompt.ask(question, **kwargs)
     end
 
-    # Conviencence Method to resolve text using +CLI::UI::Formatter.format+
+    # Convenience Method to resolve text using +CLI::UI::Formatter.format+
     # Check +CLI::UI::Formatter::SGR_MAP+ for available formatting options
     #
     # ==== Attributes
@@ -75,10 +92,10 @@ module CLI
       return input if input.nil?
       formatted = CLI::UI::Formatter.new(input).format
       return formatted unless truncate_to
-      return CLI::UI::Truncater.call(formatted, truncate_to)
+      CLI::UI::Truncater.call(formatted, truncate_to)
     end
 
-    # Conviencence Method to format text using +CLI::UI::Formatter.format+
+    # Convenience Method to format text using +CLI::UI::Formatter.format+
     # Check +CLI::UI::Formatter::SGR_MAP+ for available formatting options
     #
     # https://user-images.githubusercontent.com/3074765/33799827-6d0721a2-dd01-11e7-9ab5-c3d455264afe.png
@@ -96,7 +113,18 @@ module CLI
       CLI::UI::Formatter.new(input).format(enable_color: enable_color)
     end
 
-    # Conviencence Method for +CLI::UI::Frame.open+
+    # Convenience Method for +CLI::UI::Printer.puts+
+    #
+    # ==== Attributes
+    #
+    # * +msg+ - Message to print
+    # * +kwargs+ - keyword arguments for +Printer.puts+
+    #
+    def self.puts(msg, **kwargs)
+      CLI::UI::Printer.puts(msg, **kwargs)
+    end
+
+    # Convenience Method for +CLI::UI::Frame.open+
     #
     # ==== Attributes
     #
@@ -107,7 +135,7 @@ module CLI
       CLI::UI::Frame.open(*args, &block)
     end
 
-    # Conviencence Method for +CLI::UI::Spinner.spin+
+    # Convenience Method for +CLI::UI::Spinner.spin+
     #
     # ==== Attributes
     #
@@ -118,7 +146,7 @@ module CLI
       CLI::UI::Spinner.spin(*args, &block)
     end
 
-    # Conviencence Method to override frame color using +CLI::UI::Frame.with_frame_color+
+    # Convenience Method to override frame color using +CLI::UI::Frame.with_frame_color+
     #
     # ==== Attributes
     #
@@ -142,7 +170,7 @@ module CLI
       CLI::UI::StdoutRouter.duplicate_output_to = File.open(path, 'w')
       yield
     ensure
-      if file_descriptor = CLI::UI::StdoutRouter.duplicate_output_to
+      if (file_descriptor = CLI::UI::StdoutRouter.duplicate_output_to)
         file_descriptor.close
         CLI::UI::StdoutRouter.duplicate_output_to = nil
       end
@@ -181,6 +209,19 @@ module CLI
     end
 
     self.enable_color = $stdout.tty?
+
+    # Set the default frame style.
+    # Convenience method for setting the default frame style with +CLI::UI::Frame.frame_style=+
+    #
+    # Raises ArgumentError if +frame_style+ is not valid
+    #
+    # ==== Attributes
+    #
+    # * +symbol+ - the default frame style to use for frames
+    #
+    def self.frame_style=(frame_style)
+      Frame.frame_style = frame_style.to_sym
+    end
   end
 end
 

data/vendor/deps/cli-ui/lib/cli/ui/color.rb

@@ -31,15 +31,19 @@ module CLI
       BOLD    = new('1',  :bold)
       WHITE   = new('97', :white)
 
+      # 240 is very dark gray; 255 is very light gray. 244 is somewhat dark.
+      GRAY = new('38;5;244', :grey)
+
       MAP = {
-        red:     RED,
-        green:   GREEN,
-        yellow:  YELLOW,
-        blue:    BLUE,
+        red: RED,
+        green: GREEN,
+        yellow: YELLOW,
+        blue: BLUE,
         magenta: MAGENTA,
-        cyan:    CYAN,
-        reset:   RESET,
-        bold:    BOLD,
+        cyan: CYAN,
+        reset: RESET,
+        bold: BOLD,
+        gray: GRAY,
       }.freeze
 
       class InvalidColorName < ArgumentError

data/vendor/deps/cli-ui/lib/cli/ui/formatter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-
-require 'cli/ui'
-require 'strscan'
+require('cli/ui')
+require('strscan')
 
 module CLI
   module UI
@@ -13,39 +12,40 @@ module CLI
       #
       SGR_MAP = {
         # presentational
-        'red'       => '31',
-        'green'     => '32',
-        'yellow'    => '33',
-         # default blue is low-contrast against black in some default terminal color scheme
-        'blue'      => '94', # 9x = high-intensity fg color x
-        'magenta'   => '35',
-        'cyan'      => '36',
-        'bold'      => '1',
-        'italic'    => '3',
+        'red' => '31',
+        'green' => '32',
+        'yellow' => '33',
+        # default blue is low-contrast against black in some default terminal color scheme
+        'blue' => '94', # 9x = high-intensity fg color x
+        'magenta' => '35',
+        'cyan' => '36',
+        'bold' => '1',
+        'italic' => '3',
         'underline' => '4',
-        'reset'     => '0',
+        'reset' => '0',
 
         # semantic
-        'error'   => '31', # red
+        'error' => '31', # red
         'success' => '32', # success
         'warning' => '33', # yellow
-        'info'    => '94', # bright blue
+        'info' => '94', # bright blue
         'command' => '36', # cyan
       }.freeze
 
       BEGIN_EXPR = '{{'
       END_EXPR   = '}}'
 
+      SCAN_WIDGET   = %r[@widget/(?<handle>\w+):(?<args>.*?)}}]
       SCAN_FUNCNAME = /\w+:/
       SCAN_GLYPH    = /.}}/
-      SCAN_BODY     = /
+      SCAN_BODY     = %r{
         .*?
         (
           #{BEGIN_EXPR} |
           #{END_EXPR}   |
           \z
         )
-      /mx
+      }mx
 
       DISCARD_BRACES = 0..-3
 
@@ -123,7 +123,7 @@ module CLI
       end
 
       def parse_expr(sc, stack)
-        if match = sc.scan(SCAN_GLYPH)
+        if (match = sc.scan(SCAN_GLYPH))
           glyph_handle = match[0]
           begin
             glyph = Glyph.lookup(glyph_handle)
@@ -136,7 +136,20 @@ module CLI
               index
             )
           end
-        elsif match = sc.scan(SCAN_FUNCNAME)
+        elsif (match = sc.scan(SCAN_WIDGET))
+          match_data = SCAN_WIDGET.match(match) # Regexp.last_match doesn't work here
+          widget_handle = match_data['handle']
+          begin
+            widget = Widgets.lookup(widget_handle)
+            emit(widget.call(match_data['args']), stack)
+          rescue Widgets::InvalidWidgetHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise(FormatError.new(
+              "invalid widget handle at index #{index}: '#{widget_handle}'",
+              @text, index,
+            ))
+          end
+        elsif (match = sc.scan(SCAN_FUNCNAME))
           funcname = match.chop
           stack.push(funcname)
         else
@@ -153,10 +166,10 @@ module CLI
 
       def parse_body(sc, stack = [])
         match = sc.scan(SCAN_BODY)
-        if match && match.end_with?(BEGIN_EXPR)
+        if match&.end_with?(BEGIN_EXPR)
           emit(match[DISCARD_BRACES], stack)
           parse_expr(sc, stack)
-        elsif match && match.end_with?(END_EXPR)
+        elsif match&.end_with?(END_EXPR)
           emit(match[DISCARD_BRACES], stack)
           if stack.pop == LITERAL_BRACES
             emit('}}', stack)

data/vendor/deps/cli-ui/lib/cli/ui/frame.rb

@@ -1,4 +1,7 @@
+# coding: utf-8
 require 'cli/ui'
+require 'cli/ui/frame/frame_stack'
+require 'cli/ui/frame/frame_style'
 
 module CLI
   module UI
@@ -7,6 +10,22 @@ module CLI
       class << self
         DEFAULT_FRAME_COLOR = CLI::UI.resolve_color(:cyan)
 
+        def frame_style
+          @frame_style ||= FrameStyle::Box
+        end
+
+        # Set the default frame style.
+        #
+        # Raises ArgumentError if +frame_style+ is not valid
+        #
+        # ==== Attributes
+        #
+        # * +symbol+ or +FrameStyle+ - the default frame style to use for frames
+        #
+        def frame_style=(frame_style)
+          @frame_style = CLI::UI.resolve_style(frame_style)
+        end
+
         # Opens a new frame. Can be nested
         # Can be invoked in two ways: block and blockless
         # * In block form, the frame is closed automatically when the block returns
@@ -27,6 +46,7 @@ module CLI
         # * +:failure_text+ - If the block failed, what do we output? Defaults to nil
         # * +:success_text+ - If the block succeeds, what do we output? Defaults to nil
         # * +:timing+ - How long did the frame content take? Invalid for blockless. Defaults to true for the block form
+        # * +frame_style+ - The frame style to use for this frame
         #
         # ==== Example
         #
@@ -34,7 +54,7 @@ module CLI
         #
         #   CLI::UI::Frame.open('Open') { puts 'hi' }
         #
-        # Output:
+        # Default Output:
         #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
         #   ┃ hi
         #   ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ (0.0s) ━━
@@ -43,7 +63,7 @@ module CLI
         #
         #   CLI::UI::Frame.open('Open')
         #
-        # Output:
+        # Default Output:
         #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
         #
         #
@@ -52,8 +72,10 @@ module CLI
           color: DEFAULT_FRAME_COLOR,
           failure_text: nil,
           success_text: nil,
-          timing:       nil
+          timing:       nil,
+          frame_style:  self.frame_style
         )
+          frame_style = CLI::UI.resolve_style(frame_style)
           color = CLI::UI.resolve_color(color)
 
           unless block_given?
@@ -61,18 +83,17 @@ module CLI
               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?
+            elsif timing
               raise ArgumentError, "timing is not compatible with blockless invocation"
             end
           end
 
-          timing = true if timing.nil?
-
-          t_start = Time.now.to_f
+          t_start = Time.now
           CLI::UI.raw do
-            puts edge(text, color: color, first: CLI::UI::Box::Heavy::TL)
+            print prefix.chop
+            puts frame_style.open(text, color: color)
           end
-          FrameStack.push(color)
+          FrameStack.push(color: color, style: frame_style)
 
           return unless block_given?
 
@@ -82,14 +103,14 @@ module CLI
             success = yield
           rescue
             closed = true
-            t_diff = timing ? (Time.now.to_f - t_start) : nil
+            t_diff = elasped(t_start, timing)
             close(failure_text, color: :red, elapsed: t_diff)
             raise
           else
             success
           ensure
             unless closed
-              t_diff = timing ? (Time.now.to_f - t_start) : nil
+              t_diff = elasped(t_start, timing)
               if success != false
                 close(success_text, color: color, elapsed: t_diff)
               else
@@ -99,8 +120,8 @@ module CLI
           end
         end
 
-        # Closes a frame
-        # Automatically called for a block-form +open+
+        # Adds a divider in a frame
+        # Used to separate information within a single frame
         #
         # ==== Attributes
         #
@@ -109,31 +130,38 @@ module CLI
         # ==== Options
         #
         # * +:color+ - The color of the frame. Defaults to +DEFAULT_FRAME_COLOR+
-        # * +:elapsed+ - How long did the frame take? Defaults to nil
+        # * +frame_style+ - The frame style to use for this frame
         #
         # ==== Example
         #
-        #   CLI::UI::Frame.close('Close')
+        #   CLI::UI::Frame.open('Open') { CLI::UI::Frame.divider('Divider') }
         #
-        # Output:
-        #   ┗━━ Close ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        # Default Output:
+        #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        #   ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
         #
+        # ==== Raises
         #
-        def close(text, color: DEFAULT_FRAME_COLOR, elapsed: nil)
-          color = CLI::UI.resolve_color(color)
+        # MUST be inside an open frame or it raises a +UnnestedFrameException+
+        #
+        def divider(text, color: nil, frame_style: nil)
+          fs_item = FrameStack.pop
+          raise UnnestedFrameException, "No frame nesting to unnest" unless fs_item
+
+          color = CLI::UI.resolve_color(color) || fs_item.color
+          frame_style = CLI::UI.resolve_style(frame_style) || fs_item.frame_style
 
-          FrameStack.pop
-          kwargs = {}
-          if elapsed
-            kwargs[:right_text] = "(#{elapsed.round(2)}s)"
-          end
           CLI::UI.raw do
-            puts edge(text, color: color, first: CLI::UI::Box::Heavy::BL, **kwargs)
+            print prefix.chop
+            puts frame_style.divider(text, color: color)
           end
+
+          FrameStack.push(fs_item)
         end
 
-        # Adds a divider in a frame
-        # Used to separate information within a single frame
+        # Closes a frame
+        # Automatically called for a block-form +open+
         #
         # ==== Attributes
         #
@@ -141,51 +169,69 @@ module CLI
         #
         # ==== Options
         #
-        # * +:color+ - The color of the frame. Defaults to +DEFAULT_FRAME_COLOR+
+        # * +:color+ - The color of the frame. Defaults to nil
+        # * +:elapsed+ - How long did the frame take? Defaults to nil
+        # * +frame_style+ - The frame style to use for this frame.  Defaults to nil
         #
         # ==== Example
         #
-        #   CLI::UI::Frame.open('Open') { CLI::UI::Frame.divider('Divider') }
+        #   CLI::UI::Frame.close('Close')
         #
-        # Output:
-        #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-        #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-        #   ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        # Default Output:
+        #   ┗━━ Close ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
         #
         # ==== Raises
         #
         # MUST be inside an open frame or it raises a +UnnestedFrameException+
         #
-        def divider(text, color: nil)
+        def close(text, color: nil, elapsed: nil, frame_style: nil)
           fs_item = FrameStack.pop
-          raise UnnestedFrameException, "no frame nesting to unnest" unless fs_item
-          color = CLI::UI.resolve_color(color)
-          item  = CLI::UI.resolve_color(fs_item)
+          raise UnnestedFrameException, "No frame nesting to unnest" unless fs_item
+
+          color = CLI::UI.resolve_color(color) || fs_item.color
+          frame_style = CLI::UI.resolve_style(frame_style) || fs_item.frame_style
+
+          kwargs = {}
+          if elapsed
+            kwargs[:right_text] = "(#{elapsed.round(2)}s)"
+          end
 
           CLI::UI.raw do
-            puts edge(text, color: (color || item), first: CLI::UI::Box::Heavy::DIV)
+            print prefix.chop
+            puts frame_style.close(text, color: color, **kwargs)
           end
-          FrameStack.push(item)
         end
 
         # Determines the prefix of a frame entry taking multi-nested frames into account
         #
         # ==== Options
         #
-        # * +:color+ - The color of the prefix. Defaults to +Thread.current[:cliui_frame_color_override]+ or nil
+        # * +:color+ - The color of the prefix. Defaults to +Thread.current[:cliui_frame_color_override]+
         #
-        def prefix(color: nil)
-          pfx = +''
-          items = FrameStack.items
-          items[0..-2].each do |item|
-            pfx << CLI::UI.resolve_color(item).code << CLI::UI::Box::Heavy::VERT
+        def prefix(color: Thread.current[:cliui_frame_color_override])
+          +''.tap do |output|
+            items = FrameStack.items
+
+            items[0..-2].each do |item|
+              output << item.color.code << item.frame_style.prefix
+            end
+
+            if (item = items.last)
+              final_color = color || item.color
+              output << CLI::UI.resolve_color(final_color).code \
+                << item.frame_style.prefix \
+                << ' ' \
+                << CLI::UI::Color::RESET.code
+            end
           end
-          if item = items.last
-            c = Thread.current[:cliui_frame_color_override] || color || item
-            pfx << CLI::UI.resolve_color(c).code \
-              << CLI::UI::Box::Heavy::VERT << ' ' << CLI::UI::Color::RESET.code
+        end
+
+        # The width of a prefix given the number of Frames in the stack
+        # Does _not_ account for the space at the end of the final prefix
+        def prefix_width
+          FrameStack.items.reduce(0) do |width, item|
+            width + item.frame_style.prefix_width
           end
-          pfx
         end
 
         # Override a color for a given thread.
@@ -202,107 +248,19 @@ module CLI
           Thread.current[:cliui_frame_color_override] = prev
         end
 
-        # The width of a prefix given the number of Frames in the stack
-        #
-        def prefix_width
-          w = FrameStack.items.size
-          w.zero? ? 0 : w + 1
-        end
-
         private
 
-        def edge(text, color: raise, first: raise, right_text: nil)
-          color = CLI::UI.resolve_color(color)
-          text  = CLI::UI.resolve_text("{{#{color.name}:#{text}}}")
-
-          prefix = +''
-          FrameStack.items.each do |item|
-            prefix << CLI::UI.resolve_color(item).code << CLI::UI::Box::Heavy::VERT
-          end
-          prefix << color.code << first << (CLI::UI::Box::Heavy::HORZ * 2)
-          text ||= ''
-          unless text.empty?
-            prefix << ' ' << text << ' '
-          end
-
-          termwidth = CLI::UI::Terminal.width
-
-          suffix = +''
-          if right_text
-            suffix << ' ' << right_text << ' '
-          end
-
-          suffix_width = CLI::UI::ANSI.printing_width(suffix)
-          suffix_end   = termwidth - 2
-          suffix_start = suffix_end - suffix_width
-
-          prefix_width = CLI::UI::ANSI.printing_width(prefix)
-          prefix_start = 0
-          prefix_end   = prefix_start + prefix_width
-
-          if prefix_end > suffix_start
-            suffix = ''
-            # if prefix_end > termwidth
-            # we *could* truncate it, but let's just let it overflow to the
-            # next line and call it poor usage of this API.
-          end
-
-          o = +''
-
-          is_ci = ![0, '', nil].include?(ENV['CI'])
-
-          # Jumping around the line can cause some unwanted flashes
-          o << CLI::UI::ANSI.hide_cursor
-
-          o << if is_ci
-                 # In CI, we can't use absolute horizontal positions because of timestamps.
-                 # So we move around the line by offset from this cursor position.
-                 CLI::UI::ANSI.cursor_save
-               else
-                 # Outside of CI, we reset to column 1 so that things like ^C don't
-                 # cause output misformatting.
-                 "\r"
-               end
-
-          o << color.code
-          o << CLI::UI::Box::Heavy::HORZ * termwidth # draw a full line
-          o << print_at_x(prefix_start, prefix, is_ci)
-          o << color.code
-          o << print_at_x(suffix_start, suffix, is_ci)
-          o << CLI::UI::Color::RESET.code
-          o << CLI::UI::ANSI.show_cursor
-          o << "\n"
-
-          o
-        end
-
-        def print_at_x(x, str, is_ci)
-          if is_ci
-            CLI::UI::ANSI.cursor_restore + CLI::UI::ANSI.cursor_forward(x) + str
-          else
-            CLI::UI::ANSI.cursor_horizontal_absolute(1 + x) + str
-          end
-        end
-
-        module FrameStack
-          ENVVAR = 'CLI_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
+        # If timing is:
+        #   Numeric: return it
+        #   false: return nil
+        #   true or nil: defaults to Time.new
+        #   Time: return the difference with start
+        def elasped(start, timing)
+          return timing if timing.is_a?(Numeric)
+          return if timing.is_a?(FalseClass)
+
+          timing = Time.new if timing.is_a?(TrueClass) || timing.nil?
+          timing - start
         end
       end
     end