byebug 5.0.0 → 6.0.0

data/lib/byebug/commands/tracevar.rb

@@ -5,14 +5,28 @@ 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
+    def self.regexp
       /^\s* tr(?:acevar)? (?: \s+ (\S+))?  # (variable-name)?
                           (?: \s+ (stop|nostop))?
        \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        tr[acevar] <variable> [[no]stop]
+
+        #{short_description}
+
+        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
+
+    def self.short_description
+      'Enables tracing of a global variable'
+    end
+
     def execute
       var = @match[1]
       return errmsg(pr('trace.errors.needs_global_variable')) unless var
@@ -30,22 +44,12 @@ module Byebug
       puts pr('trace.messages.success', var: var)
     end
 
+    private
+
     def on_change(name, value, stop)
       puts pr('trace.messages.on_change', name: name, value: value)
 
-      @state.context.step_out(1, false) if stop
-    end
-
-    def description
-      <<-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
+      context.step_out(1, false) if stop
     end
   end
 end

data/lib/byebug/commands/undisplay.rb

@@ -8,39 +8,43 @@ module Byebug
   class UndisplayCommand < Command
     include Helpers::ParseHelper
 
-    self.allow_in_post_mortem = false
+    self.allow_in_post_mortem = true
 
-    def regexp
+    def self.regexp
       /^\s* undisp(?:lay)? (?:\s+(\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        undisp[lay][ nnn]
+
+        #{short_description}
+
+        Arguments are the code numbers of the expressions to stop displaying. No
+        argument means cancel all automatic-display expressions. Type "info
+        display" to see the current list of code numbers.
+      EOD
+    end
+
+    def self.short_description
+      'Stops displaying all or some expressions when program stops'
+    end
+
     def execute
       if @match[1]
-        pos, err = get_int(@match[1], 'Undisplay', 1, @state.display.size)
+        pos, err = get_int(@match[1], 'Undisplay', 1, Byebug.displays.size)
         return errmsg(err) unless err.nil?
 
-        unless @state.display[pos - 1]
+        unless Byebug.displays[pos - 1]
           return errmsg(pr('display.errors.undefined', expr: pos))
         end
 
-        @state.display[pos - 1][0] = nil
+        Byebug.displays[pos - 1][0] = nil
       else
         return unless confirm(pr('display.confirmations.clear_all'))
 
-        @state.display.each { |d| d[0] = false }
+        Byebug.displays.each { |d| d[0] = false }
       end
     end
-
-    def description
-      <<-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.
-      EOD
-    end
   end
 end

data/lib/byebug/commands/untracevar.rb

@@ -5,12 +5,22 @@ module Byebug
   # Stop tracing a global variable.
   #
   class UntracevarCommand < Command
-    self.allow_in_post_mortem = false
-
-    def regexp
+    def self.regexp
       /^\s* untr(?:acevar)? (?:\s+ (\S+))? \s*$/x
     end
 
+    def self.description
+      <<-EOD
+        untr[acevar] <variable>
+
+        #{short_description}
+      EOD
+    end
+
+    def self.short_description
+      'Stops tracing a global variable'
+    end
+
     def execute
       var = @match[1]
       if global_variables.include?(:"#{var}")
@@ -20,13 +30,5 @@ module Byebug
         errmsg pr('trace.errors.not_global', var: var)
       end
     end
-
-    def description
-      <<-EOD
-        untr[acevar] <variable>
-
-        Stop tracing global variable <variable>.
-      EOD
-    end
   end
 end

data/lib/byebug/commands/up.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'pathname'
 require 'byebug/command'
 require 'byebug/helpers/frame'
@@ -13,27 +11,33 @@ module Byebug
     include Helpers::FrameHelper
     include Helpers::ParseHelper
 
-    def regexp
-      /^\s* u(?:p)? (?:\s+(\S+))? \s*$/x
-    end
+    self.allow_in_post_mortem = true
 
-    def execute
-      pos, err = parse_steps(@match[1], 'Up')
-      return errmsg(err) unless pos
-
-      adjust_frame(pos, false)
-
-      ListCommand.new(@state).execute if Setting[:autolist]
+    def self.regexp
+      /^\s* u(?:p)? (?:\s+(\S+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         up[ count]
 
-        Move to a higher frame in the stack trace.
+        #{short_description}
 
         Use the "bt" command to find out where you want to go.
       EOD
     end
+
+    def self.short_description
+      'Moves to a higher frame in the stack trace'
+    end
+
+    def execute
+      pos, err = parse_steps(@match[1], 'Up')
+      return errmsg(err) unless pos
+
+      jump_frames(pos)
+
+      ListCommand.new(processor).execute if Setting[:autolist]
+    end
   end
 end

data/lib/byebug/commands/var.rb

@@ -1,6 +1,7 @@
 require 'byebug/subcommands'
 
 require 'byebug/commands/var/all'
+require 'byebug/commands/var/args'
 require 'byebug/commands/var/const'
 require 'byebug/commands/var/instance'
 require 'byebug/commands/var/local'
@@ -13,16 +14,22 @@ module Byebug
   class VarCommand < Command
     include Subcommands
 
-    def regexp
+    self.allow_in_post_mortem = true
+
+    def self.regexp
       /^\s* v(?:ar)? (?:\s+ (.+))? \s*$/x
     end
 
-    def description
+    def self.description
       <<-EOD
         [v]ar <subcommand>
 
-        Shows variables and its values.
+        #{short_description}
       EOD
     end
+
+    def self.short_description
+      'Shows variables and its values'
+    end
   end
 end

data/lib/byebug/commands/var/all.rb

@@ -8,30 +8,32 @@ module Byebug
     #
     # Shows global, instance and local variables
     #
-    class AllSubcommand < Command
+    class AllCommand < Command
       include Helpers::VarHelper
 
-      def regexp
-        /^\s* a(?:ll)? \s*$/x
-      end
-
-      def execute
-        var_global
-        var_instance('self')
-        var_local
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Shows local, global and instance variables of self.'
+      def self.regexp
+        /^\s* a(?:ll)? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           v[ar] a[ll]
 
           #{short_description}
         EOD
       end
+
+      def self.short_description
+        'Shows local, global and instance variables of self.'
+      end
+
+      def execute
+        var_global
+        var_instance('self')
+        var_local
+      end
     end
   end
 end

data/lib/byebug/commands/var/args.rb

@@ -0,0 +1,37 @@
+require 'byebug/helpers/var'
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +args+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Information about arguments of the current method/block
+    #
+    class ArgsCommand < Command
+      include Helpers::VarHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
+        /^\s* a(?:rgs)? \s*$/x
+      end
+
+      def self.description
+        <<-EOD
+          v[ar] a[args]
+
+          #{short_description}
+        EOD
+      end
+
+      def self.short_description
+        'Information about arguments of the current scope'
+      end
+
+      def execute
+        var_args
+      end
+    end
+  end
+end

data/lib/byebug/commands/var/const.rb

@@ -1,3 +1,5 @@
+require 'byebug/helpers/eval'
+
 module Byebug
   #
   # Reopens the +var+ command to define the +const+ subcommand
@@ -6,32 +8,41 @@ module Byebug
     #
     # Shows constants
     #
-    class ConstSubcommand < Command
-      def regexp
+    class ConstCommand < Command
+      include Helpers::EvalHelper
+
+      self.allow_in_post_mortem = true
+
+      def self.regexp
         /^\s* c(?:onst)? (?:\s+ (.+))? \s*$/x
       end
 
+      def self.description
+        <<-EOD
+          v[ar] c[onstant]
+
+          #{short_description}
+        EOD
+      end
+
+      def self.short_description
+        'Shows constants of an object.'
+      end
+
       def execute
-        str_obj = @match[1] || 'self.class'
-        obj = bb_warning_eval(str_obj)
+        obj = single_thread_eval(str_obj)
         unless obj.is_a?(Module)
           return errmsg(pr('variable.errors.not_module', object: str_obj))
         end
 
-        constants = bb_eval("#{str_obj}.constants")
+        constants = single_thread_eval("#{str_obj}.constants")
         puts prv(constants.sort.map { |c| [c, obj.const_get(c)] }, 'constant')
       end
 
-      def short_description
-        'Shows constants of an object.'
-      end
-
-      def description
-        <<-EOD
-          v[ar] c[onstant]
+      private
 
-          #{short_description}
-        EOD
+      def str_obj
+        @str_obj ||= @match[1] || 'self.class'
       end
     end
   end

data/lib/byebug/commands/var/global.rb

@@ -6,28 +6,30 @@ module Byebug
     #
     # Shows global variables
     #
-    class GlobalSubcommand < Command
+    class GlobalCommand < Command
       include Helpers::VarHelper
 
-      def regexp
-        /^\s* g(?:lobal)? \s*$/x
-      end
-
-      def execute
-        var_global
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Shows global variables.'
+      def self.regexp
+        /^\s* g(?:lobal)? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           v[ar] g[lobal]
 
           #{short_description}
         EOD
       end
+
+      def self.short_description
+        'Shows global variables.'
+      end
+
+      def execute
+        var_global
+      end
     end
   end
 end

data/lib/byebug/commands/var/instance.rb

@@ -8,28 +8,30 @@ module Byebug
     #
     # Shows instance variables
     #
-    class InstanceSubcommand < Command
+    class InstanceCommand < Command
       include Helpers::VarHelper
 
-      def regexp
-        /^\s* i(?:nstance)? (?:\s+ (.+))? \s*$/x
-      end
-
-      def execute
-        var_instance(@match[1])
-      end
+      self.allow_in_post_mortem = true
 
-      def short_description
-        'Shows instance variables of self or a specific object.'
+      def self.regexp
+        /^\s* i(?:nstance)? (?:\s+ (.+))? \s*$/x
       end
 
-      def description
+      def self.description
         <<-EOD
           v[ar] i[nstance][ <object>]
 
           #{short_description}
         EOD
       end
+
+      def self.short_description
+        'Shows instance variables of self or a specific object.'
+      end
+
+      def execute
+        var_instance(@match[1])
+      end
     end
   end
 end