ruby_jard 0.1.0 → 0.2.0

data/lib/ruby_jard/repl_processor.rb

@@ -4,140 +4,130 @@ module RubyJard
   ##
   # Byebug allows customizing processor with a series of hooks (https://github.com/deivid-rodriguez/byebug/blob/e1fb8209d56922f7bafd128af84e61568b6cd6a7/lib/byebug/processors/command_processor.rb)
   #
-  # This class is a bridge between Pry and Byebug. It is inherited from
+  # This class is a bridge between REPL library and Byebug. It is inherited from
   # Byebug::CommandProcessor, the processor is triggered. It starts draw the
-  # UI, starts a new pry session, listen for control-flow events threw from
-  # pry commands (lib/commands/*), and triggers Byebug debugger if needed.
+  # UI, starts a new REPL session, listen for control-flow events threw from
+  # repl, and triggers Byebug debugger if needed.
   #
   class ReplProcessor < Byebug::CommandProcessor
-    # Some commands overlaps with Jard, Ruby, and even cause confusion for
-    # users. It's better ignore or re-implement those commands.
-    PRY_EXCLUDED_COMMANDS = [
-      'pry-backtrace', # Redundant method for normal user
-      'watch',         # Conflict with byebug and jard watch
-      'whereami',      # Jard already provides similar. Keeping this command makes conflicted experience
-      'edit',          # Sorry, but a file should not be editted while debugging, as it made breakpoints shifted
-      'play',          # What if the played files or methods include jard again?
-      '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
-      'jump-to',       # No need to complicate things
-      'nesting',       # No need to complicate things
-      'switch-to',     # No need to complicate things
-      'disable-pry'    # No need to complicate things
-    ].freeze
-
     def initialize(context, interface = LocalInterface.new)
       super(context, interface)
+      @repl_proxy = RubyJard::ReplProxy.new(
+        key_bindings: RubyJard.global_key_bindings
+      )
     end
 
     def at_line
-      process_commands
+      process_commands_with_lock
     end
 
     def at_return(_)
-      process_commands
+      process_commands_with_lock
     end
 
     def at_end
-      process_commands
+      process_commands_with_lock
     end
 
     private
 
-    def process_commands
-      RubyJard.current_session.refresh
+    def process_commands_with_lock
+      allowing_other_threads do
+        RubyJard.current_session.lock do
+          process_commands
+        end
+      end
+    end
+
+    def process_commands(update = true)
+      if update
+        RubyJard.current_session.update
+        RubyJard::ScreenManager.update
+      end
       return_value = nil
 
-      flow = catch(:control_flow) do
-        return_value = allowing_other_threads do
-          start_pry_session
-        end
-        {}
+      flow = RubyJard::ControlFlow.listen do
+        return_value = @repl_proxy.repl(frame._binding)
       end
 
-      @pry = flow[:pry]
-      if @pry
-        @pry.binding_stack.clear
-        send("handle_#{flow[:command]}_command", @pry, flow[:options])
+      unless flow.nil?
+        command = flow.command
+        send("handle_#{command}_command", flow.arguments)
       end
 
       return_value
+    rescue StandardError => e
+      RubyJard::ScreenManager.draw_error(e)
+      raise
     end
 
-    def start_pry_session
-      if @pry.nil?
-        @pry = Pry.start(
-          frame._binding,
-          prompt: pry_jard_prompt,
-          quiet: true,
-          commands: pry_command_set
-        )
-      else
-        @pry.repl(frame._binding)
-      end
+    def handle_next_command(_options = {})
+      Byebug.current_context.step_over(1, Byebug.current_context.frame.pos)
+      proceed!
     end
 
-    def handle_next_command(_pry_instance, _options)
-      Byebug::NextCommand.new(self, 'next').execute
+    def handle_step_command(_options = {})
+      Byebug.current_context.step_into(1, Byebug.current_context.frame.pos)
+      proceed!
     end
 
