cli-ui 1.2.2 → 1.5.1

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,27 +72,28 @@ 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?
             if failure_text
-              raise ArgumentError, "failure_text is not compatible with blockless invocation"
+              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"
+              raise ArgumentError, 'success_text is not compatible with blockless invocation'
+            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

data/lib/cli/ui/frame/frame_stack.rb

@@ -0,0 +1,98 @@
+module CLI
+  module UI
+    module Frame
+      module FrameStack
+        COLOR_ENVVAR = 'CLI_FRAME_STACK'
+        STYLE_ENVVAR = 'CLI_STYLE_STACK'
+
+        class StackItem
+          attr_reader :color, :frame_style
+
+          def initialize(color_name, style_name)
+            @color = CLI::UI.resolve_color(color_name)
+            @frame_style = CLI::UI.resolve_style(style_name)
+          end
+        end
+
+        class << self
+          # Fetch all items off the frame stack
+          def items
+            colors = ENV.fetch(COLOR_ENVVAR, '').split(':').map(&:to_sym)
+            styles = ENV.fetch(STYLE_ENVVAR, '').split(':').map(&:to_sym)
+
+            colors.length.times.map do |i|
+              StackItem.new(colors[i], styles[i] || Frame.frame_style)
+            end
+          end
+
+          # Push a new item onto the frame stack.
+          #
+          # Either an item or a :color/:style pair should be pushed onto the stack.
+          #
+          # ==== Attributes
+          #
+          # * +item+ a +StackItem+ to push onto the stack. Defaults to nil
+          #
+          # ==== Options
+          #
+          # * +:color+ the color of the new stack item. Defaults to nil
+          # * +:style+ the style of the new stack item. Defaults to nil
+          #
+          # ==== Raises
+          #
+          # If both an item and a color/style pair are given, raises an +ArgumentError+
+          # If the given item is not a +StackItem+, raises an +ArgumentError+
+          #
+          def push(item = nil, color: nil, style: nil)
+            unless item.nil?
+              unless item.is_a?(StackItem)
+                raise ArgumentError, 'item must be a StackItem'
+              end
+
+              unless color.nil? && style.nil?
+                raise ArgumentError, 'Must give one of item or color: and style:'
+              end
+            end
+
+            item ||= StackItem.new(color, style)
+
+            curr = items
+            curr << item
+
+            serialize(curr)
+          end
+
+          # Removes and returns the last stack item off the stack
+          def pop
+            curr = items
+            ret = curr.pop
+
+            serialize(curr)
+
+            ret.nil? ? nil : ret
+          end
+
+          private
+
+          # Serializes the item stack into two ENV variables.
+          #
+          # This is done to preserve backward compatibility with earlier versions of cli/ui.
+          # This ensures that any code that relied upon previous stack behavior should continue
+          # to work.
+          def serialize(items)
+            colors = []
+            styles = []
+
+            items.each do |item|
+              colors << item.color.name
+              styles << item.frame_style.name
+            end
+
+            ENV[COLOR_ENVVAR] = colors.join(':')
+            ENV[STYLE_ENVVAR] = styles.join(':')
+          end
+        end
+      end
+    end
+  end
+end