vim-jar 0.0.1

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/list.rb

@@ -0,0 +1,94 @@
+module Debugger
+  # Implements debugger "list" command.
+  class ListCommand < Command
+
+    register_setting_get(:autolist) do
+      ListCommand.always_run 
+    end
+    register_setting_set(:autolist) do |value|
+      ListCommand.always_run = value
+    end
+
+    def regexp
+      /^\s* l(?:ist)? (?:\s*([-=])|\s+(.+))? $/x
+    end
+
+    def execute
+      listsize = Command.settings[:listsize]
+      if !@match || !(@match[1] || @match[2])
+        b = @state.previous_line ? 
+        @state.previous_line + listsize : @state.line - (listsize/2)
+        e = b + listsize - 1
+      elsif @match[1] == '-'
+        b = if @state.previous_line
+              if  @state.previous_line > 0
+                @state.previous_line - listsize 
+              else
+                @state.previous_line
+              end
+            else 
+              @state.line - (listsize/2)
+            end
+        e = b + listsize - 1
+      elsif @match[1] == '='
+        @state.previous_line = nil
+        b = @state.line - (listsize/2)
+        e = b + listsize -1
+      else
+        b, e = @match[2].split(/[-,]/)
+        if e
+          b = b.to_i
+          e = e.to_i
+        else
+          b = b.to_i - (listsize/2)
+          e = b + listsize - 1
+        end
+      end
+      @state.previous_line = display_list(b, e, @state.file, @state.line)
+    end
+
+    class << self
+      def help_command
+        'list'
+      end
+
+      def help(cmd)
+        %{
+          l[ist]\t\tlist forward
+          l[ist] -\tlist backward
+          l[ist] =\tlist current line
+          l[ist] nn-mm\tlist given lines
+          * NOTE - to turn on autolist, use 'set autolist'
+        }
+      end
+    end
+
+    private
+
+    # Show FILE from line B to E where CURRENT is the current line number.
+    # If we can show from B to E then we return B, otherwise we return the
+    # previous line @state.previous_line.
+    def display_list(b, e, file, current)
+      lines = LineCache::getlines(file, 
+                                  Command.settings[:reload_source_on_change])
+      if lines
+        b = lines.size - (e - b) if b >= lines.size
+        e = lines.size if lines.size < e
+        print "[%d, %d] in %s\n", b, e, file
+        [b, 1].max.upto(e) do |n|
+          if n > 0 && lines[n-1]
+            if n == current
+              print "=> %d  %s\n", n, lines[n-1].chomp
+            else
+              print "   %d  %s\n", n, lines[n-1].chomp
+            end
+          end
+        end
+      else
+        errmsg "No sourcefile available for %s\n", file
+        return @state.previous_line
+      end
+      return b
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/method.rb

@@ -0,0 +1,84 @@
+module Debugger
+
+  begin
+    require 'methodsig'
+    have_methodsig = true
+  rescue LoadError
+    have_methodsig = false
+  end
+
+  # Implements the debugger 'method sig' command.
+  class MethodSigCommand < Command
+    def regexp
+      /^\s*m(?:ethod)?\s+sig(?:nature)?\s+(\S+)\s*$/
+    end
+
+    def execute
+      obj = debug_eval('method(:%s)' % @match[1])
+      if obj.is_a?(Method)
+        begin
+          print "%s\n", obj.signature.to_s
+        rescue
+          errmsg("Can't get signature for '#{@match[1]}'\n")
+        end
+      else
+        errmsg("Can't make method out of '#{@match[1]}'\n")
+      end
+    end
+
+    class << self
+      def help_command
+        'method'
+      end
+
+      def help(cmd)
+        %{
+          m[ethod] sig[nature] <obj>\tshow the signature of a method
+        }
+      end
+    end
+  end if have_methodsig
+
+  # Implements the debugger 'method' command.
+  class MethodCommand < Command
+    def regexp
+      /^\s*m(?:ethod)?\s+((iv)|(i(:?nstance\s+)?)\s+)?/
+    end
+
+    def execute
+      if @match[1] == "iv"
+        obj = debug_eval(@match.post_match)
+        obj.instance_variables.sort.each do |v|
+          print "%s = %s\n", v, obj.instance_variable_get(v).inspect
+        end
+      elsif @match[1]
+        obj = debug_eval(@match.post_match)
+        print "%s\n", columnize(obj.methods.sort(), 
+                                self.class.settings[:width])
+      else
+        obj = debug_eval(@match.post_match)
+        unless obj.kind_of? Module
+          print "Should be Class/Module: %s\n", @match.post_match
+        else
+          print "%s\n", columnize(obj.instance_methods(false).sort(), 
+                                  self.class.settings[:width])
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'method'
+      end
+
+      def help(cmd)
+        %{
+          m[ethod] i[nstance] <obj>\tshow methods of object
+          m[ethod] iv <obj>\t\tshow instance variables of object
+          m[ethod] <class|module>\t\tshow instance methods of class or module
+        }
+      end
+    end
+  end
+
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/quit.rb

