ruby_jard 0.2.3 → 0.3.0

data/lib/ruby_jard/reflection.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # User classes may override basic Kernel methods, such as #inspect
+  # or #to_s, or even #is_a?. It's not very wise to call those methods
+  # directly, as there maybe side effects. Therefore, this class is
+  # to extract unbound methods from Kernel module, and then call them
+  # in Object's context.
+  class Reflection
+    class << self
+      def call_class(object)
+        if call_is_a?(object, Module)
+          bind_call(Kernel, :class, object)
+        else
+          instance_bind_call(Kernel, :class, object)
+        end
+      end
+
+      def call_respond_to?(object, method_name)
+        if call_is_a?(object, Module)
+          bind_call(Kernel, :respond_to?, object, method_name)
+        else
+          instance_bind_call(Kernel, :respond_to?, object, method_name)
+        end
+      end
+
+      def call_instance_variables(object)
+        bind_call(Kernel, :instance_variables, object)
+      end
+
+      def call_instance_variable_get(object, variable)
+        bind_call(Kernel, :instance_variable_get, object, variable)
+      end
+
+      def call_instance_variable_set(object, variable, value)
+        bind_call(Kernel, :instance_variable_set, object, variable, value)
+      end
+
+      def call_inspect(object)
+        if call_is_a?(object, Module)
+          bind_call(Kernel, :inspect, object)
+        else
+          instance_bind_call(Kernel, :inspect, object)
+        end
+      end
+
+      def call_to_s(object)
+        if call_is_a?(object, Module)
+          bind_call(Kernel, :to_s, object)
+        else
+          instance_bind_call(Kernel, :to_s, object)
+        end
+      end
+
+      def call_is_a?(object, comparing_class)
+        bind_call(Kernel, :is_a?, object, comparing_class)
+      end
+
+      def call_const_get(object, const_name)
+        bind_call(Kernel, :const_get, object, const_name)
+      end
+
+      def call_const_defined?(object, const_name)
+        bind_call(Kernel, :const_defined?, object, const_name)
+      end
+
+      def bind_call(owner, method_name, object, *args)
+        @method_cache ||= {}
+        @method_cache[owner] ||= {}
+        @method_cache[owner][method_name] ||= fetch_method(owner, method_name)
+        @method_cache[owner][method_name].bind(object).call(*args)
+      end
+
+      def instance_bind_call(owner, method_name, object, *args)
+        @instance_method_cache ||= {}
+        @instance_method_cache[owner] ||= {}
+        @instance_method_cache[owner][method_name] ||= fetch_instance_method(owner, method_name)
+        @instance_method_cache[owner][method_name].bind(object).call(*args)
+      end
+
+      def fetch_method(object, method_name)
+        @method_cache ||= {}
+        @method_cache[::Kernel] ||= {}
+        @method_cache[::Kernel][:method] ||= ::Kernel.method(:method).unbind
+        @method_cache[::Kernel][:method].bind(object).call(method_name).unbind
+      end
+
+      def fetch_instance_method(object, method_name)
+        @method_cache ||= {}
+        @method_cache[::Kernel] ||= {}
+        @method_cache[::Kernel][:instance_method] ||= ::Kernel.method(:instance_method).unbind
+        @method_cache[::Kernel][:instance_method].bind(object).call(method_name)
+      end
+    end
+  end
+end

data/lib/ruby_jard/repl_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'ruby_jard/commands/validation_helpers'
+require 'ruby_jard/commands/color_helpers'
 require 'ruby_jard/commands/continue_command'
 require 'ruby_jard/commands/exit_command'
 require 'ruby_jard/commands/up_command'
@@ -24,9 +25,11 @@ module RubyJard
   class ReplProcessor < Byebug::CommandProcessor
     def initialize(context, *args)
       super(context, *args)
+      @config = RubyJard.config
       @repl_proxy = RubyJard::ReplProxy.new(
         key_bindings: RubyJard.global_key_bindings
       )
+      @previous_flow = nil
     end
 
     def at_line
@@ -45,27 +48,29 @@ module RubyJard
 
     def process_commands_with_lock
       allowing_other_threads do
-        RubyJard.current_session.lock do
+        RubyJard::Session.lock do
+          RubyJard::Session.sync(@context)
+          unless RubyJard::Session.should_stop?
+            handle_flow(@previous_flow)
+            return
+          end
+
           process_commands
         end
       end
     end
 
-    def process_commands(update = true)
-      if update
-        RubyJard.current_session.update
-        RubyJard::ScreenManager.update
-      end
+    def process_commands(redraw = true)
+      RubyJard::Session.sync(@context)
+      RubyJard::ScreenManager.draw_screens if redraw
+
       return_value = nil
 
       flow = RubyJard::ControlFlow.listen do
         return_value = @repl_proxy.repl(frame._binding)
       end
 
-      unless flow.nil?
-        command = flow.command
-        send("handle_#{command}_command", flow.arguments)
-      end
+      handle_flow(flow)
 
       return_value
     rescue StandardError => e
@@ -73,58 +78,65 @@ module RubyJard
       raise
     end
 
