byebug 3.5.1 → 4.0.0

data/lib/byebug/commands/threads.rb

@@ -1,14 +1,19 @@
+require 'byebug/command'
+
+#
+# TODO: Implement thread commands as a single command with subcommands, just
+# like `info`, `var`, `enable` and `disable`. This allows consistent help
+# format and we can go back to showing help for a single command in the `help`
+# command.
+#
 module Byebug
   #
   # Utilities to assist commands related to threads.
   #
   module ThreadFunctions
     def display_context(context, should_show_top_frame = true)
-      args = thread_arguments(context, should_show_top_frame)
-      interp = format("%s%s%d %s\t%s",
-                      args[:status_flag], args[:debug_flag], args[:id],
-                      args[:thread], args[:file_line])
-      puts interp
+      puts pr('thread.context',
+              thread_arguments(context, should_show_top_frame))
     end
 
     def thread_arguments(context, should_show_top_frame = true)
@@ -18,50 +23,47 @@ module Byebug
                       context.thread == Thread.current ? '+' : ' '
                     end
       debug_flag = context.ignored? ? '!' : ' '
+
       if should_show_top_frame
-        if context.thread == Thread.current && !context.dead?
-          file = context.frame_file(0)
-          line = context.frame_line(0)
+        if context == Byebug.current_context
+          file_line = "#{@state.file}:#{@state.line}"
         else
-          if context.thread.backtrace_locations &&
-             context.thread.backtrace_locations[0]
-            file = context.thread.backtrace_locations[0].path
-            line = context.thread.backtrace_locations[0].lineno
+          backtrace = context.thread.backtrace_locations
+          if backtrace && backtrace[0]
+            file_line = "#{backtrace[0].path}:#{backtrace[0].lineno}"
           end
         end
-        file_line = "#{file}:#{line}"
       end
       {
         status_flag: status_flag,
         debug_flag: debug_flag,
         id: context.thnum,
         thread: context.thread.inspect,
-        file_line: file_line ? file_line : ''
+        file_line: file_line || ''
       }
     end
 
     def parse_thread_num(subcmd, arg)
-      return errmsg("\"#{subcmd}\" needs a thread number") if '' == arg
-
-      thread_num, err = get_int(arg, subcmd, 1)
-      return errmsg(err) unless thread_num
+      thnum, err = get_int(arg, subcmd, 1)
+      return [nil, err] unless thnum
 
       Byebug.contexts.find { |c| c.thnum == thnum }
     end
 
     def parse_thread_num_for_cmd(subcmd, arg)
-      c = parse_thread_num(subcmd, arg)
-      return unless c
+      c, err = parse_thread_num(subcmd, arg)
 
       case
-      when nil == c
-        errmsg 'No such thread'
+      when err
+        [c, err]
+      when c.nil?
+        [nil, pr('thread.errors.no_thread')]
       when @state.context == c
-        errmsg "It's the current thread"
+        [c, pr('thread.errors.current_thread')]
       when c.ignored?
-        errmsg "Can't #{subcmd} thread #{arg}"
+        [c, pr('thread.errors.wrong_action', subcmd: subcmd, arg: arg)]
       else
-        c
+        [c, nil]
       end
     end
   end
@@ -70,6 +72,8 @@ module Byebug
   # List current threads.
   #
   class ThreadListCommand < Command
+    include ThreadFunctions
+
     self.allow_in_control = true
 
     def regexp
@@ -77,8 +81,13 @@ module Byebug
     end
 
     def execute
-      Byebug.contexts.select { |c| Thread.list.include?(c.thread) }
-                     .sort_by(&:thnum).each { |c| display_context(c) }
+      contexts = Byebug.contexts.sort_by(&:thnum)
+
+      thread_list = prc('thread.context', contexts) do |context, _|
+        thread_arguments(context)
+      end
+
+      print(thread_list)
     end
 
     class << self
@@ -87,7 +96,9 @@ module Byebug
       end
 
       def description
-        %(th[read] l[ist]        Lists all threads.)
+        prettify <<-EOD
+          th[read] l[ist]  Lists all threads.
+        EOD
       end
     end
   end
@@ -96,6 +107,8 @@ module Byebug
   # Show current thread.
   #
   class ThreadCurrentCommand < Command
+    include ThreadFunctions
+
     def regexp
       /^\s* th(?:read)? \s+ (?:cur(?:rent)?)? \s*$/x
     end
@@ -110,7 +123,9 @@ module Byebug
       end
 
       def description
-        %(th[read] [cur[rent]]        Shows current thread.)
+        prettify <<-EOD
+          th[read] cur[rent]  Shows current thread.
+        EOD
       end
     end
   end
