cli-ui 1.2.0 → 1.4.0

data/lib/cli/ui/color.rb

@@ -31,19 +31,24 @@ 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
         def initialize(name)
+          super
           @name = name
         end
 

data/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/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,70 @@ 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
+        def prefix_width
+          w = FrameStack.items.reduce(0) do |width, item|
+            width + item.frame_style.prefix_width
           end
-          pfx
+
+          w.zero? ? w : w + 1
         end
 
         # Override a color for a given thread.
@@ -202,107 +249,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