gorails 0.1.2 → 0.1.5

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

@@ -0,0 +1,216 @@
+# 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)
+      # and semantic (error, info, command) formatters available
+      #
+      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',
+        'gray' => '38;5;244',
+        'white' => '97',
+        'bold' => '1',
+        'italic' => '3',
+        'underline' => '4',
+        'reset' => '0',
+
+        # semantic
+        'error' => '31', # red
+        'success' => '32', # success
+        'warning' => '33', # yellow
+        '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     = %r{
+        .*?
+        (
+          #{BEGIN_EXPR} |
+          #{END_EXPR}   |
+          \z
+        )
+      }mx
+
+      DISCARD_BRACES = 0..-3
+
+      LITERAL_BRACES = Class.new
+
+      Stack = T.type_alias { T::Array[T.any(String, LITERAL_BRACES)] }
+
+      class FormatError < StandardError
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_accessor :input
+
+        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
+        end
+      end
+
+      # Initialize a formatter with text.
+      #
+      # ===== Attributes
+      #
+      # * +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.
+      #
+      # ===== Attributes
+      #
+      # * +sgr_map+ - the mapping of the formattings. Defaults to +SGR_MAP+
+      #
+      # ===== Options
+      #
+      # * +: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.replace([])
+        stack = parse_body(StringScanner.new(@text))
+        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)
+          end
+          str << text
+          prev_fmt = fmt
+        end
+
+        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? || T.must(@nodes.last)[1].empty?)
+          content << apply_format('', stack, sgr_map)
+        end
+        content
+      end
+
+      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.is_a?(LITERAL_BRACES)
+
+          begin
+            str << ';' << sgr_map.fetch(name)
+          rescue KeyError
+            raise FormatError.new(
+              "invalid format specifier: #{name}",
+              @text,
+              -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 = T.must(match[0])
+          begin
+            glyph = Glyph.lookup(glyph_handle)
+            emit(glyph.char, [glyph.color.name.to_s])
+          rescue Glyph::InvalidGlyphHandle
+            index = sc.pos - 2 # rewind past '}}'
+            raise FormatError.new(
+              "invalid glyph handle at index #{index}: '#{glyph_handle}'",
+              @text,
+              index
+            )
+          end
+        elsif (match = sc.scan(SCAN_WIDGET))
+          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(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,
+            ))
+          end
+        elsif (match = sc.scan(SCAN_FUNCNAME))
+          funcname = match.chop
+          stack.push(funcname)
+        else
+          # We read a {{ but it's not apparently Formatter syntax.
+          # We could error, but it's nicer to just pass through as text.
+          # We do kind of assume that the text will probably have balanced
+          # pairs of {{ }} at least.
+          emit('{{', stack)
+          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(T.must(match[DISCARD_BRACES]), stack)
+          parse_expr(sc, stack)
+        elsif match&.end_with?(END_EXPR)
+          emit(T.must(match[DISCARD_BRACES]), stack)
+          if stack.pop.is_a?(LITERAL_BRACES)
+            emit('}}', stack)
+          end
+          parse_body(sc, stack)
+        elsif match
+          emit(match, stack)
+        else
+          emit(sc.rest, stack)
+        end
+        stack
+      end
+
+      sig { params(text: String, stack: Stack).void }
+      def emit(text, stack)
+        return if text.empty?
+
+        @nodes << [text, stack.reject { |n| n.is_a?(LITERAL_BRACES) }]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# typed: true
+module CLI
+  module UI
+    module Frame
+      module FrameStack
+        COLOR_ENVVAR = 'CLI_FRAME_STACK'
+        STYLE_ENVVAR = 'CLI_STYLE_STACK'
+
+        class StackItem
+          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)
+          end
+        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.each_with_index.map do |color, i|
+              StackItem.new(color, 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+
+          #
+          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)
+            if color.nil? != style.nil? || item.nil? == color.nil?
+              raise ArgumentError, 'Must give one of item or color: and style:'
+            end
+
+            item ||= StackItem.new(T.must(color), T.must(style))
+
+            curr = items
+            curr << item
+
+            serialize(curr)
+          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.
+          sig { params(items: T::Array[StackItem]).void }
+          def serialize(items)
+            colors = []
+            styles = []
+
+            items.each do |item|
+              colors << item.color.name
+              styles << item.frame_style.style_name
+            end
+
+            ENV[COLOR_ENVVAR] = colors.join(':')
+            ENV[STYLE_ENVVAR] = styles.join(':')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# typed: true
+module CLI
+  module UI
+    module Frame
+      module FrameStyle
+        module Box
+          extend FrameStyle
+
+          VERTICAL    = '┃'
+          HORIZONTAL  = '━'
+          DIVIDER     = '┣'
+          TOP_LEFT    = '┏'
+          BOTTOM_LEFT = '┗'
+
+          class << self
+            extend T::Sig
+
+            sig { override.returns(Symbol) }
+            def style_name
+              :box
+            end
+
+            sig { override.returns(String) }
+            def prefix
+              VERTICAL
+            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.
+            #
+            # ==== Output:
+            #
+            #   ┏━━ Open ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+            #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def start(text, color:)
+              edge(text, color: color, first: TOP_LEFT)
+            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.
+            #
+            # ==== Output:
+            #
+            #   ┣━━ Divider ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+            #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def divider(text, color:)
+              edge(text, color: color, first: DIVIDER)
+            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
+            #
+            # ==== Output:
+            #
+            #   ┗━━ 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)
+
+              preamble = +''
+
+              preamble << color.code << first << (HORIZONTAL * 2)
+
+              unless text.empty?
+                preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
+              end
+
+              termwidth = CLI::UI::Terminal.width
+
+              suffix = +''
+
+              if right_text
+                suffix << ' ' << right_text << ' '
+              end
+
+              preamble_width = CLI::UI::ANSI.printing_width(preamble)
+              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_end = preamble_start + preamble_width
+
+              suffix_width = CLI::UI::ANSI.printing_width(suffix)
+              suffix_end   = termwidth - 2
+              suffix_start = suffix_end - suffix_width
+
+              if preamble_end > suffix_start
+                suffix = ''
+                # if preamble_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 = +''
+
+              # Shopify's CI system supports terminal emulation, but not some of
+              # the fancier features that we normally use to draw frames
+              # extra-reliably, so we fall back to a less foolproof strategy. This
+              # is probably better in general for cases with impoverished terminal
+              # emulators and no active user.
+              unless [0, '', nil].include?(ENV['CI'])
+                linewidth = [0, termwidth - (preamble_end + suffix_width + 1)].max
+
+                o << color.code << preamble
+                o << color.code << (HORIZONTAL * linewidth)
+                o << color.code << suffix
+                o << CLI::UI::Color::RESET.code << "\n"
+                return o
+              end
+
+              # 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"
+
+              # This code will print out a full line with the given preamble and
+              # suffix, as exemplified below.
+              #
+              # preamble_start                         suffix_start
+              # |                 preamble_end         |            suffix_end
+              # |                 |                    |            | termwidth
+              # |                 |                    |            | |
+              # V                 V                    V            V V
+              # --- Preamble text --------------------- suffix text --
+              o << color.code
+              o << print_at_x(preamble_start, HORIZONTAL * (termwidth - preamble_start)) # draw a full line
+              o << print_at_x(preamble_start, preamble)
+              o << color.code
+              o << print_at_x(suffix_start, suffix)
+              o << CLI::UI::Color::RESET.code
+              o << CLI::UI::ANSI.show_cursor
+              o << "\n"
+
+              o
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# typed: true
+module CLI
+  module UI
+    module Frame
+      module FrameStyle
+        module Bracket
+          extend FrameStyle
+
+          VERTICAL    = '┃'
+          HORIZONTAL  = '━'
+          DIVIDER     = '┣'
+          TOP_LEFT    = '┏'
+          BOTTOM_LEFT = '┗'
+
+          class << self
+            extend T::Sig
+
+            sig { override.returns(Symbol) }
+            def style_name
+              :bracket
+            end
+
+            sig { override.returns(String) }
+            def prefix
+              VERTICAL
+            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.
+            #
+            # ==== Output
+            #
+            #   ┏━━ Open
+            #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def start(text, color:)
+              edge(text, color: color, first: TOP_LEFT)
+            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.
+            #
+            # ==== Output:
+            #
+            #   ┣━━ Divider
+            #
+            sig { override.params(text: String, color: CLI::UI::Color).returns(String) }
+            def divider(text, color:)
+              edge(text, color: color, first: DIVIDER)
+            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
+            #
+            # ==== Output:
+            #
+            #   ┗━━ 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)
+
+              preamble = +''
+
+              preamble << color.code << first << (HORIZONTAL * 2)
+
+              unless text.empty?
+                preamble << ' ' << CLI::UI.resolve_text("{{#{color.name}:#{text}}}") << ' '
+              end
+
+              suffix = +''
+
+              if right_text
+                suffix << ' ' << right_text << ' '
+              end
+
+              o = +''
+
+              # Shopify's CI system supports terminal emulation, but not some of
+              # the fancier features that we normally use to draw frames
+              # extra-reliably, so we fall back to a less foolproof strategy. This
+              # is probably better in general for cases with impoverished terminal
+              # emulators and no active user.
+              unless [0, '', nil].include?(ENV['CI'])
+                o << color.code << preamble
+                o << color.code << suffix
+                o << CLI::UI::Color::RESET.code
+                o << "\n"
+
+                return o
+              end
+
+              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?
+
+              # 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
+            end
+          end
+        end
+      end
+    end
+  end
+end