byebug 4.0.5 → 5.0.0

data/lib/byebug/commands/untracevar.rb

@@ -21,18 +21,12 @@ module Byebug
       end
     end
 
-    class << self
-      def names
-        %w(untracevar)
-      end
-
-      def description
-        prettify <<-EOD
-          untr[acevar] <variable>
+    def description
+      <<-EOD
+        untr[acevar] <variable>
 
-          Stop tracing global variable <variable>.
-        EOD
-      end
+        Stop tracing global variable <variable>.
+      EOD
     end
   end
 end

data/lib/byebug/commands/up.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'pathname'
+require 'byebug/command'
+require 'byebug/helpers/frame'
+require 'byebug/helpers/parse'
+
+module Byebug
+  #
+  # Move the current frame up in the backtrace.
+  #
+  class UpCommand < Command
+    include Helpers::FrameHelper
+    include Helpers::ParseHelper
+
+    def regexp
+      /^\s* u(?:p)? (?:\s+(\S+))? \s*$/x
+    end
+
+    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]
+    end
+
+    def description
+      <<-EOD
+        up[ count]
+
+        Move to a higher frame in the stack trace.
+
+        Use the "bt" command to find out where you want to go.
+      EOD
+    end
+  end
+end

data/lib/byebug/commands/var.rb

@@ -1,107 +1,28 @@
-require 'byebug/command'
+require 'byebug/subcommands'
 
-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
+require 'byebug/commands/var/all'
+require 'byebug/commands/var/const'
+require 'byebug/commands/var/instance'
+require 'byebug/commands/var/local'
+require 'byebug/commands/var/global'
 
+module Byebug
   #
-  # Show variables and its values.
+  # Shows 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
+    include Subcommands
 
     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
+      /^\s* v(?:ar)? (?:\s+ (.+))? \s*$/x
     end
 
-    class << self
-      def names
-        %w(var)
-      end
-
-      def description
-        prettify <<-EOD
-          [v]ar
+    def description
+      <<-EOD
+        [v]ar <subcommand>
 
-          Show variables and its values.
-        EOD
-      end
+        Shows variables and its values.
+      EOD
     end
   end
 end

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

@@ -0,0 +1,37 @@
+require 'byebug/helpers/var'
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +all+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows global, instance and local variables
+    #
+    class AllSubcommand < Command
+      include Helpers::VarHelper
+
+      def regexp
+        /^\s* a(?:ll)? \s*$/x
+      end
+
+      def execute
+        var_global
+        var_instance('self')
+        var_local
+      end
+
+      def short_description
+        'Shows local, global and instance variables of self.'
+      end
+
+      def description
+        <<-EOD
+          v[ar] a[ll]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Byebug
+  #
+  # Reopens the +var+ command to define the +const+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows constants
+    #
+    class ConstSubcommand < Command
+      def regexp
+        /^\s* c(?:onst)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def execute
+        str_obj = @match[1] || 'self.class'
+        obj = bb_warning_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")
+        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]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Byebug
+  #
+  # Reopens the +var+ command to define the +global+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows global variables
+    #
+    class GlobalSubcommand < Command
+      include Helpers::VarHelper
+
+      def regexp
+        /^\s* g(?:lobal)? \s*$/x
+      end
+
+      def execute
+        var_global
+      end
+
+      def short_description
+        'Shows global variables.'
+      end
+
+      def description
+        <<-EOD
+          v[ar] g[lobal]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'byebug/helpers/var'
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +instance+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows instance variables
+    #
+    class InstanceSubcommand < Command
+      include Helpers::VarHelper
+
+      def regexp
+        /^\s* i(?:nstance)? (?:\s+ (.+))? \s*$/x
+      end
+
+      def execute
+        var_instance(@match[1])
+      end
+
+      def short_description
+        'Shows instance variables of self or a specific object.'
+      end
+
+      def description
+        <<-EOD
+          v[ar] i[nstance][ <object>]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'byebug/helpers/var'
+
+module Byebug
+  #
+  # Reopens the +var+ command to define the +local+ subcommand
+  #
+  class VarCommand < Command
+    #
+    # Shows local variables in current scope
+    #
+    class LocalSubcommand < Command
+      include Helpers::VarHelper
+
+      def regexp
+        /^\s* l(?:ocal)? \s*$/x
+      end
+
+      def execute
+        var_local
+      end
+
+      def short_description
+        'Shows local variables in current scope.'
+      end
+
+      def description
+        <<-EOD
+          v[ar] l[ocal]
+
+          #{short_description}
+        EOD
+      end
+    end
+  end
+end

data/lib/byebug/commands/where.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'pathname'
+require 'byebug/command'
+require 'byebug/helpers/frame'
+
+module Byebug
+  #
+  # Show current backtrace.
+  #
+  class WhereCommand < Command
+    include Helpers::FrameHelper
+
+    def regexp
+      /^\s* (?:w(?:here)?|bt|backtrace) \s*$/x
+    end
+
+    def execute
+      print_backtrace
+    end
+
+    def description
+      <<-EOD
+        w[here]|bt|backtrace
+
+        Display stack frames.
+
+        Print the entire stack frame. Each frame is numbered; the most recent
+        frame is 0. A frame number can be referred to in the "frame" command.
+        "up" and "down" add or subtract respectively to frame numbers shown.
+        The position of the current frame is marked with -->. C-frames hang
+        from their most immediate Ruby frame to indicate that they are not
+        navigable.
+      EOD
+    end
+
+    private
+
+    def print_backtrace
+      bt = prc('frame.line', (0...@state.context.stack_size)) do |_, index|
+        get_pr_arguments(index)
+      end
+
+      print(bt)
+    end
+  end
+end

data/lib/byebug/core.rb

@@ -55,6 +55,16 @@ module Byebug
     run_script(cwd_rc) if File.exist?(cwd_rc) && cwd_rc != home_rc
   end
 
+  #
+  # A Byebug command is a class defined right under the Byebug module and
+  # named <something>Command
+  #
+  def commands
+    const_list = constants.map { |const| const_get(const, false) }
+
+    const_list.select { |c| c.is_a?(Class) && c.name =~ /[a-z]Command$/ }
+  end
+
   private
 
   #

data/lib/byebug/helpers/eval.rb

@@ -0,0 +1,47 @@
+module Byebug
+  module Helpers
+    #
+    # Utilities used by the eval command
+    #
+    module EvalHelper
+      #
+      # Run block temporarily ignoring all TracePoint events.
+      #
+      # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
+      # creating new threads won't be properly evaluated because new threads
+      # will get blocked by byebug's main thread.
+      #
+      def allowing_other_threads
+        Byebug.unlock
+        res = yield
+        Byebug.lock
+        res
+      end
+
+      #
+      # Get current binding and yield it to the given block
+      #
+      def run_with_binding
+        binding = get_binding
+        yield binding
+      end
+
+      #
+      # Evaluate +expression+ using +binding+
+      #
+      # @param binding [Binding] Context where to evaluate the expression
+      # @param expression [String] Expression to evaluation
+      # @param stack_on_error [Boolean] Whether to show a stack trace on error.
+      #
+      def eval_with_setting(binding, expression, stack_on_error)
+        allowing_other_threads do
+          if stack_on_error
+            bb_eval(expression, binding)
+          else
+            bb_warning_eval(expression, binding)
+          end
+        end
+      end
+    end
+  end
+end