+    def handle_flow(flow)
+      return if flow.nil?
+
+      @previous_flow = flow
+      command = flow.command
+      send("handle_#{command}_command", flow.arguments)
+    end
+
     def handle_next_command(options = {})
       times = options[:times] || 1
-      Byebug.current_context.step_over(times, Byebug.current_context.frame.pos)
-      proceed!
+      RubyJard::Session.step_over(times)
     end
 
     def handle_step_command(options = {})
       times = options[:times] || 1
-      Byebug.current_context.step_into(times, Byebug.current_context.frame.pos)
-      proceed!
+      RubyJard::Session.step_into(times)
     end
 
     def handle_step_out_command(options = {})
       times = options[:times] || 1
 
-      next_frame = up_n_frames(Byebug.current_context.frame.pos, times)
-      Byebug.current_context.frame = next_frame
-      Byebug.current_context.step_over(1, Byebug.current_context.frame.pos)
-      proceed!
+      next_frame = up_n_frames(RubyJard::Session.current_frame.real_pos, times)
+      RubyJard::Session.frame = next_frame
+      RubyJard::Session.step_over(1)
     end
 
     def handle_up_command(options = {})
       times = options[:times] || 1
 
-      next_frame = up_n_frames(Byebug.current_context.frame.pos, times)
-      Byebug.current_context.frame = next_frame
-      proceed!
+      next_frame = up_n_frames(RubyJard::Session.current_frame.real_pos, times)
+      RubyJard::Session.frame = next_frame
       process_commands
     end
 
     def handle_down_command(options = {})
       times = options[:times] || 1
-      next_frame = down_n_frames(Byebug.current_context.frame.pos, times)
-      Byebug.current_context.frame = next_frame
-      proceed!
+      next_frame = down_n_frames(RubyJard::Session.current_frame.real_pos, times)
+      RubyJard::Session.frame = next_frame
       process_commands
     end
 
     def handle_frame_command(options)
-      next_frame = options[:frame].to_i
-      if Byebug::Frame.new(Byebug.current_context, next_frame).c_frame?
+      next_frame = find_frame(options[:frame].to_i)
+      if next_frame.nil?
+        # There must be an error in outer validators
+        RubyJard::ScreenManager.puts 'Error: Frame not found. There should be an error with Jard.'
+        process_commands(false)
+      elsif next_frame.c_frame?
         RubyJard::ScreenManager.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!
+        RubyJard::Session.frame = next_frame.real_pos
         process_commands(true)
       end
     end
 
     def handle_continue_command(_options = {})
-      RubyJard::ScreenManager.puts '► ► Program resumed ► ►'
+      RubyJard::ScreenManager.puts '▸▸ Program resumed ▸▸'
+      Byebug.stop if Byebug.stoppable?
     end
 
     def handle_exit_command(_options = {})
@@ -145,28 +157,49 @@ module RubyJard
       process_commands
     end
 
-    def up_n_frames(current_frame, times)
-      next_frame = current_frame
+    def handle_switch_filter_command(_options = {})
+      index = RubyJard::PathFilter::FILTERS.index(@config.filter) || -1
+      index = (index + 1) % RubyJard::PathFilter::FILTERS.length
+      @config.filter = RubyJard::PathFilter::FILTERS[index]
+
+      process_commands
+    end
+
+    def up_n_frames(real_pos, times)
+      next_frame = real_pos
       times.times do
