ruby-debug-ide22 0.7.4

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 : Command.unescape_incoming(@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! unless ENV['DEBUGGER_KEEP_PROCESS_ALIVE'] == "true" # 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

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

@@ -0,0 +1,203 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module EnableDisableFunctions # :nodoc:
+    def enable_disable_breakpoints(is_enable, args)
+      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
+        errmsg "No breakpoints have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} breakpoints", 1, largest)
+        return nil unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            enabled = ("Enable" == is_enable)
+            if enabled
+              unless syntax_valid?(b.expr)
+                errmsg("Expression \"#{b.expr}\" syntactically incorrect; breakpoint remains disabled.\n")
+                break
+              end
+            end
+            b.enabled = enabled
+            enabled ? print_breakpoint_enabled(b) : print_breakpoint_disabled(b)
+            break
+          end
+        end
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      if 0 == @state.display.size 
+        errmsg "No display expressions have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return nil unless pos
+        @state.display[pos-1][0] = ("Enable" == is_enable)
+      end
+    end
+
+  end
+
+  class EnableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Enable specified breakpoints",
+"Give breakpoint numbers (separated by spaces) as arguments.
+This is used to cancel the effect of the \"disable\" command."
+       ],
+       ['display', 2, 
+        "Enable some expressions to be displayed when program stops",
+"Arguments are the code numbers of the expressions to resume displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* en(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"enable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("enable_#{subcmd.name}", args)
+        else
+          send("enable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def enable_breakpoints(args)
+      enable_disable_breakpoints("Enable", args)
+    end
+    
+    def enable_display(args)
+      enable_disable_display("Enable", args)
+    end
+    
+    class << self
+      def help_command
+        'enable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'enable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Enable some things.
+          This is used to cancel the effect of the "disable" command.
+          -- 
+          List of enable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "enable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+  class DisableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 1, "Disable some breakpoints",
+"Arguments are breakpoint numbers with spaces in between.
+A disabled breakpoint is not forgotten, but has no effect until reenabled."],
+       ['display', 1, "Disable some display expressions when program stops",
+"Arguments are the code numbers of the expressions to stop displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* dis(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"disable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("disable_#{subcmd.name}", args)
+        else
+          send("disable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def disable_breakpoints(args)
+      enable_disable_breakpoints("Disable", args)
+    end
+    
+    def disable_display(args)
+      enable_disable_display("Disable", args)
+    end
+    
+    class << self
+      def help_command
+        'disable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'disable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Disable some things.
+
+          A disabled item is not forgotten, but has no effect until reenabled.
+          Use the "enable" command to have it take effect again.
+          -- 
+          List of disable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "disable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+end # module Debugger

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

@@ -0,0 +1,64 @@
+module Debugger
+  class EvalCommand < Command # :nodoc:
+    #self.control = true
+
+    def match(input)
+      @input = input
+      super
+    end
+    
+    def regexp
+      /^\s*(p|e(?:val)?)\s+/
+    end
+
+    def execute
+      expr = @match ? @match.post_match : @input
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      print_eval expr, debug_eval(expr, binding).inspect
+    end
+
+    class << self
+      def help_command
+        %w|p eval|
+      end
+
+      def help(cmd)
+        if cmd == 'p'
+          %{
+            p expression\tevaluate expression and print its value
+          }
+        else
+          %{
+            e[val] expression\tevaluate expression and print its value,
+            \t\t\talias for p.
+          }
+        end
+      end
+    end
+  end
+
+  class PPCommand < Command # :nodoc:
+    def regexp
+      /^\s*pp\s+/
+    end
+
+    def execute
+      exp = @match.post_match
+      out = StringIO.new
+      PP.pp(debug_eval(exp), out) rescue out.puts $!.message
+      print_pp out.string
+    end
+
+    class << self
+      def help_command
+        'pp'
+      end
+
+      def help(cmd)
+        %{
+          pp expression\tevaluate expression and print its value
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'stringio'
+require 'irb/ruby-lex'
+
+module Debugger
+
+  class ExpressionInfoCommand < Command
+    def regexp
+      /^\s*ex(?:pression_info)?\s+/
+    end
+
+    def execute
+      string_to_parse = Command.unescape_incoming(@match.post_match) + " \n \n\n"
+      total_lines = string_to_parse.count("\n") + 1
+
+      lexer = RubyLex.new
+      lexer.set_input(create_io_reader(string_to_parse))
+
+      last_statement = ''
+      last_prompt = ''
+      last_indent = 0
+      lexer.set_prompt do |ltype, indent, continue, lineno|
+        next if (lineno >= total_lines)
+
+        last_prompt = ltype || ''
+        last_indent = indent
+      end
+
+      lexer.each_top_level_statement do |line, line_no|
+        last_statement = line
+      end
+
+      incomplete = true
+      if /\A\s*\Z/m =~ last_statement
+        incomplete = false
+      end
+
+      @printer.print_expression_info(incomplete, last_prompt, last_indent)
+    end
+
+    def create_io_reader(string_to_parse)
+      io = StringIO.new(string_to_parse)
+
+      if string_to_parse.respond_to?(:encoding)
+        io.instance_exec(string_to_parse.encoding) do |string_encoding|
+          @my_encoding = string_encoding
+          def self.encoding
+            @my_encoding
+          end
+        end
+      end
+
+      io
+    end
+
+    class << self
+      def help_command
+        "expression_info"
+      end
+
+      def help(cmd)
+        %{
+          ex[pression_info] <expression>\t
+          returns parser-related information for the expression given\t\t
+          'incomplete'=true|false\tindicates whether expression is a complete ruby
+          expression and can be evaluated without getting syntax errors
+        }
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,107 @@
+module Debugger
+  class IncludeFile < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*include\s+(.+?)\s*$/x
+    end
+
+    def execute
+      file = @match[1]
+
+      return if file.nil?
+      file = realpath(file)
+
+      if Command.file_filter_supported?
+        Debugger.file_filter.include(file)
+        print_file_included(file)
+      else
+        print_debug("file filter is not supported")
+      end
+    end
+
+    class << self
+      def help_command
+        'include'
+      end
+
+      def help(cmd)
+        %{
+          include file - adds file/dir to file filter (either remove already excluded or add as included)
+        }
+      end
+    end
+  end
+
+  class ExcludeFile < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*exclude\s+(.+?)\s*$/x
+    end
+
+    def execute
+      file = @match[1]
+
+      return if file.nil?
+      file = realpath(file)
+
+      if Command.file_filter_supported?
+        Debugger.file_filter.exclude(file)
+        print_file_excluded(file)
+      else
+        print_debug("file filter is not supported")
+      end
+    end
+
+    class << self
+      def help_command
+        'include'
+      end
+
+      def help(cmd)
+        %{
+          exclude file - exclude file/dir from file filter (either remove already included or add as exclude)
+        }
+      end
+    end
+  end
+
+  class FileFilterCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*file-filter\s+(on|off)\s*$/x
+    end
+
+    def execute
+      action = @match[1]
+
+      if Command.file_filter_supported?
+        if 'on' == action
+          Debugger.file_filter.enable
+          print_file_filter_status(true)
+        elsif 'off' == action
+          Debugger.file_filter.disable
+          print_file_filter_status(false)
+        else
+          print_error "Unknown option '#{action}'"
+        end
+      else
+        print_debug("file filter is not supported")
+      end
+    end
+
+    class << self
+      def help_command
+        'file-filter'
+      end
+
+      def help(cmd)
+        %{
+          file-filter (on|off) - enable/disable file  filtering
+        }
+      end
+    end
+  end
+end