ruby_jard 0.2.2 → 0.2.3

data/lib/ruby_jard/repl_proxy.rb

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 
-require 'ruby_jard/commands/continue_command'
-require 'ruby_jard/commands/up_command'
-require 'ruby_jard/commands/down_command'
-require 'ruby_jard/commands/next_command'
-require 'ruby_jard/commands/step_command'
-require 'ruby_jard/commands/step_out_command'
-require 'ruby_jard/commands/frame_command'
-require 'ruby_jard/commands/list_command'
-require 'ruby_jard/commands/color_scheme_command'
+require 'pty'
+require 'ruby_jard/pager'
 
 module RubyJard
   ##
@@ -44,7 +37,6 @@ module RubyJard
       'stat',          # Included in jard UI
       'backtrace',     # Re-implemented later
       'break',         # Re-implemented later
-      'exit',          # Conflicted with continue
       'exit-all',      # Conflicted with continue
       'exit-program',  # We already have `exit` native command
       '!pry',          # No need to complicate things
@@ -54,119 +46,218 @@ module RubyJard
       'disable-pry'    # No need to complicate things
     ].freeze
 
-    COMMANDS = [
-      CMD_FLOW      = :flow,
-      CMD_EVALUATE  = :evaluate,
-      CMD_IDLE      = :idle,
-      CMD_INTERRUPT = :interrupt
-    ].freeze
-
-    # rubocop:disable Layout/HashAlignment
     INTERNAL_KEY_BINDINGS = {
-      RubyJard::Keys::END_LINE => (KEY_BINDING_ENDLINE   = :end_line),
-      RubyJard::Keys::CTRL_C   => (KEY_BINDING_INTERRUPT = :interrupt)
+      RubyJard::Keys::CTRL_C => (KEY_BINDING_INTERRUPT = :interrupt)
     }.freeze
-    # rubocop:enable Layout/HashAlignment
 
-    KEYPRESS_POLLING = 0.1 # 100ms
+    KEY_READ_TIMEOUT = 0.2           # 200ms
+    PTY_OUTPUT_TIMEOUT = 1.to_f / 60 # 60hz
+
+    ##
+    # A tool to communicate between functional threads and main threads
+    class FlowInterrupt < StandardError
+      attr_reader :flow
+
+      def initialize(msg = '', flow = nil)
+        super(msg)
+        @flow = flow
+      end
+    end
+
+    ##
+    # A class to store the state with multi-thread guarding
+    # Ready => Processing/Exiting
+    # Processing => Ready again
+    # Exiting => Exited
+    # Exited => Ready
+    class ReplState
+      STATES = [
+        STATE_READY      = 0,
+        STATE_EXITING    = 1,
+        STATE_PROCESSING = 2,
+        STATE_EXITED     = 3
+      ].freeze
+      def initialize
+        @state = STATE_EXITED
+        @mutex = Mutex.new
+      end
+
+      def check(method_name)
+        @mutex.synchronize { yield if send(method_name) }
+      end
+
+      def ready?
+        @state == STATE_READY
+      end
+
+      def ready!
+        if ready? || processing? || exited?
+          @mutex.synchronize { @state = STATE_READY }
+        end
+      end
+
+      def processing?
+        @state == STATE_PROCESSING
+      end
+
+      def processing!
+        return unless ready?
+
+        @mutex.synchronize { @state = STATE_PROCESSING }
+      end
+
+      def exiting?
+        @state == STATE_EXITING
+      end
+
+      def exiting!
+        @mutex.synchronize { @state = STATE_EXITING }
+      end
+
+      def exited?
+        @state == STATE_EXITED
+      end
+
+      def exited!
+        @mutex.synchronize { @state = STATE_EXITED }
+      end
+    end
 
     def initialize(key_bindings: nil)
-      @pry_read_stream, @pry_write_stream = IO.pipe
+      @state = ReplState.new
+
+      @pry_input_pipe_read, @pry_input_pipe_write = IO.pipe
+      @pry_output_pty_read, @pry_output_pty_write = PTY.open
       @pry = pry_instance
-      @commands = Queue.new
+
       @key_bindings = key_bindings || RubyJard::KeyBindings.new
       INTERNAL_KEY_BINDINGS.each do |sequence, action|
         @key_bindings.push(sequence, action)
       end
