byebug 3.2.0 → 3.3.0

data/lib/byebug/helper.rb

@@ -1,32 +1,32 @@
 module Byebug
+  #
+  # Miscelaneous Utilities
+  #
   module ParseFunctions
-    Position_regexp = '(?:(\d+)|(.+?)[:.#]([^.:\s]+))'
-
     #
     # 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, default = 1)
-      unless str
-        return default if default
-        print "You need to specify an argument for \"#{cmd}\"\n"
-        return nil
+    def get_int(str, cmd, min = nil, max = nil)
+      if str !~ /\A[0-9]+\z/
+        return nil, "\"#{cmd}\" argument \"#{str}\" needs to be a number"
       end
 
-      begin
-        int = Integer(str)
-        if min and int < min
-          print "\"#{cmd}\" argument \"#{str}\" needs to be at least #{min}\n"
-          return nil
-        elsif max and int > max
-          print "\"#{cmd}\" argument \"#{str}\" needs to be at most #{max}\n"
-          return nil
-        end
-        return int
-      rescue
-        print "\"#{cmd}\" argument \"#{str}\" needs to be a number\n"
-        return nil
+      int = str.to_i
+      if min && int < min
+        return nil, "\"#{cmd}\" argument \"#{str}\" needs to be at least #{min}"
+      elsif max && int > max
+        return nil, "\"#{cmd}\" argument \"#{str}\" needs to be at most #{max}"
       end
+
+      int
+    end
+
+    #
+    # Fills SCRIPT_LINES__ entry for <filename> if not already filled.
+    #
+    def lines(filename)
+      SCRIPT_LINES__[filename] ||= File.readlines(filename)
     end
 
     #
@@ -35,21 +35,17 @@ module Byebug
     def get_lines(filename)
       return nil unless File.exist?(filename)
 
-      unless lines = SCRIPT_LINES__[filename]
-        lines = File.readlines(filename) rescue []
-        SCRIPT_LINES__[filename] = lines
-      end
-
-      return lines
+      lines(filename)
     end
 
     #
     # Gets a single line in a source code file
     #
     def get_line(filename, lineno)
-      return nil unless lines = get_lines(filename)
+      lines = get_lines(filename)
+      return nil unless lines
 
-      return lines[lineno-1]
+      lines[lineno - 1]
     end
 
     #
@@ -60,5 +56,18 @@ module Byebug
     rescue SyntaxError
       false
     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

data/lib/byebug/history.rb

@@ -1,6 +1,9 @@
 require 'readline'
 
 module Byebug
+  #
+  # Handles byebug's history of commands.
+  #
   class History
     class << self
       def load
@@ -21,17 +24,18 @@ module Byebug
       end
 
       def to_s(size = Setting[:histsize])
-        n_entries = Readline::HISTORY.length < size ? Readline::HISTORY.length : size
+        rl_size = Readline::HISTORY.length
+        n_entries = rl_size < size ? rl_size : size
 
-        first = Readline::HISTORY.length - n_entries
+        first = rl_size - n_entries
         commands = Readline::HISTORY.to_a.last(n_entries)
 
         s = ''
         commands.each_with_index do |command, index|
-          s += ("%5d  %s\n" % [first + index + 1, command])
+          s += format("%5d  %s\n", first + index + 1, command)
         end
 
-        return s
+        s
       end
     end
   end

data/lib/byebug/interface.rb

@@ -1,4 +1,12 @@
+#
+# Namespace for all of byebug's code
+#
 module Byebug
+  #
+  # Main Interface class
+  #
+  # Contains common functionality to all implemented interfaces.
+  #
   class Interface
     attr_accessor :command_queue, :restart_file
 
@@ -6,25 +14,12 @@ module Byebug
       @command_queue, @restart_file = [], nil
     end
 
+    #
     # Common routine for reporting byebug error messages.
     # Derived classes may want to override this to capture output.
-    def errmsg(*args)
-      print '*** '
-      print(*args)
-    end
-
-    def format(*args)
-      if args.is_a?(Array)
-        new_args = args.first
-        new_args = new_args % args[1..-1] unless args[1..-1].empty?
-      else
-        new_args = args
-      end
-      new_args
-    end
-
-    def escape(msg)
-      msg.gsub('%', '%%')
+    #
+    def errmsg(message)
+      print("*** #{message}\n")
     end
   end
 

data/lib/byebug/interfaces/local_interface.rb

@@ -1,6 +1,9 @@
 require 'byebug/history'
 
 module Byebug
+  #
+  # Interface class for standard byebug use.
+  #
   class LocalInterface < Interface
     attr_reader :history
 
