byebug 5.0.0 → 6.0.0

data/lib/byebug/interface.rb

@@ -19,6 +19,11 @@ module Byebug
     def initialize
       @command_queue = []
       @history = History.new
+      @last_line = ''
+    end
+
+    def last_if_empty(input)
+      @last_line = input.empty? ? @last_line : input
     end
 
     #
@@ -27,11 +32,7 @@ module Byebug
     def read_command(prompt)
       return command_queue.shift unless command_queue.empty?
 
-      cmds = read_input(prompt)
-      return unless cmds
-
-      command_queue.concat(cmds)
-      command_queue.shift
+      read_input(prompt)
     end
 
     #
@@ -42,15 +43,32 @@ module Byebug
     end
 
     #
-    # Reads a new line from the interface's input stream.
+    # Reads a new line from the interface's input stream, parses it into
+    # commands and saves it to history.
+    #
+    # @return [String] Representing something to be run by the debugger.
     #
     def read_input(prompt, save_hist = true)
-      line = readline(prompt)
+      line = prepare_input(prompt)
       return unless line
 
       history.push(line) if save_hist
 
-      split_commands(line)
+      command_queue.concat(split_commands(line))
+      command_queue.shift
+    end
+
+    #
+    # Reads a new line from the interface's input stream.
+    #
+    # @return [String] New string read or the previous string if the string
+    # read now was empty.
+    #
+    def prepare_input(prompt)
+      line = readline(prompt)
+      return unless line
+
+      last_if_empty(line)
     end
 
     #
@@ -106,7 +124,7 @@ module Byebug
 
       cmd_line.split(/;/).each_with_object([]) do |v, m|
         if m.empty? || m.last[-1] != '\\'
-          m << v
+          m << v.strip
           next
         end
 

data/lib/byebug/option_setter.rb

@@ -0,0 +1,93 @@
+module Byebug
+  #
+  # Handles byebug's command line options
+  #
+  class OptionSetter
+    def initialize(runner, opts)
+      @runner = runner
+      @opts = opts
+    end
+
+    def setup
+      debug
+      include_flag
+      post_mortem
+      quit
+      rc
+      stop
+      require_flag
+      remote
+      trace
+      version
+      help
+    end
+
+    private
+
+    def debug
+      @opts.on '-d', '--debug', 'Set $DEBUG=true' do
+        $DEBUG = true
+      end
+    end
+
+    def include_flag
+      @opts.on('-I', '--include list', 'Add to paths to $LOAD_PATH') do |list|
+        $LOAD_PATH.push(list.split(':')).flatten!
+      end
+    end
+
+    def post_mortem
+      @opts.on '-m', '--[no-]post-mortem', 'Use post-mortem mode' do |v|
+        Setting[:post_mortem] = v
+      end
+    end
+
+    def quit
+      @opts.on '-q', '--[no-]quit', 'Quit when script finishes' do |v|
+        @runner.quit = v
+      end
+    end
+
+    def rc
+      @opts.on '-x', '--[no-]rc', 'Run byebug initialization file' do |v|
+        Byebug.run_init_script if v
+      end
+    end
+
+    def stop
+      @opts.on '-s', '--[no-]stop', 'Stop when script is loaded' do |v|
+        @runner.stop = v
+      end
+    end
+
+    def require_flag
+      @opts.on '-r', '--require file', 'Require library before script' do |lib|
+        require lib
+      end
+    end
+
+    def remote
+      @opts.on '-R', '--remote [host:]port', 'Remote debug [host:]port' do |p|
+        @runner.remote = p
+      end
+    end
+
+    def trace
+      @opts.on '-t', '--[no-]trace', 'Turn on line tracing' do |v|
+        Setting[:linetrace] = v
+      end
+    end
+
+    def version
+      @opts.on '-v', '--version', 'Print program version' do
+        @runner.version = Byebug::VERSION
+      end
+    end
+
+    def help
+      @opts.on('-h', '--help', 'Display this message') do
+        @runner.help = @opts.help
+      end
+    end
+  end
+end

data/lib/byebug/printers/base.rb

@@ -2,6 +2,9 @@ require 'yaml'
 
 module Byebug
   module Printers
+    #
+    # Base printer
+    #
     class Base
       class MissedPath < StandardError; end
       class MissedArgument < StandardError; end

data/lib/byebug/printers/plain.rb

@@ -2,9 +2,10 @@ require 'byebug/printers/base'
 
 module Byebug
   module Printers
+    #
+    # Plain text printer
+    #
     class Plain < Base
-      include Columnize
-
       def print(path, args = {})
         message = translate(locate(path), args)
         tail = parts(path).include?('confirmations') ? ' (y/n) ' : "\n"