-    end
 
-    def read_key
-      RubyJard::Console.getch(STDIN, KEYPRESS_POLLING)
+      @pry_pty_output_thread = Thread.new { pry_pty_output }
+      @pry_pty_output_thread.name = '<<Jard: Pty Output Thread>>'
     end
 
     def repl(current_binding)
-      Readline.input = @pry_read_stream
-      @commands.clear
+      @state.ready!
+      @openning_pager = false
+
+      RubyJard::Console.disable_echo!
+      RubyJard::Console.raw!
+
+      Readline.input = @pry_input_pipe_read
+      Readline.output = @pry_output_pty_write
       @pry.binding_stack.clear
 
-      pry_thread = Thread.new do
-        pry_repl(current_binding)
-      end
-      pry_thread.report_on_exception = false if pry_thread.respond_to?(:report_on_exception)
-      loop do
-        break unless pry_thread.alive?
+      @main_thread = Thread.current
+
+      @pry_input_thread = Thread.new { pry_repl(current_binding) }
+      @pry_input_thread.abort_on_exception = true
+      @pry_input_thread.report_on_exception = false
+      @pry_input_thread.name = '<<Jard: Pry input thread >>'
 
-        if @commands.empty?
-          listen_key_press
+      @key_listen_thread = Thread.new { listen_key_press }
+      @key_listen_thread.abort_on_exception = true
+      @key_listen_thread.report_on_exception = false
+      @key_listen_thread.name = '<<Jard: Repl key listen >>'
+
+      [@pry_input_thread, @key_listen_thread].map(&:join)
+    rescue FlowInterrupt => e
+      @state.exiting!
+      sleep PTY_OUTPUT_TIMEOUT until @state.exited?
+      RubyJard::ControlFlow.dispatch(e.flow)
+    ensure
+      RubyJard::Console.enable_echo!
+      RubyJard::Console.cooked!
+      Readline.input = STDIN
+      Readline.output = STDOUT
+      @key_listen_thread&.exit if @key_listen_thread&.alive?
+      @pry_input_thread&.exit if @pry_input_thread&.alive?
+      @state.exited!
+    end
+
+    private
+
+    def read_key
+      RubyJard::Console.getch(STDIN, KEY_READ_TIMEOUT)
+    end
+
+    def pry_pty_output
+      loop do
+        if @state.exiting?
+          if @pry_output_pty_read.ready?
+            STDOUT.write @pry_output_pty_read.read_nonblock(2048), from_jard: true
+          else
+            @state.exited!
+          end
+        elsif @state.exited?
+          sleep PTY_OUTPUT_TIMEOUT
         else
-          cmd, value = @commands.deq
-          handle_command(pry_thread, cmd, value)
+          output = @pry_output_pty_read.read_nonblock(2048)
+          unless output.nil?
+            STDOUT.write output, from_jard: true
+          end
         end
+      rescue IO::WaitReadable, IO::WaitWritable
+        # Retry
+        sleep PTY_OUTPUT_TIMEOUT
       end
-      pry_thread&.join
-      Readline.input = STDIN
     end
 
     def pry_repl(current_binding)
       flow = RubyJard::ControlFlow.listen do
         @pry.repl(current_binding)
       end
-      @commands << [CMD_FLOW, flow]
-    rescue StandardError => e
-      RubyJard::ScreenManager.draw_error(e)
-      raise
+      @state.check(:ready?) do
+        @main_thread.raise FlowInterrupt.new('Interrupt from repl thread', flow)
+      end
     end
 
     def listen_key_press
-      key = @key_bindings.match { read_key }
-      if key.is_a?(RubyJard::KeyBinding)
-        handle_key_binding(key)
-      elsif !key.empty?
-        @pry_write_stream.write(key)
+      loop do
+        break if @state.exiting? || @state.exited?
+
+        if @state.processing? && @openning_pager
+          # Discard all keys unfortunately
+          sleep PTY_OUTPUT_TIMEOUT
+        else
+          key = @key_bindings.match { read_key }
+          if key.is_a?(RubyJard::KeyBinding)
+            continue = handle_key_binding(key)
+            break unless continue
+          elsif !key.empty?
+            @pry_input_pipe_write.write(key)
+          end
+        end
       end
     end
 
     def handle_key_binding(key_binding)
       case key_binding.action
