ruby-debug-ide-docker 0.6.1

data/lib/ruby-debug-ide/command.rb

@@ -0,0 +1,177 @@
+if RUBY_VERSION < '2.0' || defined?(JRUBY_VERSION)
+  require 'ruby-debug-base'
+else
+  require 'debase'
+end
+
+require 'ruby-debug-ide/helper'
+require 'delegate'
+
+module Debugger
+
+  class Command < SimpleDelegator # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    # 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 = {
+        :event => true, 
+        :control => false, 
+        :unknown => false,
+        :need_context => false,
+      }
+      
+      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.dirname(__FILE__)
+        Dir[File.join(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 unescape_incoming(str)
+        str.gsub(/((?:^|[^\\])(?:\\\\)*)((?:\\n)+)/) do |_|
+          $1 + "\n" * ($2.size / 2)
+        end.gsub(/\\\\/, '\\')
+      end
+
+      def file_filter_supported?
+        defined?(Debugger.file_filter)
+      end
+    end
+    
+    def initialize(state, printer)
+      @state, @printer = state, printer
+      super @printer
+    end
+    
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    def errmsg(*args)
+      @printer.print_error(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    # see Timeout::timeout, the difference is that we must use a DebugThread
+    # because every other thread would be halted when the event hook is reached
+    # in ruby-debug.c
+    def timeout(sec)
+      return yield if sec == nil or sec.zero?
+      if Thread.respond_to?(:critical) and Thread.critical
+        raise ThreadError, "timeout within critical session"      
+      end
+      begin
+        x = Thread.current
+        y = DebugThread.start {
+          sleep sec
+          x.raise StandardError, "Timeout: evaluation took longer than #{sec} seconds." if x.alive?
+        }
+        yield sec
+      ensure
+        y.kill if y and y.alive?
+      end
+    end
+
+    def debug_eval(str, b = get_binding)
+      begin
+        str = str.to_s
+        str.force_encoding('UTF-8') if(RUBY_VERSION >= '2.0')
+        to_inspect = Command.unescape_incoming(str)
+        max_time = Debugger.evaluation_timeout
+        @printer.print_debug("Evaluating %s with timeout after %i sec", str, max_time)
+        timeout(max_time) do
+          eval(to_inspect, b)
+        end
+      rescue StandardError, ScriptError => e
+        @printer.print_exception(e, @state.binding) 
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        str = str.to_s
+        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
+
+    def realpath(filename)
+      is_dir = filename.end_with?(File::SEPARATOR)
+      if filename.index(File::SEPARATOR) || File::ALT_SEPARATOR && filename.index(File::ALT_SEPARATOR)
+        filename = File.expand_path(filename)
+      end
+      if (RUBY_VERSION < '1.9') || (RbConfig::CONFIG['host_os'] =~ /mswin/)
+        filename
+      else
+        filename = File.realpath(filename) rescue filename
+        filename = filename + File::SEPARATOR if is_dir && !filename.end_with?(File::SEPARATOR)
+        filename
+      end
+    end
+  end
+  
+  Command.load_commands
+end

data/lib/ruby-debug-ide/commands/breakpoints.rb

@@ -0,0 +1,128 @@
+module Debugger
+  class AddBreakpoint < Command # :nodoc:
+    self.control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        (?: \s+
+        (?:
+          (\d+) |
+          (.+?)[:.#]([^.:\s]+)
+        ))?
+        (?:\s+
+          if\s+(.+)
+        )?
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        line, _, _, expr = @match.captures
+      else
+        _, file, line, expr = @match.captures
+      end
+
+      if file.nil?
+        file = File.basename(@state.file)
+      else
+        if line !~ /^\d+$/
+          klass = debug_silent_eval(file)
+          if klass && !klass.kind_of?(Module)
+            print_error "Unknown class #{file}"
+            throw :debug_error
+          end
+          file = klass.name if klass
+        else
+          file = realpath(file)
+        end
+      end
+      
+      if line =~ /^\d+$/
+        line = line.to_i
+      else
+        line = line.intern.id2name
+      end
+      
+      b = Debugger.add_breakpoint file, line, expr
+      print_breakpoint_added b
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] file:line [if expr]
+          b[reak] [file|class(:|.|#)]<line|method> [if expr] -
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  class BreakpointsCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*info\s*break$/
+    end
+
+    def execute
+      print_breakpoints Debugger.breakpoints
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak]\tlist breakpoints
+        }
+      end
+    end
+  end
+
+  class DeleteBreakpointCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*del(?:ete)?(?:\s+(.*))?$/
+    end
+
+    def execute
+      brkpts = @match[1]
+      unless brkpts
+          Debugger.breakpoints.clear
+      else
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          b = Debugger.remove_breakpoint(pos)
+          if b
+            print_breakpoint_deleted b
+          else
+            print_error "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/lib/ruby-debug-ide/commands/catchpoint.rb

@@ -0,0 +1,64 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.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.
+        errmsg "Exception class must be specified for 'catch' command"
+      elsif not @match[2]
+        # One arg given.
+        if 'off' == excn
+          clear_catchpoints
+        else
+          Debugger.add_catchpoint(excn)
+          print_catchpoint_set(excn)
+        end
+      elsif @match[2] != 'off'
+        errmsg "Off expected. Got %s\n", @match[2]
+      elsif remove_catchpoint(excn)
+        print_catchpoint_deleted(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\t\tshow catchpoint
+          cat[ch] off \tremove all catch points
+          cat[ch] <an Exception>\tset catchpoint to an exception
+          cat[ch] <an Exception> off \tremove catchpoint for an exception
+        }
+      end
+    end
+
+    private
+
+    def clear_catchpoints
+      if Debugger.respond_to?(:clear_catchpoints)
+        Debugger.clear_catchpoints
+      else
+        Debugger.catchpoints.clear
+      end
+    end
+
+    def remove_catchpoint(excn)
+      return Debugger.remove_catchpoint(excn) if Debugger.respond_to?(:remove_catchpoint)
+      return Debugger.catchpoints.delete(excn) if Debugger.catchpoints.member?(excn)
+      false
+    end
+  end
+end

data/lib/ruby-debug-ide/commands/condition.rb

@@ -0,0 +1,51 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+    self.control = true
+
+    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_so_far, b|
+          b.id if b.id > largest_so_far
+        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]
+            print_contdition_set(b.id)
+            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

data/lib/ruby-debug-ide/commands/control.rb

@@ -0,0 +1,158 @@
+module Debugger
+  class QuitCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(?:q(?:uit)?|exit)\s*$/
+    end
+
+    def execute
+      begin
+        @printer.print_msg("finished")
+        @printer.print_debug("Exiting debugger.")
+      ensure
+        exit! # exit -> exit!: No graceful way to stop threads...
+      end
+    end
+
+    class << self
+      def help_command
+        %w[quit exit]
+      end
+
+      def help(cmd)
+        %{
+          q[uit]\texit from debugger, 
+          exit\talias to quit
+        }
+      end
+    end
+  end
+  
+  class RestartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*
+      (restart|R)
+      (\s+ \S+ .*)?
+      $
+      /x
+    end
+    
+    def execute
+      if not defined? Debugger::RDEBUG_SCRIPT or not defined? Debugger::ARGV
+        print "We are not in a context we can restart from.\n"
+        return
+      end
+      if @match[2]
+        args = Debugger::PROG_SCRIPT + " " + @match[2]
+      else
+        args = Debugger::ARGV.join(" ")
+      end
+
+      # An execv would be preferable to the "exec" below.
+      cmd = Debugger::RDEBUG_SCRIPT + " " + args
+      print "Re exec'ing:\n\t#{cmd}\n"
+      exec cmd
+    end
+
+    class << self
+      def help_command
+        'restart'
+      end
+
+      def help(cmd)
+        %{
+          restart|R [args] 
+          Restart the program. This is is a re-exec - all debugger state
+          is lost. If command arguments are passed those are used.
+        }
+      end
+    end
+  end
+
+  class StartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(start)(\s+ \S+ .*)?$/x
+    end
+    
+    def execute
+      @printer.print_debug("Starting: running program script")
+      Debugger.run_prog_script #Debugger.prog_script_running?
+    end
+
+    class << self
+      def help_command
+        'start'
+      end
+
+      def help(cmd)
+        %{
+          run prog script
+        }
+      end
+    end
+  end
+
+
+  class InterruptCommand < Command # :nodoc:
+    self.event = false
+    self.control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*i(?:nterrupt)?\s*$/
+    end
+    
+    def execute
+      unless Debugger.interrupt_last
+        context = Debugger.thread_context(Thread.main)
+        context.interrupt
+      end
+    end
+    
+    class << self
+      def help_command
+        'interrupt'
+      end
+      
+      def help(cmd)
+        %{
+          i[nterrupt]\tinterrupt the program
+        }
+      end
+    end
+  end
+
+
+  class DetachCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*detach\s*$/
+    end
+
+    def execute
+      Debugger.stop
+      Debugger.interface.close
+      Debugger::MultiProcess.undo_monkey
+      Debugger.control_thread = nil
+      Thread.current.exit #@control_thread is a current thread
+    end
+
+    class << self
+      def help_command
+        'detach'
+      end
+
+      def help(cmd)
+        %{
+          detach\ndetach debugger\nnote: this option is only for remote debugging (or local attach)
+        }
+      end
+    end
+  end
+end