@@ -119,7 +134,9 @@ module Byebug
   # Stop execution of a thread.
   #
   class ThreadStopCommand < Command
-    self.allow_in_control     = true
+    include ThreadFunctions
+
+    self.allow_in_control = true
     self.allow_in_post_mortem = false
 
     def regexp
@@ -127,8 +144,8 @@ module Byebug
     end
 
     def execute
-      c = parse_thread_num_for_cmd('thread stop', @match[1])
-      return unless c
+      c, err = parse_thread_num_for_cmd('thread stop', @match[1])
+      return errmsg(err) if err
 
       c.suspend
       display_context(c)
@@ -140,7 +157,9 @@ module Byebug
       end
 
       def description
-        %(th[read] stop <n>        Stops thread <n>.)
+        prettify <<-EOD
+          th[read] stop <n>  Stops thread <n>.
+        EOD
       end
     end
   end
@@ -149,7 +168,9 @@ module Byebug
   # Resume execution of a thread.
   #
   class ThreadResumeCommand < Command
-    self.allow_in_control     = true
+    include ThreadFunctions
+
+    self.allow_in_control = true
     self.allow_in_post_mortem = false
 
     def regexp
@@ -157,9 +178,10 @@ module Byebug
     end
 
     def execute
-      c = parse_thread_num_for_cmd('thread resume', @match[1])
-      return unless c
-      return errmsg('Already running') unless c.suspended?
+      c, err = parse_thread_num_for_cmd('thread resume', @match[1])
+      return errmsg(err) if err
+      return errmsg pr('thread.errors.already_running') unless c.suspended?
+
       c.resume
       display_context(c)
     end
@@ -170,7 +192,9 @@ module Byebug
       end
 
       def description
-        %(th[read] resume <n>        Resumes thread <n>.)
+        prettify <<-EOD
+          th[read] resume <n>   Resumes thread <n>.
+        EOD
       end
     end
   end
@@ -179,24 +203,22 @@ module Byebug
   # Switch execution to a different thread.
   #
   class ThreadSwitchCommand < Command
-    self.allow_in_control     = true
+    include ThreadFunctions
+
+    self.allow_in_control = true
     self.allow_in_post_mortem = false
 
     def regexp
-      /^\s* th(?:read)? \s+ (?:sw(?:itch)?\s+)? (\S+) \s*$/x
+      /^\s* th(?:read)? \s+ sw(?:itch)? (?:\s+(\S+))? \s*$/x
     end
 
     def execute
-      if @match[1] =~ /switch/
-        return errmsg('"thread switch" needs a thread number')
-      end
-
-      c = parse_thread_num_for_cmd('thread switch', @match[1])
-      return unless c
+      c, err = parse_thread_num_for_cmd('thread switch', @match[1])
+      return errmsg(err) if err
 
       display_context(c)
-      c.step_into 1
-      c.thread.run
+
+      c.switch
       @state.proceed
     end
 
@@ -206,7 +228,9 @@ module Byebug
       end
 
       def description
-        %(th[read] [sw[itch]] <nnn>        Switches thread context to <n>.)
+        prettify <<-EOD
+          th[read] sw[itch] <n>  Switches thread context to <n>.
+        EOD
       end
     end
   end

data/lib/byebug/commands/tracevar.rb

@@ -0,0 +1,56 @@
+require 'byebug/command'
+
+module Byebug
+  #
+  # Show (and possibily stop) at every line that changes a global variable.
+  #
+  class TracevarCommand < Command
+    self.allow_in_post_mortem = false
+
+    def regexp
+      /^\s* tr(?:acevar)? (?: \s+ (\S+))?  # (variable-name)?
+                          (?: \s+ (stop|nostop))?
+       \s*$/x
+    end
+
+    def execute
+      var = @match[1]
+      return errmsg(pr('trace.errors.needs_global_variable')) unless var
+
+      unless global_variables.include?(:"#{var}")
+        return errmsg(pr('trace.errors.var_is_not_global', name: var))
+      end
+
+      stop = @match[2] && @match[2] !~ /nostop/
+
+      instance_eval do
+        trace_var(:"#{var}") { |val| on_change(var, val, stop) }
+      end
+
+      puts pr('trace.messages.success', var: var)
+    end
+
+    def on_change(name, value, stop)
+      puts pr('trace.messages.on_change', name: name, value: value)
+      byebug(1, false) if stop
+    end
+
+    class << self
+      def names
+        %w(tracevar)
+      end
+
+      def description
+        prettify <<-EOD
+          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.
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/undisplay.rb

@@ -1,3 +1,5 @@
+require 'byebug/command'
+
 module Byebug
   #
   # Remove expressions from display list.
