ruby-debug-ide-docker 0.6.1

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

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

@@ -0,0 +1,155 @@
+module Debugger
+
+  module FrameFunctions # :nodoc:
+
+    def adjust_frame(frame_pos, absolute)
+      if absolute
+        if frame_pos < 0
+          abs_frame_pos = @state.context.stack_size + frame_pos
+        else
+          abs_frame_pos = frame_pos - 1
+        end
+      else
+        abs_frame_pos = @state.frame_pos + frame_pos
+      end
+
+      if abs_frame_pos >= @state.context.stack_size then
+        print_error "Adjusting would put us beyond the oldest (initial) frame.\n"
+        return
+      elsif abs_frame_pos < 0 then
+        print_error "Adjusting would put us beyond the newest (innermost) frame.\n"
+        return
+      end
+      if @state.frame_pos != abs_frame_pos then
+        @state.previous_line = nil
+        @state.frame_pos = abs_frame_pos
+      end
+      @state.file = @state.context.frame_file(@state.frame_pos)
+      @state.line = @state.context.frame_line(@state.frame_pos)
+      
+      print_current_frame(@state.frame_pos)
+    end
+
+  end
+
+  class WhereCommand < Command # :nodoc:
+    def regexp
+      /^\s*(?:w(?:here)?|bt|backtrace)$/
+    end
+
+    def execute
+      print_frames(@state.context, @state.frame_pos)
+    end
+
+    class << self
+      def help_command
+        %w|where backtrace|
+      end
+
+      def help(cmd)
+        if cmd == 'where'
+          %{
+            w[here]\tdisplay frames
+          }
+        else
+          %{
+            bt|backtrace\t\talias for where
+          }
+        end
+      end
+    end
+  end
+
+  class UpCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* u(?:p)? (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      unless @match[1]
+        pos = 1
+      else
+        pos = get_int(@match[1], "Up")
+        return unless pos
+      end
+      adjust_frame(pos, false)
+    end
+
+    class << self
+      def help_command
+        'up'
+      end
+
+      def help(cmd)
+        %{
+          up[count]\tmove to higher frame
+        }
+      end
+    end
+  end
+
+  class DownCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* down (?:\s+(.*))? .*$/x
+    end
+
+    def execute
+      if not @match[1]
+        pos = 1
+      else
+        pos = get_int(@match[1], "Down")
+        return unless pos
+      end
+      adjust_frame(-pos, false)
+    end
+
+    class << self
+      def help_command
+        'down'
+      end
+
+      def help(cmd)
+        %{
+          down[count]\tmove to lower frame
+        }
+      end
+    end
+  end
+  
+  class FrameCommand < Command # :nodoc:
+    include FrameFunctions
+    def regexp
+      /^\s* f(?:rame)? (?:\s+ (.*))? \s*$/x
+    end
+
+    def execute
+      if not @match[1]
+        print "Missing a frame number argument.\n"
+        return
+      else
+        pos = get_int(@match[1], "Frame")
+        return unless pos
+      end
+      adjust_frame(pos, true)
+    end
+
+    class << self
+      def help_command
+        'frame'
+      end
+
+      def help(cmd)
+        %{
+          f[rame] frame-number
+          Move the current frame to the specified frame number.
+
+          A negative number indicates position from the other end.  So
+          'frame -1' moves to the oldest frame, and 'frame 0' moves to
+          the newest frame.
+        }
+      end
+    end
+  end
+end