@@ -17,8 +20,8 @@ module Byebug
       readline(prompt, false)
     end
 
-    def print(*args)
-      STDOUT.printf(escape(format(*args)))
+    def puts(*args)
+      STDOUT.puts(*args)
     end
 
     def close
@@ -27,11 +30,11 @@ module Byebug
 
     private
 
-      def readline(prompt, hist)
-        Readline::readline(prompt, hist)
-      rescue Interrupt
-        print "^C\n"
-        retry
-      end
+    def readline(prompt, hist)
+      Readline.readline(prompt, hist)
+    rescue Interrupt
+      puts '^C'
+      retry
+    end
   end
 end

data/lib/byebug/interfaces/remote_interface.rb

@@ -1,6 +1,9 @@
 require 'byebug/history'
 
 module Byebug
+  #
+  # Interface class for remote use of byebug.
+  #
   class RemoteInterface < Interface
     attr_reader :history
 
@@ -23,17 +26,17 @@ module Byebug
       send_command "PROMPT #{prompt}"
     end
 
-    def print(*args)
-      @socket.printf(escape(format(*args)))
+    def puts(message)
+      @socket.puts(message)
     end
 
     private
 
-      def send_command(msg)
-        @socket.puts msg
-        result = @socket.gets
-        raise IOError unless result
-        result.chomp
-      end
+    def send_command(msg)
+      @socket.puts msg
+      result = @socket.gets
+      fail IOError unless result
+      result.chomp
+    end
   end
 end

data/lib/byebug/interfaces/script_interface.rb

@@ -1,13 +1,16 @@
 module Byebug
+  #
+  # Interface class for command execution from script files.
+  #
   class ScriptInterface < Interface
-    def initialize(file, out, verbose=false)
+    def initialize(file, out, verbose = false)
       super()
       @file = file.respond_to?(:gets) ? file : open(file)
       @out, @verbose = out, verbose
     end
 
-    def read_command(prompt)
-      while result = @file.gets
+    def read_command(_prompt)
+      while (result = @file.gets)
         puts "# #{result}" if @verbose
         next if result =~ /^\s*#/
         next if result.strip.empty?
@@ -15,12 +18,12 @@ module Byebug
       end
     end
 
-    def confirm(prompt)
+    def confirm(_prompt)
       'y'
     end
 
-    def print(*args)
-      @out.printf(*args)
+    def puts(message)
+      @out.printf(message)
     end
 
     def close

data/lib/byebug/options.rb

@@ -0,0 +1,46 @@
+module Byebug
+  #
+  # Set of options that byebug's script accepts.
+  #
+  class Options
+    def self.parse
+      Slop.parse!(strict: true) do
+        banner <<-EOB.gsub(/^ {8}/, '')
+
+          byebug #{Byebug::VERSION}
+
+          Usage: byebug [options] <script.rb> -- <script.rb parameters>
+        EOB
+
+        on :d, :debug, 'Set $DEBUG=true' do
+          $DEBUG = true
+        end
+
+        on :I, :include=, 'Add to $LOAD_PATH', as: Array, delimiter: ':' do |l|
+          $LOAD_PATH.push(l).flatten!
+        end
+
+        on :q, :quit, 'Quit when script finishes', default: true
+
+        on :s, :stop, 'Stop when script is loaded', default: true
+
+        on :x, :rc, 'Run byebug initialization file', default: true
+
+        on :m, :'post-mortem', 'Run byebug in post-mortem mode', default: false
+
+        on :r, :require=, 'Require library before script' do |name|
+          require name
+        end
+
+        on :R, :remote=, '[HOST:]PORT for remote debugging',
+           as: Array, delimiter: ':', limit: 2
+
+        on :t, :trace, 'Turn on line tracing'
+
+        on :v, :version, 'Print program version'
+
+        on :h, :help, 'Display this message'
+      end
+    end
+  end
+end

data/lib/byebug/processor.rb

@@ -5,11 +5,17 @@ module Byebug
     attr_accessor :interface
 
     extend Forwardable
-    def_delegators :@interface, :errmsg, :print
+    def_delegators :@interface, :errmsg, :puts
 
     def initialize(interface)
       @interface = interface
     end
+
+    def without_exceptions
+      yield
+    rescue
+      nil
+    end
   end
 end
 

data/lib/byebug/processors/command_processor.rb

@@ -1,4 +1,7 @@
 module Byebug
+  #
+  # Processes commands in regular mode
+  #
   class CommandProcessor < Processor
     attr_reader :display
 
@@ -41,7 +44,7 @@ module Byebug
 
     def self.protect(mname)
       alias_method "__#{mname}", mname
