vim-jar 0.0.1

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

@@ -0,0 +1,251 @@
+module Debugger
+  # Mix-in module to showing settings
+  module ShowFunctions # :nodoc:
+    def show_setting(setting_name)
+      case setting_name
+      when /^annotate$/
+        Debugger.annotate ||= 0
+        return ("Annotation level is #{Debugger.annotate}")
+      when /^args$/
+        if Command.settings[:argv] and Command.settings[:argv].size > 0
+          if defined?(Debugger::RDEBUG_SCRIPT)
+            # rdebug was called initially. 1st arg is script name.
+            args = Command.settings[:argv][1..-1].join(' ')
+          else
+            # rdebug wasn't called initially. 1st arg is not script name.
+            args = Command.settings[:argv].join(' ')
+          end
+        else
+          args = ''
+        end
+        return "Argument list to give program being debugged when it is started is \"#{args}\"."
+      when /^autolist$/
+        on_off = Command.settings[:autolist] > 0
+        return "autolist is #{show_onoff(on_off)}."
+      when /^autoeval$/
+        on_off = Command.settings[:autoeval]
+        return "autoeval is #{show_onoff(on_off)}."
+      when /^autoreload$/
+        on_off = Command.settings[:reload_source_on_change]
+        return "autoreload is #{show_onoff(on_off)}."
+      when /^autoirb$/
+        on_off = Command.settings[:autoirb] > 0
+        return "autoirb is #{show_onoff(on_off)}."
+      when /^basename$/
+        on_off = Command.settings[:basename]
+        return "basename is #{show_onoff(on_off)}."
+      when /^callstyle$/
+        style = Command.settings[:callstyle]
+        return "Frame call-display style is #{style}."
+      when /^commands(:?\s+(\d+))?$/
+        return 'No readline support.' unless @state.interface.readline_support?
+        s = '';
+        args = @match[1].split
+        if args[1]
+          first_line = args[1].to_i - 4
+          last_line  = first_line + 10 - 1
+          if first_line > Readline::HISTORY.length
+            first_line = last_line = Readline::HISTORY.length
+          elsif first_line <= 0
+            first_line = 1
+          end
+          if last_line > Readline::HISTORY.length
+            last_line = Readline::HISTORY.length
+          end
+          i = first_line
+          commands = Readline::HISTORY.to_a[first_line..last_line]
+        else
+          if Readline::HISTORY.length > 10
+            commands = Readline::HISTORY.to_a[-10..-1]
+            i = Readline::HISTORY.length - 10
+          else
+            commands = Readline::HISTORY.to_a
+            i = 1
+          end
+        end
+        commands.each do |cmd|
+          s += ("%5d  %s\n" % [i, cmd])
+          i += 1
+        end
+        return s
+      when /^debuggertesting$/
+        on_off = Command.settings[:debuggertesting]
+        return "Currently testing the debugger is #{show_onoff(on_off)}."
+      when /^forcestep$/
+        on_off = self.class.settings[:force_stepping]
+        return "force-stepping is #{show_onoff(on_off)}."
+      when /^fullpath$/
+        on_off = Command.settings[:full_path]
+        return "Displaying frame's full file names is #{show_onoff(on_off)}."
+      when /^history(:?\s+(filename|save|size))?$/
+        return 'No readline support.' unless @state.interface.readline_support?
+        args = @match[1].split
+        interface = @state.interface
+        if args[1] 
+          show_save = show_size = show_filename = false
+          prefix = false
+          if args[1] == "save"
+            show_save = true
+          elsif args[1] == "size"
+            show_size = true
+          elsif args[1] == "filename"
+            show_filename = true
+          end
+        else
+          show_save = show_size = show_filename = true
+          prefix = true
+        end
+        s = []
+        if show_filename
+          msg = (prefix ? "filename: " : "") + 
+            "The filename in which to record the command history is " +
+                      "#{interface.histfile.inspect}"
+          s << msg
+        end
+        if show_save
+          msg = (prefix ? "save: " : "") + 
+            "Saving of history save is #{show_onoff(interface.history_save)}."
+          s << msg
+        end
+        if show_size
+          msg = (prefix ? "size: " : "") + 
+            "Debugger history size is #{interface.history_length}"
+          s << msg
+        end
+        return s.join("\n")
+      when /^keep-frame-bindings$/
+        on_off = Debugger.keep_frame_binding?
+        return "keep-frame-bindings is #{show_onoff(on_off)}."
+      when /^linetrace$/
+        on_off = Debugger.tracing
+        return "line tracing is #{show_onoff(on_off)}."
+      when /^linetrace\+$/
+        on_off = Command.settings[:tracing_plus]
+        if on_off
+          return "line tracing style is different consecutive lines."
+        else
+          return "line tracing style is every line."
+        end
+      when /^listsize$/
+        listlines = Command.settings[:listsize]
+        return "Number of source lines to list by default is #{listlines}."
+      when /^port$/
+        return "server port is #{Debugger::PORT}."
+      when /^post-mortem$/
+        on_off = Debugger.post_mortem?
+        return "post-mortem handling is #{show_onoff(on_off)}."
+      when /^trace$/
+        on_off = Command.settings[:stack_trace_on_error]
+        return "Displaying stack trace is #{show_onoff(on_off)}."
+      when /^version$/
+        return "ruby-debug #{Debugger::VERSION}"
+      when /^width$/
+        return "width is #{self.class.settings[:width]}."
+      else
+        return "Unknown show subcommand #{setting_name}."
+      end
+    end
+  end
+
+  # Implements debugger "show" command.
+  class ShowCommand < Command
+    
+    Subcommands = 
+      [
+       ['annotate', 2, "Show annotation level",
+"0 == normal; 2 == output annotated suitably for use by programs that control 
+ruby-debug."],
+       ['args', 2, 
+        "Show 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, "Show if unrecognized command are evaluated"],
+       ['autolist',  4, "Show if 'list' commands is run on breakpoints"],
+       ['autoirb',   4, "Show if IRB is invoked on debugger stops"],
+       ['autoreload', 4, "Show if source code is reloaded when changed"],
+       ['basename',  1, "Show if basename used in reporting files"],
+       ['callstyle', 2, "Show paramater style used showing call frames"],
+       ['commands',  2, "Show the history of commands you typed",
+"You can supply a command number to start with."],
+       ['forcestep', 1, "Show if sure 'next/step' forces move to a new line"],
+       ['fullpath',  2, "Show if full file names are displayed in frames"],
+       ['history', 2, "Generic command for showing command history parameters",
+"show history filename -- Show the filename in which to record the command history
+show history save -- Show saving of the history record on exit
+show history size -- Show the size of the command history"],
+       ['keep-frame-bindings', 1, "Save frame binding on each call"],
+       ['linetrace', 3, "Show line execution tracing"],
+       ['linetrace+', 10, 
+        "Show if consecutive lines should be different are shown in tracing"],
+       ['listsize', 3, "Show number of source lines to list by default"],
+       ['port', 3, "Show server port"],
+       ['post-mortem', 3, "Show whether we go into post-mortem debugging on an uncaught exception"],
+       ['trace', 1, 
+        "Show if a stack trace is displayed when 'eval' raises exception"],
+       ['version', 1, 
+        "Show what version of the debugger this is"],
+       ['width', 1, 
+        "Show the number of characters the debugger thinks are in a line"],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+    
+    self.allow_in_control = true
+
+    def regexp
+      /^show (?: \s+ (.+) )?$/xi
+    end
+
+    def execute
+      if not @match[1]
+        print "\"show\" must be followed by the name of an show command:\n"
+        print "List of show subcommands:\n\n"
+        for subcmd in Subcommands do
+          print "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          print "%s\n" % show_setting(subcmd.name)
+        else
+          print "Unknown show command #{param}\n"
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        "show"
+      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 'show' subcommand '#{args[1]}'."
+          end
+        end
+        s = "
+          Generic command for showing things about the debugger.
+
+          -- 
+          List of show subcommands:
+          --  
+        "
+        for subcmd in Subcommands do
+          s += "show #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Debugger
+  # Implements debugger "source" command.
+  class SourceCommand < Command
+    self.allow_in_control = true
+    
+    def regexp
+      /^\s* so(?:urce)? (\s+ -v)? \s+ (.+) $/x
+    end
+    
+    def execute
+      if 3 == @match.size then
+        verbose=true
+        file=@match[2]
+      else
+        verbose=false
+        file=@match[1]
+      end
+        
+      file = File.expand_path(file).strip
+      unless File.exist?(file)
+        errmsg "Command file '#{file}' is not found\n"
+        return
+      end
+      if @state and @state.interface
+        @state.interface.command_queue += File.open(file).readlines
+      else
+        Debugger.run_script(file, @state, verbose)
+      end
+    end
+    
+    class << self
+      def help_command
+        'source'
+      end
+      
+      def help(cmd)
+        %{
+          source FILE\texecutes a file containing debugger commands
+        }
+      end
+    end
+  end
+  
+end

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

@@ -0,0 +1,81 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module SteppingFunctions # :nodoc:
+    def parse_stepping_args(command_name, match)
+      if match[1].nil? 
+          force = Command.settings[:force_stepping]
+      elsif match[1] == '+' 
+        force = true
+      elsif match[1] == '-' 
+        force = false
+      end
+      steps = get_int(match[2], command_name, 1)
+      return [steps, force]
+    end
+  end
+  # Implements debugger "next" command.
+  class NextCommand < Command
+    self.allow_in_post_mortem  = false
+    self.need_context          = true
+    
+    def regexp
+      /^\s* n(?:ext)? 
+        ([+-])?(?:\s+(\S+))? 
+        \s*$/x
+    end
+
+    def execute
+      steps, force = parse_stepping_args("Next", @match)
+      return unless steps
+      @state.context.step_over steps, @state.frame_pos, force
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'next'
+      end
+
+      def help(cmd)
+        %{
+          n[ext][+-]?[ nnn]\tstep over once or nnn times, 
+          \t\t'+' forces to move to another line.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
+        }
+      end
+    end
+  end
+
+  # Implements debugger "step" command.
+  class StepCommand < Command
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s* s(?:tep)?
+        ([+-])?(?:\s+(\S+))?
+        \s*$/x
+    end
+
+    def execute
+      steps, force = parse_stepping_args("Step", @match)
+      return unless steps
+      @state.context.step(steps, force)
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'step'
+      end
+
+      def help(cmd)
+        %{
+          s[tep][+-]?[ nnn]\tstep (into methods) once or nnn times
+          \t\t'+' forces to move to another line.
+          \t\t'-' is the opposite of '+' and disables the force_stepping setting.
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+module Debugger
+  module ThreadFunctions # :nodoc:
+    def display_context(c, show_top_frame=true)
+      c_flag = c.thread == Thread.current ? '+' : ' '
+      c_flag = '$' if c.suspended?
+      d_flag = c.ignored? ? '!' : ' '
+      print "%s%s", c_flag, d_flag
+      print "%d ", c.thnum
+      print "%s\t", c.thread.inspect
+      if c.stack_size > 0 and show_top_frame
+        print "%s:%d", c.frame_file(0), c.frame_line(0)
+      end
+      print "\n"
+    end
+    
+    def parse_thread_num(subcmd, arg)
+      if '' == arg
+        errmsg "'%s' needs a thread number\n" % subcmd
+        nil
+      else
+        thread_num = get_int(arg, "thread #{subcmd}", 1)
+        return nil unless thread_num
+        get_context(thread_num)
+      end
+    end
+
+    def parse_thread_num_for_cmd(subcmd, arg)
+      c = parse_thread_num(subcmd, arg)
+      return nil unless c
+      case 
+      when nil == c
+        errmsg "No such thread.\n"
+      when @state.context == c
+        errmsg "It's the current thread.\n"
+      when c.ignored?
+        errmsg "Can't #{subcmd} to the debugger thread #{arg}.\n"
+      else # Everything is okay
+        return c
+      end
+      return nil
+    end
+  end
+
+  class ThreadListCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      /^\s*th(?:read)?\s+l(?:ist)?\s*$/
+    end
+
+    def execute
+      threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
+        display_context(c)
+      end
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] l[ist]\t\t\tlist all threads
+        }
+      end
+    end
+  end
+
+  class ThreadStopCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s*th(?:read)?\s+stop\s*(\S*)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread stop", @match[1])
+      return unless c 
+      c.suspend
+      display_context(c)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] stop <nnn>\t\tstop thread nnn
+        }
+      end
+    end
+  end
+
+  class ThreadResumeCommand < Command # :nodoc:
+    self.allow_in_post_mortem = false
+    self.allow_in_control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*th(?:read)?\s+resume\s*(\S*)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread resume", @match[1])
+      return unless c 
+      if !c.thread.stop?
+        print "Already running."
+        return
+      end
+      c.resume
+      display_context(c)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] resume <nnn>\t\tresume thread nnn
+        }
+      end
+    end
+  end
+
+  # Thread switch Must come after "Thread resume" because "switch" is
+  # optional
+
+  class ThreadSwitchCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.need_context         = true
+    
+    def regexp
+      /^\s*th(?:read)?\s*(?:sw(?:itch)?)?\s+(\S+)\s*$/
+    end
+
+    def execute
+      c = parse_thread_num_for_cmd("thread switch", @match[1])
+      return unless c 
+      display_context(c)
+      c.stop_next = 1
+      c.thread.run
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
+        }
+      end
+    end
+  end
+
+  class ThreadCurrentCommand < Command # :nodoc:
+    self.need_context = true
+    
+    def regexp
+      /^\s*th(?:read)?\s*(?:cur(?:rent)?)?\s*$/
+    end
+
+    def execute
+      display_context(@state.context)
+    end
+
+    class << self
+      def help_command
+        'thread'
+      end
+
+      def help(cmd)
+        %{
+          th[read] [cur[rent]]\t\tshow current thread
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Debugger
+  if RUBY_PLATFORM =~ /darwin/
+    class TextMateCommand < Command # :nodoc:
+      def regexp
+        /^\s*tm(?:ate)?(?:\s*(\d+))?$/
+      end
+
+      def execute
+        if @match[1]
+          frm_n = @match[1].to_i
+          if frm_n > @state.context.stack_size || frm_n == 0
+            print "Wrong frame number\n"
+            return
+          end
+          file, line = @state.context.frame_file(frm_n-1), @state.context.frame_line(frm_n-1)
+        else
+          file, line = @state.file, @state.line
+        end
+        %x|open 'txmt://open?url=file://#{File.expand_path(file)}&line=#{line}'|
+      end
+
+      class << self
+        def help_command
+          'tmate'
+        end
+
+        def help(cmd)
+          %{
+            tm[ate] n\topens a current file in TextMate. 
+            \t\tIt uses n-th frame if arg (n) is specifed.
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Debugger
+  class TraceCommand < Command # :nodoc:
+    def regexp
+      /^\s* tr(?:ace)? (?: \s+ (\S+))         # on |off | var(iable)
+                       (?: \s+ (\S+))?        # (all | variable-name)?
+                       (?: \s+ (\S+))? \s*    # (stop | nostop)? 
+       $/ix
+    end
+
+    def execute
+      if @match[1] =~ /on|off/
+        onoff = 'on' == @match[1] 
+        if @match[2]
+          Debugger.current_context.tracing = onoff
+          print "Tracing %s all threads.\n" % (onoff ? 'on' : 'off')
+        else
+          Debugger.tracing = onoff
+          print "Tracing %s on current thread.\n"  % (onoff ? 'on' : 'off')
+        end
+      elsif @match[1] =~ /var(?:iable)?/
+        varname=@match[2]
+        if debug_eval("defined?(#{varname})")
+          if @match[3] && @match[3] !~ /(:?no)?stop/
+            errmsg("expecting 'stop' or 'nostop'; got %s\n" % @match[3])
+          else
+            dbg_cmd = if @match[3] && (@match[3] !~ /nostop/) 
+                        'debugger' else '' end
+          end
+          eval("
+           trace_var(:#{varname}) do |val|
+              print \"traced variable #{varname} has value \#{val}\n\"
+              #{dbg_cmd}
+           end")
+        else
+          errmsg "#{varname} is not a global variable.\n"
+        end
+      else 
+        errmsg("expecting 'on', 'off', 'var' or 'variable'; got: %s\n" %
+               @match[1])
+      end
+    end
+
+    class << self
+      def help_command
+        'trace'
+      end
+
+      def help(cmd)
+        %{
+          tr[ace] (on|off)\tset trace mode of current thread
+          tr[ace] (on|off) all\tset trace mode of all threads
+          tr[ace] var(iable) VARNAME [stop|nostop]\tset trace variable on VARNAME
+        }
+      end
+    end
+  end
+end