cli-ui 1.5.1 → 2.2.3

data/lib/cli/ui/formatter.rb

@@ -1,10 +1,14 @@
+# typed: true
 # frozen_string_literal: true
+
 require('cli/ui')
 require('strscan')
 
 module CLI
   module UI
     class Formatter
+      extend T::Sig
+
       # Available mappings of formattings
       # To use any of them, you can use {{<key>:<string>}}
       # There are presentational (colours and formatters)
@@ -19,6 +23,8 @@ module CLI
         'blue' => '94', # 9x = high-intensity fg color x
         'magenta' => '35',
         'cyan' => '36',
+        'gray' => '38;5;244',
+        'white' => '97',
         'bold' => '1',
         'italic' => '3',
         'underline' => '4',
@@ -49,12 +55,21 @@ module CLI
 
       DISCARD_BRACES = 0..-3
 
-      LITERAL_BRACES = :__literal_braces__
+      LITERAL_BRACES = Class.new
+
+      Stack = T.type_alias { T::Array[T.any(String, LITERAL_BRACES)] }
 
       class FormatError < StandardError
-        attr_accessor :input, :index
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_accessor :input
 
-        def initialize(message = nil, input = nil, index = nil)
+        sig { returns(Integer) }
+        attr_accessor :index
+
+        sig { params(message: String, input: String, index: Integer).void }
+        def initialize(message, input, index)
           super(message)
           @input = input
           @index = index
@@ -67,8 +82,10 @@ module CLI
       #
       # * +text+ - the text to format
       #
+      sig { params(text: String).void }
       def initialize(text)
         @text = text
+        @nodes = T.let([], T::Array[[String, Stack]])
       end
 
       # Format the text using a map.
@@ -81,10 +98,11 @@ module CLI
       #
       # * +:enable_color+ - enable color output? Default is true unless output is redirected
       #
+      sig { params(sgr_map: T::Hash[String, String], enable_color: T::Boolean).returns(String) }
       def format(sgr_map = SGR_MAP, enable_color: CLI::UI.enable_color?)
-        @nodes = []
+        @nodes.replace([])
         stack = parse_body(StringScanner.new(@text))
-        prev_fmt = nil
+        prev_fmt = T.let(nil, T.nilable(Stack))
         content = @nodes.each_with_object(+'') do |(text, fmt), str|
           if prev_fmt != fmt && enable_color
             text = apply_format(text, fmt, sgr_map)
@@ -93,12 +111,12 @@ module CLI
           prev_fmt = fmt
         end
 
-        stack.reject! { |e| e == LITERAL_BRACES }
+        stack.reject! { |e| e.is_a?(LITERAL_BRACES) }
 
         return content unless enable_color
         return content if stack == prev_fmt
 
-        unless stack.empty? && (@nodes.size.zero? || @nodes.last[1].empty?)
+        unless stack.empty? && (@nodes.empty? || T.must(@nodes.last)[1].empty?)
           content << apply_format('', stack, sgr_map)
         end
         content
@@ -106,25 +124,28 @@ module CLI
 
       private
 
+      sig { params(text: String, fmt: Stack, sgr_map: T::Hash[String, String]).returns(String) }
       def apply_format(text, fmt, sgr_map)
         sgr = fmt.each_with_object(+'0') do |name, str|
-          next if name == LITERAL_BRACES
+          next if name.is_a?(LITERAL_BRACES)
+
           begin
             str << ';' << sgr_map.fetch(name)
           rescue KeyError
             raise FormatError.new(
               "invalid format specifier: #{name}",
               @text,
-              -1
+              -1,
             )
           end
         end
         CLI::UI::ANSI.sgr(sgr) + text
       end
 
+      sig { params(sc: StringScanner, stack: Stack).returns(Stack) }
       def parse_expr(sc, stack)
         if (match = sc.scan(SCAN_GLYPH))
-          glyph_handle = match[0]
+          glyph_handle = T.must(match[0])
           begin
             glyph = Glyph.lookup(glyph_handle)
             emit(glyph.char, [glyph.color.name.to_s])
@@ -133,20 +154,21 @@ module CLI
             raise FormatError.new(
               "invalid glyph handle at index #{index}: '#{glyph_handle}'",
               @text,
-              index
+              index,
             )
           end
         elsif (match = sc.scan(SCAN_WIDGET))
-          match_data = SCAN_WIDGET.match(match) # Regexp.last_match doesn't work here
-          widget_handle = match_data['handle']
+          match_data = T.must(SCAN_WIDGET.match(match)) # Regexp.last_match doesn't work here
+          widget_handle = T.must(match_data['handle'])
           begin
             widget = Widgets.lookup(widget_handle)
