byebug 3.2.0 → 3.3.0

data/lib/byebug/commands/enable.rb

@@ -1,154 +0,0 @@
-module Byebug
-  #
-  # Mixin to assist command parsing
-  #
-  module EnableDisableFunctions
-    def enable_disable_breakpoints(is_enable, args)
-      return errmsg "No breakpoints have been set" if Byebug.breakpoints.empty?
-
-      all_breakpoints = Byebug.breakpoints.sort_by {|b| b.id }
-      if args.empty?
-        selected_breakpoints = all_breakpoints
-      else
-        selected_ids = []
-        args.each do |pos|
-          pos = get_int(pos, "#{is_enable} breakpoints", 1, all_breakpoints.last.id)
-          return nil unless pos
-          selected_ids << pos
-        end
-        selected_breakpoints = all_breakpoints.select {
-          |b| selected_ids.include?(b.id) }
-      end
-
-      selected_breakpoints.each do |b|
-        enabled = ('enable' == is_enable)
-        if enabled && !syntax_valid?(b.expr)
-          errmsg "Expression \"#{b.expr}\" syntactically incorrect; " \
-                 "breakpoint remains disabled.\n"
-        else
-          b.enabled = enabled
-        end
-      end
-    end
-
-    def enable_disable_display(is_enable, args)
-      if 0 == @state.display.size
-        return errmsg "No display expressions have been set\n"
-      end
-      args.each do |pos|
-        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
-        return nil unless pos
-        @state.display[pos-1][0] = ('enable' == is_enable)
-      end
-    end
-  end
-
-  class EnableCommand < Command
-    Subcommands = [
-      ['breakpoints', 2, 'Enable breakpoints. This is used to cancel the '  \
-                         'effect of the "disable" command. Give breakpoint' \
-                         ' numbers (separated by spaces) as arguments or '  \
-                         'no argument at all if you want to reenable '      \
-                         'every breakpoint'                                   ],
-      ['display'    , 2, 'Enable some expressions to be displayed when '    \
-                         'program stops. Arguments are the code numbers of' \
-                         ' the expressions to resume displaying. Do "info ' \
-                         'display" to see the current list of code numbers'   ]
-    ].map do |name, min, help|
-      Subcmd.new(name, min, help)
-    end unless defined?(Subcommands)
-
-    def regexp
-      /^\s* en(?:able)? (?:\s+(.+))? \s*$/x
-    end
-
-    def execute
-      return errmsg "\"enable\" must be followed by \"display\", " \
-                    "\"breakpoints\" or breakpoint ids\n" unless @match[1]
-
-      args = @match[1].split(/[ \t]+/)
-      param = args.shift
-      subcmd = Command.find(Subcommands, param)
-      if subcmd
-        send("enable_#{subcmd.name}", args)
-      else
-        send('enable_breakpoints', args.unshift(param))
-      end
-    end
-
-    def enable_breakpoints(args)
-      enable_disable_breakpoints('enable', args)
-    end
-
-    def enable_display(args)
-      enable_disable_display('enable', args)
-    end
-
-    class << self
-      def names
-        %w(enable)
-      end
-
-      def description
-        %{Enable breakpoints or displays.
-
-          This is used to cancel the effect of the "disable" command.}
-      end
-    end
-  end
-
-  class DisableCommand < Command
-    Subcommands = [
-      ['breakpoints', 1, 'Disable breakpoints. A disabled breakpoint is '   \
-                         'not forgotten, but has no effect until '          \
-                         'reenabled. Give breakpoint numbers (separated by' \
-                         'spaces) as arguments or no argument at all if '   \
-                         'you want to disable every breakpoint'               ],
-      ['display'    , 1, 'Disable some display expressions when program '   \
-                         'stops. Arguments are the code numbers of the '    \
-                         'expressions to stop displaying. Do "info '        \
-                         'display" to see the current list of code numbers.'  ]
-    ].map do |name, min, help|
-      Subcmd.new(name, min, help)
-    end unless defined?(Subcommands)
-
-    def regexp
-      /^\s* dis(?:able)? (?:\s+(.+))? \s*$/x
-    end
-
-    def execute
-      return errmsg "\"disable\" must be followed by \"display\", " \
-                    "\"breakpoints\" or breakpoint ids\n" unless @match[1]
-
-      args = @match[1].split(/[ \t]+/)
-      param = args.shift
-      subcmd = Command.find(Subcommands, param)
-      if subcmd
-        send("disable_#{subcmd.name}", args)
-      else
-        send('disable_breakpoints', args.unshift(param))
-      end
-    end
-
-    def disable_breakpoints(args)
-      enable_disable_breakpoints('disable', args)
-    end
-
-    def disable_display(args)
-      enable_disable_display('disable', args)
-    end
-
-    class << self
-      def names
-        %w(disable)
-      end
-
-      def description
-        %{Disable breakpoints or displays.
-
-          A disabled item is not forgotten, but has no effect until reenabled.
-          Use the "enable" command to have it take effect again.}
-      end
-    end
-  end
-end