-      when KEY_BINDING_ENDLINE
-        @pry_write_stream.write(key_binding.sequence)
-        @commands << [CMD_EVALUATE]
       when KEY_BINDING_INTERRUPT
-        @commands << [CMD_INTERRUPT]
+        handle_interrupt_command
+        true
       else
-        @commands << [
-          CMD_FLOW, RubyJard::ControlFlow.new(:key_binding, action: key_binding.action)
-        ]
-      end
-    end
-
-    def handle_command(pry_thread, cmd, value)
-      case cmd
-      when CMD_FLOW
-        pry_thread.exit if pry_thread.alive?
-        RubyJard::ControlFlow.dispatch(value)
-      when CMD_EVALUATE
-        loop do
-          cmd, value = @commands.deq
-          break if [CMD_IDLE, CMD_FLOW, CMD_INTERRUPT].include?(cmd)
+        flow = RubyJard::ControlFlow.new(:key_binding, action: key_binding.action)
+        @state.check(:ready?) do
+          @main_thread.raise FlowInterrupt.new('Interrupt from repl thread', flow)
         end
-        handle_command(pry_thread, cmd, value)
-      when CMD_INTERRUPT
-        handle_interrupt_command(pry_thread)
-      when CMD_IDLE
-        # Ignore
+        false
       end
     end
 
-    def handle_interrupt_command(pry_thread)
-      pry_thread.raise Interrupt if pry_thread.alive?
+    def handle_interrupt_command
+      @state.check(:ready?) do
+        @pry_input_thread&.raise Interrupt if @pry_input_thread&.alive?
+      end
       loop do
         begin
-          sleep 0.1
+          sleep PTY_OUTPUT_TIMEOUT
         rescue Interrupt
           # Interrupt spam. Ignore.
         end
-        break unless pry_thread.pending_interrupt?
+        break unless @pry_input_thread&.pending_interrupt?
       end
     end
 
@@ -175,7 +266,8 @@ module RubyJard
         prompt: pry_jard_prompt,
         quiet: true,
         commands: pry_command_set,
-        hooks: pry_hooks
+        hooks: pry_hooks,
+        output: @pry_output_pty_write
       )
       # I'll be burned in hell for this
       # TODO: Contact pry author to add :after_handle_line hook
@@ -186,6 +278,10 @@ module RubyJard
         end
         alias_method :_original_handle_line, :handle_line
         alias_method :handle_line, :_jard_handle_line
+
+        def pager
+          RubyJard::Pager.new(self)
+        end
       end
       pry_instance
     end
@@ -215,18 +311,26 @@ module RubyJard
 
     def pry_hooks
       hooks = Pry::Hooks.default
-      hooks.add_hook(:after_read, :jard_proxy_acquire_lock) do |read_string, _pry|
-        @commands <<
-          if Pry::Code.complete_expression?(read_string)
-            [CMD_EVALUATE]
-          else
-            [CMD_IDLE]
-          end
-      rescue SyntaxError
-        @commands << [CMD_IDLE]
+      hooks.add_hook(:after_read, :jard_proxy_acquire_lock) do |_read_string, _pry|
+        RubyJard::Console.cooked!
+        @state.processing!
+        # Sleep 2 ticks, wait for pry to print out all existing output in the queue
+        sleep PTY_OUTPUT_TIMEOUT * 2
       end
       hooks.add_hook(:after_handle_line, :jard_proxy_release_lock) do
-        @commands << [CMD_IDLE]
+        RubyJard::Console.raw!
+        @state.ready!
+      end
+      hooks.add_hook(:before_pager, :jard_proxy_before_pager) do
+        @openning_pager = true
+
+        @state.processing!
+        RubyJard::Console.cooked!
+      end
+      hooks.add_hook(:after_pager, :jard_proxy_after_pager) do
+        @openning_pager = false
+        @state.ready!
+        RubyJard::Console.raw!
       end
     end
   end

data/lib/ruby_jard/row.rb

@@ -1,16 +1,31 @@
 # frozen_string_literal: true
 
 module RubyJard
