byebug 5.0.0 → 6.0.0

data/README.md

@@ -2,19 +2,16 @@
 
 [![Ver][gem]][gem_url]
 [![Gpa][gpa]][gpa_url]
-[![Dep][dep]][dep_url]
 [![Cov][cov]][cov_url]
 [![Git][tip]][tip_url]
 
 [gem]: https://img.shields.io/gem/v/byebug.svg
 [gpa]: https://img.shields.io/codeclimate/github/deivid-rodriguez/byebug.svg
-[dep]: https://img.shields.io/gemnasium/deivid-rodriguez/byebug.svg
 [cov]: https://img.shields.io/codeclimate/coverage/github/deivid-rodriguez/byebug.svg
 [tip]: https://img.shields.io/gittip/deivid-rodriguez.svg
 
 [gem_url]: https://rubygems.org/gems/byebug
 [gpa_url]: https://codeclimate.com/github/deivid-rodriguez/byebug
-[dep_url]: https://gemnasium.com/deivid-rodriguez/byebug
 [cov_url]: https://codeclimate.com/github/deivid-rodriguez/byebug
 [tip_url]: https://www.gittip.com/deivid-rodriguez
 
@@ -92,7 +89,6 @@ are debugging rails, start the server and once the execution gets to your
     `down`      |              |
     `edit`      |              |
     `enable`    |              | `breakpoints` `display`
-    `eval`      |              |
     `finish`    |              |
     `frame`     |              |
     `help`      |              |
@@ -103,15 +99,13 @@ are debugging rails, start the server and once the execution gets to your
     `list`      |              |
     `method`    |              | `instance`
     `next`      |              |
-    `pp`        |              |
     `pry`       |              |
     `ps`        |              |
-    `putl`      |              |
-    `quit`      | `exit`       |
+    `quit`      |              |
     `restart`   |              |
     `save`      |              |