-        next_frame = [next_frame + 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 = [next_frame + 1, RubyJard::Session.current_backtrace.length - 1].min
+        while next_frame < RubyJard::Session.current_backtrace.length &&
+              (
+                RubyJard::Session.current_backtrace[next_frame].c_frame? ||
+                RubyJard::Session.current_backtrace[next_frame].hidden?
+              )
           next_frame += 1
         end
+        return real_pos if next_frame >= RubyJard::Session.current_backtrace.length
       end
       next_frame
     end
 
-    def down_n_frames(current_frame, times)
-      next_frame = current_frame
+    def down_n_frames(real_pos, times)
+      next_frame = real_pos
       times.times do
         next_frame = [next_frame - 1, 0].max
-        while Byebug::Frame.new(Byebug.current_context, next_frame).c_frame? &&
-              next_frame > 0
+        while next_frame >= 0 &&
+              (
+                RubyJard::Session.current_backtrace[next_frame].c_frame? ||
+                RubyJard::Session.current_backtrace[next_frame].hidden?
+              )
+
           next_frame -= 1
         end
+        return real_pos if next_frame < 0
       end
       next_frame
     end
+
+    def find_frame(virtual_pos)
+      RubyJard::Session.current_backtrace.find { |frame| frame.virtual_pos == virtual_pos }
+    end
   end
 end

data/lib/ruby_jard/row_renderer.rb

@@ -30,7 +30,8 @@ module RubyJard
         @drawing_lines = 1
 
         column.spans.each do |span|
-          render_span(column, span)
+          to_continue = render_span(column, span)
+          break unless to_continue
         end
 
         @original_x += column.width
@@ -61,7 +62,7 @@ module RubyJard
             @x = @original_x
           end
         elsif column.content_width - @drawing_width <= 0
-          return
+          return false
         end
         drawing_content = line_content[0..column.content_width - @drawing_width - 1]
         line_content = line_content[column.content_width - @drawing_width..-1]
@@ -73,11 +74,12 @@ module RubyJard
            !line_content.empty?
           drawing_content[drawing_content.length - ELLIPSIS.length..-1] = ELLIPSIS
           draw_content(drawing_content, span.styles)
-          return
+          return false
         else
           draw_content(drawing_content, span.styles)
         end
       end
+      true
     end
     # rubocop:enable Metrics/MethodLength
 

data/lib/ruby_jard/screen.rb

@@ -8,8 +8,8 @@ module RubyJard
   class Screen
     attr_accessor :layout, :rows, :window, :cursor, :selected
 
-    def initialize(session: nil, layout:)
-      @session = session || RubyJard.current_session
+    def initialize(layout, session: nil)
+      @session = session || RubyJard::Session
       @layout = layout
       @window = []
       @cursor = nil

data/lib/ruby_jard/screen_manager.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'tempfile'
 require 'ruby_jard/console'
 
 require 'ruby_jard/decorators/color_decorator'
@@ -30,7 +29,7 @@ module RubyJard
     class << self
       extend Forwardable
 
-      def_delegators :instance, :update, :puts, :draw_error, :started?, :updating?
+      def_delegators :instance, :draw_screens, :puts, :draw_error, :start, :stop, :started?, :updating?
 
       def instance
         @instance ||= new
@@ -44,7 +43,6 @@ module RubyJard
       @screens = {}
       @started = false
       @updating = false
-      @output_storage = Tempfile.new('jard')
     end
 
     def start
@@ -52,21 +50,8 @@ module RubyJard
 
       # Load configurations
       RubyJard.config
-      RubyJard::Console.start_alternative_terminal(@output)
       RubyJard::Console.clear_screen(@output)
 
-      # rubocop:disable Lint/NestedMethodDefinition
-      def $stdout.write(*string, from_jard: false)
-        # NOTE: `RubyJard::ScreenManager.instance` is a must. Jard doesn't work well with delegator
-        # TODO: Debug and fix the issues permanently
-        if !RubyJard::ScreenManager.instance.updating? && RubyJard::ScreenManager.instance.started? && !from_jard
-          RubyJard::ScreenManager.instance.output_storage.write(*string)
-        end
-        super(*string)
-      end
-      # rubocop:enable Lint/NestedMethodDefinition
-
-      at_exit { stop }
       @started = true
     end
 
@@ -83,21 +68,16 @@ module RubyJard
 
       @started = false
 
-      RubyJard::Console.stop_alternative_terminal(@output)
       RubyJard::Console.cooked!
       RubyJard::Console.enable_echo!
       RubyJard::Console.enable_cursor!
-
-      @output_storage.rewind
-      @output.write @output_storage.read until @output_storage.eof?
-      @output_storage.close
-      @output_storage.unlink
     end
 
-    def update
+    def draw_screens
       start unless started?
       @updating = true
 
+      RubyJard::Console.clear_screen(@output)
       RubyJard::Console.disable_cursor!
       width, height = RubyJard::Console.screen_size(@output)
 
@@ -107,7 +87,13 @@ module RubyJard
       RubyJard::Console.move_to(@output, 0, 0)
 
       draw_box(@screens)
-      draw_screens(@screens)
+      @screens.each do |screen|
+        RubyJard::ScreenDrawer.new(
+          output: @output,
+          screen: screen,
+          color_scheme: pick_color_scheme
+        ).draw
+      end
 
       RubyJard::Console.move_to(@output, 0, total_screen_height(@layouts) + 1)
       RubyJard::Console.clear_screen_to_end(@output)
@@ -139,6 +125,7 @@ module RubyJard
         @output.puts exception.backtrace.first(10)
       end
       @output.puts '-------------'
+      RubyJard.error(exception)
     end
 
     def puts(content)
@@ -159,7 +146,7 @@ module RubyJard
     def build_screens(layouts)
       screens = layouts.map do |layout|
         screen_class = fetch_screen(layout.template.screen)
-        screen = screen_class.new(layout: layout)
+        screen = screen_class.new(layout)
         screen.build
         render_screen(screen)
         screen
@@ -167,7 +154,7 @@ module RubyJard
       RubyJard::ScreenAdjuster.new(screens).adjust
       layouts.map do |layout|
         screen_class = fetch_screen(layout.template.screen)
-        screen = screen_class.new(layout: layout)
+        screen = screen_class.new(layout)
         screen.build
         render_screen(screen)
         screen
@@ -182,16 +169,6 @@ module RubyJard
       ).draw
     end
 
-    def draw_screens(screens)
-      screens.each do |screen|
-        RubyJard::ScreenDrawer.new(
-          output: @output,
-          screen: screen,
-          color_scheme: pick_color_scheme
-        ).draw
-      end
-    end
-
     def render_screen(screen)
       RubyJard::ScreenRenderer.new(
         screen: screen,