debug 1.0.0.beta7 → 1.0.0

data/lib/debug/{run.rb → start.rb}

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'console'
+require_relative 'session'
 return unless defined?(DEBUGGER__)
 DEBUGGER__.start

data/lib/debug/thread_client.rb

@@ -7,6 +7,17 @@ require_relative 'frame_info'
 require_relative 'color'
 
 module DEBUGGER__
+  module SkipPathHelper
+    def skip_path?(path)
+      (skip_paths = CONFIG[:skip_path]) && skip_paths.any?{|skip_path| path.match?(skip_path)}
+    end
+
+    def skip_location?(loc)
+      loc_path = loc.absolute_path || "!eval:#{loc.path}"
+      skip_path?(loc_path)
+    end
+  end
+
   class ThreadClient
     def self.current
       Thread.current[:DEBUGGER__ThreadClient] || begin
@@ -16,8 +27,9 @@ module DEBUGGER__
     end
 
     include Color
+    include SkipPathHelper
 
-    attr_reader :location, :thread, :mode, :id
+    attr_reader :location, :thread, :id, :recorder
 
     def assemble_arguments(args)
       args.map do |arg|
@@ -54,14 +66,14 @@ module DEBUGGER__
       result = "#{call_identifier_str} at #{location_str}"
 
       if return_str = frame.return_str
-        return_str = colorize(frame.return_str, [:MAGENTA, :BOLD])
-        result += " #=> #{return_str}"
+        result += " #=> #{colorize_magenta(frame.return_str)}"
       end
 
       result
     end
 
     def initialize id, q_evt, q_cmd, thr = Thread.current
+      @is_management = false
       @id = id
       @thread = thr
       @target_frames = nil
@@ -71,11 +83,52 @@ module DEBUGGER__
       @output = []
       @frame_formatter = method(:default_frame_formatter)
       @var_map = {} # { thread_local_var_id => obj } for DAP
-      set_mode nil
+      @recorder = nil
+      @mode = :waiting
+      set_mode :running
+      thr.instance_variable_set(:@__thread_client_id, id)
 
       ::DEBUGGER__.info("Thread \##{@id} is created.")
     end
 
+    def deactivate
+      @step_tp.disable if @step_tp
+    end
+
+    def management?
+      @is_management
+    end
+
+    def is_management
+      @is_management = true
+    end
+
+    def set_mode mode
+      # STDERR.puts "#{@mode} => #{mode} @ #{caller.inspect}"
+      #pp caller
+
+      # mode transition check
+      case mode
+      when :running
+        raise "#{mode} is given, but #{mode}" unless self.waiting?
+      when :waiting
+        # TODO: there is waiting -> waiting
+        # raise "#{mode} is given, but #{mode}" unless self.running?
+      else
+        raise
+      end
+
+      @mode = mode
+    end
+
+    def running?
+      @mode == :running
+    end
+
+    def waiting?
+      @mode == :waiting
+    end
+
     def name
       "##{@id} #{@thread.name || @thread.backtrace.last}"
     end
@@ -85,17 +138,33 @@ module DEBUGGER__
     end
 
     def inspect
-      "#<DBG:TC #{self.id}:#{self.mode}@#{@thread.backtrace[-1]}>"
+      "#<DBG:TC #{self.id}:#{@mode}@#{@thread.backtrace[-1]}>"
+    end
+
+    def to_s
+      loc = current_frame&.location
+
+      if loc
+        str = "(#{@thread.name || @thread.status})@#{loc}"
+      else
+        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
+      end
+
+      str += " (not under control)" unless self.waiting?
+      str
     end
 
     def puts str = ''
+      if @recorder&.replaying?
+        prefix = colorize_dim("[replay] ")
+      end
       case str
       when nil
         @output << "\n"
       when Array
         str.each{|s| puts s}
       else
-        @output << str.chomp + "\n"
+        @output << "#{prefix}#{str.chomp}\n"
       end
     end
 
@@ -116,40 +185,61 @@ module DEBUGGER__
 
     ## events
 
