byebug 9.0.5 → 11.1.3

data/ext/byebug/threads.c

@@ -14,12 +14,12 @@ t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
 {
   UNUSED(tbl);
 
-  rb_gc_mark((VALUE) key);
+  rb_gc_mark((VALUE)key);
 
   if (!value)
     return ST_CONTINUE;
 
-  rb_gc_mark((VALUE) value);
+  rb_gc_mark((VALUE)value);
 
   return ST_CONTINUE;
 }
@@ -27,16 +27,16 @@ t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
 static void
 t_tbl_mark(void *data)
 {
-  threads_table_t *t_tbl = (threads_table_t *) data;
+  threads_table_t *t_tbl = (threads_table_t *)data;
   st_table *tbl = t_tbl->tbl;
 
-  st_foreach(tbl, t_tbl_mark_keyvalue, (st_data_t) tbl);
+  st_foreach(tbl, t_tbl_mark_keyvalue, (st_data_t)tbl);
 }
 
 static void
 t_tbl_free(void *data)
 {
-  threads_table_t *t_tbl = (threads_table_t *) data;
+  threads_table_t *t_tbl = (threads_table_t *)data;
 
   st_free_table(t_tbl->tbl);
   xfree(t_tbl);
@@ -70,7 +70,7 @@ check_thread_i(st_data_t key, st_data_t value, st_data_t data)
   if (!value)
     return ST_DELETE;
 
-  if (!is_living_thread((VALUE) key))
+  if (!is_living_thread((VALUE)key))
     return ST_DELETE;
 
   return ST_CONTINUE;
@@ -110,7 +110,7 @@ cleanup_dead_threads(void)
  * Looks up a context in the threads table. If not present, it creates it.
  */
 void
-thread_context_lookup(VALUE thread, VALUE * context)
+thread_context_lookup(VALUE thread, VALUE *context)
 {
   threads_table_t *t_tbl;
 
@@ -118,7 +118,7 @@ thread_context_lookup(VALUE thread, VALUE * context)
 
   if (!st_lookup(t_tbl->tbl, thread, context) || !*context)
   {
-    *context = context_create(thread);
+    *context = byebug_context_create(thread);
     st_insert(t_tbl->tbl, thread, *context);
   }
 }
@@ -129,12 +129,12 @@ thread_context_lookup(VALUE thread, VALUE * context)
  * Thanks to this, all threads are "frozen" while the user is typing commands.
  */
 void
-acquire_lock(debug_context_t * dc)
+acquire_lock(debug_context_t *dc)
 {
   while ((!NIL_P(locker) && locker != rb_thread_current())
          || CTX_FL_TEST(dc, CTX_FL_SUSPEND))
   {
-    add_to_locked(rb_thread_current());
+    byebug_add_to_locked(rb_thread_current());
     rb_thread_stop();
 
     if (CTX_FL_TEST(dc, CTX_FL_SUSPEND))
@@ -159,10 +159,10 @@ release_lock(void)
   locker = Qnil;
 
   if (NIL_P(next_thread))
-    thread = pop_from_locked();
+    thread = byebug_pop_from_locked();
   else
   {
-    remove_from_locked(next_thread);
+    byebug_remove_from_locked(next_thread);
     thread = next_thread;
     next_thread = Qnil;
   }

data/lib/byebug/attacher.rb

@@ -1,14 +1,13 @@
+# frozen_string_literal: true
+
 #
 # Main Container for all of Byebug's code
 #
 module Byebug
   #
-  # Enters byebug right before (or right after if _before_ is false) return
-  # events occur. Before entering byebug the init script is read.
+  # Starts byebug, and stops at the first line of user's code.
   #
   def self.attach
-    require 'byebug/core'
-
     unless started?
       self.mode = :attached
 
@@ -18,6 +17,13 @@ module Byebug
 
     current_context.step_out(3, true)
   end
+
+  def self.spawn(host = "localhost", port = nil)
+    require_relative "core"
+
+    self.wait_connection = true
+    start_server(host, port || PORT)
+  end
 end
 
 #
@@ -27,6 +33,14 @@ end
 #
 module Kernel
   def byebug
+    require_relative "core"
+
+    Byebug.attach unless Byebug.mode == :off
+  end
+
+  def remote_byebug(host = "localhost", port = nil)
+    Byebug.spawn(host, port)
+
     Byebug.attach
   end
 

data/lib/byebug/breakpoint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Byebug
   #
   # Implements breakpoints
@@ -49,12 +51,30 @@ module Byebug
     #
     def self.potential_lines(filename)
       name = "#{Time.new.to_i}_#{rand(2**31)}"
-      lines = {}
       iseq = RubyVM::InstructionSequence.compile(File.read(filename), name)
 
+      if iseq.respond_to?(:each_child)
+        potential_lines_with_trace_points(iseq, {})
+      else
+        potential_lines_without_trace_points(iseq, {})
+      end
+    end
+
+    def self.potential_lines_with_trace_points(iseq, lines)
+      iseq.trace_points.each { |(line, _)| lines[line] = true }
+      iseq.each_child do |child|
+        potential_lines_with_trace_points(child, lines)
+      end
+
+      lines.keys.sort
+    end
+
+    private_class_method :potential_lines_with_trace_points
+
+    def self.potential_lines_without_trace_points(iseq, lines)
       iseq.disasm.each_line do |line|
         res = /^\d+ (?<insn>\w+)\s+.+\(\s*(?<lineno>\d+)\)$/.match(line)
-        next unless res && res[:insn] == 'trace'
+        next unless res && res[:insn] == "trace"
 
         lines[res[:lineno].to_i] = true
       end
@@ -62,6 +82,8 @@ module Byebug
       lines.keys
     end
 
+    private_class_method :potential_lines_without_trace_points
+
     #
     # Returns true if a breakpoint could be set in line number +lineno+ in file
     # name +filename.
@@ -81,10 +103,8 @@ module Byebug
     # 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(', ')
+      meths = %w[id pos source expr hit_condition hit_count hit_value enabled?]
+      values = meths.map { |field| "#{field}: #{send(field)}" }.join(", ")
       "#<Byebug::Breakpoint #{values}>"
     end
   end

data/lib/byebug/command.rb

@@ -1,5 +1,7 @@
-require 'forwardable'
-require 'byebug/helpers/string'
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "helpers/string"
 
 module Byebug
   #
@@ -16,11 +18,11 @@ module Byebug
   #   end
   #
   #   def self.description
-  #     'Custom long desc'
+  #     "Custom long desc"
   #   end
   #
   #   def.short_description
-  #     'Custom short desc'
+  #     "Custom short desc"
   #   end
   #
   #   def execute
@@ -47,16 +49,16 @@ module Byebug
     end
 
     def arguments
-      @match[0].split(' ').drop(1).join(' ')
+      @match[0].split(" ").drop(1).join(" ")
     end
 
-    def_delegators :'self.class', :help, :match
+    def_delegators "self.class", :help, :match
 
-    def_delegator :'processor.printer', :print, :pr
-    def_delegator :'processor.printer', :print_collection, :prc
-    def_delegator :'processor.printer', :print_variables, :prv
+    def_delegator "processor.printer", :print, :pr
+    def_delegator "processor.printer", :print_collection, :prc
+    def_delegator "processor.printer", :print_variables, :prv
 
-    def_delegators :'processor.interface', :errmsg, :puts, :print, :confirm
+    def_delegators "processor.interface", :errmsg, :puts, :print, :confirm
 
     class << self
       include Helpers::StringHelper
@@ -77,14 +79,18 @@ module Byebug
       #
       def to_s
         name
-          .split('::')
-          .map { |n| n.gsub(/Command$/, '').downcase if n =~ /Command$/ }
+          .split("::")
+          .map { |n| n.gsub(/Command$/, "").downcase if /Command$/.match?(n) }
           .compact
-          .join(' ')
+          .join(" ")
       end
 
       def columnize(width)
-        format("  %-#{width}s -- %s\n", to_s, short_description)
+        format(
+          "  %-<name>#{width}s -- %<description>s\n",
+          name: to_s,
+          description: short_description
+        )
       end
 
       #

data/lib/byebug/command_list.rb

@@ -1,4 +1,6 @@
-require 'byebug/errors'
+# frozen_string_literal: true
+
+require_relative "errors"
 
 module Byebug
   #

data/lib/byebug/commands/break.rb

@@ -1,7 +1,10 @@
-require 'byebug/command'
-require 'byebug/helpers/eval'
-require 'byebug/helpers/file'
-require 'byebug/helpers/parse'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
+require_relative "../helpers/file"
+require_relative "../helpers/parse"
+require_relative "../source_file_formatter"
 
 module Byebug
   #
@@ -19,32 +22,30 @@ module Byebug
     end
 
     def self.description
-      <<-EOD
-        b[reak] [file:]line [if expr]
-        b[reak] [module::...]class(.|#)method [if expr]
+      <<-DESCRIPTION
+        b[reak] [<file>:]<line> [if <expr>]
+        b[reak] [<module>::...]<class>(.|#)<method> [if <expr>]
 
         They can be specified by line or method and an expression can be added
         for conditionally enabled breakpoints.
 
         #{short_description}
-      EOD
+      DESCRIPTION
     end
 
     def self.short_description
-      'Sets breakpoints in the source code'
+      "Sets breakpoints in the source code"
     end
 
     def execute
       return puts(help) unless @match[1]
 
       b = line_breakpoint(@match[1]) || method_breakpoint(@match[1])
-      return errmsg(pr('break.errors.location')) unless b
+      return errmsg(pr("break.errors.location")) unless b
 
-      if syntax_valid?(@match[2])
-        return puts(pr('break.created', id: b.id, file: b.source, line: b.pos))
-      end
+      return puts(pr("break.created", id: b.id, file: b.source, line: b.pos)) if syntax_valid?(@match[2])
 
-      errmsg(pr('break.errors.expression', expr: @match[2]))
+      errmsg(pr("break.errors.expression", expr: @match[2]))
       b.enabled = false
     end
 
@@ -73,26 +74,39 @@ module Byebug
     def target_object(str)
       k = error_eval(str)
 
-      k && k.is_a?(Module) ? k.name : str
-    rescue
-      errmsg('Warning: breakpoint source is not yet defined')
+      k&.is_a?(Module) ? k.name : str
+    rescue StandardError
+      errmsg("Warning: breakpoint source is not yet defined")
       str
     end
 
     def add_line_breakpoint(file, line)
-      raise(pr('break.errors.source', file: file)) unless File.exist?(file)
+      raise(pr("break.errors.source", file: file)) unless File.exist?(file)
 
       fullpath = File.realpath(file)
 
-      if line > n_lines(file)
-        raise(pr('break.errors.far_line', lines: n_lines(file), file: fullpath))
-      end
+      raise(pr("break.errors.far_line", lines: n_lines(file), file: fullpath)) if line > n_lines(file)
 
       unless Breakpoint.potential_line?(fullpath, line)
-        raise(pr('break.errors.line', file: fullpath, line: line))
+        msg = pr(
+          "break.errors.line",
+          file: fullpath,
+          line: line,
+          valid_breakpoints: valid_breakpoints_for(fullpath, line)
+        )
+
+        raise(msg)
       end
 
       Breakpoint.add(fullpath, line, @match[2])
     end
+
+    def valid_breakpoints_for(path, line)
+      potential_lines = Breakpoint.potential_lines(path)
+      annotator = ->(n) { potential_lines.include?(n) ? "[B]" : "   " }
+      source_file_formatter = SourceFileFormatter.new(path, annotator)
+
+      source_file_formatter.lines_around(line).join.chomp
+    end
   end
 end

data/lib/byebug/commands/catch.rb

@@ -1,5 +1,7 @@
-require 'byebug/command'
-require 'byebug/helpers/eval'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
 
 module Byebug
   #
@@ -17,7 +19,7 @@ module Byebug
     end
 
     def self.description
-      <<-EOD
+      <<-DESCRIPTION
         cat[ch][ (off|<exception>[ off])]
 
         #{short_description}
@@ -26,19 +28,19 @@ module Byebug
         catch off             -- deletes all catchpoints
         catch <exception>     -- enables handling <exception>
         catch <exception> off -- disables handling <exception>
-      EOD
+      DESCRIPTION
     end
 
     def self.short_description
-      'Handles exception catchpoints'
+      "Handles exception catchpoints"
     end
 
     def execute
       return info unless @match[1]
 
-      return 'off' == @match[1] ? clear : add(@match[1]) unless @match[2]
+      return @match[1] == "off" ? clear : add(@match[1]) unless @match[2]
 
-      return errmsg pr('catch.errors.off', off: cmd) unless @match[2] == 'off'
+      return errmsg pr("catch.errors.off", off: cmd) unless @match[2] == "off"
 
       remove(@match[1])
     end
@@ -46,34 +48,30 @@ module Byebug
     private
 
     def remove(exception)
-      unless Byebug.catchpoints.member?(exception)
-        return errmsg pr('catch.errors.not_found', exception: exception)
-      end
+      return errmsg pr("catch.errors.not_found", exception: exception) unless Byebug.catchpoints.member?(exception)
 
-      puts pr('catch.removed', exception: exception)
+      puts pr("catch.removed", exception: exception)
       Byebug.catchpoints.delete(exception)
     end
 
     def add(exception)
-      if warning_eval(exception.is_a?(Class).to_s)
-        errmsg pr('catch.errors.not_class', class: exception)
-      end
+      errmsg pr("catch.errors.not_class", class: exception) if warning_eval(exception.is_a?(Class).to_s)
 
-      puts pr('catch.added', exception: exception)
+      puts pr("catch.added", exception: exception)
       Byebug.add_catchpoint(exception)
     end
 
     def clear
-      Byebug.catchpoints.clear if confirm(pr('catch.confirmations.delete_all'))
+      Byebug.catchpoints.clear if confirm(pr("catch.confirmations.delete_all"))
     end
 
     def info
       if Byebug.catchpoints && !Byebug.catchpoints.empty?
-        Byebug.catchpoints.each do |exception, _hits|
+        Byebug.catchpoints.each_key do |exception|
           puts("#{exception}: #{exception.is_a?(Class)}")
         end
       else
-        puts 'No exceptions set to be caught.'
+        puts "No exceptions set to be caught."
       end
     end
   end

data/lib/byebug/commands/condition.rb

@@ -1,5 +1,7 @@
-require 'byebug/command'
-require 'byebug/helpers/parse'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
 
 module Byebug
   #
@@ -17,7 +19,7 @@ module Byebug
     end
 
     def self.description
-      <<-EOD
+      <<-DESCRIPTION
         cond[ition] <n>[ expr]
 
         #{short_description}
@@ -26,28 +28,26 @@ module Byebug
         an integer and <expr> is an expression to be evaluated whenever
         breakpoint <n> is reached. If no expression is specified, the condition
         is removed.
-      EOD
+      DESCRIPTION
     end
 
     def self.short_description
-      'Sets conditions on breakpoints'
+      "Sets conditions on breakpoints"
     end
 
     def execute
       return puts(help) unless @match[1]
 
       breakpoints = Byebug.breakpoints.sort_by(&:id)
-      return errmsg(pr('condition.errors.no_breakpoints')) if breakpoints.empty?
+      return errmsg(pr("condition.errors.no_breakpoints")) if breakpoints.empty?
 
-      pos, err = get_int(@match[1], 'Condition', 1)
+      pos, err = get_int(@match[1], "Condition", 1)
       return errmsg(err) if err
 
       breakpoint = breakpoints.find { |b| b.id == pos }
-      return errmsg(pr('break.errors.no_breakpoint')) unless breakpoint
+      return errmsg(pr("break.errors.no_breakpoint")) unless breakpoint
 
-      unless syntax_valid?(@match[2])
-        return errmsg(pr('break.errors.not_changed', expr: @match[2]))
-      end
+      return errmsg(pr("break.errors.not_changed", expr: @match[2])) unless syntax_valid?(@match[2])
 
       breakpoint.expr = @match[2]
     end

data/lib/byebug/commands/continue.rb

@@ -1,5 +1,7 @@
-require 'byebug/command'
-require 'byebug/helpers/parse'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
 
 module Byebug
   #
@@ -12,37 +14,55 @@ module Byebug
     include Helpers::ParseHelper
 
     def self.regexp
-      /^\s* c(?:ont(?:inue)?)? (?:\s+(\S+))? \s*$/x
+      /^\s* c(?:ont(?:inue)?)? (?:(!|\s+unconditionally|\s+\S+))? \s*$/x
     end
 
     def self.description
-      <<-EOD
+      <<-DESCRIPTION
         c[ont[inue]][ <line_number>]
 
         #{short_description}
-      EOD
+
+        Normally the program stops at the next breakpoint. However, if the
+        parameter "unconditionally" is given or the command is suffixed with
+        "!", the program will run until the end regardless of any enabled
+        breakpoints.
+      DESCRIPTION
     end
 
     def self.short_description
-      'Runs until program ends, hits a breakpoint or reaches a line'
+      "Runs until program ends, hits a breakpoint or reaches a line"
     end
 
     def execute
-      if @match[1]
-        num, err = get_int(@match[1], 'Continue', 0, nil)
+      if until_line?
+        num, err = get_int(modifier, "Continue", 0, nil)
         return errmsg(err) unless num
 
         filename = File.expand_path(frame.file)
-        unless Breakpoint.potential_line?(filename, num)
-          return errmsg(pr('continue.errors.unstopped_line', line: num))
-        end
+        return errmsg(pr("continue.errors.unstopped_line", line: num)) unless Breakpoint.potential_line?(filename, num)
 
         Breakpoint.add(filename, num)
       end
 
       processor.proceed!
 
-      Byebug.stop if Byebug.stoppable?
+      Byebug.mode = :off if unconditionally?
+      Byebug.stop if unconditionally? || Byebug.stoppable?
+    end
+
+    private
+
+    def until_line?
+      @match[1] && !["!", "unconditionally"].include?(modifier)
+    end
+
+    def unconditionally?
+      @match[1] && ["!", "unconditionally"].include?(modifier)
+    end
+
+    def modifier
+      @match[1].lstrip
     end
   end
 end

data/lib/byebug/commands/debug.rb

@@ -1,5 +1,7 @@
-require 'byebug/command'
-require 'byebug/helpers/eval'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/eval"
 
 module Byebug
   #
@@ -13,18 +15,18 @@ module Byebug
     end
 
     def self.description
-      <<-EOD
+      <<-DESCRIPTION
         debug <expression>
 
         #{short_description}
 
         Allows, for example, setting breakpoints on expressions evaluated from
         the debugger's prompt.
-      EOD
+      DESCRIPTION
     end
 
     def self.short_description
-      'Spawns a subdebugger'
+      "Spawns a subdebugger"
     end
 
     def execute

data/lib/byebug/commands/delete.rb

@@ -1,5 +1,7 @@
-require 'byebug/command'
-require 'byebug/helpers/parse'
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../helpers/parse"
 
 module Byebug
   #
@@ -16,36 +18,36 @@ module Byebug
     end
 
     def self.description
-      <<-EOD
+      <<-DESCRIPTION
         del[ete][ nnn...]
 
         #{short_description}
 
         Without and argument, deletes all breakpoints. With integer arguments,
         it deletes specific breakpoints.
-      EOD
+      DESCRIPTION
     end
 
     def self.short_description
-      'Deletes breakpoints'
+      "Deletes breakpoints"
     end
 
     def execute
       unless @match[1]
-        if confirm(pr('break.confirmations.delete_all'))
-          Byebug.breakpoints.clear
-        end
+        Byebug.breakpoints.clear if confirm(pr("break.confirmations.delete_all"))
 
         return
       end
 
       @match[1].split(/ +/).each do |number|
-        pos, err = get_int(number, 'Delete', 1)
+        pos, err = get_int(number, "Delete", 1)
 
         return errmsg(err) unless pos
 
-        unless Breakpoint.remove(pos)
-          return errmsg(pr('break.errors.no_breakpoint_delete', pos: pos))
+        if Breakpoint.remove(pos)
+          puts(pr("break.messages.breakpoint_deleted", pos: pos))
+        else
+          errmsg(pr("break.errors.no_breakpoint_delete", pos: pos))
         end
       end
     end