-    def handle_step_command(_pry_instance, _options)
-      Byebug::StepCommand.new(self, 'step').execute
+    def handle_step_out_command(_options = {})
+      # TODO: handle c-frame and out of range frames
+      Byebug.current_context.frame = 1
+      proceed!
+      Byebug.current_context.step_over(1, Byebug.current_context.frame.pos)
+      proceed!
     end
 
-    def handle_up_command(_pry_instance, _options)
-      Byebug::UpCommand.new(self, 'up 1').execute
-
+    def handle_up_command(_options = {})
+      next_frame = [
+        Byebug.current_context.frame.pos + 1,
+        Byebug.current_context.backtrace.length - 1
+      ].min
+      while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
+            next_frame < Byebug.current_context.backtrace.length - 1
+        next_frame += 1
+      end
+      Byebug.current_context.frame = next_frame
+      proceed!
       process_commands
     end
 
-    def handle_down_command(_pry_instance, _options)
-      Byebug::DownCommand.new(self, 'down 1').execute
-
+    def handle_down_command(_options = {})
+      next_frame = [Byebug.current_context.frame.pos - 1, 0].max
+      while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
+            next_frame > 0
+        next_frame -= 1
+      end
+      Byebug.current_context.frame = next_frame
+      proceed!
       process_commands
     end
 
-    def handle_finish_command(_pry_instance, _options)
-      RubyJard.current_session.disable
-      context.step_out(2, true)
-      Byebug::NextCommand.new(self, 'next').execute
-      RubyJard.current_session.enable
+    def handle_frame_command(options)
+      next_frame = options[:frame].to_i
+      if Byebug::Frame.new(Byebug.current_context, next_frame).c_frame?
+        puts "Error: Frame #{next_frame} is a c-frame. Not able to inspect c layer!"
+        process_commands(false)
+      else
+        Byebug.current_context.frame = next_frame
+        proceed!
+        process_commands(true)
+      end
     end
 
-    def handle_continue_command(_pry_instance, _options)
+    def handle_continue_command(_options = {})
       # Do nothing
     end
 
-    def pry_command_set
-      @pry_command_set ||=
-        begin
-          set = Pry::CommandSet.new
-          set.import_from(
-            Pry.config.commands,
-            *(Pry.config.commands.list_commands - PRY_EXCLUDED_COMMANDS)
-          )
-          set
-        end
-    end
-
-    def pry_jard_prompt
-      @pry_jard_prompt ||=
-        Pry::Prompt.new(
-          :jard,
-          'Custom pry promt for Jard', [
-            proc do |_context, _nesting, _pry_instance|
-              'jard >> '
-            end,
-            proc do |_context, _nesting, _pry_instance|
-              'jard *> '
-            end
-          ]
-        )
+    def handle_key_binding_command(options)
+      method_name = "handle_#{options[:action]}_command"
+      if respond_to?(method_name, true)
+        send(method_name)
+      else
+        raise RubyJard::Error,
+              "Fail to handle key binding `#{options[:action]}`"
+      end
     end
   end
 end

data/lib/ruby_jard/repl_proxy.rb