+  ##
+  # This class is an object to store a row of data display on a screen
   class Row
     extend Forwardable
 
-    attr_accessor :columns, :line_limit, :content
+    attr_accessor :columns, :line_limit, :content, :rendered
 
     def initialize(line_limit: 1, columns: [], ellipsis: true)
       @content = []
       @columns = columns
       @ellipsis = ellipsis
       @line_limit = line_limit
+      @rendered = false
+    end
+
+    def rendered?
+      @rendered == true
+    end
+
+    def mark_rendered
+      @rendered = true
+    end
+
+    def reset_rendered
+      @rendered = false
     end
   end
 end

data/lib/ruby_jard/row_renderer.rb

@@ -14,63 +14,72 @@ module RubyJard
     end
 
     def render
+      @row.reset_rendered
+
       @x = 0
       @y = 0
+      @original_x = 0
+      @original_y = 0
       @content_map = []
 
-      original_x = 0
-      @row.columns.each_with_index do |column, index|
-        @y = 0
-        @x = original_x
-        content_width = column.width
-        content_width -= 1 if index < @row.columns.length - 1
-        render_column(column, original_x, content_width)
+      @row.columns.each do |column|
+        @x = @original_x
+        @y = @original_y
+
+        @drawing_width = 0
+        @drawing_lines = 1
 
-        original_x += column.width
+        column.spans.each do |span|
+          render_span(column, span)
+        end
+
+        @original_x += column.width
       end
 
       generate_bitmap
+
+      @row.mark_rendered
     end
 
-    def render_column(column, original_x, content_width)
-      width = 0
-      lines = 1
-
-      column.spans.each do |span|
-        line_content = span.content
-
-        until line_content.nil? || line_content.empty?
-          if column.word_wrap == RubyJard::Column::WORD_WRAP_NORMAL
-            if content_width - width < line_content.length && width != 0
-              width = 0
-              lines += 1
-              @y += 1
-              @x = original_x
-            end
-          elsif column.word_wrap == RubyJard::Column::WORD_WRAP_BREAK_WORD
-            if content_width - width <= 0
-              width = 0
-              lines += 1
-              @y += 1
-              @x = original_x
-            end
-          elsif content_width - width <= 0
-            return
+    # rubocop:disable Metrics/MethodLength
+    def render_span(column, span)
+      line_content = span.content
+
+      until line_content.nil? || line_content.empty?
+        if column.word_wrap == RubyJard::Column::WORD_WRAP_NORMAL
+          if column.content_width - @drawing_width < line_content.length && @drawing_width != 0
+            @drawing_width = 0
+            @drawing_lines += 1
+            @y += 1
+            @x = @original_x
           end
-          drawing_content = line_content[0..content_width - width - 1]
-          line_content = line_content[content_width - width..-1]
-          width += drawing_content.length
-
-          if !@row.line_limit.nil? && lines >= @row.line_limit && !line_content.nil? && !line_content.empty?
-            drawing_content[drawing_content.length - ELLIPSIS.length..-1] = ELLIPSIS
-            draw_content(drawing_content, span.styles)
-            return
-          else
-            draw_content(drawing_content, span.styles)
+        elsif column.word_wrap == RubyJard::Column::WORD_WRAP_BREAK_WORD
+          if column.content_width - @drawing_width <= 0
+            @drawing_width = 0
+            @drawing_lines += 1
+            @y += 1
+            @x = @original_x
           end
+        elsif column.content_width - @drawing_width <= 0
+          return
+        end
+        drawing_content = line_content[0..column.content_width - @drawing_width - 1]
+        line_content = line_content[column.content_width - @drawing_width..-1]
+        @drawing_width += drawing_content.length
+
+        if !@row.line_limit.nil? &&
+           @drawing_lines >= @row.line_limit &&
+           !line_content.nil? &&
+           !line_content.empty?
+          drawing_content[drawing_content.length - ELLIPSIS.length..-1] = ELLIPSIS
+          draw_content(drawing_content, span.styles)
+          return
+        else
+          draw_content(drawing_content, span.styles)
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
 
     def draw_content(drawing_content, styles)
       return if @y < 0 || @y >= @height