-    def on_trap sig
-      if self.mode == :wait_next_action
-        # raise Interrupt
-      else
-        on_suspend :trap, sig: sig
-      end
-    end
+    def wait_reply event_arg
+      return if management?
 
-    def on_pause
-      on_suspend :pause
+      set_mode :waiting
+
+      event!(*event_arg)
+      wait_next_action
     end
 
     def on_thread_begin th
-      event! :thread_begin, th
-      wait_next_action
+      wait_reply [:thread_begin, th]
     end
 
     def on_load iseq, eval_src
-      event! :load, iseq, eval_src
-      wait_next_action
+      wait_reply [:load, iseq, eval_src]
     end
 
     def on_init name
-      event! :init, name
-      wait_next_action
+      wait_reply [:init, name]
+    end
+
+    def on_trace trace_id, msg
+      wait_reply [:trace, trace_id, msg]
     end
 
     def on_breakpoint tp, bp
-      on_suspend tp.event, tp, bp: bp
+      suspend tp.event, tp, bp: bp
     end
 
-    def on_suspend event, tp = nil, bp: nil, sig: nil
+    def on_trap sig
+      if waiting?
+        # raise Interrupt
+      else
+        suspend :trap, sig: sig
+      end
+    end
+
+    def on_pause
+      suspend :pause
+    end
+
+    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil
+      return if management?
+
       @current_frame_index = 0
-      @target_frames = DEBUGGER__.capture_frames __dir__
+
+      case
+      when postmortem_frames
+        @target_frames = postmortem_frames
+        @postmortem = true
+      when replay_frames
+        @target_frames = replay_frames
+      else
+        @target_frames = DEBUGGER__.capture_frames(__dir__)
+      end
 
       cf = @target_frames.first
       if cf
@@ -167,8 +257,10 @@ module DEBUGGER__
       end
 
       if event != :pause
-        show_src max_lines: (::DEBUGGER__::CONFIG[:show_src_lines] || 10)
-        show_frames ::DEBUGGER__::CONFIG[:show_frames] || 2
+        show_src max_lines: (CONFIG[:show_src_lines] || 10)
+        show_frames CONFIG[:show_frames] || 2
+
+        set_mode :waiting
 
         if bp
           event! :suspend, :breakpoint, bp.key
@@ -177,11 +269,18 @@ module DEBUGGER__
         else
           event! :suspend, event
         end
+      else
+        set_mode :waiting
       end
 
       wait_next_action
     end
 
+    def replay_suspend
+      # @recorder.current_position
+      suspend :replay, replay_frames: @recorder.current_frame
+    end
+
     ## control all
 
     begin
@@ -191,41 +290,77 @@ module DEBUGGER__
       SUPPORT_TARGET_THREAD = false
     end
 
-    def step_tp
+    def step_tp iter
       @step_tp.disable if @step_tp
 
       thread = Thread.current
 
       if SUPPORT_TARGET_THREAD
         @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
-          next if SESSION.break? tp.path, tp.lineno
+          next if SESSION.break_at? tp.path, tp.lineno
           next if !yield
           next if tp.path.start_with?(__dir__)
-          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+          next if tp.path.start_with?('<internal:trace_point>')
+          next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+          next if iter && (iter -= 1) > 0
 
           tp.disable
-          on_suspend tp.event, tp
+          suspend tp.event, tp
         }
         @step_tp.enable(target_thread: thread)
       else
         @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
           next if thread != Thread.current
-          next if SESSION.break? tp.path, tp.lineno
+          next if SESSION.break_at? tp.path, tp.lineno
           next if !yield
-          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+          next if tp.path.start_with?(__dir__)
+          next if tp.path.start_with?('<internal:trace_point>')
+          next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+          next if iter && (iter -= 1) > 0
 
           tp.disable
-          on_suspend tp.event, tp
+          suspend tp.event, tp
         }
         @step_tp.enable
       end
     end
 