@@ -0,0 +1,44 @@
+module Debugger
+
+  # Implements debugger "quit" command
+  class QuitCommand < Command
+    self.allow_in_control = true
+
+    # An input line is matched against this regular expression. If we have
+    # a match, run this command.
+    def regexp
+      / ^\s*
+         (?:q(?:uit)?|exit) \s*
+         (!|\s+unconditionally)? \s*
+         $
+      /ix
+    end
+
+    # The code that implements this command.
+    def execute
+      if @match[1] or confirm("Really quit? (y/n) ") 
+        @state.interface.finalize
+        exit! # exit -> exit!: No graceful way to stop threads...
+      end
+    end
+
+    class << self
+      # The command name listed via 'help'
+      def help_command
+        %w[quit exit]
+      end
+
+      # Returns a String given the help description of this command
+      def help(cmd)
+        %{
+          q[uit] [!|unconditionally]\texit from debugger. 
+          exit[!]\talias to quit
+
+          Normally we prompt before exiting. However if the parameter
+          "unconditionally" or is given or suffixed with !, we stop
+          without asking further questions.  
+         }
+     end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/raise.RB

@@ -0,0 +1,41 @@
+module Debugger
+  class RaiseCommand < Command # :nodoc:
+    self.allow_in_control = false
+
+    def regexp
+      /^\s* raise
+           (?:\s+ (\S+))? \s* $/ix
+    end
+
+    def execute
+      excn = @match[1]
+      exception = 
+        if not excn
+          # No args given.
+          RuntimeError
+        else
+          unless debug_eval("#{excn}.is_a?(Class)", binding)
+            errmsg "#{excn} is not known to be a Class\n"
+            return
+          end
+          debug_eval(excn, binding)
+        end
+      @state.exception = exception
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'raise'
+      end
+
+      def help(cmd)
+        %{
+           raise EXCEPTION
+
+          Raise an exception in the debugged program."
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/reload.rb

@@ -0,0 +1,40 @@
+module Debugger
+  # Implements debugger "reload" command.
+  class ReloadCommand < Command
+    self.allow_in_control = true
+
+    register_setting_get(:reload_source_on_change) do 
+      Debugger.reload_source_on_change
+    end
+    register_setting_set(:reload_source_on_change) do |value|
+      Debugger.reload_source_on_change = value
+    end
+    
+    def regexp
+      /^\s*r(?:eload)?$/
+    end
+    
+    def execute
+      Debugger.source_reload
+      print "Source code is reloaded. Automatic reloading is #{source_reloading}.\n"
+    end
+    
+    private
+    
+    def source_reloading
+      Debugger.reload_source_on_change ? 'on' : 'off'
+    end
+    
+    class << self
+      def help_command
+        'reload'
+      end
+
+      def help(cmd)
+        %{
+          r[eload]\tforces source code reloading
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/save.rb

@@ -0,0 +1,90 @@
+module Debugger
+  module SaveFunctions # :nodoc:
+
+    # Create a temporary file to write in if file is nil
+    def open_save
+      require "tempfile"
+      file = Tempfile.new("rdebug-save")
+      # We want close to not unlink, so redefine.
+      def file.close
+        @tmpfile.close if @tmpfile
+      end
+      return file
+    end
+  end
+
+  class SaveCommand < Command # :nodoc:
+    self.allow_in_control = true
+    
+    def save_breakpoints(file)
+      Debugger.breakpoints.each do |b|
+        file.puts "break #{b.source}:#{b.pos}#{" if #{b.expr}" if b.expr}"
+      end
+    end
+
+    def save_catchpoints(file)
+      Debugger.catchpoints.keys.each do |c|
+        file.puts "catch #{c}" 
+      end
+    end
+    
+    def save_displays(file)
+      for d in @state.display
+        if d[0]
+          file.puts "display #{d[1]}"
+        end
+      end
+    end
+    
+    def save_settings(file)
+      # FIXME put routine in set
+      %w(autoeval basename debuggertesting).each do |setting|
+        on_off = show_onoff(Command.settings[setting.to_sym])
+        file.puts "set #{setting} #{on_off}"
+      end
+      %w(autolist autoirb).each do |setting|
+        on_off = show_onoff(Command.settings[setting.to_sym] > 0)
+        file.puts "set #{setting} #{on_off}"
+      end
+    end
+    
+    def regexp
+      /^\s* sa(?:ve)?
+        (?:\s+(.+))? 
+        \s*$/ix
+    end
+    
+    def execute
+      if not @match[1] or @match[1].strip.empty?
+        file = open_save()
+      else
+        file = open(@match[1], 'w')
+      end
+      save_breakpoints(file)
+      save_catchpoints(file)
+      # save_displays(file)
+      save_settings(file)
+      print "Saved to '#{file.path}'\n"
+      if @state and @state.interface
+        @state.interface.restart_file = file.path
+      end
+      file.close
+    end
+
+    class << self
+      def help_command
+        'save'
+      end
+      
+      def help(cmd)
+        %{
+save [FILE]
+Saves current debugger state to FILE as a script file.
+This includes breakpoints, catchpoints, display expressions and some settings.
+If no filename is given, we will fabricate one.
+
+Use the 'source' command in another debug session to restore them.}
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/set.rb

@@ -0,0 +1,237 @@
+module Debugger
+  # Implements debugger "set" command.
+  class SetCommand < Command
+    SubcmdStruct2=Struct.new(:name, :min, :is_bool, :short_help, 
+                             :long_help) unless defined?(SubcmdStruct2)
+    Subcommands = 
+      [
+       ['annotate', 2, false,
+       "Set annotation level",
+"0 == normal;
+2 == output annotated suitably for use by programs that control 
+ruby-debug."],
+       ['args', 2, false,
+       "Set argument list to give program being debugged when it is started",
+"Follow this command with any number of args, to be passed to the program."],
+       ['autoeval', 4, true,
+        "Evaluate every unrecognized command"],
+       ['autolist', 4, true,
+        "Execute 'list' command on every breakpoint"],
+       ['autoirb', 4, true,
+        "Invoke IRB on every stop"],
+       ['autoreload', 4, true,
+        "Reload source code when changed"],
+       ['basename', 1, true,
+        "Report file basename only showing file names"],
+       ['callstyle', 2, false,
+        "Set how you want call parameters displayed"],
+       ['debuggertesting', 8, false,
+        "Used when testing the debugger"],
+       ['forcestep', 2, true,
+        "Make sure 'next/step' commands always move to a new line"],
+       ['fullpath', 2, true,
+        "Display full file names in frames"],
+       ['history', 2, false,
+        "Generic command for setting command history parameters",
+"set history filename -- Set the filename in which to record the command history
+set history save -- Set saving of the history record on exit
+set history size -- Set the size of the command history"],
+       ['keep-frame-bindings', 1, true,
+        "Save frame binding on each call"],
+       ['linetrace+', 10, true,
+       "Set line execution tracing to show different lines"],
+       ['linetrace', 3, true,
+       "Set line execution tracing"],
+       ['listsize', 3, false,
+       "Set number of source lines to list by default"],
+#        ['post-mortem', 3, true,
+#        "Set whether we do post-mortem handling on an uncaught exception"],
+       ['trace', 1, true,
+        "Display stack trace when 'eval' raises exception"],
+       ['width', 1, false,
+        "Number of characters the debugger thinks are in a line"],
+      ].map do |name, min, is_bool, short_help, long_help| 
+      SubcmdStruct2.new(name, min, is_bool, short_help, long_help)
+    end unless defined?(Subcommands)
+    
+    self.allow_in_control = true
+
+    def regexp
+      /^set (?: \s+ (.*) )?$/ix
+    end
+
+    def execute
+      if not @match[1]
+        print "\"set\" must be followed by the name of an set command:\n"
+        print "List of set subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "set #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        args = @match[1].split(/[ \t]+/)
+        subcmd = args.shift
+        subcmd.downcase!
+        if subcmd =~ /^no/i
+          set_on = false
+          subcmd = subcmd[2..-1]
+        else
+          set_on = true
+        end
+        for try_subcmd in Subcommands do
+          if (subcmd.size >= try_subcmd.min) and
+              (try_subcmd.name[0..subcmd.size-1] == subcmd)
+            begin
+              if try_subcmd.is_bool
+                if args.size > 0 
+                  set_on = get_onoff(args[0]) 
+                end
+              end
+              case try_subcmd.name
+              when /^annotate$/
+                level = get_int(args[0], "Set annotate", 0, 3, 0)
+                if level
+                  Debugger.annotate = level
+                else
+                  return
+                end
+                if defined?(Debugger::RDEBUG_SCRIPT)
+                  # rdebug was called initially. 1st arg is script name.
+                  Command.settings[:argv][1..-1] = args
+                else
+                  # rdebug wasn't called initially. 1st arg is not script name.
+                  Command.settings[:argv] = args
+                end
+              when /^args$/
+                Command.settings[:argv][1..-1] = args
+              when /^autolist$/
+                Command.settings[:autolist] = (set_on ? 1 : 0)
+              when /^autoeval$/
+                Command.settings[:autoeval] = set_on
+              when /^basename$/
+                Command.settings[:basename] = set_on
+              when /^callstyle$/
+                if args[0]
+                  arg = args[0].downcase.to_sym
+                  case arg
+                  when :short, :last, :tracked
+                    Command.settings[:callstyle] = arg
+                    Debugger.track_frame_args = arg == :tracked ? true : false
+                    print "%s\n" % show_setting(try_subcmd.name)
+                    return
+                  end
+                end
+                print "Invalid call style #{arg}. Should be one of: " +
+                  "'short', 'last', or 'tracked'.\n"
+              when /^trace$/
+                Command.settings[:stack_trace_on_error] = set_on
+              when /^fullpath$/
+                Command.settings[:full_path] = set_on
+              when /^autoreload$/
+                Command.settings[:reload_source_on_change] = set_on
+              when /^autoirb$/
+                Command.settings[:autoirb] = (set_on ? 1 : 0)
+              when /^debuggertesting$/
+                Command.settings[:debuggertesting] = set_on
+                if set_on
+                  Command.settings[:basename] = true
+                end
+              when /^forcestep$/
+                self.class.settings[:force_stepping] = set_on
+              when /^history$/
+                if 2 == args.size
+                  interface = @state.interface
+                  case args[0]
+                  when /^save$/
+                    interface.history_save = get_onoff(args[1])
+                  when /^size$/
+                    interface.history_length = get_int(args[1],
+                                                       "Set history size")
+                  else
+                    print "Invalid history parameter #{args[0]}. Should be 'save' or 'size'.\n" 
+                  end
+                else
+                  print "Need two parameters for 'set history'; got #{args.size}.\n" 
+                  return
+                end
+              when /^keep-frame-bindings$/
+                Debugger.keep_frame_binding = set_on
+              when /^linetrace\+$/
+                self.class.settings[:tracing_plus] = set_on
+              when /^linetrace$/
+                Debugger.tracing = set_on
+              when /^listsize$/
+                listsize = get_int(args[0], "Set listsize", 1, nil, 10)
+                if listsize
+                  self.class.settings[:listsize] = listsize
+                else
+                  return
+                end
+#               when /^post-mortem$/
+#                 unless Debugger.post_mortem? == set_on
+#                   if set_on
+#                     Debugger.post_mortem
+#                   else
+#                     errmsg "Can't turn off post-mortem once it is on.\n"
+#                     return
+#                   end
+#                 end
+              when /^width$/
+                width = get_int(args[0], "Set width", 10, nil, 80)
+                if width
+                  self.class.settings[:width] = width
+                  ENV['COLUMNS'] = width.to_s
+                else
+                  return
+                end
+              else
+                print "Unknown setting #{@match[1]}.\n"
+                return
+              end
+              print "%s\n" % show_setting(try_subcmd.name)
+              return
+            rescue RuntimeError
+              return
+            end
+          end
+        end
+        print "Unknown set command #{subcmd}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        "set"
+      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 'set' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Modifies parts of the ruby-debug environment. Boolean values take
+          on, off, 1 or 0.
+          You can see these environment settings with the \"show\" command.
+
+          -- 
+          List of set subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "set #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end