-    `set`       |              | `autoeval` `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `verbose` `width`
-    `show`      |              | `autoeval` `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `verbose` `width`
+    `set`       |              | `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
+    `show`      |              | `autoirb` `autolist` `autosave` `basename` `callstyle` `fullpath` `histfile` `histsize` `linetrace` `listsize` `post_mortem` `savefile` `stack_on_error` `width`
     `source`    |              |
     `step`      |              |
     `thread`    |              | `current` `list` `resume` `stop` `switch`
@@ -154,10 +148,10 @@ See [Getting Started with Development](CONTRIBUTING.md).
 ## Credits
 
 Everybody who has ever contributed to this forked and reforked piece of
-software, specially:
+software, especially:
 
 * @ko1, author of the awesome TracePoint API for Ruby.
-* @cldwalker, [debugger][]'s mantainer.
+* @cldwalker, [debugger][]'s maintainer.
 * @denofevil, author of [debase][], the starting point of this.
 * @kevjames3 for testing, bug reports and the interest in the project.
 * @FooBarWidget for working and helping with remote debugging.

data/ext/byebug/byebug.c

@@ -357,8 +357,7 @@ raw_return_event(VALUE trace_point, void *data)
 static void
 raise_event(VALUE trace_point, void *data)
 {
-  VALUE expn_class, ancestors;
-  VALUE path, lineno, binding, post_mortem_context;
+  VALUE expn_class, ancestors, path, lineno, pm_context;
   int i;
   debug_context_t *new_dc;
 
@@ -366,19 +365,14 @@ raise_event(VALUE trace_point, void *data)
 
   path = rb_tracearg_path(trace_arg);
   lineno = rb_tracearg_lineno(trace_arg);
-  binding = rb_tracearg_binding(trace_arg);
   raised_exception = rb_tracearg_raised_exception(trace_arg);
 
   if (post_mortem == Qtrue)
   {
-    post_mortem_context = context_dup(dc);
-    rb_ivar_set(raised_exception, rb_intern("@__bb_file"), path);
-    rb_ivar_set(raised_exception, rb_intern("@__bb_line"), lineno);
-    rb_ivar_set(raised_exception, rb_intern("@__bb_binding"), binding);
-    rb_ivar_set(raised_exception, rb_intern("@__bb_context"),
-                post_mortem_context);
-
-    Data_Get_Struct(post_mortem_context, debug_context_t, new_dc);
+    pm_context = context_dup(dc);
+    rb_ivar_set(raised_exception, rb_intern("@__bb_context"), pm_context);
+
+    Data_Get_Struct(pm_context, debug_context_t, new_dc);
     rb_debug_inspector_open(context_backtrace_set, (void *)new_dc);
   }
 
@@ -655,36 +649,6 @@ Debug_load(int argc, VALUE * argv, VALUE self)
   return status;
 }
 
-/*
- *  call-seq:
- *    Byebug.verbose? -> bool
- *
- *  Returns +true+ if verbose output of TracePoint API events is enabled.
- */
-static VALUE
-Verbose(VALUE self)
-{
-  UNUSED(self);
-
-  return verbose;
-}
-
-/*
- *  call-seq:
- *    Byebug.verbose = bool
- *
- *  Enable verbose output of every TracePoint API events, useful for debugging
- *  byebug.
- */
-static VALUE
-Set_verbose(VALUE self, VALUE value)
-{
-  UNUSED(self);
-
-  verbose = RTEST(value) ? Qtrue : Qfalse;
-  return value;
-}
-
 /*
  *  call-seq:
  *    Byebug.tracing? -> bool
@@ -789,8 +753,6 @@ Init_byebug()
   rb_define_module_function(mByebug, "thread_context", Thread_context, 1);
   rb_define_module_function(mByebug, "tracing?", Tracing, 0);
   rb_define_module_function(mByebug, "tracing=", Set_tracing, 1);
-  rb_define_module_function(mByebug, "verbose?", Verbose, 0);
-  rb_define_module_function(mByebug, "verbose=", Set_verbose, 1);
 
   Init_threads_table(mByebug);
   Init_context(mByebug);

data/ext/byebug/byebug.h

@@ -45,7 +45,12 @@ typedef struct {
   VALUE backtrace;             /* [[loc, self, klass, binding], ...] */
 } debug_context_t;
 
-enum frame_component { LOCATION, SELF, CLASS, BINDING };
+typedef enum {
+  LOCATION,
+  SELF,
+  CLASS,
+  BINDING
+} frame_part;
 
 struct call_with_inspection_data {
   debug_context_t *dc;

data/ext/byebug/context.c

@@ -90,8 +90,7 @@ context_dup(debug_context_t * context)
 
 
 static VALUE
-dc_frame_get(const debug_context_t * context, int frame_index,
-             enum frame_component type)
+dc_frame_get(const debug_context_t * context, int frame_index, frame_part type)
 {
   VALUE frame;
 
@@ -257,7 +256,7 @@ Context_frame_file(int argc, VALUE * argv, VALUE self)
  *  call-seq:
  *    context.frame_line(frame_position = 0) -> int
  *
- *  Returns the line number in the file.
+ *  Returns the line number in the file in the frame.
  */
 static VALUE
 Context_frame_line(int argc, VALUE * argv, VALUE self)
@@ -275,7 +274,7 @@ Context_frame_line(int argc, VALUE * argv, VALUE self)
  *  call-seq:
  *    context.frame_method(frame_position = 0) -> sym
  *
- *  Returns the sym of the called method.
+ *  Returns the sym of the method in the frame.
  */
 static VALUE
 Context_frame_method(int argc, VALUE * argv, VALUE self)
@@ -640,7 +639,7 @@ dt_inherited(VALUE klass)
  *
  *   == Summary
  *
- *   Byebug keeps a single instance of this class.
+ *   Byebug keeps a single instance of this class per thread.
  */
 void
 Init_context(VALUE mByebug)

data/lib/byebug/command.rb

@@ -1,4 +1,3 @@
-require 'columnize'
 require 'forwardable'
 require 'byebug/helpers/string'
 
@@ -6,78 +5,68 @@ module Byebug
   #
   # Parent class of all byebug commands.
   #
-  # Subclasses need to implement a `regexp` method and an `execute` method.
+  # Subclass it and name the subclass ending with the word Command to implement
+  # your own custom command.
+  #
+  # @example
+  #
+  # class MyCustomCommand < Command
+  #   def self.regexp
+  #     /custom_regexp/
+  #   end
+  #
+  #   def self.description
+  #     'Custom long desc'
+  #   end
+  #
+  #   def.short_description
+  #     'Custom short desc'
+  #   end
+  #
+  #   def execute
+  #     # My command's implementation
+  #   end
+  # end
   #
   class Command
     extend Forwardable
 
-    include Helpers::StringHelper
+    attr_reader :processor
 
-    def initialize(state)
-      @match = nil
-      @state = state
+    def initialize(processor, input = self.class.to_s)
+      @processor = processor
+      @match = match(input)
     end
 
-    def match(input)
-      @match = regexp.match(input)
+    def context
+      @context ||= processor.context
     end
 
-    def_delegators :'self.class', :to_name, :description
-
-    #
-    # Default help text for a command.
-    #
-    def help
-      prettify(description)
+    def frame
+      @frame ||= context.frame
     end
 
-    def_delegator :"Byebug.printer", :print, :pr
-    def_delegator :"Byebug.printer", :print_collection, :prc
-    def_delegator :"Byebug.printer", :print_variables, :prv
-
-    protected
-
-    def_delegators :@state, :errmsg, :puts, :print, :confirm
-
-    #
-    # Evaluates a string containing Ruby code, using binding +b+. In case of
-    # error full stack trace and error are printed.
-    #
-    def bb_eval(str, b = get_binding)
-      b.eval(str)
-    rescue StandardError, ScriptError => e
-      at = e.backtrace
-      locations = []
-      locations << "#{at.shift}: #{e.class} Exception(#{e.message})"
-      locations += at.map { |path| "\tfrom #{path}" }
-
-      errmsg(pr('eval.exception', text_message: locations.join("\n")))
-      nil
+    def arguments
+      @match[0].split(' ').drop(1).join(' ')
     end
 
-    #
-    # Evaluates a string containing Ruby code, using binding +b+. In case of
-    # error, an error message with the exception is printed.
-    #
-    def bb_warning_eval(str, b = get_binding)
-      b.eval(str)
-    rescue StandardError, ScriptError => e
-      text_message = "#{e.class} Exception: #{e.message}"
-      errmsg(pr('eval.exception', text_message: text_message))
-      nil
-    end
+    def_delegators :'self.class', :help, :match
 
-    def get_binding(pos = @state.frame)
-      @state.context ? @state.context.frame_binding(pos) : TOPLEVEL_BINDING
-    end
+    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
 
     class << self
-      attr_accessor :allow_in_control
-      attr_writer :allow_in_post_mortem, :always_run
+      include Helpers::StringHelper
 
-      def allow_in_post_mortem
-        !defined?(@allow_in_post_mortem) ? true : false
-      end
+      #
+      # Special methods to allow command filtering in processors
+      #
+      attr_accessor :allow_in_control, :allow_in_post_mortem
+
+      attr_writer :always_run
 
       def always_run
         @always_run ||= 0
@@ -86,19 +75,30 @@ module Byebug
       #
       # Name of the command, as executed by the user.
       #
-      def to_name
-        name.gsub(/^Byebug::/, '').gsub(/Command$/, '').downcase
+      def to_s
+        name
+          .split('::')
+          .map { |n| n.gsub(/Command$/, '').downcase if n =~ /Command$/ }
+          .compact
+          .join(' ')
+      end
+
+      def columnize(width)
+        format("  %-#{width}s -- %s\n", to_s, short_description)
       end
 
       #
-      # Available subcommands for the current command
-      #
-      # A subcommand is any class defined inside the parent's command class
+      # Default help text for a command.
       #
-      def subcommands
-        const_list = constants(false).map { |const| const_get(const, false) }
+      def help
+        prettify(description)
+      end
 
-        const_list.select { |c| c.is_a?(Class) }
+      #
+      # Command's regexp match against an input
+      #
+      def match(input)
+        regexp.match(input)
       end
     end
   end

data/lib/byebug/command_list.rb

@@ -0,0 +1,32 @@
+require 'byebug/errors'
+
+module Byebug
+  #
+  # Holds an array of subcommands for a command
+  #
+  class CommandList
+    include Enumerable
+
+    def initialize(commands)
+      @commands = commands.sort_by(&:to_s)
+    end
+
+    def match(input)
+      find { |cmd| cmd.match(input) }
+    end
+
+    def each
+      @commands.each { |cmd| yield(cmd) }
+    end
+
+    def to_s
+      "\n" + map { |cmd| cmd.columnize(width) }.join + "\n"
+    end
+
+    private
+
+    def width
+      @width ||= map(&:to_s).max_by(&:size).size
+    end
+  end
+end

data/lib/byebug/commands.rb

@@ -0,0 +1,37 @@
+require 'byebug/commands/break'
+require 'byebug/commands/catch'
+require 'byebug/commands/condition'
+require 'byebug/commands/continue'
+require 'byebug/commands/delete'
+require 'byebug/commands/disable'
+require 'byebug/commands/display'
+require 'byebug/commands/down'
+require 'byebug/commands/edit'
+require 'byebug/commands/enable'
+require 'byebug/commands/finish'
+require 'byebug/commands/frame'
+require 'byebug/commands/help'
+require 'byebug/commands/history'
+require 'byebug/commands/info'
+require 'byebug/commands/interrupt'
+require 'byebug/commands/irb'
+require 'byebug/commands/kill'
+require 'byebug/commands/list'
+require 'byebug/commands/method'
+require 'byebug/commands/next'
+require 'byebug/commands/pry'
+require 'byebug/commands/ps'
+require 'byebug/commands/quit'
+require 'byebug/commands/restart'
+require 'byebug/commands/save'
+require 'byebug/commands/set'
+require 'byebug/commands/show'
+require 'byebug/commands/source'
+require 'byebug/commands/step'
+require 'byebug/commands/thread'
+require 'byebug/commands/tracevar'
+require 'byebug/commands/undisplay'
+require 'byebug/commands/untracevar'
+require 'byebug/commands/up'
+require 'byebug/commands/var'
+require 'byebug/commands/where'

data/lib/byebug/commands/break.rb

@@ -1,4 +1,5 @@
 require 'byebug/command'
+require 'byebug/helpers/eval'
 require 'byebug/helpers/file'
 require 'byebug/helpers/parse'
 
@@ -7,16 +8,32 @@ module Byebug
   # Implements breakpoint functionality
   #
   class BreakCommand < Command
+    include Helpers::EvalHelper
     include Helpers::FileHelper
     include Helpers::ParseHelper
 
-    self.allow_in_post_mortem = false
     self.allow_in_control = true
 
-    def regexp
+    def self.regexp
       /^\s* b(?:reak)? (?:\s+ (\S+))? (?:\s+ if \s+(.+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        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
+    end
+
+    def self.short_description
+      'Sets breakpoints in the source code'
+    end
+
     def execute
       return puts(help) unless @match[1]
 
@@ -28,62 +45,53 @@ module Byebug
 
       errmsg(pr('break.errors.expression', expr: @match[2]))
       b.enabled = false
-    rescue => e
-      errmsg(e.message)
-    end
-
-    def short_description
-      'Set breakpoint to some position, (optionally) if expr == true'
-    end
-
-    def description
-      <<-EOD
-        b[reak] [file:]line [if expr]
-        b[reak] [module::...]class(.|#)method [if expr]
-
-        #{short_description}
-      EOD
     end
 
     private
 
-    def line_breakpoint(loc)
-      line = loc.match(/^(\d+)$/)
-      file_line = loc.match(/^([^:]+):(\d+)$/)
-      return nil unless line || file_line
+    def line_breakpoint(location)
+      line_match = location.match(/^(\d+)$/)
+      file_line_match = location.match(/^([^:]+):(\d+)$/)
+      return unless line_match || file_line_match
 
-      f, l = line ? [@state.file, line[1]] : [file_line[1], file_line[2]]
+      file = line_match ? frame.file : file_line_match[1]
+      line = line_match ? line_match[1].to_i : file_line_match[2].to_i
 
-      check_errors(f, l.to_i)
-
-      Breakpoint.add(File.expand_path(f), l.to_i, @match[2])
+      add_line_breakpoint(file, line)
     end
 
     def method_breakpoint(location)
       location.match(/([^.#]+)[.#](.+)/) do |match|
-        k = bb_warning_eval(match[1])
-        m = match[2]
-
-        klass = k && k.is_a?(Module) ? k.name : match[1]
-        method = m.intern
+        klass = target_object(match[1])
+        method = match[2].intern
 
         Breakpoint.add(klass, method, @match[2])
       end
     end
 
-    def check_errors(file, line)
-      path = File.expand_path(file)
-      deco_path = normalize(file)
+    def target_object(str)
+      k = warning_eval(str)
+
+      k && k.is_a?(Module) ? k.name : str
+    rescue
+      errmsg('Warning: breakpoint source is not yet defined')
+      str
+    end
+
+    def add_line_breakpoint(file, line)
+      fail(pr('break.errors.source', file: file)) unless File.exist?(file)
 
-      fail(pr('break.errors.source', file: deco_path)) unless File.exist?(path)
+      fullpath = File.realpath(file)
 
       if line > n_lines(file)
-        fail(pr('break.errors.far_line', lines: n_lines(file), file: deco_path))
+        fail(pr('break.errors.far_line', lines: n_lines(file), file: fullpath))
       end
 
-      return if Breakpoint.potential_line?(path, line)
+      unless Breakpoint.potential_line?(fullpath, line)
+        fail(pr('break.errors.line', file: fullpath, line: line))
+      end
 
-      fail(pr('break.errors.line', file: deco_path, line: line))
+      Breakpoint.add(fullpath, line, @match[2])
     end
   end
 end