-    def current_frame
-      if @target_frames
-        @target_frames[@current_frame_index]
-      else
-        nil
+    ## cmd helpers
+
+    # this method is extracted to hide frame_eval's local variables from C method eval's binding
+    def instance_eval_for_cmethod frame_self, src
+      frame_self.instance_eval(src)
+    end
+
+    def frame_eval src, re_raise: false
+      begin
+        @success_last_eval = false
+
+        b = current_frame.eval_binding
+        result = if b
+                   f, _l = b.source_location
+                   b.eval(src, "(rdbg)/#{f}")
+                 else
+                   frame_self = current_frame.self
+                   instance_eval_for_cmethod(frame_self, src)
+                 end
+        @success_last_eval = true
+        result
+
+      rescue Exception => e
+        return yield(e) if block_given?
+
+        puts "eval error: #{e}"
+
+        e.backtrace_locations&.each do |loc|
+          break if loc.path == __FILE__
+          puts "  #{loc}"
+        end
+        raise if re_raise
       end
     end
 
@@ -240,11 +375,9 @@ module DEBUGGER__
           frame_line = frame.location.lineno - 1
 
           lines = file_lines.map.with_index do |e, i|
-            if i == frame_line
-              "=> #{'%4d' % (i+1)}| #{e}"
-            else
-              "   #{'%4d' % (i+1)}| #{e}"
-            end
+            cur = i == frame_line ? '=>' : '  '
+            line = colorize_dim('%4d|' % (i+1))
+            "#{cur}#{line} #{e}"
           end
 
           unless start_line
@@ -282,113 +415,138 @@ module DEBUGGER__
       exit!
     end
 
-    def show_by_editor path = nil
-      unless path
-        if @target_frames && frame = @target_frames[@current_frame_index]
-          path = frame.path
-        else
-          return # can't get path
-        end
-      end
-
-      if File.exist?(path)
-        if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
-          puts "command: #{editor}"
-          puts "   path: #{path}"
-          system(editor, path)
-        else
-          puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
-        end
+    def current_frame
+      if @target_frames
+        @target_frames[@current_frame_index]
       else
-        puts "Can not find file: #{path}"
+        nil
       end
     end
 
-    def puts_variable_info label, obj
-      info = "#{colorize_cyan(label)} => #{colored_inspect(obj)}".lines
-      w = SESSION.width
-      max_inspect_lines = CONFIG[:show_inspect_lines] || 10
+    ## cmd: show
 
-      if (max_inspect_lines > 0 && (info.size > max_inspect_lines)) || info.any?{|l| l.size > w}
-        info = "#{colorize_cyan(label)} => #{colored_inspect(obj, no_color: true)}".lines
-        if max_inspect_lines > 0 && info.size > max_inspect_lines
-          info = info.first(max_inspect_lines - 2) +
-                 ["...(#{info.size - (max_inspect_lines - 1)} lines)\n" + info.last]
-        end
-        info.map!{|l|
-          l.length > w ? l[0..(w-4)] + '...' : l
-        }
-      end
-
-      puts info
-    end
-
-    def show_locals
+    def show_locals pat
       if s = current_frame&.self
-        puts_variable_info '%self', s
+        puts_variable_info '%self', s, pat
       end
       if current_frame&.has_return_value
-        puts_variable_info '%return', current_frame.return_value
+        puts_variable_info '%return', current_frame.return_value, pat
       end
       if current_frame&.has_raised_exception
-        puts_variable_info "%raised", current_frame.raised_exception
+        puts_variable_info "%raised", current_frame.raised_exception, pat
       end