-            emit(widget.call(match_data['args']), stack)
+            emit(widget.call(T.must(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,
+              @text,
+              index,
             ))
           end
         elsif (match = sc.scan(SCAN_FUNCNAME))
@@ -158,20 +180,21 @@ module CLI
           # We do kind of assume that the text will probably have balanced
           # pairs of {{ }} at least.
           emit('{{', stack)
-          stack.push(LITERAL_BRACES)
+          stack.push(LITERAL_BRACES.new)
         end
         parse_body(sc, stack)
         stack
       end
 
+      sig { params(sc: StringScanner, stack: Stack).returns(Stack) }
       def parse_body(sc, stack = [])
         match = sc.scan(SCAN_BODY)
         if match&.end_with?(BEGIN_EXPR)
-          emit(match[DISCARD_BRACES], stack)
+          emit(T.must(match[DISCARD_BRACES]), stack)
           parse_expr(sc, stack)
         elsif match&.end_with?(END_EXPR)
-          emit(match[DISCARD_BRACES], stack)
-          if stack.pop == LITERAL_BRACES
+          emit(T.must(match[DISCARD_BRACES]), stack)
+          if stack.pop.is_a?(LITERAL_BRACES)
             emit('}}', stack)
           end
           parse_body(sc, stack)
@@ -183,9 +206,11 @@ module CLI
         stack
       end
 
+      sig { params(text: String, stack: Stack).void }
       def emit(text, stack)
-        return if text.nil? || text.empty?
-        @nodes << [text, stack.reject { |n| n == LITERAL_BRACES }]
+        return if text.empty?
+
+        @nodes << [text, stack.reject { |n| n.is_a?(LITERAL_BRACES) }]
       end
     end
   end

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

@@ -1,13 +1,22 @@
+# typed: true
+
 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
+          extend T::Sig
+
+          sig { returns(CLI::UI::Color) }
+          attr_reader :color
 
+          sig { returns(CLI::UI::Frame::FrameStyle) }
+          attr_reader :frame_style
+
+          sig do
+            params(color_name: CLI::UI::Colorable, style_name: FrameStylable)
+              .void
+          end
           def initialize(color_name, style_name)
             @color = CLI::UI.resolve_color(color_name)
             @frame_style = CLI::UI.resolve_style(style_name)
@@ -15,14 +24,12 @@ module CLI
         end
 
         class << self
+          extend T::Sig
+
           # Fetch all items off the frame stack
+          sig { returns(T::Array[StackItem]) }
           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
+            Thread.current[:cliui_frame_stack] ||= []
           end
 
           # Push a new item onto the frame stack.
@@ -43,53 +50,26 @@ module CLI
           # 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+
           #
+          sig do
+            params(
+              item: T.nilable(StackItem),
+              color: T.nilable(CLI::UI::Color),
+              style: T.nilable(CLI::UI::Frame::FrameStyle),
+            )
+              .void
+          end
           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
+            if color.nil? != style.nil? || item.nil? == color.nil?
+              raise ArgumentError, 'Must give one of item or color: and style:'
             end
 
-            item ||= StackItem.new(color, style)
-
-            curr = items
-            curr << item
-
-            serialize(curr)
+            items.push(item || StackItem.new(T.must(color), T.must(style)))
           end
 
           # Removes and returns the last stack item off the stack
+          sig { returns(T.nilable(StackItem)) }
           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(':')
+            items.pop
           end
         end
       end

data/lib/cli/ui/frame/frame_style/box.rb

@@ -1,3 +1,5 @@
+# typed: true
+
 module CLI
   module UI
     module Frame
@@ -12,10 +14,14 @@ module CLI
           BOTTOM_LEFT = '┗'
 
           class << self
-            def name
-              'box'
+            extend T::Sig
+
+            sig { override.returns(Symbol) }
+            def style_name
+              :box
             end
 
+            sig { override.returns(String) }
             def prefix
               VERTICAL
             end
@@ -34,7 +40,8 @@ module CLI
             #
             #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
             #
-            def open(text, color:)
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def start(text, color:)
               edge(text, color: color, first: TOP_LEFT)
             end
 
@@ -52,6 +59,7 @@ module CLI
             #
             #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
             #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
             def divider(text, color:)
               edge(text, color: color, first: DIVIDER)
             end
@@ -71,12 +79,16 @@ module CLI
             #
             #   ┗━━ Close ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
             #
+            sig { override.params(text: String, color: CLI::UI::Color, right_text: T.nilable(String)).returns(String) }
             def close(text, color:, right_text: nil)
               edge(text, color: color, right_text: right_text, first: BOTTOM_LEFT)
             end
 
             private
 
+            sig do
+              params(text: String, color: CLI::UI::Color, first: String, right_text: T.nilable(String)).returns(String)
+            end
             def edge(text, color:, first:, right_text: nil)
               color = CLI::UI.resolve_color(color)
 
@@ -84,7 +96,6 @@ module CLI
 
               preamble << color.code << first << (HORIZONTAL * 2)
 
-              text ||= ''
               unless text.empty?
                 preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
               end
@@ -101,7 +112,7 @@ module CLI
               preamble_start = Frame.prefix_width
               # If prefix_width is non-zero, we need to subtract the width of
               # the final space, since we're going to write over it.
-              preamble_start -= 1 unless preamble_start.zero?
+              preamble_start -= 1 if preamble_start.nonzero?
               preamble_end = preamble_start + preamble_width
 
               suffix_width = CLI::UI::ANSI.printing_width(suffix)

data/lib/cli/ui/frame/frame_style/bracket.rb

@@ -1,3 +1,5 @@
+# typed: true
+
 module CLI
   module UI
     module Frame
@@ -12,10 +14,14 @@ module CLI
           BOTTOM_LEFT = '┗'
 
           class << self
-            def name
-              'bracket'
+            extend T::Sig
+
+            sig { override.returns(Symbol) }
+            def style_name
+              :bracket
             end
 
+            sig { override.returns(String) }
             def prefix
               VERTICAL
             end
@@ -34,7 +40,8 @@ module CLI
             #
             #   ┏━━ Open
             #
-            def open(text, color:)
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def start(text, color:)
               edge(text, color: color, first: TOP_LEFT)
             end
 
@@ -52,6 +59,7 @@ module CLI
             #
             #   ┣━━ Divider
             #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
             def divider(text, color:)
               edge(text, color: color, first: DIVIDER)
             end
@@ -71,12 +79,16 @@ module CLI
             #
             #   ┗━━ Close
             #
+            sig { override.params(text: String, color: CLI::UI::Color, right_text: T.nilable(String)).returns(String) }
             def close(text, color:, right_text: nil)
               edge(text, color: color, right_text: right_text, first: BOTTOM_LEFT)
             end
 
             private
 
+            sig do
+              params(text: String, color: CLI::UI::Color, first: String, right_text: T.nilable(String)).returns(String)
+            end
             def edge(text, color:, first:, right_text: nil)
               color = CLI::UI.resolve_color(color)
 
@@ -84,7 +96,6 @@ module CLI
 
               preamble << color.code << first << (HORIZONTAL * 2)
 
-              text ||= ''
               unless text.empty?
                 preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
               end
@@ -115,18 +126,18 @@ module CLI
 
               # If prefix_width is non-zero, we need to subtract the width of
               # the final space, since we're going to write over it.
-              preamble_start -= 1 unless preamble_start.zero?
+              preamble_start -= 1 if preamble_start.nonzero?
 
-              # Prefix_width includes the width of the terminal space, which we
-              # want to remove.  The clamping is done to avoid a negative
-              # preamble start which can occur for the first frame.
+              # Jumping around the line can cause some unwanted flashes
               o << CLI::UI::ANSI.hide_cursor
 
               # reset to column 1 so that things like ^C don't ruin formatting
               o << "\r"
+
               o << color.code
               o << print_at_x(preamble_start, preamble + color.code + suffix)
               o << CLI::UI::Color::RESET.code
+              o << CLI::UI::ANSI.show_cursor
               o << "\n"
 
               o

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

@@ -1,120 +1,117 @@
+# typed: true
+
 require 'cli/ui/frame'
 
 module CLI
   module UI
     module Frame
       module FrameStyle
-        class << self
-          # rubocop:disable Style/ClassVars
-          @@loaded_styles = []
+        include Kernel
+        extend T::Sig
+        extend T::Helpers
+        abstract!
 
-          def loaded_styles
-            @@loaded_styles.map(&:name)
-          end
+        autoload(:Box, 'cli/ui/frame/frame_style/box')
+        autoload(:Bracket, 'cli/ui/frame/frame_style/bracket')
+
+        MAP = {
+          box: -> { FrameStyle::Box },
+          bracket: -> { FrameStyle::Bracket },
+        }
+
+        class << self
+          extend T::Sig
 
           # Lookup a frame style via its name
           #
           # ==== Attributes
           #
           # * +symbol+ - frame style name to lookup
+          sig { params(name: T.any(String, Symbol)).returns(FrameStyle) }
           def lookup(name)
-            @@loaded_styles
-              .find { |style| style.name.to_sym == name }
-              .tap  { |style| raise InvalidFrameStyleName, name if style.nil? }
+            MAP.fetch(name.to_sym).call
+          rescue KeyError
+            raise(InvalidFrameStyleName, name)
           end
-
-          def extended(base)
-            @@loaded_styles << base
-            base.extend(Interface)
-          end
-          # rubocop:enable Style/ClassVars
         end
 
-        class InvalidFrameStyleName < ArgumentError
-          def initialize(name)
-            super
-            @name = name
-          end
+        sig { abstract.returns(Symbol) }
+        def style_name; end
 
-          def message
-            keys = FrameStyle.loaded_styles.map(&:inspect).join(',')
-            "invalid frame style: #{@name.inspect}" \
-              ' -- must be one of CLI::UI::Frame::FrameStyle.loaded_styles ' \
-              "(#{keys})"
-          end
+        # Returns the character(s) that should be printed at the beginning
+        # of lines inside this frame
+        sig { abstract.returns(String) }
+        def prefix; end
+
+        # Returns the printing width of the prefix
+        sig { returns(Integer) }
+        def prefix_width
+          CLI::UI::ANSI.printing_width(prefix)
         end
 
-        # Public interface for FrameStyles
-        # Applied by extending FrameStyle
-        module Interface
-          def name
-            raise NotImplementedError
-          end
+        # Draws the "Open" line for this frame style
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - (required) The color of the frame.
+        #
+        sig { abstract.params(text: String, color: CLI::UI::Color).returns(String) }
+        def start(text, color:); end
 
-          # Returns the character(s) that should be printed at the beginning
-          # of lines inside this frame
-          def prefix
-            raise NotImplementedError
-          end
+        # Draws the "Close" line for this frame style
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - (required) The color of the frame.
+        # * +:right_text+ - Text to print at the right of the line. Defaults to nil
+        #
+        sig { abstract.params(text: String, color: CLI::UI::Color, right_text: T.nilable(String)).returns(String) }
+        def close(text, color:, right_text: nil); end
 
-          # Returns the printing width of the prefix
-          def prefix_width
-            CLI::UI::ANSI.printing_width(prefix)
-          end
+        # Draws a "divider" line for the current frame style
+        #
+        # ==== Attributes
+        #
+        # * +text+ - (required) the text/title to output in the frame
+        #
+        # ==== Options
+        #
+        # * +:color+ - (required) The color of the frame.
+        #
+        sig { abstract.params(text: String, color: CLI::UI::Color).returns(String) }
+        def divider(text, color:); end
 
-          # Draws the "Open" line for this frame style
-          #
-          # ==== Attributes
-          #
-          # * +text+ - (required) the text/title to output in the frame
-          #
-          # ==== Options
-          #
-          # * +:color+ - (required) The color of the frame.
-          #
-          def open(text, color:)
-            raise NotImplementedError
-          end
+        sig { params(x: Integer, str: String).returns(String) }
+        def print_at_x(x, str)
+          CLI::UI::ANSI.cursor_horizontal_absolute(1 + x) + str
+        end
 
-          # Draws the "Close" line for this frame style
-          #
-          # ==== Attributes
-          #
-          # * +text+ - (required) the text/title to output in the frame
-          #
-          # ==== Options
-          #
-          # * +:color+ - (required) The color of the frame.
-          # * +:right_text+ - Text to print at the right of the line. Defaults to nil
-          #
-          def close(text, color:, right_text: nil)
-            raise NotImplementedError
-          end
+        class InvalidFrameStyleName < ArgumentError
+          extend T::Sig
 
-          # Draws a "divider" line for the current frame style
-          #
-          # ==== Attributes
-          #
-          # * +text+ - (required) the text/title to output in the frame
-          #
-          # ==== Options
-          #
-          # * +:color+ - (required) The color of the frame.
-          #
-          def divider(text, color: nil)
-            raise NotImplementedError
+          sig { params(name: T.any(String, Symbol)).void }
+          def initialize(name)
+            super
+            @name = name
           end
 
-          private
-
-          def print_at_x(x, str)
-            CLI::UI::ANSI.cursor_horizontal_absolute(1 + x) + str
+          sig { returns(String) }
+          def message
+            keys = FrameStyle::MAP.keys.map(&:inspect).join(', ')
+            "invalid frame style: #{@name.inspect}" \
+              ' -- must be one of CLI::UI::Frame::FrameStyle::MAP ' \
+              "(#{keys})"
           end
         end
       end
     end
   end
 end
-
-require 'cli/ui/frame/frame_style/box'
-require 'cli/ui/frame/frame_style/bracket'