byebug 3.5.1 → 4.0.0

data/lib/byebug/context.rb

@@ -5,59 +5,66 @@ module Byebug
   # at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
   #
   class Context
-    class << self
-      def stack_size(byebug_frames = false)
-        backtrace = Thread.current.backtrace_locations(0)
-        return 0 unless backtrace
+    #
+    # List of files byebug will ignore while debugging
+    #
+    def self.ignored_files
+      Byebug.mode == :standalone ? lib_files + [bin_file] : lib_files
+    end
+
+    def self.bin_file
+      @bin_file ||= Gem.bin_path('byebug', 'byebug')
+    end
 
-        unless byebug_frames
-          backtrace = backtrace.drop_while { |l| !ignored(l.path) }
-                               .drop_while { |l|  ignored(l.path) }
-                               .take_while { |l| !ignored(l.path) }
-        end
+    def self.lib_files
+      @lib_files ||= Dir.glob(File.expand_path('../../**/*.rb', __FILE__))
+    end
+
+    #
+    # Tells whether a file is ignored by the debugger.
+    #
+    # @param path [String] filename to be checked.
+    #
+    def ignored_file?(path)
+      self.class.ignored_files.include?(path)
+    end
 
-        backtrace.size
-      end
+    def stack_size
+      return 0 unless backtrace
 
-      def ignored(path)
-        IGNORED_FILES.include?(path)
-      end
-      private :ignored
+      backtrace.drop_while { |l| ignored_file?(l.first.path) }
+        .take_while { |l| !ignored_file?(l.first.path) }
+        .size
     end
 
     def interrupt
       step_into 1
     end
 
+    #
+    # Gets local variables for a frame.
+    #
+    # @param frame_no Frame index in the backtrace. Defaults to 0.
+    #
+    # TODO: Use brand new local_variable_{get,set,defined?} for rubies >= 2.1
+    #
     def frame_locals(frame_no = 0)
-      bind = frame_binding frame_no
-      eval 'local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}', bind
-    end
-
-    def c_frame_args(frame_no)
-      myself = frame_self frame_no
-      return [] unless myself.to_s != 'main'
-      myself.send(:method, frame_method(frame_no)).parameters
-    end
+      bind = frame_binding(frame_no)
+      return [] unless bind
 
-    def ruby_frame_args(bind)
-      return [] unless eval '__method__', bind
-      begin
-        eval 'self.method(__method__).parameters', bind
-      rescue NameError => e
-        puts "WARNING: Got exception #{e.class}: \"#{e.message}\" " \
-             'while retreving parameters from frame'
-        return []
-      end
+      bind.eval('local_variables.inject({}){|h, v| h[v] = eval(v.to_s); h}')
     end
 
+    #
+    # Gets current method arguments for a frame.
+    #
+    # @param frame_no Frame index in the backtrace. Defaults to 0.
+    #
     def frame_args(frame_no = 0)
-      bind = frame_binding frame_no
-      if bind.nil?
-        c_frame_args frame_no
-      else
-        ruby_frame_args bind
-      end
+      bind = frame_binding(frame_no)
+      return c_frame_args(frame_no) unless bind
+
+      ruby_frame_args(bind)
     end
 
     def handler
@@ -73,15 +80,44 @@ module Byebug
     end
 
     def at_tracing(file, line)
-      handler.at_tracing(self, file, line)
+      handler.at_tracing(self, file, line) unless ignored_file?(file)
     end
 
     def at_line(file, line)
-      handler.at_line(self, file, line) unless IGNORED_FILES.include?(file)
+      handler.at_line(self, file, line) unless ignored_file?(file)
     end
 
     def at_return(file, line)
-      handler.at_return(self, file, line)
+      handler.at_return(self, file, line) unless ignored_file?(file)
+    end
+
+    private
+
+    #
+    # Gets method arguments for a c-frame.
+    #
+    # @param frame_no Frame index in the backtrace.
+    #
+    def c_frame_args(frame_no)
+      myself = frame_self(frame_no)
+      return [] unless myself.to_s != 'main'
+
+      myself.method(frame_method(frame_no)).parameters
+    end
+
+    #
+    # Gets method arguments for a ruby-frame.
+    #
+    # @param bind Binding for the ruby-frame.
+    #
+    def ruby_frame_args(bind)
+      return [] unless bind.eval('__method__')
+
+      bind.eval('method(__method__).parameters')
+    rescue NameError => e
+      Byebug.errmsg \
+        "Exception #{e.class} (#{e.message}) while retreving frame params"
+      []
     end
   end
 end