-      if b = current_frame&.binding
-        b.local_variables.each{|loc|
-          value = b.local_variable_get(loc)
-          puts_variable_info loc, value
+
+      if vars = current_frame&.local_variables
+        vars.each{|var, val|
+          puts_variable_info var, val, pat
         }
       end
     end
 
-    def show_ivars
+    def show_ivars pat
       if s = current_frame&.self
-        s.instance_variables.each{|iv|
+        s.instance_variables.sort.each{|iv|
           value = s.instance_variable_get(iv)
-          puts_variable_info iv, value
+          puts_variable_info iv, value, pat
         }
       end
     end
 
-    def instance_eval_for_cmethod frame_self, src
-      frame_self.instance_eval(src)
+    def show_consts pat, only_self: false
+      if s = current_frame&.self
+        cs = {}
+        if s.kind_of? Module
+          cs[s] = :self
+        else
+          s = s.class
+          cs[s] = :self unless only_self
+        end
+
+        unless only_self
+          s.ancestors.each{|c| break if c == Object; cs[c] = :ancestors}
+          if b = current_frame&.binding
+            b.eval('Module.nesting').each{|c| cs[c] = :nesting unless cs.has_key? c}
+          end
+        end
+
+        names = {}
+
+        cs.each{|c, _|
+          c.constants(false).sort.each{|name|
+            next if names.has_key? name
+            names[name] = nil
+            value = c.const_get(name)
+            puts_variable_info name, value, pat
+          }
+        }
+      end
     end
 
-    def frame_eval src, re_raise: false
-      begin
-        @success_last_eval = false
+    SKIP_GLOBAL_LIST = %i[$= $KCODE $-K $SAFE].freeze
+    def show_globals pat
+      global_variables.sort.each{|name|
+        next if SKIP_GLOBAL_LIST.include? name
 
-        b = current_frame.binding
-        result = if b
-                   f, _l = b.source_location
-                   b.eval(src, "(rdbg)/#{f}")
-                 else
-                   frame_self = current_frame.self
-                   instance_eval_for_cmethod(frame_self, src)
-                 end
-        @success_last_eval = true
-        result
+        value = eval(name.to_s)
+        puts_variable_info name, value, pat
+      }
+    end
+
+    def puts_variable_info label, obj, pat
+      return if pat && pat !~ label
 
+      begin
+        inspected = obj.inspect
       rescue Exception => e
-        return yield(e) if block_given?
+        inspected = e.inspect
+      end
+      mono_info = "#{label} = #{inspected}"
 
-        puts "eval error: #{e}"
+      w = SESSION::width
 
-        e.backtrace_locations.each do |loc|
-          break if loc.path == __FILE__
-          puts "  #{loc}"
-        end
-        raise if re_raise
+      if mono_info.length >= w
+        info = truncate(mono_info, width: w)
+      else
+        valstr = colored_inspect(obj, width: 2 ** 30)
+        valstr = inspected if valstr.lines.size > 1
+        info = "#{colorize_cyan(label)} = #{valstr}"
       end
+
+      puts info
     end
 
-    def frame_str(i, frame: @target_frames[i])
-      cur_str = (@current_frame_index == i ? '=>' : '  ')
-      prefix = "#{cur_str}##{i}"
-      frame_string = @frame_formatter.call(frame)
-      "#{prefix}\t#{frame_string}"
+    def truncate(string, width:)
+      str = string[0 .. (width-4)] + '...'
+      str += ">" if str.start_with?("#<")
+      str
+    end
+
+    ### cmd: show edit
+
+    def show_by_editor path = nil
+      unless path
+        if @target_frames && frame = @target_frames[@current_frame_index]
+          path = frame.path
+        else
+          return # can't get path
+        end
+      end
+
+      if File.exist?(path)
+        if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
+          puts "command: #{editor}"
+          puts "   path: #{path}"
+          system(editor, path)
+        else
+          puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
+        end
+      else
+        puts "Can not find file: #{path}"
+      end
     end
 
+    ### cmd: show frames
+
     def show_frames max = nil, pattern = nil
       if @target_frames && (max ||= @target_frames.size) > 0
         frames = []
@@ -420,29 +578,60 @@ module DEBUGGER__
       puts frame_str(i)
     end
 
-    def show_object_info expr
+    def frame_str(i, frame: @target_frames[i])
+      cur_str = (@current_frame_index == i ? '=>' : '  ')
+      prefix = "#{cur_str}##{i}"
+      frame_string = @frame_formatter.call(frame)
+      "#{prefix}\t#{frame_string}"
+    end
+
+    ### cmd: show outline
+
+    def show_outline expr
       begin
-        result = frame_eval(expr, re_raise: true)
+        obj = frame_eval(expr, re_raise: true)
       rescue Exception
         # ignore
       else
-        klass = ObjectSpace.internal_class_of(result)
-        exists = []
-        klass.ancestors.each{|k|
-          puts "= #{k}"
-          if (ms = (k.instance_methods(false) - exists)).size > 0
-            puts ms.sort.join("\t")
-            exists |= ms
-          end
-        }
+        o = Output.new(@output)
+
+        locals = current_frame&.local_variables
+        klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
+
+        o.dump("constants", obj.constants) if obj.respond_to?(:constants)
+        outline_method(o, klass, obj)
+        o.dump("instance variables", obj.instance_variables)
+        o.dump("class variables", klass.class_variables)
+        o.dump("locals", locals.keys) if locals
       end
     end
 
+    def outline_method(o, klass, obj)
+      singleton_class = begin obj.singleton_class; rescue TypeError; nil end
+      maps = class_method_map((singleton_class || klass).ancestors)
+      maps.each do |mod, methods|
+        name = mod == singleton_class ? "#{klass}.methods" : "#{mod}#methods"
+        o.dump(name, methods)
+      end
+    end
+
+    def class_method_map(classes)
+      dumped = Array.new
+      classes.reject { |mod| mod >= Object }.map do |mod|
+        methods = mod.public_instance_methods(false).select do |m|
+          dumped.push(m) unless dumped.include?(m)
+        end
+        [mod, methods]
+      end.reverse
+    end
+
+    ## cmd: breakpoint
+
     def make_breakpoint args
       case args.first
       when :method
         klass_name, op, method_name, cond, cmd = args[1..]
-        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond, command: cmd)
+        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond: cond, command: cmd)
         begin
           bp.enable
         rescue Exception => e