@@ -15,12 +17,12 @@ module Byebug
         return errmsg(err) unless err.nil?
 
         unless @state.display[pos - 1]
-          return errmsg("Display expression #{pos} is not defined.")
+          return errmsg(pr('display.errors.undefined', expr: pos))
         end
 
         @state.display[pos - 1][0] = nil
       else
-        return unless confirm('Clear all expressions? (y/n) ')
+        return unless confirm(pr('display.confirmations.clear_all'))
 
         @state.display.each { |d| d[0] = false }
       end
@@ -32,13 +34,15 @@ module Byebug
       end
 
       def description
-        %(undisp[lay][ nnn]
+        prettify <<-EOD
+          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.)
+          the current list of code numbers.
+        EOD
       end
     end
   end

data/lib/byebug/commands/untracevar.rb

@@ -0,0 +1,38 @@
+require 'byebug/command'
+
+module Byebug
+  #
+  # Stop tracing a global variable.
+  #
+  class UntracevarCommand < Command
+    self.allow_in_post_mortem = false
+
+    def regexp
+      /^\s* untr(?:acevar)? (?:\s+ (\S+))? \s*$/x
+    end
+
+    def execute
+      var = @match[1]
+      if global_variables.include?(:"#{var}")
+        eval("untrace_var(:\"#{var}\")")
+        puts pr('trace.messages.undo', var: var)
+      else
+        errmsg pr('trace.errors.not_global', var: var)
+      end
+    end
+
+    class << self
+      def names
+        %w(untracevar)
+      end
+
+      def description
+        prettify <<-EOD
+          untr[acevar] <variable>
+
+          Stop tracing global variable <variable>.
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/var.rb

@@ -0,0 +1,107 @@
+require 'byebug/command'
+
+module Byebug
+  #
+  # Utilities for the var command.
+  #
+  module VarFunctions
+    def var_list(ary, b = get_binding)
+      vars = ary.sort.map do |v|
+        s = begin
+          b.eval(v.to_s).inspect
+        rescue
+          begin
+            b.eval(v.to_s).to_s
+          rescue
+            '*Error in evaluation*'
+          end
+        end
+        [v, s]
+      end
+      puts prv(vars)
+    end
+
+    def var_global(_str = nil)
+      globals = global_variables.reject do |v|
+        [:$IGNORECASE, :$=, :$KCODE, :$-K, :$binding].include?(v)
+      end
+
+      var_list(globals)
+    end
+
+    def var_instance(str)
+      obj = bb_warning_eval(str || 'self')
+      var_list(obj.instance_variables, obj.instance_eval { binding })
+    end
+
+    def var_constant(str)
+      str ||= 'self.class'
+      obj = bb_warning_eval(str)
+      is_mod = obj.is_a?(Module)
+      return errmsg(pr('variable.errors.not_module', object: str)) unless is_mod
+
+      constants = bb_eval("#{str}.constants")
+      puts prv(constants.sort.map { |c| [c, obj.const_get(c)] })
+    end
+
+    def var_local(_str = nil)
+      _self = @state.context.frame_self(@state.frame)
+      locals = @state.context.frame_locals
+      puts prv(locals.keys.sort.map { |k| [k, locals[k]] })
+    end
+
+    def var_all(_str = nil)
+      var_global
+      var_instance('self')
+      var_local
+    end
+  end
+
+  #
+  # Show variables and its values.
+  #
+  class VarCommand < Command
+    include VarFunctions
+
+    Subcommands = [
+      ['constant', 2, 'Show constants of an object'],
+      ['global', 1, 'Show global variables'],
+      ['instance', 1, 'Show instance variables of self or a specific object'],
+      ['local', 1, 'Show local variables in current scope'],
+      ['all', 1, 'Shows local, global and instance variables of self']
+    ].map do |name, min, help|
+      Subcmd.new(name, min, help)
+    end
+
+    def regexp
+      /^\s* v(?:ar)? (?: \s+(\S+) (?:\s(\S+))? )? \s*$/x
+    end
+
+    def execute
+      return puts(self.class.help) unless @match[1]
+
+      subcmd = Command.find(Subcommands, @match[1])
+      return errmsg("Unknown var command #{@match[1]}\n") unless subcmd
+
+      if @state.context
+        send("var_#{subcmd.name}", @match[2])
+      else
+        errmsg "'var #{subcmd.name}' not available without a context.\n"
+      end
+    end
+
+    class << self
+      def names
+        %w(var)
+      end
+
+      def description
+        prettify <<-EOD
+          [v]ar
+
+          Show variables and its values.
+        EOD
+      end
+    end
+  end
+end