data/lib/byebug/core.rb

@@ -4,72 +4,110 @@ require 'byebug/context'
 require 'byebug/breakpoint'
 require 'byebug/interface'
 require 'byebug/processor'
-require 'byebug/setting'
 require 'byebug/remote'
-
-require 'stringio'
-require 'tracer'
-require 'linecache19'
+require 'byebug/printers/plain'
 
 module Byebug
-  #
-  # List of files byebug will ignore while debugging
-  #
-  IGNORED_FILES = Dir.glob(File.expand_path('../**/*.rb', __FILE__))
+  extend self
+
+  class NoScript < StandardError
+  end
+
+  class NonExistentScript < StandardError
+  end
 
   #
   # Configuration file used for startup commands. Default value is .byebugrc
   #
   INIT_FILE = '.byebugrc' unless defined?(INIT_FILE)
 
-  class << self
-    attr_accessor :handler, :debugged_program
-
-    extend Forwardable
-    def_delegators :handler, :errmsg, :puts
-  end
+  #
+  # Main debugger's processor
+  #
+  attr_accessor :handler
+  self.handler = CommandProcessor.new
 
-  Byebug.handler = CommandProcessor.new
+  #
+  # Main debugger's printer
+  #
+  attr_accessor :printer
+  self.printer = Printers::Plain.new
 
-  def self.source_reload
-    hsh = 'SCRIPT_LINES__'
-    Object.send(:remove_const, hsh) if Object.const_defined?(hsh)
-    Object.const_set(hsh, {})
-  end
+  extend Forwardable
+  def_delegators :handler, :errmsg, :puts
 
   #
-  # Byebug's interface is its handler's interface
+  # Running mode of the debugger. Can be either:
   #
-  def self.interface=(value)
-    handler.interface = value
-  end
+  # * :attached => Attached to a running program through the `byebug` method.
+  # * :standalone => Started through `bin/byebug` script.
+  #
+  attr_accessor :mode
 
   #
   # Runs normal byebug initialization scripts.
   #
   # Reads and executes the commands from init file (if any) in the current
-  # working directory.  This is only done if the current directory is
-  # different from your home directory.  Thus, you can have more than one init
-  # file, one generic in your home directory, and another, specific to the
-  # program you are debugging, in the directory where you invoke byebug.
-  #
-  def self.run_init_script(out = handler.interface)
-    cwd_script  = File.expand_path(File.join('.', INIT_FILE))
-    run_script(cwd_script, out, true) if File.exist?(cwd_script)
-
-    home_script = File.expand_path(File.join(ENV['HOME'].to_s, INIT_FILE))
-    if File.exist?(home_script) && cwd_script != home_script
-      run_script(home_script, out, true)
+  # working directory. This is only done if the current directory is different
+  # from your home directory. Thus, you can have more than one init file, one
+  # generic in your home directory, and another, specific to the program you
+  # are debugging, in the directory where you invoke byebug.
+  #
+  def run_init_script
+    home_rc = File.expand_path(File.join(ENV['HOME'].to_s, INIT_FILE))
+    run_script(home_rc) if File.exist?(home_rc)
+
+    cwd_rc = File.expand_path(File.join('.', INIT_FILE))
+    run_script(cwd_rc) if File.exist?(cwd_rc) && cwd_rc != home_rc
+  end
+
+  #
+  # Extracts debugged program from command line args
+  #
+  def setup_cmd_line_args
+    unless $PROGRAM_NAME.include?('bin/byebug')
+      self.mode = :attached
+      return
     end
+
+    self.mode = :standalone
+
+    fail(NoScript, 'You must specify a program to debug...') if $ARGV.empty?
+
+    program = which($ARGV.shift)
+    program = which($ARGV.shift) if program == which('ruby')
+    fail(NonExistentScript, "The script doesn't exist") unless program
+
+    $PROGRAM_NAME = program
   end
 