data/lib/byebug/commands/repl.rb

@@ -1,126 +0,0 @@
-module IRB
-  module ExtendCommand
-    class Continue
-      def self.execute(conf)
-        throw :IRB_EXIT, :cont
-      end
-    end
-    class Next
-      def self.execute(conf)
-        throw :IRB_EXIT, :next
-      end
-    end
-    class Step
-      def self.execute(conf)
-        throw :IRB_EXIT, :step
-      end
-    end
-  end
-
-  require 'irb'
-  ExtendCommandBundle.def_extend_command 'cont', :Continue
-  ExtendCommandBundle.def_extend_command 'next', :Next
-  ExtendCommandBundle.def_extend_command 'step', :Step
-
-  def self.start_session(binding)
-    unless @__initialized ||= false
-      args = ARGV.dup
-      ARGV.replace([])
-      IRB.setup(nil)
-      ARGV.replace(args)
-      @__initialized = true
-    end
-
-    workspace = WorkSpace.new(binding)
-    irb = Irb.new(workspace)
-
-    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
-    @CONF[:MAIN_CONTEXT] = irb.context
-
-    trap('SIGINT') do
-      irb.signal_handle
-    end
-
-    catch(:IRB_EXIT) do
-      irb.eval_input
-    end
-  end
-end
-
-module Byebug
-  class IrbCommand < Command
-    def regexp
-      /^\s* irb \s*$/x
-    end
-
-    def execute
-      unless @state.interface.kind_of?(LocalInterface)
-        print "Command is available only in local mode.\n"
-        throw :debug_error
-      end
-
-      cont = IRB.start_session(get_binding)
-      case cont
-      when :cont
-        @state.proceed
-      when :step
-        force = Setting[:forcestep]
-        @state.context.step_into 1, force
-        @state.proceed
-      when :next
-        force = Setting[:forcestep]
-        @state.context.step_over 1, @state.frame_pos, force
-        @state.proceed
-      else
-        print @state.location
-        @state.previous_line = nil
-      end
-    end
-
-    class << self
-      def names
-        %w(irb)
-      end
-
-      def description
-        %{irb\tstarts an Interactive Ruby (IRB) session.
-
-          IRB is extended with methods "cont", "n" and "step" which run the
-          corresponding byebug commands. In contrast to the real byebug commands
-          these commands don't allow arguments.}
-      end
-    end
-  end
-
-  begin
-    require 'pry'
-    has_pry = true
-  rescue LoadError
-    has_pry = false
-  end
-
-  class PryCommand < Command
-    def regexp
-      /^\s* pry \s*$/x
-    end
-
-    def execute
-      unless @state.interface.kind_of?(LocalInterface)
-        print "Command is available only in local mode.\n"
-        throw :debug_error
-      end
-
-      get_binding.pry
-    end
-
-    class << self
-      def names
-        %w(pry)
-      end
-
-      def description
-        %{pry\tstarts a Pry session.}
-      end
-    end
-  end if has_pry
-end

data/test/irb_test.rb

@@ -1,47 +0,0 @@
-module Byebug
-  class IrbTestCase < TestCase
-    def setup
-      @example = -> do
-        byebug
-        a = 2
-        a = 3
-        a = 4
-        a = 5
-        a = 6
-      end
-
-      super
-
-      interface.stubs(:kind_of?).with(LocalInterface).returns(true)
-      IRB::Irb.stubs(:new).returns(irb)
-    end
-
-    def irb
-      @irb ||= stub(context: -> {})
-    end
-
-    def test_irb_supports_next_command
-      irb.stubs(:eval_input).throws(:IRB_EXIT, :next)
-      enter 'irb'
-      debug_proc(@example) { assert_equal 7, state.line }
-    end
-
-    def test_irb_supports_step_command
-      irb.stubs(:eval_input).throws(:IRB_EXIT, :step)
-      enter 'irb'
-      debug_proc(@example) { assert_equal 7, state.line }
-    end
-
-    def test_irb_supports_cont_command
-      irb.stubs(:eval_input).throws(:IRB_EXIT, :cont)
-      enter 'break 8', 'irb'
-      debug_proc(@example) { assert_equal 8, state.line }
-    end
-
-    def test_autoirb_calls_irb_automatically_after_every_stop
-      irb.expects(:eval_input)
-      enter 'set autoirb', 'break 8', 'cont'
-      debug_proc(@example)
-    end
-  end
-end

data/test/support/breakpoint.rb

@@ -1,13 +0,0 @@
-module Byebug
-
-  class Breakpoint
-
-    def inspect
-      values = %w{id pos source expr hit_condition hit_count hit_value enabled?}.map do |field|
-        "#{field}: #{send(field)}"
-      end.join(", ")
-      "#<Byebug::Breakpoint #{values}>"
-    end
-
-  end
-end