ruby-debug193 0.0.1

data/cli/ruby-debug/command.rb

@@ -0,0 +1,228 @@
+require 'rubygems'
+require 'columnize'
+require_relative 'helper'
+
+module Debugger
+  RUBY_DEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
+    defined?(RUBY_DEBUG_DIR)
+
+  class Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    include Columnize
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
+    class << self
+      def commands
+        @commands ||= []
+      end
+      
+      DEF_OPTIONS = {
+        :allow_in_control     => false, 
+        :allow_in_post_mortem => true,
+        :event => true, 
+        :always_run => 0,
+        :unknown => false,
+        :need_context => false,
+      } unless defined?(DEF_OPTIONS)
+      
+      def inherited(klass)
+        DEF_OPTIONS.each do |o, v|
+          klass.options[o] = v if klass.options[o].nil?
+        end
+        commands << klass
+      end 
+
+      def load_commands
+        Dir[File.join(Debugger.const_get(:RUBY_DEBUG_DIR), 'commands', '*')].each do |file|
+          require file if file =~ /\.rb$/
+        end
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        end
+      end
+      
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^(.+?)=$/
+          @options[$1.intern] = args.first
+        else
+          if @options.has_key?(meth)
+            @options[meth]
+          else
+            super
+          end
+        end
+      end
+      
+      def options
+        @options ||= {}
+      end
+
+      def settings_map
+        @@settings_map ||= {}
+      end
+      private :settings_map
+      
+      def settings
+        unless true and defined? @settings and @settings
+          @settings = Object.new
+          map = settings_map
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          else
+            c.send(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          end
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          else
+            c.send(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          end
+        end
+        @settings
+      end
+
+      def register_setting_var(name, default)
+        var_name = "@@#{name}"
+        class_variable_set(var_name, default)
+        register_setting_get(name) { class_variable_get(var_name) }
+        register_setting_set(name) { |value| class_variable_set(var_name, value) }
+      end
+
+      def register_setting_get(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:getter] = block
+      end
+
+      def register_setting_set(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:setter] = block
+      end
+    end
+
+    register_setting_var(:basename, false)  # use basename in showing files? 
+    register_setting_var(:callstyle, :last)
+    register_setting_var(:debuggertesting, false)
+    register_setting_var(:force_stepping, false)
+    register_setting_var(:full_path, true)
+    register_setting_var(:listsize, 10)    # number of lines in list command
+    register_setting_var(:stack_trace_on_error, false)
+    register_setting_var(:tracing_plus, false) # different linetrace lines?
+    
+    # width of line output. Use COLUMNS value if it exists and is 
+    # not too rediculously large.
+    width = ENV['COLUMNS'].to_i 
+    width = 80 unless width > 10
+    register_setting_var(:width, width)  
+
+    if not defined? Debugger::ARGV
+      Debugger::ARGV = ARGV.clone
+    end
+    register_setting_var(:argv, Debugger::ARGV)
+    
+    def initialize(state)
+      @state = state
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @state.errmsg(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    def debug_eval(str, b = get_binding)
+      begin
+        val = eval(str, b)
+      rescue StandardError, ScriptError => e
+        if Command.settings[:stack_trace_on_error]
+          at = eval("caller(1)", b)
+          print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
+          for i in at
+            print "\tfrom %s\n", i
+          end
+        else
+          print "#{e.class} Exception: #{e.message}\n"
+        end
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        eval(str, get_binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+
+    def get_binding
+      @state.context.frame_binding(@state.frame_pos)
+    end
+
+    def line_at(file, line)
+      Debugger.line_at(file, line)
+    end
+
+    def get_context(thnum)
+      Debugger.contexts.find{|c| c.thnum == thnum}
+    end  
+  end
+  
+  Command.load_commands
+
+  # Returns setting object.
+  # Use Debugger.settings[] and Debugger.settings[]= methods to query and set
+  # debugger settings. These settings are available:
+  # 
+  # - :autolist - automatically calls 'list' command on breakpoint
+  # - :autoeval - evaluates input in the current binding if it's not recognized as a debugger command
+  # - :autoirb - automatically calls 'irb' command on breakpoint
+  # - :stack_trace_on_error - shows full stack trace if eval command results with an exception
+  # - :frame_full_path - displays full paths when showing frame stack
+  # - :frame_class_names - displays method's class name when showing frame stack
+  # - :reload_source_on_change - makes 'list' command to always display up-to-date source code
+  # - :force_stepping - stepping command asways move to the new line
+  # 
+  def self.settings
+    Command.settings
+  end
+end

data/cli/ruby-debug/commands/breakpoints.rb

@@ -0,0 +1,153 @@
+module Debugger
+
+  # Implements debugger "break" command.
+  class AddBreakpoint < Command
+    self.allow_in_control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        (?: \s+ #{Position_regexp})? \s*
+        (?: \s+ (.*))? \s*
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        line, _, _, expr = @match.captures
+      else
+        _, file, line, expr = @match.captures
+      end
+      if expr 
+        if expr !~ /^\s*if\s+(.+)/
+          if file or line
+            errmsg "Expecting 'if' in breakpoint condition; got: #{expr}.\n"
+          else
+            errmsg "Invalid breakpoint location: #{expr}.\n"
+          end
+          return
+        else
+          expr = $1
+        end
+      end
+
+      brkpt_filename = nil
+      if file.nil?
+        unless @state.context
+          errmsg "We are not in a state that has an associated file.\n"
+          return 
+        end
+        brkpt_filename = @state.file
+        file = File.basename(@state.file)
+        if line.nil? 
+          # Set breakpoint at current line
+          line = @state.line.to_s
+        end
+      elsif line !~ /^\d+$/
+        # See if "line" is a method/function name
+        klass = debug_silent_eval(file)
+        if klass && klass.kind_of?(Module)
+          class_name = klass.name if klass
+        else
+          errmsg "Unknown class #{file}.\n"
+          throw :debug_error
+        end
+      else
+        # FIXME: This should be done in LineCache.
+        file = File.expand_path(file) if file.index(File::SEPARATOR) || \
+        File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+        brkpt_filename = file
+      end
+      
+      if line =~ /^\d+$/
+        line = line.to_i
+        if LineCache.cache(brkpt_filename, Command.settings[:reload_source_on_change])
+          last_line = LineCache.size(brkpt_filename)
+          if line > last_line
+            errmsg("There are only %d lines in file \"%s\".\n", last_line, file) 
+            return
+          end
+          unless LineCache.trace_line_numbers(brkpt_filename).member?(line)
+            errmsg("Line %d is not a stopping point in file \"%s\".\n", line, file) 
+            return
+          end
+        else
+          errmsg("No source file named %s\n" % file)
+          return unless confirm("Set breakpoint anyway? (y/n) ")
+        end
+
+        unless @state.context
+          errmsg "We are not in a state we can add breakpoints.\n"
+          return 
+        end
+        b = Debugger.add_breakpoint brkpt_filename, line, expr
+        print "Breakpoint %d file %s, line %s\n", b.id, brkpt_filename, line.to_s
+        unless syntax_valid?(expr)
+          errmsg("Expression \"#{expr}\" syntactically incorrect; breakpoint disabled.\n")
+          b.enabled = false
+        end
+      else
+        method = line.intern.id2name
+        b = Debugger.add_breakpoint class_name, method, expr
+        print "Breakpoint %d at %s::%s\n", b.id, class_name, method.to_s
+      end
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] file:line [if expr]
+          b[reak] class(.|#)method [if expr]
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  # Implements debugger "delete" command.
+  class DeleteBreakpointCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      /^\s *del(?:ete)? (?:\s+(.*))?$/ix
+    end
+
+    def execute
+      unless @state.context
+        errmsg "We are not in a state we can delete breakpoints.\n"
+        return 
+      end
+      brkpts = @match[1]
+      unless brkpts
+        if confirm("Delete all breakpoints? (y or n) ")
+          Debugger.breakpoints.clear
+        end
+      else
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          unless Debugger.remove_breakpoint(pos)
+            errmsg "No breakpoint number %d\n", pos
+          end
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'delete'
+      end
+
+      def help(cmd)
+        %{
+          del[ete][ nnn...]\tdelete some or all breakpoints
+        }
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/catchpoint.rb

@@ -0,0 +1,55 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      /^\s* cat(?:ch)? 
+           (?:\s+ (\S+))? 
+           (?:\s+ (off))? \s* $/ix
+    end
+
+    def execute
+      excn = @match[1] 
+      if not excn
+        # No args given.
+        info_catch
+      elsif not @match[2]
+        # One arg given.
+        if 'off' == excn
+          Debugger.catchpoints.clear if 
+            confirm("Delete all catchpoints? (y or n) ")
+        else
+          binding = @state.context ? get_binding : TOPLEVEL_BINDING
+          unless debug_eval("#{excn}.is_a?(Class)", binding)
+            print "Warning #{excn} is not known to be a Class\n"
+          end
+          Debugger.add_catchpoint(excn)
+          print "Catch exception %s.\n", excn
+        end
+      elsif @match[2] != 'off'
+        errmsg "Off expected. Got %s\n", @match[2]
+      elsif Debugger.catchpoints.member?(excn)
+        Debugger.catchpoints.delete(excn)
+        print "Catch for exception %s removed.\n", excn
+      else
+        errmsg "Catch for exception %s not found.\n", excn
+      end
+    end
+
+    class << self
+      def help_command
+        'catch'
+      end
+
+      def help(cmd)
+        %{
+          cat[ch]\t\tsame as "info catch"
+          cat[ch] <exception-name> [on|off]
+\tIntercept <exception-name> when there would otherwise be no handler.
+\tWith an "on" or "off", turn handling the exception on or off.
+          cat[ch] off\tdelete all catchpoints
+        }
+      end
+    end
+  end
+end

data/cli/ruby-debug/commands/condition.rb

@@ -0,0 +1,49 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+
+    def regexp
+      /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"condition\" must be followed a breakpoint number and expression\n"
+      else
+        breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+        largest = breakpoints.inject(0) do |largest, b| 
+          largest = b.id if b.id > largest
+        end
+        if 0 == largest
+          print "No breakpoints have been set.\n"
+          return
+        end
+        pos = get_int(@match[1], "Condition", 1, largest)
+        return unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            b.expr = @match[2].empty? ? nil : @match[2]
+            break
+          end
+        end
+
+      end
+    end
+    
+    class << self
+      def help_command
+        'condition'
+      end
+
+      def help(cmd)
+        %{
+          Condition breakpoint-number expression
+Specify breakpoint number N to break only if COND is true.
+N is an integer and COND is an expression to be evaluated whenever 
+breakpoint N is reached. If the empty string is used, the condition is removed.
+        }
+      end
+    end
+  end
+
+end # module Debugger