byebug 3.2.0 → 3.3.0

data/lib/byebug/commands/trace.rb

@@ -1,4 +1,7 @@
 module Byebug
+  #
+  # Show information about every line that is executed.
+  #
   class TraceCommand < Command
     def regexp
       /^\s* tr(?:acevar)? (?: \s+ (\S+))?  # (variable-name)?
@@ -7,20 +10,24 @@ module Byebug
     end
 
     def execute
-      varname = @match[1]
-      if global_variables.include?("$#{varname}".to_sym)
+      var = @match[1]
+      if global_variables.include?("$#{var}".to_sym)
         if @match[2] && @match[2] !~ /(:?no)?stop/
-          errmsg "expecting \"stop\" or \"nostop\"; got \"#{@match[2]}\"\n"
+          errmsg "expecting \"stop\" or \"nostop\"; got \"#{@match[2]}\""
         else
-          dbg_cmd = (@match[2] && @match[2] !~ /nostop/) ? 'byebug(1, false)' : ''
+          dbg_cmd = if @match[2] && @match[2] !~ /nostop/
+                      'byebug(1, false)'
+                    else
+                      ''
+                    end
         end
-        eval("trace_var(:\"\$#{varname}\") do |val|
-                print \"traced global variable '#{varname}' has value '\#{val}'\"\n
+        eval("trace_var(:\"\$#{var}\") do |val|
+                puts \"traced global variable '#{var}' has value '\#{val}'\"
                 #{dbg_cmd}
               end")
-        print "Tracing global variable \"#{varname}\".\n"
+        puts "Tracing global variable \"#{var}\"."
       else
-        errmsg "'#{varname}' is not a global variable.\n"
+        errmsg "'#{var}' is not a global variable."
       end
     end
 
@@ -30,7 +37,13 @@ module Byebug
       end
 
       def description
-        %{tr[acevar] VARNAME [stop|nostop]\tset trace variable on VARNAME}
+        %(tr[acevar] <variable> [[no]stop]
+
+          Start tracing variable <variable>.
+
+          If "stop" is specified, execution will stop every time the variable
+          changes its value. If nothing or "nostop" is specified, execution
+          won't stop, changes will just be logged in byebug's output.)
       end
     end
   end

data/lib/byebug/commands/undisplay.rb

@@ -0,0 +1,45 @@
+module Byebug
+  #
+  # Remove expressions from display list.
+  #
+  class UndisplayCommand < Command
+    self.allow_in_post_mortem = false
+
+    def regexp
+      /^\s* undisp(?:lay)? (?:\s+(\S+))? \s*$/x
+    end
+
+    def execute
+      if @match[1]
+        pos, err = get_int(@match[1], 'Undisplay')
+        return errmsg(err) unless pos
+
+        unless @state.display[pos - 1]
+          return errmsg("Display expression #{pos} is not defined.")
+        end
+
+        @state.display[pos - 1][0] = nil
+      else
+        return unless confirm('Clear all expressions? (y/n) ')
+
+        @state.display.each { |d| d[0] = false }
+      end
+    end
+
+    class << self
+      def names
+        %w(undisplay)
+      end
+
+      def description
+        %(undisp[lay][ nnn]
+
+          Cancel some expressions to be displayed when program stops. Arguments
+          are the code numbers of the expressions to stop displaying. No
+          argument means cancel all automatic-display expressions. "delete
+          display" has the same effect as this command. Do "info display" to see
+          the current list of code numbers.)
+      end
+    end
+  end
+end

data/lib/byebug/commands/variables.rb

@@ -1,20 +1,23 @@
 module Byebug
+  #
+  # Utilities for the var command.
+  #
   module VarFunctions
     def var_list(ary, b = get_binding)
       ary.sort!
-      for v in ary
+      ary.each do |v|
         begin
           s = bb_eval(v.to_s, b).inspect
         rescue
           begin
             s = bb_eval(v.to_s, b).to_s
           rescue
-            s = "*Error in evaluation*"
+            s = '*Error in evaluation*'
           end
         end
         s = "#{v} = #{s}"
-        s[Setting[:width]-3..-1] = "..." if s.size > Setting[:width]
-        print "#{s}\n"
+        s[Setting[:width] - 3..-1] = '...' if s.size > Setting[:width]
+        puts s
       end
     end
 
@@ -24,20 +27,65 @@ module Byebug
     end
 
     def var_global
-      var_list(global_variables.reject { |v| [:$=, :$KCODE, :$-K].include?(v) })
+      globals = global_variables.reject do |v|
+        [:$IGNORECASE, :$=, :$KCODE, :$-K].include?(v)
+      end
+
+      var_list(globals)
+    end
+
+    def var_instance(where)
+      obj = bb_eval(where)
+      var_list(obj.instance_variables, obj.instance_eval { binding })
+    end
+
+    def var_local
+      _self = @state.context.frame_self(@state.frame_pos)
+      locals = @state.context.frame_locals
+      locals.keys.sort.each do |name|
+        puts format('  %s => %p', name, locals[name])
+      end
     end
   end
 
+  #
+  # Show all variables and its values.
+  #
+  class VarAllCommand < Command
+    def regexp
+      /^\s* v(?:ar)? \s+ a(?:ll)? \s*$/x
+    end
+
+    def execute
+      var_class_self
+      var_global
+      var_instance('self')
+      var_local
+    end
+
+    class << self
+      def names
+        %w(var)
+      end
+
+      def description
+        %(v[ar] a[ll]
+
+          Show local, global and instance & class variables of self.)
+      end
+    end
+  end
+
+  #
+  # Show class variables and its values.
+  #
   class VarClassCommand < Command
     def regexp
       /^\s* v(?:ar)? \s+ cl(?:ass)? \s*/x
     end
 
     def execute
-      unless @state.context
-        errmsg "can't get class variables here.\n"
-        return
-      end
+      return errmsg "can't get class variables here.\n" unless @state.context
       var_class_self
     end
 
@@ -47,11 +95,14 @@ module Byebug
       end
 
       def description
-        %{v[ar] cl[ass] \t\t\tshow class variables of self}
+        %(v[ar] cl[ass]        Show class variables of self.)
       end
     end
   end
 
+  #
+  # Show constants and its values.
+  #
   class VarConstantCommand < Command
     def regexp
       /^\s* v(?:ar)? \s+ co(?:nst(?:ant)?)? \s+/x
@@ -59,16 +110,15 @@ module Byebug
 
     def execute
       obj = bb_eval(@match.post_match)
-      if obj.kind_of? Module
+      if obj.is_a? Module
         constants = bb_eval("#{@match.post_match}.constants")
         constants.sort!
-        for c in constants
-          next if c =~ /SCRIPT/
-          value = obj.const_get(c) rescue "ERROR: #{$!}"
-          print " %s => %p\n", c, value
+        constants.each do |c|
+          value = obj.const_get(c)
+          puts format(' %s => %p', c, value)
         end
       else
-        print "Should be Class/Module: #{@match.post_match}\n"
+        puts "Should be Class/Module: #{@match.post_match}"
       end
     end
 
@@ -78,11 +128,14 @@ module Byebug
       end
 
       def description
-        %{v[ar] co[nst] <object>\t\tshow constants of object}
+        %(v[ar] co[nst] <object>        Show constants of <object>.)
       end
     end
   end
 
+  #
+  # Show global variables and its values.
+  #
   class VarGlobalCommand < Command
     def regexp
       /^\s* v(?:ar)? \s+ g(?:lobal)? \s*$/x
@@ -98,19 +151,21 @@ module Byebug
       end
 
       def description
-        %{v[ar] g[lobal]\t\t\tshow global variables}
+        %(v[ar] g[lobal]        Show global variables.)
       end
     end
   end
 
+  #
+  # Show instance variables and its values.
+  #
   class VarInstanceCommand < Command
     def regexp
       /^\s* v(?:ar)? \s+ ins(?:tance)? \s*/x
     end
 
     def execute
-      obj = bb_eval(@match.post_match.empty? ? 'self' : @match.post_match)
-      var_list(obj.instance_variables, obj.instance_eval { binding() })
+      var_instance(@match.post_match.empty? ? 'self' : @match.post_match)
     end
 
     class << self
@@ -119,22 +174,23 @@ module Byebug
       end
 
       def description
-        %{v[ar] i[nstance] <object>\tshow instance variables of object}
+        %(v[ar] i[nstance] <object>
+
+        Show instance variables of <object>.)
       end
     end
   end
 
+  #
+  # Show local variables and its values.
+  #
   class VarLocalCommand < Command
     def regexp
       /^\s* v(?:ar)? \s+ l(?:ocal)? \s*$/x
     end
 
     def execute
-      _self = @state.context.frame_self(@state.frame_pos)
-      locals = @state.context.frame_locals
-      locals.keys.sort.each do |name|
-        print "  %s => %p\n", name, locals[name]
-      end
+      var_local
     end
 
     class << self
@@ -143,7 +199,7 @@ module Byebug
       end
 
       def description
-        %{v[ar] l[ocal]\t\t\tshow local variables}
+        %(v[ar] l[ocal]        Sow local variables.)
       end
     end
   end

data/lib/byebug/context.rb

@@ -1,19 +1,22 @@
 module Byebug
-
+  #
+  # Mantains context information for the debugger and it's the main
+  # communication point between the library and the C-extension through the
+  # at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
+  #
   class Context
-
     class << self
       def stack_size(byebug_frames = false)
-        if backtrace = Thread.current.backtrace_locations(0)
-          unless byebug_frames
-            backtrace = backtrace.drop_while { |l| !ignored(l.path) }
-                                 .drop_while { |l|  ignored(l.path) }
-                                 .take_while { |l| !ignored(l.path) }
-          end
-          backtrace.size
-        else
-          0
+        backtrace = Thread.current.backtrace_locations(0)
+        return 0 unless backtrace
+
+        unless byebug_frames
+          backtrace = backtrace.drop_while { |l| !ignored(l.path) }
+                               .drop_while { |l|  ignored(l.path) }
+                               .take_while { |l| !ignored(l.path) }
         end
+
+        backtrace.size
       end
 
       def ignored(path)
@@ -23,32 +26,32 @@ module Byebug
     end
 
     def interrupt
-      self.step_into 1
+      step_into 1
     end
 
-    def frame_locals frame_no = 0
+    def frame_locals(frame_no = 0)
       bind = frame_binding frame_no
-      eval "local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}", bind
+      eval 'local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}', bind
     end
 
-    def c_frame_args frame_no
+    def c_frame_args(frame_no)
       myself = frame_self frame_no
       return [] unless myself.to_s != 'main'
       myself.send(:method, frame_method(frame_no)).parameters
     end
 
-    def ruby_frame_args bind
+    def ruby_frame_args(bind)
       return [] unless eval '__method__', bind
       begin
-        eval "self.method(__method__).parameters", bind
+        eval 'self.method(__method__).parameters', bind
       rescue NameError => e
-        print "WARNING: Got exception #{e.class}: \"#{e.message}\" " \
-              "while retreving parameters from frame\n"
+        puts "WARNING: Got exception #{e.class}: \"#{e.message}\" " \
+             'while retreving parameters from frame'
         return []
       end
     end
 
-    def frame_args frame_no = 0
+    def frame_args(frame_no = 0)
       bind = frame_binding frame_no
       if bind.nil?
         c_frame_args frame_no
@@ -58,7 +61,7 @@ module Byebug
     end
 
     def handler
-      Byebug.handler or raise 'No interface loaded'
+      Byebug.handler || fail('No interface loaded')
     end
 
     def at_breakpoint(brkpnt)
@@ -74,7 +77,7 @@ module Byebug
     end
 
     def at_line(file, line)
-      handler.at_line(self, file, line)
+      handler.at_line(self, file, line) unless IGNORED_FILES.include?(file)
     end
 
     def at_return(file, line)

data/lib/byebug/core.rb

@@ -0,0 +1,82 @@
+require 'byebug/byebug'
+require 'byebug/version'
+require 'byebug/context'
+require 'byebug/breakpoint'
+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)
+
+  class << self
+    attr_accessor :handler
+  end
+
+  Byebug.handler = CommandProcessor.new
+
+  def self.source_reload
+    hsh = 'SCRIPT_LINES__'
+    Object.send(:remove_const, hsh) if Object.const_defined?(hsh)
+    Object.const_set(hsh, {})
+  end
+
+  #
+  # Byebug's interface is its handler's interface
+  #
+  def self.interface=(value)
+    handler.interface = value
+  end
+
+  #
+  # Byebug's prints according to its handler's interface
+  #
+  def self.puts(message)
+    handler.interface.puts(message)
+  end
+
+  #
+  # 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 self.run_init_script(out = handler.interface)
+    cwd_script  = File.expand_path(File.join('.', INITFILE))
+    run_script(cwd_script, out, true) if File.exist?(cwd_script)
+
+    home_script = File.expand_path(File.join(ENV['HOME'].to_s, INITFILE))
+    if File.exist?(home_script) && cwd_script != home_script
+      run_script(home_script, out, true)
+    end
+  end
+
+  #
+  # Runs a script file
+  #
+  def self.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
+
+#
+# Extends the extension class to be able to pass information about the
+# debugging environment from the c-extension to the user.
+#
+class Exception
+  attr_reader :__bb_file, :__bb_line, :__bb_binding, :__bb_context
+end