byebug 3.2.0 → 3.3.0

data/ext/byebug/byebug.h

@@ -66,16 +66,15 @@ extern void add_to_locked(VALUE thread);
 extern VALUE remove_from_locked();
 
 /* functions from threads.c */
-extern VALUE threads_create(void);
-extern void threads_clear(VALUE table);
-extern void check_thread_contexts(void);
+extern void Init_threads_table(VALUE mByebug);
+extern VALUE create_threads_table(void);
+extern void check_threads_table(void);
 extern void thread_context_lookup(VALUE thread, VALUE *context);
 extern void halt_while_other_thread_is_active(debug_context_t *dc);
 
 /* global variables */
 extern VALUE locker;
 extern VALUE threads;
-extern VALUE cThreadsTable;
 
 /* functions */
 extern void Init_context(VALUE mByebug);
@@ -117,11 +116,11 @@ typedef struct {
   enum hit_condition hit_condition;
 } breakpoint_t;
 
+extern void Init_breakpoint(VALUE mByebug);
 extern VALUE catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name);
 extern VALUE find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
                                     VALUE binding);
 extern VALUE find_breakpoint_by_method(VALUE breakpoints, VALUE klass,
                                        VALUE mid, VALUE binding, VALUE self);
-extern void Init_breakpoint(VALUE mByebug);
 
 #endif

data/ext/byebug/context.c

@@ -40,7 +40,7 @@ context_mark(void *data)
 static int
 real_stack_size()
 {
-  return FIX2INT(rb_funcall(cContext, rb_intern("stack_size"), 1, Qtrue));
+  return FIX2INT(rb_funcall(cContext, rb_intern("stack_size"), 0));
 }
 
 extern VALUE
@@ -182,25 +182,19 @@ call_with_debug_inspector(struct call_with_inspection_data *data)
                    close_debug_inspector, (VALUE)data);
 }
 
-#define FRAME_SETUP                                                   \
-  debug_context_t *context;                                           \
-  VALUE frame_no;                                                     \
-  int frame_n, stack_size;                                            \
-  Data_Get_Struct(self, debug_context_t, context);                    \
-  if (!rb_scan_args(argc, argv, "01", &frame_no))                     \
-    frame_n = 0;                                                      \
-  else                                                                \
-    frame_n = FIX2INT(frame_no);                                      \
-  stack_size = real_stack_size();                                     \
-  if (frame_n < 0 || frame_n >= stack_size)                           \
-  {                                                                   \
-    rb_raise(rb_eArgError, "Invalid frame number %d, stack (0...%d)", \
-             frame_n, stack_size - 1);                                \
-  }                                                                   \
+#define FRAME_SETUP                                \
+  debug_context_t *context;                        \
+  VALUE frame_no;                                  \
+  int frame_n;                                     \
+  Data_Get_Struct(self, debug_context_t, context); \
+  if (!rb_scan_args(argc, argv, "01", &frame_no))  \
+    frame_n = 0;                                   \
+  else                                             \
+    frame_n = FIX2INT(frame_no);
 
 /*
  *  call-seq:
- *    context.frame_binding(frame_position=0) -> binding
+ *    context.frame_binding(frame_position = 0) -> binding
  *
  *  Returns frame's binding.
  */
