gorails 0.1.1 → 0.1.4

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

@@ -0,0 +1,107 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    # Truncater truncates a string to a provided printable width.
+    module Truncater
+      PARSE_ROOT = :root
+      PARSE_ANSI = :ansi
+      PARSE_ESC  = :esc
+      PARSE_ZWJ  = :zwj
+
+      ESC                 = 0x1b
+      LEFT_SQUARE_BRACKET = 0x5b
+      ZWJ                 = 0x200d # emojipedia.org/emoji-zwj-sequences
+      SEMICOLON           = 0x3b
+
+      # EMOJI_RANGE in particular is super inaccurate. This is best-effort.
+      # If you need this to be more accurate, we'll almost certainly accept a
+      # PR improving it.
+      EMOJI_RANGE    = 0x1f300..0x1f5ff
+      NUMERIC_RANGE  = 0x30..0x39
+      LC_ALPHA_RANGE = 0x40..0x5a
+      UC_ALPHA_RANGE = 0x60..0x71
+
+      TRUNCATED = "\x1b[0m…"
+
+      class << self
+        extend T::Sig
+
+        sig { params(text: String, printing_width: Integer).returns(String) }
+        def call(text, printing_width)
+          return text if text.size <= printing_width
+
+          width            = 0
+          mode             = PARSE_ROOT
+          truncation_index = T.let(nil, T.nilable(Integer))
+
+          codepoints = text.codepoints
+          codepoints.each.with_index do |cp, index|
+            case mode
+            when PARSE_ROOT
+              case cp
+              when ESC # non-printable, followed by some more non-printables.
+                mode = PARSE_ESC
+              when ZWJ # non-printable, followed by another non-printable.
+                mode = PARSE_ZWJ
+              else
+                width += width(cp)
+                if width >= printing_width
+                  truncation_index ||= index
+                  # it looks like we could break here but we still want the
+                  # width calculation for the rest of the characters.
+                end
+              end
+            when PARSE_ESC
+              mode = case cp
+              when LEFT_SQUARE_BRACKET
+                PARSE_ANSI
+              else
+                PARSE_ROOT
+              end
+            when PARSE_ANSI
+              # ANSI escape codes preeeetty much have the format of:
+              # \x1b[0-9;]+[A-Za-z]
+              case cp
+              when NUMERIC_RANGE, SEMICOLON
+              when LC_ALPHA_RANGE, UC_ALPHA_RANGE
+                mode = PARSE_ROOT
+              else
+                # unexpected. let's just go back to the root state I guess?
+                mode = PARSE_ROOT
+              end
+            when PARSE_ZWJ
+              # consume any character and consider it as having no width
+              # width(x+ZWJ+y) = width(x).
+              mode = PARSE_ROOT
+            end
+          end
+
+          # Without the `width <= printing_width` check, we truncate
+          # "foo\x1b[0m" for a width of 3, but it should not be truncated.
+          # It's specifically for the case where we decided "Yes, this is the
+          # point at which we'd have to add a truncation!" but it's actually
+          # the end of the string.
+          return text if !truncation_index || width <= printing_width
+
+          T.must(codepoints[0...truncation_index]).pack('U*') + TRUNCATED
+        end
+
+        private
+
+        sig { params(printable_codepoint: Integer).returns(Integer) }
+        def width(printable_codepoint)
+          case printable_codepoint
+          when EMOJI_RANGE
+            2
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# typed: true
+module CLI
+  module UI
+    VERSION = '1.5.1'
+  end
+end

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