@@ -459,28 +648,58 @@ module DEBUGGER__
       end
     end
 
-    def set_mode mode
-      @mode = mode
+    class SuspendReplay < Exception
     end
 
     def wait_next_action
-      set_mode :wait_next_action
+      wait_next_action_
+    rescue SuspendReplay
+      replay_suspend
+    end
 
-      SESSION.check_forked
+    def wait_next_action_
+      # assertions
+      raise "@mode is #{@mode}" unless @mode == :waiting
+
+      unless SESSION.active?
+        pp caller
+        set_mode :running
+        return
+      end
+      # SESSION.check_forked
 
-      while cmds = @q_cmd.pop
-        # pp [self, cmds: cmds]
+      while true
+        begin
+          set_mode :waiting if @mode != :waiting
+          cmds = @q_cmd.pop
+          # pp [self, cmds: cmds]
+          break unless cmds
+        ensure
+          set_mode :running
+        end
 
         cmd, *args = *cmds
 
         case cmd
         when :continue
           break
+
         when :step
           step_type = args[0]
+          iter = args[1]
+
           case step_type
           when :in
-            step_tp{true}
+            if @recorder&.replaying?
+              @recorder.step_forward
+              raise SuspendReplay
+            else
+              step_tp iter do
+                true
+              end
+              break
+            end
+
           when :next
             frame = @target_frames.first
             path = frame.location.absolute_path || "!eval:#{frame.path}"
@@ -496,7 +715,7 @@ module DEBUGGER__
 
             depth = @target_frames.first.frame_depth
 
-            step_tp{
+            step_tp iter do
               loc = caller_locations(2, 1).first
               loc_path = loc.absolute_path || "!eval:#{loc.path}"
 
@@ -507,17 +726,39 @@ module DEBUGGER__
               (next_line && loc_path == path &&
                (loc_lineno = loc.lineno) > line &&
                loc_lineno <= next_line)
-            }
+            end
+            break
+
           when :finish
             depth = @target_frames.first.frame_depth