@@ -214,7 +208,7 @@ Context_frame_binding(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.frame_class(frame_position=0) -> binding
+ *    context.frame_class(frame_position = 0) -> binding
  *
  *  Returns frame's defined class.
  */
@@ -228,7 +222,7 @@ Context_frame_class(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.frame_file(frame_position=0) -> string
+ *    context.frame_file(frame_position = 0) -> string
  *
  *  Returns the name of the file in the frame.
  */
@@ -418,32 +412,32 @@ Context_step_into(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.step_out(frame)
+ *    context.step_out(n_frames = 1, force = false)
  *
- *  Stops after +n_frames+ frames are finished. Implements +finish+ and
- *  +next+ commands. +force+ parameter (if true) ensures that the cursor will
- *  stop in the specified frame even when there's no more instructions to run.
- *  In that case, it will stop when the return event for that frame is
- *  triggered.
+ *  Stops after +n_frames+ frames are finished. +force+ parameter (if true)
+ *  ensures that the execution will stop in the specified frame even when there
+ *  are no more instructions to run. In that case, it will stop when the return
+ *  event for that frame is triggered.
  */
 static VALUE
 Context_step_out(int argc, VALUE *argv, VALUE self)
 {
   int n_args, n_frames;
-  VALUE v_frames, v_force;
+  VALUE v_frames, force;
   debug_context_t *context;
 
-  n_args = rb_scan_args(argc, argv, "02", &v_frames, &v_force);
+  n_args = rb_scan_args(argc, argv, "02", &v_frames, &force);
   n_frames = n_args == 0 ? 1 : FIX2INT(v_frames);
-  v_force = (n_args < 2) ? Qfalse : v_force;
 
   Data_Get_Struct(self, debug_context_t, context);
 
   if (n_frames < 0 || n_frames >= context->calced_stack_size)
-    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+    rb_raise(rb_eRuntimeError,
+             "You wan't to finish %d frames, but stack size is only %d",
+             n_frames, context->calced_stack_size);
 
   context->steps_out = n_frames;
-  if (RTEST(v_force))
+  if (n_args == 2 && RTEST(force))
     CTX_FL_SET(context, CTX_FL_STOP_ON_RET);
   else
     CTX_FL_UNSET(context, CTX_FL_STOP_ON_RET);
@@ -453,17 +447,18 @@ Context_step_out(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.step_over(lines, frame = nil, force = false)
+ *    context.step_over(lines, frame = 0, force = false)
  *
  *  Steps over +lines+ lines.
- *  Make step over operation on +frame+, by default the current frame.
+ *  Make step over operation on +frame+, by default the newest frame.
  *  +force+ parameter (if true) ensures that the cursor moves away from the
  *  current line.
  */
 static VALUE
 Context_step_over(int argc, VALUE *argv, VALUE self)
 {
-  VALUE lines, frame, force;
+  int n_args, frame;
+  VALUE lines, v_frame, force;
   debug_context_t *context;
 
   Data_Get_Struct(self, debug_context_t, context);
@@ -471,14 +466,18 @@ Context_step_over(int argc, VALUE *argv, VALUE self)
   if (context->calced_stack_size == 0)
     rb_raise(rb_eRuntimeError, "No frames collected.");
 
-  rb_scan_args(argc, argv, "12", &lines, &frame, &force);
-  if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->calced_stack_size)
-    rb_raise(rb_eRuntimeError, "Destination frame is out of range.");
+  n_args = rb_scan_args(argc, argv, "12", &lines, &v_frame, &force);
+  frame = n_args == 1 ? 0 : FIX2INT(v_frame);
+
+  if (frame < 0 || frame >= context->calced_stack_size)
+    rb_raise(rb_eRuntimeError,
+             "Destination frame (%d) is out of range (%d)",
+             frame, context->calced_stack_size);
 
   context->lines = FIX2INT(lines);
-  context->dest_frame = context->calced_stack_size - FIX2INT(frame);
+  context->dest_frame = context->calced_stack_size - frame;
 
-  if (RTEST(force))
+  if (n_args == 3 && RTEST(force))
     CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
   else
     CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
@@ -597,7 +596,6 @@ Context_set_tracing(VALUE self, VALUE value)
   return value;
 }
 
-
 /* :nodoc: */
 static VALUE
 DebugThread_inherited(VALUE klass)

data/ext/byebug/threads.c

@@ -1,5 +1,8 @@
 #include <byebug.h>
 
+/* Threads table class */
+static VALUE cThreadsTable;
+
 static int
 t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
 {
@@ -29,8 +32,12 @@ t_tbl_free(void* data)
   xfree(t_tbl);
 }
 
+/*
+ *  Creates a numeric hash whose keys are the currently active threads and
+ *  whose values are their associated contexts.
+ */
 VALUE
-threads_create(void)
+create_threads_table(void)
 {
   threads_table_t *t_tbl;
 
@@ -39,42 +46,42 @@ threads_create(void)
   return Data_Wrap_Struct(cThreadsTable, t_tbl_mark, t_tbl_free, t_tbl);
 }
 
-void
-threads_clear(VALUE table)
-{
-  threads_table_t *t_tbl;
-
-  Data_Get_Struct(table, threads_table_t, t_tbl);
-  st_clear(t_tbl->tbl);
-}
-
+/*
+ *  The condition to be in the thread's table is to be either running or
+ *  sleeping, namely, to be Thread#alive?
+ */
 static int
 is_living_thread(VALUE thread)
 {
   return rb_funcall(thread, rb_intern("alive?"), 0) == Qtrue;
 }
 
+/*
+ *  Checks a single entry in the threads table.
+ *
+ *  If it has no associated context or the key doesn't correspond to a living
+ *  thread, the entry is removed from the thread's list.
+ */
 static int
-t_tbl_check_i(st_data_t key, st_data_t value, st_data_t dummy)
+check_thread_i(st_data_t key, st_data_t value, st_data_t dummy)
 {
-  VALUE thread;
-
   if (!value) return ST_DELETE;
 
-  thread = (VALUE)key;
-
-  if (!is_living_thread(thread)) return ST_DELETE;
+  if (!is_living_thread((VALUE)key)) return ST_DELETE;
 
   return ST_CONTINUE;
 }
 
+/*
+ *  Checks threads table for dead/finished threads.
+ */
 void
-check_thread_contexts(void)
+check_threads_table(void)
 {
   threads_table_t *t_tbl;
 
   Data_Get_Struct(threads, threads_table_t, t_tbl);
-  st_foreach(t_tbl->tbl, t_tbl_check_i, 0);
+  st_foreach(t_tbl->tbl, check_thread_i, 0);
 }
 
 void
@@ -111,3 +118,17 @@ halt_while_other_thread_is_active(debug_context_t *dc)
     else break;
   }
 }
+
+/*
+ *
+ *    Document-class: ThreadsTable
+ *
+ *    == Sumary
+ *
+ *    Hash table holding currently active threads and their associated contexts
+ */
+void
+Init_threads_table(VALUE mByebug)
+{
+  cThreadsTable = rb_define_class_under(mByebug, "ThreadsTable", rb_cObject);
+}

data/lib/byebug.rb

@@ -1,110 +1,2 @@
-require 'byebug/byebug'
-require 'byebug/version'
-require 'byebug/context'
-require 'byebug/interface'
-require 'byebug/processor'
-require 'byebug/setting'
-require 'byebug/remote'
-require 'stringio'
-require 'tracer'
-require 'linecache19'
-
-module Byebug
-
-  # List of files byebug will ignore while debugging
-  IGNORED_FILES = Dir.glob(File.expand_path('../**/*.rb', __FILE__))
-
-  # Configuration file used for startup commands. Default value is .byebugrc
-  INITFILE = '.byebugrc' unless defined?(INITFILE)
-
-  # Stores program being debugged to make restarts possible
-  PROG_SCRIPT = $0 unless defined?(PROG_SCRIPT)
-
-  class << self
-
-    # processor modules provide +handler+ object
-    attr_accessor :handler
-    Byebug.handler = CommandProcessor.new
-
-    def source_reload
-      hsh = 'SCRIPT_LINES__'
-      Object.send(:remove_const, hsh) if Object.const_defined?(hsh)
-      Object.const_set(hsh, {})
-    end
-
-    #
-    # Add a new breakpoint
-    #
-    # @param [String] file
-    # @param [Fixnum] line
-    # @param [String] expr
-    #
-    def add_breakpoint(file, line, expr=nil)
-      breakpoint = Breakpoint.new(file, line, expr)
-      breakpoints << breakpoint
-      breakpoint
-    end
-
-    #
-    # Remove a breakpoint
-    #
-    # @param [integer] breakpoint number
-    #
-    def remove_breakpoint(id)
-      breakpoints.reject! { |b| b.id == id }
-    end
-
-    def interface=(value)
-      handler.interface = value
-    end
-
-    extend Forwardable
-    def_delegators :"handler.interface", :print
-
-    #
-    # Runs normal byebug initialization scripts.
-    #
-    # Reads and executes the commands from init file (if any) in the current
-    # working directory.  This is only done if the current directory is
-    # different from your home directory.  Thus, you can have more than one init
-    # file, one generic in your home directory, and another, specific to the
-    # program you are debugging, in the directory where you invoke byebug.
-    #
-    def run_init_script(out = handler.interface)
-      cwd_script  = File.expand_path(File.join(".", INITFILE))
-      run_script(cwd_script, out) if File.exist?(cwd_script)
-
-      home_script = File.expand_path(File.join(ENV['HOME'].to_s, INITFILE))
-      if File.exist?(home_script) and cwd_script != home_script
-        run_script(home_script, out)
-      end
-    end
-
-    #
-    # Runs a script file
-    #
-    def run_script(file, out = handler.interface, verbose=false)
-      interface = ScriptInterface.new(File.expand_path(file), out)
-      processor = ControlCommandProcessor.new(interface)
-      processor.process_commands(verbose)
-    end
-  end
-end
-
-class Exception
-  attr_reader :__bb_file, :__bb_line, :__bb_binding, :__bb_context
-end
-
-module Kernel
-  #
-  # Enters byebug right before (or right after if _before_ is false) return
-  # events occur. Before entering byebug the init script is read.
-  #
-  def byebug(steps_out = 1, before = true)
-    Byebug.run_init_script(StringIO.new)
-    Byebug.start
-    Byebug.current_context.step_out(steps_out, before)
-  end
-
-  alias_method :debugger, :byebug
-end
+require 'byebug/core'
+require 'byebug/attacher'

data/lib/byebug/attacher.rb

@@ -0,0 +1,23 @@
+module Byebug
+  # Stores program being debugged to make restarts possible
+  PROG_SCRIPT = $PROGRAM_NAME unless defined?(PROG_SCRIPT)
+end
+
+#
+# Adds a `byebug` method to the Kernel module.
+#
+# Dropping a `byebug` call anywhere in your code, you get a debug prompt.
+#
+module Kernel
+  #
+  # Enters byebug right before (or right after if _before_ is false) return
+  # events occur. Before entering byebug the init script is read.
+  #
+  def byebug(steps_out = 1, before = true)
+    Byebug.start
+    Byebug.run_init_script(StringIO.new)
+    Byebug.current_context.step_out(steps_out, before)
+  end
+
+  alias_method :debugger, :byebug
+end

data/lib/byebug/breakpoint.rb

@@ -0,0 +1,60 @@
+module Byebug
+  #
+  # Implements breakpoints
+  #
+  class Breakpoint
+    #
+    # First breakpoint, in order of creation
+    #
+    def self.first
+      Byebug.breakpoints.first
+    end
+
+    #
+    # Last breakpoint, in order of creation
+    #
+    def self.last
+      Byebug.breakpoints.last
+    end
+
+    #
+    # Adds a new breakpoint
+    #
+    # @param [String] file
+    # @param [Fixnum] line
+    # @param [String] expr
+    #
+    def self.add(file, line, expr = nil)
+      breakpoint = Breakpoint.new(file, line, expr)
+      Byebug.breakpoints << breakpoint
+      breakpoint
+    end
+
+    #
+    # Removes a breakpoint
+    #
+    # @param [integer] breakpoint number
+    #
+    def self.remove(id)
+      Byebug.breakpoints.reject! { |b| b.id == id }
+    end
+
+    #
+    # True if there's no breakpoints
+    #
+    def self.none?
+      Byebug.breakpoints.empty?
+    end
+
+    #
+    # Prints all information associated to the breakpoint
+    #
+    def inspect
+      meths = %w(id pos source expr hit_condition hit_count hit_value enabled?)
+      values = meths.map do |field|
+        "#{field}: #{send(field)}"
+      end.join(', ')
+      "#<Byebug::Breakpoint #{values}>"
+    end
+  end
+end