byebug 4.0.5 → 5.0.0

data/lib/byebug/commands/enable_disable.rb

@@ -1,132 +0,0 @@
-require 'byebug/command'
-
-module Byebug
-  #
-  # Mixin to assist command parsing
-  #
-  module EnableDisableFunctions
-    def enable_disable_breakpoints(is_enable, args)
-      return errmsg(pr('toggle.errors.no_breakpoints')) if Breakpoint.none?
-
-      all_breakpoints = Byebug.breakpoints.sort_by(&:id)
-      if args.empty?
-        selected_breakpoints = all_breakpoints
-      else
-        selected_ids = []
-        args.each do |pos|
-          last_id = all_breakpoints.last.id
-          pos, err = get_int(pos, "#{is_enable} breakpoints", 1, last_id)
-          return errmsg(err) unless pos
-
-          selected_ids << pos
-        end
-        selected_breakpoints = all_breakpoints.select do |b|
-          selected_ids.include?(b.id)
-        end
-      end
-
-      selected_breakpoints.each do |b|
-        enabled = ('enable' == is_enable)
-        if enabled && !syntax_valid?(b.expr)
-          return errmsg(pr('toggle.errors.expression', expr: b.expr))
-        end
-
-        b.enabled = enabled
-      end
-    end
-
-    def enable_disable_display(is_enable, args)
-      return errmsg(pr('toggle.errors.no_display')) if 0 == @state.display.size
-
-      args.each do |pos|
-        pos, err = get_int(pos, "#{is_enable} display", 1, @state.display.size)
-        return errmsg(err) unless err.nil?
-
-        @state.display[pos - 1][0] = ('enable' == is_enable)
-      end
-    end
-  end
-
-  #
-  # Enabling or disabling custom display expressions or breakpoints.
-  #
-  class EnableDisableCommand < Command
-    include EnableDisableFunctions
-
-    Subcommands = [
-      ['breakpoints', 2, 'Enable/disable breakpoints. Give breakpoint '      \
-                         'numbers (separated by spaces) as arguments or no ' \
-                         'argument at all if you want to enable/disable '    \
-                         'every breakpoint'],
-      ['display', 2, 'Enable/disable some expressions to be displayed when ' \
-                     ' when program stops. Arguments are the code numbers '  \
-                     'of the expressions to resume/stop displaying. Do '     \
-                     '"info display" to see the current list of code '       \
-                     'numbers']
-    ].map do |name, min, help|
-      Subcmd.new(name, min, help)
-    end
-
-    def regexp
-      /^\s* (dis|en)(?:able)? (?:\s+(.+))? \s*$/x
-    end
-
-    def execute
-      cmd = @match[1] == 'dis' ? 'disable' : 'enable'
-
-      return errmsg(pr('toggle.errors.syntax', toggle: cmd)) unless @match[2]
-
-      args = @match[2].split(/ +/)
-      param = args.shift
-      subcmd = Command.find(Subcommands, param)
-      if subcmd
-        send("#{cmd}_#{subcmd.name}", args)
-      else
-        send("#{cmd}_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
-
-    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((en|dis)able)
-      end
-
-      def description
-        prettify <<-EOD
-          (en|dis)[able][[ (breakpoints|display)][ n1[ n2[ ...[ nn]]]]]
-
-           Enables or disables breakpoints or displays.
-
-           "enable" by itself enables all breakpoints, just like
-           "enable breakpoints". On the other side, "disable" or
-           "disable breakpoints" disable all breakpoints.
-
-           You can also specify a space separated list of breakpoint numbers to
-           enable or disable specific breakpoints. You can use either
-           "enable <id1> ... <idn>" or "enable breakpoints <id1> ... <idn>" and
-           the same with "disable".
-
-           If instead of "breakpoints" you specify "display", the command will
-           work exactly the same way, but displays will get enabled/disabled
-           instead of breakpoints.
-         EOD
-      end
-    end
-  end
-end

data/lib/byebug/commands/stepping.rb

@@ -1,75 +0,0 @@
-require 'byebug/command'
-
-module Byebug
-  #
-  # Implements the next functionality.
-  #
-  # Allows the user the continue execution until the next instruction in the
-  # current frame.
-  #
-  class NextCommand < Command
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* n(?:ext)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      steps, err = parse_steps(@match[1], 'Next')
-      return errmsg(err) unless steps
-
-      @state.context.step_over(steps, @state.frame)
-      @state.proceed
-    end
-
-    class << self
-      def names
-        %w(next)
-      end
-
-      def description
-        prettify <<-EOD
-          n[ext][ nnn]
-
-          Steps over once or nnn times.
-        EOD
-      end
-    end
-  end
-
-  #
-  # Implements the step functionality.
-  #
-  # Allows the user the continue execution until the next instruction, possibily
-  # in a different frame. Use step to step into method calls or blocks.
-  #
-  class StepCommand < Command
-    self.allow_in_post_mortem = false
-
-    def regexp
-      /^\s* s(?:tep)? (?:\s+(\S+))? \s*$/x
-    end
-
-    def execute
-      steps, err = parse_steps(@match[1], 'Steps')
-      return errmsg(err) unless steps
-
-      @state.context.step_into(steps, @state.frame)
-      @state.proceed
-    end
-
-    class << self
-      def names
-        %w(step)
-      end
-
-      def description
-        prettify <<-EOD
-          s[tep][ nnn]
-
-          Steps (into methods) once or nnn times.
-        EOD
-      end
-    end
-  end
-end

data/lib/byebug/helper.rb

@@ -1,131 +0,0 @@
-module Byebug
-  #
-  # Utilities for interaction with files
-  #
-  module FileFunctions
-    #
-    # Reads lines of source file +filename+ into an array
-    #
-    def get_lines(filename)
-      File.foreach(filename).reduce([]) { |a, e| a << e.chomp }
-    end
-
-    #
-    # Reads line number +lineno+ from file named +filename+
-    #
-    def get_line(filename, lineno)
-      File.open(filename) do |f|
-        f.gets until f.lineno == lineno - 1
-        f.gets
-      end
-    end
-
-    #
-    # Returns the number of lines in file +filename+ in a portable,
-    # one-line-at-a-time way.
-    #
-    def n_lines(filename)
-      File.foreach(filename).reduce(0) { |a, _e| a + 1 }
-    end
-
-    #
-    # Regularize file name.
-    #
-    def normalize(filename)
-      return filename if ['(irb)', '-e'].include?(filename)
-
-      return File.basename(filename) if Setting[:basename]
-
-      path = File.expand_path(filename)
-
-      File.exist?(path) ? File.realpath(path) : filename
-    end
-  end
-
-  #
-  # Utilities for interaction with files
-  #
-  module StringFunctions
-    #
-    # Converts +str+ from an_underscored-or-dasherized_string to
-    # ACamelizedString.
-    #
-    def camelize(str)
-      str.dup.split(/[_-]/).map(&:capitalize).join('')
-    end
-
-    #
-    # Improves indentation and spacing in +str+ for readability in Byebug's
-    # command prompt.
-    #
-    def prettify(str)
-      "\n" + str.gsub(/^ {8}/, '') + "\n"
-    end
-  end
-
-  #
-  # Utilities to assist command parsing
-  #
-  module ParseFunctions
-    #
-    # Parse 'str' of command 'cmd' as an integer between min and max. If either
-    # min or max is nil, that value has no bound.
-    #
-    def get_int(str, cmd, min = nil, max = nil)
-      if str !~ /\A[0-9]+\z/
-        return nil, pr('parse.errors.int.not_number', cmd: cmd, str: str)
-      end
-
-      int = str.to_i
-      if min && int < min
-        return min, pr('parse.errors.int.too_low', cmd: cmd, str: str, min: min)
-      elsif max && int > max
-        return max, pr('parse.errors.int.too_high',
-                       cmd: cmd, str: str, max: max)
-      end
-
-      int
-    end
-
-    #
-    # Returns true if code is syntactically correct for Ruby
-    #
-    def syntax_valid?(code)
-      return true unless code
-
-      without_stderr do
-        begin
-          RubyVM::InstructionSequence.compile(code)
-          true
-        rescue SyntaxError
-          false
-        end
-      end
-    end
-
-    #
-    # Temporarily disable output to $stderr
-    #
-    def without_stderr
-      stderr = $stderr
-      $stderr.reopen(IO::NULL)
-
-      yield
-    ensure
-      $stderr.reopen(stderr)
-    end
-
-    #
-    # Returns the number of steps specified in <str> as an integer or 1 if <str>
-    # is empty.
-    #
-    def parse_steps(str, cmd)
-      return 1 unless str
-
-      steps, err = get_int(str, cmd, 1)
-      return nil, err unless steps
-
-      steps
-    end
-  end
-end