-            step_tp{
+            step_tp iter do
               # 3 is debugger's frame count
               DEBUGGER__.frame_depth - 3 < depth
-            }
+            end
+            break
+
+          when :back
+            if @recorder&.can_step_back?
+              unless @recorder.backup_frames
+                @recorder.backup_frames = @target_frames
+              end
+              @recorder.step_back
+              raise SuspendReplay
+            else
+              puts "Can not step back more."
+              event! :result, nil
+            end
+
+          when :reset
+            if @recorder&.replaying?
+              @recorder.step_reset
+              raise SuspendReplay
+            end
+
           else
-            raise
+            raise "unknown: #{type}"
           end
-          break
+
         when :eval
           eval_type, eval_src = *args
 
@@ -526,11 +767,16 @@ module DEBUGGER__
           case eval_type
           when :p
             result = frame_eval(eval_src)
-            puts "=> " + result.inspect
+            puts "=> " + color_pp(result, 2 ** 30)
+            if alloc_path = ObjectSpace.allocation_sourcefile(result)
+              puts "allocated at #{alloc_path}:#{ObjectSpace.allocation_sourceline(result)}"
+            end
           when :pp
             result = frame_eval(eval_src)
-            puts "=> "
             puts color_pp(result, SESSION.width)
+            if alloc_path = ObjectSpace.allocation_sourcefile(result)
+              puts "allocated at #{alloc_path}:#{ObjectSpace.allocation_sourceline(result)}"
+            end
           when :call
             result = frame_eval(eval_src)
           when :display, :try_display
@@ -580,6 +826,7 @@ module DEBUGGER__
             raise "unsupported frame operation: #{arg.inspect}"
           end
           event! :result, nil
+
         when :show
           type = args.shift
 
@@ -594,20 +841,37 @@ module DEBUGGER__
           when :edit
             show_by_editor(args.first)
 
-          when :local
-            show_frame
-            show_locals
-            show_ivars
+          when :default
+            pat = args.shift
+            show_locals pat
+            show_ivars  pat
+            show_consts pat, only_self: true
+
+          when :locals
+            pat = args.shift
+            show_locals pat
+
+          when :ivars
+            pat = args.shift
+            show_ivars pat
 
-          when :object_info
-            expr = args.shift
-            show_object_info expr
+          when :consts
+            pat = args.shift
+            show_consts pat
+
+          when :globals
+            pat = args.shift
+            show_globals pat
+
+          when :outline
+            show_outline args.first || 'self'
 
           else
             raise "unknown show param: " + [type, *args].inspect
           end
 
           event! :result, nil
+
         when :breakpoint
           case args[0]
           when :method
@@ -630,6 +894,55 @@ module DEBUGGER__
               event! :result, nil
             end
           end
+
+        when :trace
+          case args.shift
+          when :object
+            begin
+              obj = frame_eval args.shift, re_raise: true
+              opt = args.shift
+              obj_inspect = obj.inspect
+
+              width = 50
+
+              if obj_inspect.length >= width
+                obj_inspect = truncate(obj_inspect, width: width)
+              end
+
+              event! :result, :trace_pass, obj.object_id, obj_inspect, opt
+            rescue => e
+              puts e.message
+              event! :result, nil
+            end
+          else
+            raise "unreachable"
+          end
+
+        when :record
+          case args[0]
+          when nil
+            # ok
+          when :on
+            # enable recording
+            if !@recorder
+              @recorder = Recorder.new
+              @recorder.enable
+            end
+          when :off
+            if @recorder&.enabled?
+              @recorder.disable
+            end
+          else
+            raise "unknown: #{args.inspect}"
+          end
+
+          if @recorder&.enabled?
+            puts "Recorder for #{Thread.current}: on (#{@recorder.log.size} records)"
+          else
+            puts "Recorder for #{Thread.current}: off"
+          end
+          event! :result, nil
+
         when :dap
           process_dap args
         else
@@ -637,26 +950,171 @@ module DEBUGGER__
         end
       end
 