@@ -12,16 +13,11 @@ module Byebug
       end
 
       def print_collection(path, collection, &block)
-        modifier = get_modifier(path)
         lines = array_of_args(collection, &block).map do |args|
           print(path, args)
         end
 
-        if modifier == 'c'
-          columnize(lines.map { |l| l.gsub(/\n$/, '') }, Setting[:width])
-        else
-          lines.join('')
-        end
+        lines.join
       end
 
       def print_variables(variables, *_)
@@ -38,12 +34,6 @@ module Byebug
 
       private
 
-      def get_modifier(path)
-        modifier_regexp = /\|(\w+)$/
-        modifier_match = locate(path).match(modifier_regexp)
-        modifier_match && modifier_match[1]
-      end
-
       def contents_files
         [File.expand_path(File.join('..', 'texts', 'plain.yml'), __FILE__)] +
           super

data/lib/byebug/printers/texts/base.yml

@@ -18,11 +18,11 @@ break:
     delete_all: "Delete all breakpoints?"
 
 catch:
-  catching: "Catching exception {exception}."
+  added: "Catching exception {exception}."
+  removed: "Catch for exception {exception} removed"
   errors:
     off: "Off expected. Got {off}"
     not_class: "Warning {class} is not known to be a Class"
-    removed: "Catch for exception {exception} removed"
     not_found: "Catch for exception {exception} not found"
   confirmations:
     delete_all: "Delete all catchpoints? (y or n) "
@@ -54,10 +54,6 @@ frame:
     too_high: "Can't navigate beyond the newest frame"
     c_frame: "Can't navigate to c-frame"
 
-help:
-  errors:
-    undefined: "Undefined command: {cmd}. Try: help"
-
 info:
   errors:
     undefined_file: "{file} is not a valid source file"
@@ -87,7 +83,6 @@ show:
 source:
   errors:
     not_found: "File \"{file}\" not found"
-    not_available: "Source commmand not available at this time"
 
 thread:
   errors:

data/lib/byebug/processors/command_processor.rb

@@ -1,164 +1,163 @@
-require 'byebug/states/regular_state'
-require 'byebug/helpers/file'
+require 'forwardable'
+
+require 'byebug/helpers/eval'
+require 'byebug/errors'
 
 module Byebug
   #
-  # Processes commands in regular mode
+  # Processes commands in regular mode.
+  #
+  # You can override this class to create your own command processor that, for
+  # example, whitelists only certain commands to be executed.
+  #
+  # @see PostMortemProcessor for a example
   #
-  class CommandProcessor < Processor
-    include Helpers::FileHelper
+  class CommandProcessor
+    include Helpers::EvalHelper
 
-    attr_reader :display, :state
+    attr_accessor :prev_line
+    attr_reader :context
 
-    def initialize(interface = LocalInterface.new)
-      super(interface)
+    def initialize(context)
+      @context = context
 
-      @display = []
-      @last_cmd = nil # To allow empty (just <RET>) commands
-      @context_was_dead = false # Assume we haven't started.
+      @proceed = false
+      @prev_line = nil
     end
 
-    def interface=(interface)
-      @interface.close if @interface
-      @interface = interface
+    def interface
+      @interface ||= context.class.interface
     end
 
-    def at_breakpoint(_context, breakpoint)
-      n = Byebug.breakpoints.index(breakpoint) + 1
-      file = normalize(breakpoint.source)
-      line = breakpoint.pos
+    def printer
+      @printer ||= Printers::Plain.new
+    end
 
-      puts "Stopped by breakpoint #{n} at #{file}:#{line}"
+    def frame
+      @context.frame
     end
 
-    def at_catchpoint(context, excpt)
-      file = normalize(context.frame_file(0))
-      line = context.frame_line(0)
+    extend Forwardable
+    def_delegator :printer, :print, :pr
+    def_delegator :printer, :print_collection, :prc
+    def_delegator :printer, :print_variables, :prv
 
-      puts "Catchpoint at #{file}:#{line}: `#{excpt}' (#{excpt.class})"
-    end
+    def_delegators :interface, :errmsg, :puts, :confirm
 
-    def at_tracing(context, file, line)
-      puts "Tracing: #{normalize(file)}:#{line} #{get_line(file, line)}"
+    #
+    # Available commands
+    #
+    def command_list
+      @command_list ||= CommandList.new(commands)
+    end
 
-      always_run(context, file, line, 2)
+    def commands
+      Byebug.commands
     end
 
