ruby-debug-ide22 0.7.4 → 0.7.5

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

@@ -1,203 +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
+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

@@ -1,64 +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
+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

@@ -1,71 +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
+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