ruby_jard 0.1.0 → 0.3.0

data/lib/ruby_jard/path_filter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RubyJard
+  ##
+  # Check whether a particular path should be passed when debugging.
+  # Filtering is based on path classification (from PathClassifier),
+  # program's current filter mode, and filter included, excluded.
+  class PathFilter
+    FILTERS = [
+      FILTER_SOURCE_TREE = :source_tree,
+      FILTER_APPLICATION = :application,
+      FILTER_GEMS = :gems,
+      FILTER_EVERYTHING = :everything
+    ].freeze
+    def initialize(config: nil, path_classifier: nil)
+      @config = config || RubyJard.config
+      @path_classifier = path_classifier || RubyJard::PathClassifier.new
+    end
+
+    def match?(path)
+      case @config.filter
+      when FILTER_EVERYTHING
+        match_everything?(path)
+      when FILTER_GEMS
+        match_gems?(path)
+      when FILTER_APPLICATION
+        match_application?(path)
+      when FILTER_SOURCE_TREE
+        match_source_tree?(path)
+      end
+    end
+
+    private
+
+    def match_everything?(path)
+      return true if @config.filter_excluded.empty?
+
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_STDLIB
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      else
+        true
+      end
+    end
+
+    def match_gems?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM
+        !match_excluded?(info[0], expand_path: false) && !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT, RubyJard::PathClassifier::TYPE_EVALUATION
+        true
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_application?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE, RubyJard::PathClassifier::TYPE_UNKNOWN
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_GEM, RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT
+        true
+      when RubyJard::PathClassifier::TYPE_EVALUATION
+        false
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_source_tree?(path)
+      type, *info = @path_classifier.classify(path)
+
+      case type
+      when RubyJard::PathClassifier::TYPE_SOURCE_TREE
+        !match_excluded?(path)
+      when RubyJard::PathClassifier::TYPE_UNKNOWN
+        match_included?(path)
+      when RubyJard::PathClassifier::TYPE_GEM, RubyJard::PathClassifier::TYPE_STDLIB
+        match_included?(info[0], expand_path: false) || match_included?(path)
+      when RubyJard::PathClassifier::TYPE_RUBY_SCRIPT
+        true
+      when RubyJard::PathClassifier::TYPE_EVALUATION
+        false
+      when RubyJard::PathClassifier::TYPE_INTERNAL
+        false
+      end
+    end
+
+    def match_excluded?(path, expand_path: true)
+      @config.filter_excluded.any? do |excluded|
+        if expand_path
+          File.fnmatch(File.expand_path(excluded), path)
+        else
+          File.fnmatch(excluded, path)
+        end
+      end
+    end
+
+    def match_included?(path, expand_path: true)
+      @config.filter_included.any? do |included|
+        if expand_path
+          File.fnmatch(File.expand_path(included), path)
+        else
+          File.fnmatch(included, path)
+        end
+      end
+    end
+  end
+end

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,143 +1,205 @@
 # 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'
+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/jard_command'
+
 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)
+    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
-      process_commands
+      process_commands_with_lock
     end
 
-    def at_return(_)
-      process_commands
+    def at_return(_return_value)
+      process_commands_with_lock
     end
 
     def at_end
-      process_commands
+      process_commands_with_lock
     end
 
     private
 
-    def process_commands
-      RubyJard.current_session.refresh
-      return_value = nil
+    def process_commands_with_lock
+      allowing_other_threads do
+        RubyJard::Session.lock do
+          RubyJard::Session.sync(@context)
+          unless RubyJard::Session.should_stop?
+            handle_flow(@previous_flow)
+            return
+          end
 
-      flow = catch(:control_flow) do
-        return_value = allowing_other_threads do
-          start_pry_session
+          process_commands
         end
-        {}
       end
+    end
+
+    def process_commands(redraw = true)
+      RubyJard::Session.sync(@context)
+      RubyJard::ScreenManager.draw_screens if redraw
+
+      return_value = nil
 
-      @pry = flow[:pry]
-      if @pry
-        @pry.binding_stack.clear
-        send("handle_#{flow[:command]}_command", @pry, flow[:options])
+      flow = RubyJard::ControlFlow.listen do
+        return_value = @repl_proxy.repl(frame._binding)
       end
 
+      handle_flow(flow)
+
       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_flow(flow)
+      return if flow.nil?
+
+      @previous_flow = flow
+      command = flow.command
+      send("handle_#{command}_command", flow.arguments)
     end
 
-    def handle_next_command(_pry_instance, _options)
-      Byebug::NextCommand.new(self, 'next').execute
+    def handle_next_command(options = {})
+      times = options[:times] || 1
+      RubyJard::Session.step_over(times)
     end
 
-    def handle_step_command(_pry_instance, _options)
-      Byebug::StepCommand.new(self, 'step').execute
+    def handle_step_command(options = {})
+      times = options[:times] || 1
+      RubyJard::Session.step_into(times)
     end
 
-    def handle_up_command(_pry_instance, _options)
-      Byebug::UpCommand.new(self, 'up 1').execute
+    def handle_step_out_command(options = {})
+      times = options[:times] || 1
 
+      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(RubyJard::Session.current_frame.real_pos, times)
+      RubyJard::Session.frame = next_frame
       process_commands
     end
 
-    def handle_down_command(_pry_instance, _options)
-      Byebug::DownCommand.new(self, 'down 1').execute
+    def handle_down_command(options = {})
+      times = options[:times] || 1
+      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 = 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
+        RubyJard::Session.frame = next_frame.real_pos
+        process_commands(true)
+      end
+    end
+
+    def handle_continue_command(_options = {})
+      RubyJard::ScreenManager.puts '▸▸ Program resumed ▸▸'
+      Byebug.stop if Byebug.stoppable?
+    end
+
+    def handle_exit_command(_options = {})
+      Kernel.exit
+    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
+
+    def handle_list_command(_options = {})
       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_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 handle_continue_command(_pry_instance, _options)
-      # Do nothing
+    def up_n_frames(real_pos, times)
+      next_frame = real_pos
+      times.times do
+        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 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
+    def down_n_frames(real_pos, times)
+      next_frame = real_pos
+      times.times do
+        next_frame = [next_frame - 1, 0].max
+        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 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 find_frame(virtual_pos)
+      RubyJard::Session.current_backtrace.find { |frame| frame.virtual_pos == virtual_pos }
     end
   end
 end