@@ -0,0 +1,37 @@
+# typed: true
+require('cli/ui')
+
+module CLI
+  module UI
+    module Widgets
+      class Base
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig { params(argstring: String).returns(String) }
+        def self.call(argstring)
+          new(argstring).render
+        end
+
+        sig { params(argstring: String).void }
+        def initialize(argstring)
+          pat = self.class.argparse_pattern
+          unless (@match_data = pat.match(argstring))
+            raise(Widgets::InvalidWidgetArguments.new(argstring, pat))
+          end
+
+          @match_data.names.each do |name|
+            instance_variable_set(:"@#{name}", @match_data[name])
+          end
+        end
+
+        sig { abstract.returns(Regexp) }
+        def self.argparse_pattern; end
+
+        sig { abstract.returns(String) }
+        def render; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# typed: true
+# frozen-string-literal: true
+
+require('cli/ui')
+
+module CLI
+  module UI
+    module Widgets
+      class Status < Widgets::Base
+        ARGPARSE_PATTERN = %r{
+          \A (?<succeeded> \d+)
+          :  (?<failed>    \d+)
+          :  (?<working>   \d+)
+          :  (?<pending>   \d+) \z
+        }x # e.g. "1:23:3:404"
+        OPEN  = Color::RESET.code + Color::BOLD.code + '[' + Color::RESET.code
+        CLOSE = Color::RESET.code + Color::BOLD.code + ']' + Color::RESET.code
+        ARROW = Color::RESET.code + Color::GRAY.code + '◂' + Color::RESET.code
+        COMMA = Color::RESET.code + Color::GRAY.code + ',' + Color::RESET.code
+
+        SPINNER_STOPPED = '⠿'
+        EMPTY_SET = '∅'
+
+        sig { override.returns(Regexp) }
+        def self.argparse_pattern
+          ARGPARSE_PATTERN
+        end
+
+        sig { override.returns(String) }
+        def render
+          if zero?(@succeeded) && zero?(@failed) && zero?(@working) && zero?(@pending)
+            Color::RESET.code + Color::BOLD.code + EMPTY_SET + Color::RESET.code
+          else
+            #   [          0✓            ,         2✗          ◂         3⠼           ◂         4⌛︎           ]
+            "#{OPEN}#{succeeded_part}#{COMMA}#{failed_part}#{ARROW}#{working_part}#{ARROW}#{pending_part}#{CLOSE}"
+          end
+        end
+
+        private
+
+        sig { params(num_str: String).returns(T::Boolean) }
+        def zero?(num_str)
+          num_str == '0'
+        end
+
+        sig { params(num_str: String, rune: String, color: Color).returns(String) }
+        def colorize_if_nonzero(num_str, rune, color)
+          color = Color::GRAY if zero?(num_str)
+          color.code + num_str + rune
+        end
+
+        sig { returns(String) }
+        def succeeded_part
+          colorize_if_nonzero(@succeeded, Glyph::CHECK.char, Color::GREEN)
+        end
+
+        sig { returns(String) }
+        def failed_part
+          colorize_if_nonzero(@failed, Glyph::X.char, Color::RED)
+        end
+
+        sig { returns(String) }
+        def working_part
+          rune = zero?(@working) ? SPINNER_STOPPED : Spinner.current_rune
+          colorize_if_nonzero(@working, rune, Color::BLUE)
+        end
+
+        sig { returns(String) }
+        def pending_part
+          colorize_if_nonzero(@pending, Glyph::HOURGLASS.char, Color::WHITE)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# typed: true
+require('cli/ui')
+
+module CLI
+  module UI
+    # Widgets are formatter objects with more custom implementations than the
+    # other features, which all center around formatting text with colours,
+    # etc.
+    #
+    # If you want to extend CLI::UI with your own widgets, you may want to do
+    # something like this:
+    #
+    #   require('cli/ui')
+    #   class MyWidget < CLI::UI::Widgets::Base
+    #     # ...
+    #   end
+    #   CLI::UI::Widgets.register('my-widget') { MyWidget }
+    #   puts(CLI::UI.fmt("{{@widget/my-widget:args}}"))
+    module Widgets
+      extend T::Sig
+
+      MAP = {}
+
+      autoload(:Base, 'cli/ui/widgets/base')
+
+      sig { params(name: String, cb: T.proc.returns(T.class_of(Widgets::Base))).void }
+      def self.register(name, &cb)
+        MAP[name] = cb
+      end
+
+      autoload(:Status, 'cli/ui/widgets/status')
+      register('status') { Widgets::Status }
+
+      # Looks up a widget by handle
+      #
+      # ==== Raises
+      # Raises InvalidWidgetHandle if the widget is not available.
+      #
+      # ==== Returns
+      # A callable widget, to be invoked like `.call(argstring)`
+      #
+      sig { params(handle: String).returns(T.class_of(Widgets::Base)) }
+      def self.lookup(handle)
+        MAP.fetch(handle).call
+      rescue KeyError, NameError
+        raise(InvalidWidgetHandle, handle)
+      end
+
+      # All available widgets by name
+      #
+      sig { returns(T::Array[String]) }
+      def self.available
+        MAP.keys
+      end
+
+      class InvalidWidgetHandle < ArgumentError
+        extend T::Sig
+
+        sig { params(handle: String).void }
+        def initialize(handle)
+          super
+          @handle = handle
+        end
+
+        sig { returns(String) }
+        def message
+          keys = Widgets.available.join(',')
+          "invalid widget handle: #{@handle} " \
+            "-- must be one of CLI::UI::Widgets.available (#{keys})"
+        end
+      end
+
+      class InvalidWidgetArguments < ArgumentError
+        extend T::Sig
+
+        sig { params(argstring: String, pattern: Regexp).void }
+        def initialize(argstring, pattern)
+          super
+          @argstring = argstring
+          @pattern   = pattern
+        end
+
+        sig { returns(String) }
+        def message
+          "invalid widget arguments: #{@argstring} " \
+            "-- must match pattern: #{@pattern.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+# typed: true
+
+require 'cli/ui'
+require 'cli/ui/frame/frame_stack'
+require 'cli/ui/frame/frame_style'
+
+module CLI
+  module UI
+    class Wrap
+      extend T::Sig
+
+      sig { params(input: String).void }
+      def initialize(input)
+        @input = input
+      end
+
+      sig { returns(String) }
+      def wrap
+        max_width = Terminal.width - Frame.prefix_width
+        width = T.let(0, Integer)
+        final = []
+        # Create an alternation of format codes of parameter lengths 1-20, since + and {1,n} not allowed in lookbehind
+        format_codes = (1..20).map { |n| /\x1b\[[\d;]{#{n}}m/ }.join('|')
+        codes = ''
+        @input.split(/(?=\s|\x1b\[[\d;]+m|\r)|(?<=\s|#{format_codes})/).each do |token|
+          case token
+          when '\x1B[0?m'
+            codes = ''
+            final << token
+          when /\x1b\[[\d;]+m/
+            codes += token # Track in use format codes so that they are resent after frame coloring
+            final << token
+          when "\n"
+            final << "\n#{codes}"
+            width = 0
+          when /\s/
+            token_width = ANSI.printing_width(token)
+            if width + token_width <= max_width
+              final << token
+              width += token_width
+            else
+              final << "\n#{codes}"
+              width = 0
+            end
+          else
+            token_width = ANSI.printing_width(token)
+            if width + token_width <= max_width
+              final << token
+              width += token_width
+            else
+              final << "\n#{codes}"
+              final << token
+              width = token_width
+            end
+          end
+        end
+        final.join
+      end
+    end
+  end
+end