-    rescue SystemExit
+    rescue SuspendReplay, SystemExit
       raise
     rescue Exception => e
       pp ["DEBUGGER Exception: #{__FILE__}:#{__LINE__}", e, e.backtrace]
       raise
-    ensure
-      set_mode nil
     end
 
-    def to_s
-      loc = current_frame&.location
+    class Recorder
+      attr_reader :log, :index
+      attr_accessor :backup_frames
+
+      include SkipPathHelper
+
+      def initialize
+        @log = []
+        @index = 0
+        @backup_frames = nil
+        thread = Thread.current
+
+        @tp_recorder ||= TracePoint.new(:line){|tp|
+          next unless Thread.current == thread
+          next if tp.path.start_with? __dir__
+          next if tp.path.start_with? '<internal:'
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+
+          frames = DEBUGGER__.capture_frames(__dir__)
+          frames.each{|frame|
+            if b = frame.binding
+              frame.binding = nil
+              frame._local_variables = b.local_variables.map{|name|
+                [name, b.local_variable_get(name)]
+              }.to_h
+              frame._callee = b.eval('__callee__')
+            end
+          }
+          @log << frames
+        }
+      end
 
-      if loc
-        str = "(#{@thread.name || @thread.status})@#{loc}"
-      else
-        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
+      def enable
+        unless @tp_recorder.enabled?
+          @log.clear
+          @tp_recorder.enable
+        end
       end
 
-      str += " (not under control)" unless self.mode
-      str
+      def disable
+        if @tp_recorder.enabled?
+          @log.clear
+          @tp_recorder.disable
+        end
+      end
+
+      def enabled?
+        @tp_recorder.enabled?
+      end
+
+      def step_back
+        @index += 1
+      end
+
+      def step_forward
+        @index -= 1
+      end
+
+      def step_reset
+        @index = 0
+        @backup_frames = nil
+      end
+
+      def replaying?
+        @index > 0
+      end
+
+      def can_step_back?
+        log.size > @index
+      end
+
+      def log_index
+        @log.size - @index
+      end
+
+      def current_frame
+        if @index == 0
+          f = @backup_frames
+          @backup_frames = nil
+          f
+        else
+          frames = @log[log_index]
+          frames
+        end
+      end
+
+      # for debugging
+      def current_position
+        puts "INDEX: #{@index}"
+        li = log_index
+        @log.each_with_index{|frame, i|
+          loc = frame.first&.location
+          prefix = i == li ? "=> " : '   '
+          puts "#{prefix} #{loc}"
+        }
+      end
+    end
+
+    # copyed from irb
+    class Output
+      include Color
+
+      MARGIN = "  "
+
+      def initialize(output)
+        @output = output
+        @line_width = screen_width - MARGIN.length # right padding
+      end
+
+      def dump(name, strs)
+        strs = strs.sort
+        return if strs.empty?
+
+        line = "#{colorize_blue(name)}: "
+
+        # Attempt a single line
+        if fits_on_line?(strs, cols: strs.size, offset: "#{name}: ".length)
+          line += strs.join(MARGIN)
+          @output << line
+          return
+        end
+
+        # Multi-line
+        @output << line
+
+        # Dump with the largest # of columns that fits on a line
+        cols = strs.size
+        until fits_on_line?(strs, cols: cols, offset: MARGIN.length) || cols == 1
+          cols -= 1
+        end
+        widths = col_widths(strs, cols: cols)
+        strs.each_slice(cols) do |ss|
+          @output << ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
+        end
+      end
+
+      private
+
+      def fits_on_line?(strs, cols:, offset: 0)
+        width = col_widths(strs, cols: cols).sum + MARGIN.length * (cols - 1)
+        width <= @line_width - offset
+      end
+
+      def col_widths(strs, cols:)
+        cols.times.map do |col|
+          (col...strs.size).step(cols).map do |i|
+            strs[i].length
+          end.max
+        end
+      end
+
+      def screen_width
+        SESSION.width
+      rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
+        80
+      end
     end
+    private_constant :Output
   end
 end