@@ -0,0 +1,232 @@
+# 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'
+
+module RubyJard
+  ##
+  # A wrapper to wrap around Pry instance.
+  #
+  # Pry depends heavily on GNU Readline, or any Readline-like input libraries. Those libraries
+  # serve limited use cases, and specific interface to support those. Unfortunately, to serve
+  # Jard's keyboard functionalities, those libraries must support individual keyboard events,
+  # programmatically input control, etc. Ruby's GNU Readline binding obviously doesn't support
+  # those fancy features. Other pure-ruby implementation such as coolline, tty-reader is not
+  # a perfit fit, while satisfying performance and boringly stablility of GNU Readline. Indeed,
+  # while testing those libraries, I meet some weird quirks, lagging, cursor jumping around.
+  # Putting efforts in a series of monkey patches help a little bit, but it harms in long-term.
+  # Re-implementing is just like jumping into another rabbit hole.
+  #
+  # That's why I come up with another approach:
+  # - Create a proxy wrapping around pry instance, so that it reads characters one by one, in
+  # *raw* mode
+  # - Keyboard combinations are captured and handled before piping the rest to the pry instance
+  # - The proxy interacts with Pry's REPL loop via Pry hooks (Thank God) to seamlessly switch
+  # between *raw* mode and *cooked* mode while Pry interacts with TTY.
+  # - Control flow instructions are threw out, and captured by ReplProcessor.
+  #
+  # As a result, Jard may support key-binding customization without breaking pry functionalities.
+  class ReplProxy
+    # Some commands overlaps with Jard, Ruby, and even cause confusion for
+    # users. It's better ignore or re-implement those commands.
+    PRY_EXCLUDED_COMMANDS = [
+      'pry-backtrace', # Redundant method for normal user
+      'watch',         # Conflict with byebug and jard watch
+      'whereami',      # Jard already provides similar. Keeping this command makes conflicted experience
+      'edit',          # Sorry, but a file should not be editted while debugging, as it made breakpoints shifted
+      'play',          # What if the played files or methods include jard again?
+      '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
+      'jump-to',       # No need to complicate things
+      'nesting',       # No need to complicate things
+      'switch-to',     # No need to complicate things
+      '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)
+    }.freeze
+    # rubocop:enable Layout/HashAlignment
+
+    KEYPRESS_POLLING = 0.1 # 100ms
+
+    def initialize(key_bindings: nil)
+      @pry_read_stream, @pry_write_stream = IO.pipe
+      @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
+      STDIN.getch(min: 0, time: KEYPRESS_POLLING)
+    end
+
+    def repl(current_binding)
+      Readline.input = @pry_read_stream
+      @commands.clear
+      @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?
+
+        if @commands.empty?
+          listen_key_press
+        else
+          cmd, value = @commands.deq
+          handle_command(pry_thread, cmd, value)
+        end
+      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
+    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)
+      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]
+      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)
+        end
+        handle_command(pry_thread, cmd, value)
+      when CMD_INTERRUPT
+        handle_interrupt_command(pry_thread)
+      when CMD_IDLE
+        # Ignore
+      end
+    end
+
+    def handle_interrupt_command(pry_thread)
+      pry_thread.raise Interrupt if pry_thread.alive?
+      loop do
+        begin
+          sleep 0.1
+        rescue Interrupt
+          # Interrupt spam. Ignore.
+        end
+        break unless pry_thread.pending_interrupt?
+      end
+    end
+
+    def pry_instance
+      pry_instance = Pry.new(
+        prompt: pry_jard_prompt,
+        quiet: true,
+        commands: pry_command_set,
+        hooks: pry_hooks
+      )
+      # I'll be burned in hell for this
+      # TODO: Contact pry author to add :after_handle_line hook
+      class << pry_instance
+        def _jard_handle_line(*args)
+          _original_handle_line(*args)
+          exec_hook :after_handle_line, *args, self
+        end
+        alias_method :_original_handle_line, :handle_line
+        alias_method :handle_line, :_jard_handle_line
+      end
+      pry_instance
+    end
+
+    def pry_command_set
+      set = Pry::CommandSet.new
+      set.import_from(
+        Pry.config.commands,
+        *(Pry.config.commands.list_commands - PRY_EXCLUDED_COMMANDS)
+      )
+      set
+    end
+
+    def pry_jard_prompt
+      Pry::Prompt.new(
+        :jard,
+        'Custom pry promt for Jard', [
+          proc do |_context, _nesting, _pry_instance|
+            'jard >> '
+          end,
+          proc do |_context, _nesting, _pry_instance|
+            'jard *> '
+          end
+        ]
+      )
+    end
+
+    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]
+      end
+      hooks.add_hook(:after_handle_line, :jard_proxy_release_lock) do
+        @commands << [CMD_IDLE]
+      end
+    end
+  end
+end