-      module_eval <<-END, __FILE__, __LINE__+1
+      module_eval <<-END, __FILE__, __LINE__ + 1
         def #{mname}(*args)
           @mutex.synchronize do
             return unless @interface
@@ -52,24 +55,26 @@ module Byebug
         rescue SignalException
           raise
         rescue
-          print "INTERNAL ERROR!!! #\{$!\}\n" rescue nil
-          print $!.backtrace.map{|l| "\t#\{l\}"}.join("\n") rescue nil
+          without_exceptions do
+            puts "INTERNAL ERROR!!! #\{$!\}"
+            puts $!.backtrace.map{|l| "\t#\{l\}"}.join("\n")
+          end
         end
       END
     end
 
-    def at_breakpoint(context, breakpoint)
+    def at_breakpoint(_context, breakpoint)
       n = Byebug.breakpoints.index(breakpoint) + 1
       file = self.class.canonic_file(breakpoint.source)
       line = breakpoint.pos
-      print "Stopped by breakpoint #{n} at #{file}:#{line}\n"
+      puts "Stopped by breakpoint #{n} at #{file}:#{line}"
     end
     protect :at_breakpoint
 
     def at_catchpoint(context, excpt)
       file = self.class.canonic_file(context.frame_file(0))
       line = context.frame_line(0)
-      print "Catchpoint at %s:%d: `%s' (%s)\n", file, line, excpt, excpt.class
+      puts "Catchpoint at #{file}:#{line}: `#{excpt}' (#{excpt.class})"
     end
     protect :at_catchpoint
 
@@ -79,7 +84,7 @@ module Byebug
       if file != @last_file || line != @last_line || Setting[:tracing_plus]
         path = self.class.canonic_file(file)
         @last_file, @last_line = file, line
-        print "Tracing: #{path}:#{line} #{get_line(file, line)}"
+        puts "Tracing: #{path}:#{line} #{get_line(file, line)}"
       end
       always_run(context, file, line, 2)
     end
@@ -97,152 +102,157 @@ module Byebug
     protect :at_return
 
     private
-      #
-      # Prompt shown before reading a command.
-      #
-      def prompt(context)
-        return "(byebug#{context.dead?  ? ':post-mortem' : ''}) "
-      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)
-        cmds = Command.commands
+    #
+    # Prompt shown before reading a command.
+    #
+    def prompt(context)
+      "(byebug#{context.dead?  ? ':post-mortem' : ''}) "
+    end
 
-        state = State.new(cmds, context, @display, file, @interface, line)
+    #
+    # 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)
+      cmds = Command.commands
 
-        # Change default when in irb or code included in command line
-        Setting[:autolist] = false if ['(irb)', '-e'].include?(file)
+      state = State.new(cmds, context, @display, file, @interface, line)
 
-        # Bind commands to the current state.
-        commands = cmds.map { |cmd| cmd.new(state) }
+      # Change default when in irb or code included in command line
+      Setting[:autolist] = false if ['(irb)', '-e'].include?(file)
 
-        commands.select { |cmd| cmd.class.always_run >= run_level }
-                .each { |cmd| cmd.execute }
+      # Bind commands to the current state.
+      commands = cmds.map { |cmd| cmd.new(state) }
 
-        return state, commands
-      end
+      commands.select { |cmd| cmd.class.always_run >= run_level }
+              .each { |cmd| cmd.execute }
 
-      #
-      # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
-      # array of commands: [cmd1, cmd2, ..., cmdN]
-      #
-      def split_commands(cmd_line)
-        cmd_line.split(/;/).inject([]) do |m, v|
-          if m.empty?
-            m << v
+      [state, commands]
+    end
+
+    #
+    # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
+    # array of commands: [cmd1, cmd2, ..., cmdN]
+    #
+    def split_commands(cmd_line)
+      cmd_line.split(/;/).each_with_object([]) do |v, m|
+        if m.empty?
+          m << v
+        else
+          if m.last[-1] == '\\'
+            m.last[-1, 1] = ''
+            m.last << ';' << v
           else
-            if m.last[-1] == ?\\
-              m.last[-1,1] = ''
-              m.last << ';' << v
-            else
-              m << v
-            end
+            m << v
           end
-          m
         end
       end
+    end
 
-      #
-      # Handle byebug commands.
-      #
-      def process_commands(context, file, line)
-        state, commands = always_run(context, file, line, 1)
+    #
+    # Handle byebug commands.
+    #
+    def process_commands(context, file, line)
+      state, commands = always_run(context, file, line, 1)
 
-        if Setting[:testing]
-          Thread.current.thread_variable_set('state', state)
-        else
-          Thread.current.thread_variable_set('state', nil)
-        end
+      if Setting[:testing]
+        Thread.current.thread_variable_set('state', state)
+      else
+        Thread.current.thread_variable_set('state', nil)
+      end
 