-    def at_line(context, file, line)
-      process_commands(context, file, line)
+    def at_breakpoint(brkpt)
+      number = Byebug.breakpoints.index(brkpt) + 1
+
+      puts "Stopped by breakpoint #{number} at #{frame.file}:#{frame.line}"
     end
 
-    def at_return(context, file, line)
-      process_commands(context, file, line)
+    def at_catchpoint(exception)
+      puts "Catchpoint at #{context.location}: `#{exception}'"
     end
 
-    private
+    def at_tracing
+      puts "Tracing: #{context.full_location}"
 
-    #
-    # Prompt shown before reading a command.
-    #
-    def prompt(context)
-      "(byebug#{context.dead? ? ':post-mortem' : ''}) "
+      run_auto_commands(2)
     end
 
-    #
-    # Run commands everytime.
-    #
-    # For example display commands or possibly the list or irb in an "autolist"
-    # or "autoirb".
-    #
-    # @return List of commands acceptable to run bound to the current state
-    #
-    def always_run(context, file, line, run_level)
-      @state = RegularState.new(context, @display, file, @interface, line)
-
-      # Change default when in irb or code included in command line
-      Setting[:autolist] = false if ['(irb)', '-e'].include?(file)
+    def at_line
+      process_commands
+    end
 
-      # Bind commands to the current state.
-      commands.each { |cmd| cmd.execute if cmd.class.always_run >= run_level }
+    def at_return
+      process_commands
     end
 
-    def commands
-      Byebug.commands.map { |cmd| cmd.new(state) }
+    #
+    # Let the execution continue
+    #
+    def proceed!
+      @proceed = true
     end
 
     #
     # Handle byebug commands.
     #
-    def process_commands(context, file, line)
-      always_run(context, file, line, 1)
-
-      puts 'The program finished.' if program_just_finished?(context)
-      puts(state.location) if Setting[:autolist] == 0
-
-      @interface.autorestore
+    def process_commands
+      before_repl
 
-      repl(context)
+      repl
     ensure
-      @interface.autosave
+      after_repl
     end
 
+    protected
+
     #
-    # Main byebug's REPL
+    # Prompt shown before reading a command.
     #
-    def repl(context)
-      until state.proceed?
-        cmd = @interface.read_command(prompt(context))
-        return unless cmd
-
-        next if cmd == '' && @last_cmd.nil?
+    def prompt
+      '(byebug) '
+    end
 
-        cmd.empty? ? cmd = @last_cmd : @last_cmd = cmd
+    private
 
-        one_cmd(context, cmd)
-      end
+    def auto_commands_for(run_level)
+      command_list.select { |cmd| cmd.always_run >= run_level }
     end
 
     #
-    # Autoevals a single command
+    # Run permanent commands.
     #
-    def one_unknown_cmd(input)
-      unless Setting[:autoeval]
-        return errmsg("Unknown command: \"#{input}\". Try \"help\"")
-      end
+    def run_auto_commands(run_level)
+      auto_commands_for(run_level).each { |cmd| cmd.new(self).execute }
+    end
+
+    def before_repl
+      @proceed = false
+      @prev_line = nil
 
-      eval_cmd = EvalCommand.new(state)
-      eval_cmd.match(input)
-      eval_cmd.execute
+      run_auto_commands(1)
+      interface.autorestore
+    end
+
+    def after_repl
+      interface.autosave
     end
 
     #
+    # Main byebug's REPL
     #
-    # Executes a single byebug command
-    #
-    def one_cmd(context, input)
-      cmd = match_cmd(input)
+    def repl
+      until @proceed
+        cmd = interface.read_command(prompt)
+        return if cmd.nil?
 
-      return one_unknown_cmd(input) unless cmd
+        next if cmd == ''
 
-      if context.dead? && !cmd.class.allow_in_post_mortem
-        return errmsg('Command unavailable in post mortem mode.')
+        run_cmd(cmd)
       end
-
-      cmd.execute
     end
 
     #
-    # Finds a matches the command matching the input
+    # Executes the received input
     #
-    def match_cmd(input)
-      commands.find { |cmd| cmd.match(input) }
-    end
-
+    # Instantiates a command matching the input and runs it. If a matching
+    # command is not found, it evaluates the unknown input.
     #
-    # Returns true first time control is given to the user after program
-    # termination.
-    #
-    def program_just_finished?(context)
-      result = context.dead? && !@context_was_dead
-      @context_was_dead = false if result == true
-      result
+    def run_cmd(input)
+      command = command_list.match(input)
+      return command.new(self, input).execute if command
+
+      puts thread_safe_eval(input)
+    rescue => e
+      errmsg(e)
     end
   end
 end