+  private
+
   #
   # Runs a script file
   #
-  def self.run_script(file, out = handler.interface, verbose = false)
-    interface = ScriptInterface.new(File.expand_path(file), out)
+  def run_script(file, verbose = false)
+    interface = ScriptInterface.new(file, verbose)
     processor = ControlCommandProcessor.new(interface)
-    processor.process_commands(verbose)
+    processor.process_commands
+  end
+
+  #
+  # Cross-platform way of finding an executable in the $PATH.
+  # Borrowed from: http://stackoverflow.com/questions/2108727
+  #
+  def which(cmd)
+    return File.expand_path(cmd) if File.exist?(cmd)
+
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each do |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        return exe if File.executable?(exe) && !File.directory?(exe)
+      end
+    end
+
+    nil
   end
 end
 

data/lib/byebug/helper.rb

@@ -1,24 +1,65 @@
 module Byebug
   #
-  # Miscelaneous Utilities
+  # Utilities for interaction with files
   #
-  module MiscUtils
+  module FileFunctions
     #
-    # Cross-platform way of finding an executable in the $PATH.
-    # Borrowed from: http://stackoverflow.com/questions/2108727
+    # Reads lines of source file +filename+ into an array
     #
-    def which(cmd)
-      return File.expand_path(cmd) if File.exist?(cmd)
+    def get_lines(filename)
+      File.foreach(filename).reduce([]) { |a, e| a << e.chomp }
+    end
 
-      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-        exts.each do |ext|
-          exe = File.join(path, "#{cmd}#{ext}")
-          return exe if File.executable?(exe) && !File.directory?(exe)
-        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
 
-      nil
+    #
+    # Improves indentation and spacing in +str+ for readability in Byebug's
+    # command prompt.
+    #
+    def prettify(str)
+      "\n" + str.gsub(/^ {8}/, '') + "\n"
     end
   end
 
@@ -32,45 +73,20 @@ module Byebug
     #
     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"
+        return nil, pr('parse.errors.int.not_number', cmd: cmd, str: str)
       end
 
       int = str.to_i
       if min && int < min
-        return min, "\"#{cmd}\" argument \"#{str}\" needs to be at least #{min}"
+        return min, pr('parse.errors.int.too_low', cmd: cmd, str: str, min: min)
       elsif max && int > max
-        return max, "\"#{cmd}\" argument \"#{str}\" needs to be at most #{max}"
+        return max, pr('parse.errors.int.too_high',
+                       cmd: cmd, str: str, max: max)
       end
 
       int
     end
 
-    #
-    # Fills SCRIPT_LINES__ entry for <filename> if not already filled.
-    #
-    def lines(filename)
-      SCRIPT_LINES__[filename] ||= File.readlines(filename)
-    end
-
-    #
-    # Gets all lines in a source code file
-    #
-    def get_lines(filename)
-      return nil unless File.exist?(filename)
-
-      lines(filename)
-    end
-
-    #
-    # Gets a single line in a source code file
-    #
-    def get_line(filename, lineno)
-      lines = get_lines(filename)
-      return nil unless lines
-
-      lines[lineno - 1]
-    end
-
     #
     # Returns true if code is syntactically correct for Ruby.
     #

data/lib/byebug/history.rb

@@ -44,6 +44,8 @@ module Byebug
     # Adds a new command to Readline's history.
     #
     def push(cmd)
+      return if ignore?(cmd)
+
       self.size += 1
       Readline::HISTORY.push(cmd)
     end
@@ -64,11 +66,20 @@ module Byebug
 
       commands = Readline::HISTORY.to_a.last(show_size)
 
-      (self.size - show_size + 1..self.size).to_a.zip(commands).map do |l|
+      last_ids(show_size).zip(commands).map do |l|
         format('%5d  %s', l[0], l[1])
       end.join("\n") + "\n"
     end
 
+    #
+    # Array of ids of the last n commands.
+    #
+    def last_ids(n)
+      from, to = 1 + self.size - n, self.size
+
+      (from..to).to_a
+    end
+
     #
     # Max number of commands to be displayed when no size has been specified.
     #