-        preloop(commands, context)
-        print state.location if Setting[:autolist] == 0
+      preloop(commands, context)
+      puts(state.location) if Setting[:autolist] == 0
 
-        while !state.proceed?
-          input = @interface.command_queue.empty? ?
-                  @interface.read_command(prompt(context)) :
+      until state.proceed?
+        input = if @interface.command_queue.empty?
+                  @interface.read_command(prompt(context))
+                else
                   @interface.command_queue.shift
-          break unless input
-          catch(:debug_error) do
-            if input == ""
-              next unless @last_cmd
-              input = @last_cmd
-            else
-              @last_cmd = input
-            end
-            split_commands(input).each do |cmd|
-              one_cmd(commands, context, cmd)
-            end
-          end
-        end
-      end
+                end
+        break unless input
 
-      #
-      # Executes a single byebug command
-      #
-      def one_cmd(commands, context, input)
-        if cmd = commands.find { |c| c.match(input) }
-          if context.dead? && !cmd.class.allow_in_post_mortem
-            errmsg "Command unavailable in post mortem mode.\n"
-          else
-            cmd.execute
-          end
+        if input == ''
+          next unless @last_cmd
+          input = @last_cmd
         else
-          unknown_cmd = commands.find { |c| c.class.unknown }
-          if unknown_cmd
-            unknown_cmd.execute
-          else
-            errmsg "Unknown command: \"#{input}\". Try \"help\".\n"
-          end
+          @last_cmd = input
         end
+        split_commands(input).each do |cmd|
+          one_cmd(commands, context, cmd)
+        end
+      end
+    end
+
+    #
+    # Autoevals a single command
+    #
+    def one_unknown_cmd(commands, input)
+      unless Setting[:autoeval]
+        return errmsg("Unknown command: \"#{input}\". Try \"help\"")
       end
 
-      #
-      # Tasks to do before processor loop
-      #
-      def preloop(commands, context)
-        @context_was_dead = true if context.dead? and not @context_was_dead
+      commands.find { |c| c.is_a?(EvalCommand) }.execute
+    end
 
-        if @context_was_dead
-          print "The program finished.\n"
-          @context_was_dead = false
-        end
+    #
+    # Executes a single byebug command
+    #
+    def one_cmd(commands, context, input)
+      cmd = commands.find { |c| c.match(input) }
+      return one_unknown_cmd(commands, input) unless cmd
+
+      if context.dead? && !cmd.class.allow_in_post_mortem
+        return errmsg('Command unavailable in post mortem mode.')
       end
 
-      class State
-        attr_accessor :commands, :context, :display, :file, :frame_pos
-        attr_accessor :interface, :line, :previous_line
+      cmd.execute
+    end
+
+    #
+    # Tasks to do before processor loop
+    #
+    def preloop(_commands, context)
+      @context_was_dead = true if context.dead? && !@context_was_dead
+      return unless @context_was_dead
 
-        def initialize(commands, context, display, file, interface, line)
-          @commands, @context, @display = commands, context, display
-          @file, @interface, @line = file, interface, line
-          @frame_pos, @previous_line, @proceed = 0, nil, false
-        end
+      puts 'The program finished.'
+      @context_was_dead = false
+    end
 
-        extend Forwardable
-        def_delegators :@interface, :errmsg, :print, :confirm
+    class State
+      attr_accessor :commands, :context, :display, :file, :frame_pos
+      attr_accessor :interface, :line, :previous_line
 
-        def proceed?
-          @proceed
-        end
+      def initialize(commands, context, display, file, interface, line)
+        @commands, @context, @display = commands, context, display
+        @file, @interface, @line = file, interface, line
+        @frame_pos, @previous_line, @proceed = 0, nil, false
+      end
 
-        def proceed
-          @proceed = true
-        end
+      extend Forwardable
+      def_delegators :@interface, :errmsg, :puts, :confirm
 
-        def location
-          path = self.class.canonic_file(@file)
-          loc = "#{path} @ #{@line}\n"
-          loc += "#{get_line(@file, @line)}\n" unless
-            ['(irb)', '-e'].include? @file
-          loc
-        end
+      def proceed?
+        @proceed
+      end
+
+      def proceed
+        @proceed = true
       end
-  end # class CommandProcessor
+
+      def location
+        path = self.class.canonic_file(@file)
+        loc = "#{path} @ #{@line}\n"
+        loc += "#{get_line(@file, @line)}\n" unless
+          ['(irb)', '-e'].include? @file
+        loc
+      end
+    end
+  end
 end