gorails 0.1.1 → 0.1.4

data/vendor/deps/cli-ui/lib/cli/ui/spinner/spin_group.rb

@@ -0,0 +1,292 @@
+# typed: true
+module CLI
+  module UI
+    module Spinner
+      class SpinGroup
+        extend T::Sig
+
+        # Initializes a new spin group
+        # This lets you add +Task+ objects to the group to multi-thread work
+        #
+        # ==== Options
+        #
+        # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
+        #
+        # ==== Example Usage
+        #
+        #  CLI::UI::SpinGroup.new do |spin_group|
+        #    spin_group.add('Title')   { |spinner| sleep 3.0 }
+        #    spin_group.add('Title 2') { |spinner| sleep 3.0; spinner.update_title('New Title'); sleep 3.0 }
+        #  end
+        #
+        # Output:
+        #
+        # https://user-images.githubusercontent.com/3074765/33798558-c452fa26-dce8-11e7-9e90-b4b34df21a46.gif
+        #
+        sig { params(auto_debrief: T::Boolean).void }
+        def initialize(auto_debrief: true)
+          @m = Mutex.new
+          @consumed_lines = 0
+          @tasks = []
+          @auto_debrief = auto_debrief
+          @start = Time.new
+          if block_given?
+            yield self
+            wait
+          end
+        end
+
+        class Task
+          extend T::Sig
+
+          sig { returns(String) }
+          attr_reader :title, :stdout, :stderr
+
+          sig { returns(T::Boolean) }
+          attr_reader :success
+
+          sig { returns(T.nilable(Exception)) }
+          attr_reader :exception
+
+          # Initializes a new Task
+          # This is managed entirely internally by +SpinGroup+
+          #
+          # ==== Attributes
+          #
+          # * +title+ - Title of the task
+          # * +block+ - Block for the task, will be provided with an instance of the spinner
+          #
+          sig { params(title: String, block: T.proc.params(task: Task).returns(T.untyped)).void }
+          def initialize(title, &block)
+            @title = title
+            @always_full_render = title =~ Formatter::SCAN_WIDGET
+            @thread = Thread.new do
+              cap = CLI::UI::StdoutRouter::Capture.new(with_frame_inset: false) { block.call(self) }
+              begin
+                cap.run
+              ensure
+                @stdout = cap.stdout
+                @stderr = cap.stderr
+              end
+            end
+
+            @m = Mutex.new
+            @force_full_render = false
+            @done = false
+            @exception = nil
+            @success   = false
+          end
+
+          # Checks if a task is finished
+          #
+          sig { returns(T::Boolean) }
+          def check
+            return true if @done
+            return false if @thread.alive?
+
+            @done = true
+            begin
+              status = @thread.join.status
+              @success = (status == false)
+              @success = false if @thread.value == TASK_FAILED
+            rescue => exc
+              @exception = exc
+              @success = false
+            end
+
+            @done
+          end
+
+          # Re-renders the task if required:
+          #
+          # We try to be as lazy as possible in re-rendering the full line. The
+          # spinner rune will change on each render for the most part, but the
+          # body text will rarely have changed. If the body text *has* changed,
+          # we set @force_full_render.
+          #
+          # Further, if the title string includes any CLI::UI::Widgets, we
+          # assume that it may change from render to render, since those
+          # evaluate more dynamically than the rest of our format codes, which
+          # are just text formatters. This is controlled by @always_full_render.
+          #
+          # ==== Attributes
+          #
+          # * +index+ - index of the task
+          # * +force+ - force rerender of the task
+          # * +width+ - current terminal width to format for
+          #
+          sig { params(index: Integer, force: T::Boolean, width: Integer).returns(String) }
+          def render(index, force = true, width: CLI::UI::Terminal.width)
+            @m.synchronize do
+              if force || @always_full_render || @force_full_render
+                full_render(index, width)
+              else
+                partial_render(index)
+              end
+            ensure
+              @force_full_render = false
+            end
+          end
+
+          # Update the spinner title
+          #
+          # ==== Attributes
+          #
+          # * +title+ - title to change the spinner to
+          #
+          sig { params(new_title: String).void }
+          def update_title(new_title)
+            @m.synchronize do
+              @always_full_render = new_title =~ Formatter::SCAN_WIDGET
+              @title = new_title
+              @force_full_render = true
+            end
+          end
+
+          private
+
+          sig { params(index: Integer, terminal_width: Integer).returns(String) }
+          def full_render(index, terminal_width)
+            prefix = inset +
+              glyph(index) +
+              CLI::UI::Color::RESET.code +
+              ' '
+
+            truncation_width = terminal_width - CLI::UI::ANSI.printing_width(prefix)
+
+            prefix +
+              CLI::UI.resolve_text(title, truncate_to: truncation_width) +
+              "\e[K"
+          end
+
+          sig { params(index: Integer).returns(String) }
+          def partial_render(index)
+            CLI::UI::ANSI.cursor_forward(inset_width) + glyph(index) + CLI::UI::Color::RESET.code
+          end
+
+          sig { params(index: Integer).returns(String) }
+          def glyph(index)
+            if @done
+              @success ? CLI::UI::Glyph::CHECK.to_s : CLI::UI::Glyph::X.to_s
+            else
+              GLYPHS[index]
+            end
+          end
+
+          sig { returns(String) }
+          def inset
+            @inset ||= CLI::UI::Frame.prefix
+          end
+
+          sig { returns(Integer) }
+          def inset_width
+            @inset_width ||= CLI::UI::ANSI.printing_width(inset)
+          end
+        end
+
+        # Add a new task
+        #
+        # ==== Attributes
+        #
+        # * +title+ - Title of the task
+        # * +block+ - Block for the task, will be provided with an instance of the spinner
+        #
+        # ==== Example Usage:
+        #   spin_group = CLI::UI::SpinGroup.new
+        #   spin_group.add('Title') { |spinner| sleep 1.0 }
+        #   spin_group.wait
+        #
+        sig { params(title: String, block: T.proc.params(task: Task).void).void }
+        def add(title, &block)
+          @m.synchronize do
+            @tasks << Task.new(title, &block)
+          end
+        end
+
+        # Tells the group you're done adding tasks and to wait for all of them to finish
+        #
+        # ==== Example Usage:
+        #   spin_group = CLI::UI::SpinGroup.new
+        #   spin_group.add('Title') { |spinner| sleep 1.0 }
+        #   spin_group.wait
+        #
+        sig { returns(T::Boolean) }
+        def wait
+          idx = 0
+
+          loop do
+            all_done = T.let(true, T::Boolean)
+
+            width = CLI::UI::Terminal.width
+
+            @m.synchronize do
+              CLI::UI.raw do
+                @tasks.each.with_index do |task, int_index|
+                  nat_index = int_index + 1
+                  task_done = task.check
+                  all_done = false unless task_done
+
+                  if nat_index > @consumed_lines
+                    print(task.render(idx, true, width: width) + "\n")
+                    @consumed_lines += 1
+                  else
+                    offset = @consumed_lines - int_index
+                    move_to = CLI::UI::ANSI.cursor_up(offset) + "\r"
+                    move_from = "\r" + CLI::UI::ANSI.cursor_down(offset)
+
+                    print(move_to + task.render(idx, idx.zero?, width: width) + move_from)
+                  end
+                end
+              end
+            end
+
+            break if all_done
+
+            idx = (idx + 1) % GLYPHS.size
+            Spinner.index = idx
+            sleep(PERIOD)
+          end
+
+          if @auto_debrief
+            debrief
+          else
+            @m.synchronize do
+              @tasks.all?(&:success)
+            end
+          end
+        end
+
+        # Debriefs failed tasks is +auto_debrief+ is true
+        #
+        sig { returns(T::Boolean) }
+        def debrief
+          @m.synchronize do
+            @tasks.each do |task|
+              next if task.success
+
+              e = task.exception
+              out = task.stdout
+              err = task.stderr
+
+              CLI::UI::Frame.open('Task Failed: ' + task.title, color: :red, timing: Time.new - @start) do
+                if e
+                  puts "#{e.class}: #{e.message}"
+                  puts "\tfrom #{e.backtrace.join("\n\tfrom ")}"
+                end
+
+                CLI::UI::Frame.divider('STDOUT')
+                out = '(empty)' if out.nil? || out.strip.empty?
+                puts out
+
+                CLI::UI::Frame.divider('STDERR')
+                err = '(empty)' if err.nil? || err.strip.empty?
+                puts err
+              end
+            end
+            @tasks.all?(&:success)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# typed: true
+# frozen-string-literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    module Spinner
+      extend T::Sig
+
+      autoload :Async,      'cli/ui/spinner/async'
+      autoload :SpinGroup,  'cli/ui/spinner/spin_group'
+
+      PERIOD = 0.1 # seconds
+      TASK_FAILED = :task_failed
+
+      RUNES = if CLI::UI::OS.current.use_emoji?
+        ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].freeze
+      else
+        ['\\', '|', '/', '-', '\\', '|', '/', '-'].freeze
+      end
+
+      colors = [CLI::UI::Color::CYAN.code] * (RUNES.size / 2).ceil +
+        [CLI::UI::Color::MAGENTA.code] * (RUNES.size / 2).to_i
+      GLYPHS = colors.zip(RUNES).map(&:join)
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor(:index)
+
+        # We use this from CLI::UI::Widgets::Status to render an additional
+        # spinner next to the "working" element. While this global state looks
+        # a bit repulsive at first, it's worth realizing that:
+        #
+        # * It's managed by the SpinGroup#wait method, not individual tasks; and
+        # * It would be complete insanity to run two separate but concurrent SpinGroups.
+        #
+        # While it would be possible to stitch through some connection between
+        # the SpinGroup and the Widgets included in its title, this is simpler
+        # in practice and seems unlikely to cause issues in practice.
+        sig { returns(String) }
+        def current_rune
+          RUNES[index || 0]
+        end
+      end
+
+      # Adds a single spinner
+      # Uses an interactive session to allow the user to pick an answer
+      # Can use arrows, y/n, numbers (1/2), and vim bindings to control
+      #
+      # https://user-images.githubusercontent.com/3074765/33798295-d94fd822-dce3-11e7-819b-43e5502d490e.gif
+      #
+      # ==== Attributes
+      #
+      # * +title+ - Title of the spinner to use
+      #
+      # ==== Options
+      #
+      # * +:auto_debrief+ - Automatically debrief exceptions? Default to true
+      #
+      # ==== Block
+      #
+      # * *spinner+ - Instance of the spinner. Can call +update_title+ to update the user of changes
+      #
+      # ==== Example Usage:
+      #
+      #   CLI::UI::Spinner.spin('Title') { sleep 1.0 }
+      #
+      sig do
+        params(title: String, auto_debrief: T::Boolean, block: T.proc.params(task: SpinGroup::Task).void)
+          .returns(T::Boolean)
+      end
+      def self.spin(title, auto_debrief: true, &block)
+        sg = SpinGroup.new(auto_debrief: auto_debrief)
+        sg.add(title, &block)
+        sg.wait
+      end
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+# typed: true
+require 'cli/ui'
+require 'stringio'
+
+module CLI
+  module UI
+    module StdoutRouter
+      class Writer
+        extend T::Sig
+
+        sig { params(stream: IOLike, name: Symbol).void }
+        def initialize(stream, name)
+          @stream = stream
+          @name = name
+        end
+
+        sig { params(args: String).void }
+        def write(*args)
+          args = args.map do |str|
+            if auto_frame_inset?
+              str = str.dup # unfreeze
+              str = str.force_encoding(Encoding::UTF_8)
+              apply_line_prefix(str, CLI::UI::Frame.prefix)
+            else
+              @pending_newline = false
+              str
+            end
+          end
+
+          # hook return of false suppresses output.
+          if (hook = Thread.current[:cliui_output_hook])
+            return if hook.call(args.map(&:to_s).join, @name) == false
+          end
+
+          T.unsafe(@stream).write_without_cli_ui(*prepend_id(@stream, args))
+          if (dup = StdoutRouter.duplicate_output_to)
+            T.unsafe(dup).write(*prepend_id(dup, args))
+          end
+        end
+
+        private
+
+        sig { params(stream: IOLike, args: T::Array[String]).returns(T::Array[String]) }
+        def prepend_id(stream, args)
+          return args unless prepend_id_for_stream(stream)
+
+          args.map do |a|
+            next a if a.chomp.empty? # allow new lines to be new lines
+
+            "[#{Thread.current[:cliui_output_id][:id]}] #{a}"
+          end
+        end
+
+        sig { params(stream: IOLike).returns(T::Boolean) }
+        def prepend_id_for_stream(stream)
+          return false unless Thread.current[:cliui_output_id]
+          return true if Thread.current[:cliui_output_id][:streams].include?(stream)
+
+          false
+        end
+
+        sig { returns(T::Boolean) }
+        def auto_frame_inset?
+          !Thread.current[:no_cliui_frame_inset]
+        end
+
+        sig { params(str: String, prefix: String).returns(String) }
+        def apply_line_prefix(str, prefix)
+          return '' if str.empty?
+
+          prefixed = +''
+          str.force_encoding(Encoding::UTF_8).lines.each do |line|
+            if @pending_newline
+              prefixed << line
+              @pending_newline = false
+            else
+              prefixed << prefix << line
+            end
+          end
+          @pending_newline = !str.end_with?("\n")
+          prefixed
+        end
+      end
+
+      class Capture
+        extend T::Sig
+
+        @m = Mutex.new
+        @active_captures = 0
+        @saved_stdin = nil
+
+        sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+        def self.with_stdin_masked(&block)
+          @m.synchronize do
+            if @active_captures.zero?
+              @saved_stdin = $stdin
+              $stdin, w = IO.pipe
+              $stdin.close
+              w.close
+            end
+            @active_captures += 1
+          end
+
+          yield
+        ensure
+          @m.synchronize do
+            @active_captures -= 1
+            if @active_captures.zero?
+              $stdin = @saved_stdin
+            end
+          end
+        end
+
+        sig do
+          params(with_frame_inset: T::Boolean, block: T.proc.void).void
+        end
+        def initialize(with_frame_inset: true, &block)
+          @with_frame_inset = with_frame_inset
+          @block = block
+          @stdout = ''
+          @stderr = ''
+        end
+
+        sig { returns(String) }
+        attr_reader :stdout, :stderr
+
+        sig { returns(T.untyped) }
+        def run
+          require 'stringio'
+
+          StdoutRouter.assert_enabled!
+
+          out = StringIO.new
+          err = StringIO.new
+
+          prev_frame_inset = Thread.current[:no_cliui_frame_inset]
+          prev_hook = Thread.current[:cliui_output_hook]
+
+          if Thread.current.respond_to?(:report_on_exception)
+            Thread.current.report_on_exception = false
+          end
+
+          self.class.with_stdin_masked do
+            Thread.current[:no_cliui_frame_inset] = !@with_frame_inset
+            Thread.current[:cliui_output_hook] = ->(data, stream) do
+              case stream
+              when :stdout then out.write(data)
+              when :stderr then err.write(data)
+              else raise
+              end
+              false # suppress writing to terminal
+            end
+
+            begin
+              @block.call
+            ensure
+              @stdout = out.string
+              @stderr = err.string
+            end
+          end
+        ensure
+          Thread.current[:cliui_output_hook] = prev_hook
+          Thread.current[:no_cliui_frame_inset] = prev_frame_inset
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        WRITE_WITHOUT_CLI_UI = :write_without_cli_ui
+
+        NotEnabled = Class.new(StandardError)
+
+        sig { returns(T.nilable(IOLike)) }
+        attr_accessor :duplicate_output_to
+
+        sig do
+          type_parameters(:T)
+            .params(on_streams: T::Array[IOLike], block: T.proc.params(id: String).returns(T.type_parameter(:T)))
+            .returns(T.type_parameter(:T))
+        end
+        def with_id(on_streams:, &block)
+          require 'securerandom'
+          id = format('%05d', rand(10**5))
+          Thread.current[:cliui_output_id] = {
+            id: id,
+            streams: on_streams.map { |stream| T.cast(stream, IOLike) },
+          }
+          yield(id)
+        ensure
+          Thread.current[:cliui_output_id] = nil
+        end
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.any(String, IOLike)])) }
+        def current_id
+          Thread.current[:cliui_output_id]
+        end
+
+        sig { void }
+        def assert_enabled!
+          raise NotEnabled unless enabled?
+        end
+
+        sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+        def with_enabled(&block)
+          enable
+          yield
+        ensure
+          disable
+        end
+
+        # TODO: remove this
+        sig { void }
+        def ensure_activated
+          enable unless enabled?
+        end
+
+        sig { returns(T::Boolean) }
+        def enable
+          return false if enabled?($stdout) || enabled?($stderr)
+
+          activate($stdout, :stdout)
+          activate($stderr, :stderr)
+          true
+        end
+
+        sig { params(stream: IOLike).returns(T::Boolean) }
+        def enabled?(stream = $stdout)
+          stream.respond_to?(WRITE_WITHOUT_CLI_UI)
+        end
+
+        sig { returns(T::Boolean) }
+        def disable
+          return false unless enabled?($stdout) && enabled?($stderr)
+
+          deactivate($stdout)
+          deactivate($stderr)
+          true
+        end
+
+        private
+
+        sig { params(stream: IOLike).void }
+        def deactivate(stream)
+          sc = stream.singleton_class
+          sc.send(:remove_method, :write)
+          sc.send(:alias_method, :write, WRITE_WITHOUT_CLI_UI)
+        end
+
+        sig { params(stream: IOLike, streamname: Symbol).void }
+        def activate(stream, streamname)
+          writer = StdoutRouter::Writer.new(stream, streamname)
+
+          raise if stream.respond_to?(WRITE_WITHOUT_CLI_UI)
+
+          stream.singleton_class.send(:alias_method, WRITE_WITHOUT_CLI_UI, :write)
+          stream.define_singleton_method(:write) do |*args|
+            writer.write(*args)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# typed: true
+require 'cli/ui'
+require 'io/console'
+
+module CLI
+  module UI
+    module Terminal
+      extend T::Sig
+
+      DEFAULT_WIDTH = 80
+      DEFAULT_HEIGHT = 24
+
+      # Returns the width of the terminal, if possible
+      # Otherwise will return DEFAULT_WIDTH
+      #
+      sig { returns(Integer) }
+      def self.width
+        winsize[1]
+      end
+
+      # Returns the width of the terminal, if possible
+      # Otherwise, will return DEFAULT_HEIGHT
+      #
+      sig { returns(Integer) }
+      def self.height
+        winsize[0]
+      end
+
+      sig { returns([Integer, Integer]) }
+      def self.winsize
+        @winsize ||= begin
+          winsize = IO.console.winsize
+          setup_winsize_trap
+
+          if winsize.any?(&:zero?)
+            [DEFAULT_HEIGHT, DEFAULT_WIDTH]
+          else
+            winsize
+          end
+        rescue
+          [DEFAULT_HEIGHT, DEFAULT_WIDTH]
+        end
+      end
+
+      sig { void }
+      def self.setup_winsize_trap
+        @winsize_trap ||= Signal.trap('WINCH') do
+          @winsize = nil
+        end
+      end
+    end
+  end
+end