vim-jar 0.0.1

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/bin/rdebug

@@ -0,0 +1,416 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+#=== Summary
+#
+#A command-line front-end to the Ruby debugger, <tt>ruby-debug</tt>, the
+#Fast Ruby Debugger.
+#
+#Command invocation:
+#  
+#   rdebug [options] [--] [script-options] ruby-script-to-debug
+#   rdebug [options] [script-options] [--client]
+#   rdebug [--version | --help]
+#
+#=== Options
+#
+#<tt>-A | --annotate</tt> <i>level</i>::
+#    Set gdb-style annotation to <i>level</i>, a number.  Additional
+#    information is output automatically when program state is
+#    changed. This can be used by front-ends such as GNU Emacs to post
+#    this updated information without having to poll for it.
+#
+#<tt>--client</tt>::
+#    Connect to a remote debugger. Used with another rdebug invocation
+#    using <tt>--server</tt>.  See also <tt>--host</tt> and
+#    <tt>--cport</tt> options
+#
+#<tt>--cport=</tt><i>port</i>::
+#    Use port <i>port</i> for access to debugger control.
+#
+#<tt>-d | --debug</tt>::
+#    Set $DEBUG true.
+#
+#<tt>--emacs</tt>::
+#    Activates full GNU Emacs mode. Is the equivalent of setting the
+#    options <tt>--emacs-basic --annotate=3 --no-stop --no-control
+#    --post-mortem</tt>.
+#
+#<tt>--emacs-basic</tt>::
+#     Activates GNU Emacs mode. Debugger prompts are prefaced with two
+#     octal 032 characters.
+#
+#<tt>-h | --host=</tt><i>host</i>::
+#     Use host name <i>host</i> for remote debugging.
+#
+#<tt>-I | --include</tt> <i>path</i>
+#     Add <i>path</i> to <tt>$LOAD_PATH</tt>
+#
+#<tt>-m | --post-mortem</tt>::
+#     Activate post-mortem mode.
+#
+#<tt>--no-control</tt>::
+#      Do not automatically start control thread.
+#
+#<tt>--no-stop</tt>::
+#      Do not stop when script is loaded.
+#
+#<tt>-p | --port=PORT</tt>::
+#      Host name used for remote debugging.
+#
+#<tt>-r | --require</tt><i>script</i>::
+#      Require the library, before executing your script.
+#
+#<tt>--script</tt> <i>file</i>::
+#      Run debugger script file <i>file</i>
+#
+#<tt>-x | --trace</tt>::
+#      Show lines before executing them.
+#
+#<tt>--no-quit</tt>::
+#      Do not quit when script terminates. Instead rerun the
+#      program.
+#
+#<tt>--version</tt>::
+#      Show the version number and exit.
+#
+#<tt>--verbose</tt>::
+#      Turn on verbose mode.
+#
+#<tt>--v</tt>::
+#      Print the version number, then turn on verbose mode if
+#      a script name is given. If no script name is given
+#     just exit after printing the version number.
+#
+#<tt>--nx</tt>::
+#      Don’t execute commands  found in any initialization
+#      files, e.g. <tt>.rdebugrc</tt>.
+#
+#<tt>--keep-frame-binding</tt>::
+#      Keep frame bindings.
+#
+#<tt>--script=</tt><i>file</i>::
+#      Name of the script file to run 
+#
+#<tt>-s | --server</tt>::
+#      Listen for remote connections. Another rdebug session
+#      accesses using the <tt>--client</tt>  option. See also the
+#      <tt>--host</tt>, <tt>--port</tt> and <tt>--cport</tt> options
+#
+#<tt>-w | --wait</tt>::
+#      Wait for a client connection; implies <tt>-s</tt> option.
+#
+#<tt>--help</tt>::
+#      Show invocation help and exit.
+
+require 'rubygems'
+require 'optparse'
+require 'ostruct'
+require 'ruby-debug'
+
+def debug_program(options)
+  # Make sure Ruby script syntax checks okay.
+  # Otherwise we get a load message that looks like rdebug has 
+  # a problem. 
+  output = `ruby -c #{Debugger::PROG_SCRIPT.inspect} 2>&1`
+  if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+    puts output
+    exit $?.exitstatus 
+  end
+  print "\032\032starting\n" if Debugger.annotate and Debugger.annotate > 2
+
+  # Record where we are we can know if the call stack has been
+  # truncated or not.
+  Debugger.start_sentinal=caller(0)[1]
+
+  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, options.stop, false)
+  if bt
+    if options.post_mortem
+      Debugger.handle_post_mortem(bt)
+    else
+      print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+      print "Uncaught exception: #{bt}\n"
+    end
+  end
+end
+
+# Do a shell-like path lookup for prog_script and return the results.
+# If we can't find anything return prog_script.
+def whence_file(prog_script)
+  if prog_script.index(File::SEPARATOR)
+    # Don't search since this name has path separator components
+    return prog_script
+  end
+  for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
+    prog_script_try = File.join(dirname, prog_script)
+    return prog_script_try if File.exist?(prog_script_try)
+  end
+  # Failure
+  return prog_script
+end
+
+options = OpenStruct.new(
+  'annotate'           => Debugger.annotate,
+  'client'             => false,
+  'control'            => true,
+  'cport'              => Debugger::PORT + 1,
+  'frame_bind'         => false,
+  'host'               => nil,
+  'quit'               => true,
+  'no_rewrite_program' => false,
+  'stop'               => true,
+  'nx'                 => false,
+  'port'               => Debugger::PORT,
+  'post_mortem'        => false,
+  'restart_script'     => nil,
+  'script'             => nil,
+  'server'             => false,
+  'tracing'            => false,
+  'verbose_long'       => false,
+  'wait'               => false
+)
+
+def process_options(options)
+  program = File.basename($0)
+  opts = OptionParser.new do |opts|
+    opts.banner = <<EOB
+#{program} #{Debugger::VERSION}
+Usage: #{program} [options] <script.rb> -- <script.rb parameters>
+EOB
+    opts.separator ""
+    opts.separator "Options:"
+    opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do 
+      |annotate|
+        Debugger.annotate = annotate
+    end
+    opts.on("-c", "--client", "Connect to remote debugger") do 
+      options.client = true
+    end
+    opts.on("--cport PORT", Integer, "Port used for control commands") do 
+      |cport|
+      options.cport = cport
+    end
+    opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
+    opts.on("--emacs LEVEL", Integer,
+            "Activates full Emacs support at annotation level LEVEL") do 
+      |level|
+      Debugger.annotate = level.to_i
+      ENV['EMACS'] = '1'
+      ENV['COLUMNS'] = '120' if ENV['COLUMNS'].to_i < 120
+      options.control = false
+      options.quit = false
+      options.post_mortem = true
+    end
+    opts.on('--emacs-basic', 'Activates basic Emacs mode') do 
+      ENV['EMACS'] = '1'
+    end
+    opts.on('-h', '--host HOST', 'Host name used for remote debugging') do
+      |host|
+      options.host = host
+    end
+    opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') do |path|
+      $LOAD_PATH.unshift(path)
+    end
+    opts.on('--keep-frame-binding', 'Keep frame bindings') do 
+      options.frame_bind = true
+    end
+    opts.on('-m', '--post-mortem', 'Activate post-mortem mode') do 
+      options.post_mortem = true
+    end
+    opts.on('--no-control', 'Do not automatically start control thread') do 
+      options.control = false
+    end
+    opts.on('--no-quit', 'Do not quit when script finishes') do
+      options.quit = false
+    end
+    opts.on('--no-rewrite-program',
+            'Do not set $0 to the program being debugged') do 
+      options.no_rewrite_program = true
+    end
+    opts.on('--no-stop', 'Do not stop when script is loaded') do 
+      options.stop = false
+    end
+    opts.on('-nx', 'Not run debugger initialization files (e.g. .rdebugrc') do
+      options.nx = true
+    end
+    opts.on('-p', '--port PORT', Integer, 'Port used for remote debugging') do 
+      |port|
+      options.port = port
+    end
+    opts.on('-r', '--require SCRIPT', String,
+            'Require the library, before executing your script') do |name|
+      if name == 'debug'
+        puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
+      else
+        require name
+      end
+    end
+    opts.on('--restart-script FILE', String, 
+            'Name of the script file to run. Erased after read') do 
+      |restart_script|
+      options.restart_script = restart_script
+      unless File.exists?(options.restart_script)
+        puts "Script file '#{options.restart_script}' is not found"
+        exit
+      end
+    end
+    opts.on('--script FILE', String, 'Name of the script file to run') do 
+      |script|
+      options.script = script
+      unless File.exists?(options.script)
+        puts "Script file '#{options.script}' is not found"
+        exit
+      end
+    end
+    opts.on('-s', '--server', 'Listen for remote connections') do 
+      options.server = true
+    end
+    opts.on('-w', '--wait', 'Wait for a client connection, implies -s option') do
+      options.wait = true
+    end
+    opts.on('-x', '--trace', 'Turn on line tracing') {options.tracing = true}
+    opts.separator ''
+    opts.separator 'Common options:'
+    opts.on_tail('--help', 'Show this message') do
+      puts opts
+      exit
+    end
+    opts.on_tail('--version', 
+                 'Print the version') do
+      puts "ruby-debug #{Debugger::VERSION}"
+      exit
+    end
+    opts.on('--verbose', 'Turn on verbose mode') do
+      $VERBOSE = true
+      options.verbose_long = true
+    end
+    opts.on_tail('-v', 
+                 'Print version number, then turn on verbose mode') do
+      puts "ruby-debug #{Debugger::VERSION}"
+      $VERBOSE = true
+    end
+  end
+  return opts
+end
+
+# What file is used for debugger startup commands.
+unless defined?(OPTS_INITFILE)
+  if RUBY_PLATFORM =~ /mswin/
+    # Of course MS Windows has to be different
+    OPTS_INITFILE = 'rdbopt.ini'
+    HOME_DIR =  (ENV['HOME'] || 
+                 ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+  else
+    OPTS_INITFILE = '.rdboptrc'
+    HOME_DIR = ENV['HOME'].to_s
+  end
+end
+begin
+  initfile = File.join(HOME_DIR, OPTS_INITFILE)
+  eval(File.read(initfile)) if 
+    File.exist?(initfile)
+rescue
+end
+
+opts = process_options(options)
+begin
+  if not defined? Debugger::ARGV
+    Debugger::ARGV = ARGV.clone
+  end
+  rdebug_path = File.expand_path($0)
+  if RUBY_PLATFORM =~ /mswin/
+    rdebug_path += '.cmd' unless rdebug_path =~ /\.cmd$/i
+  end
+  Debugger::RDEBUG_SCRIPT = rdebug_path
+  Debugger::RDEBUG_FILE = __FILE__
+  Debugger::INITIAL_DIR = Dir.pwd
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+end
+
+if options.client
+  Debugger.start_client(options.host, options.port)
+else
+  if ARGV.empty?
+    exit if $VERBOSE and not options.verbose_long
+    puts opts
+    puts
+    puts 'Must specify a script to run'
+    exit(-1)
+  end
+  
+  # save script name
+  prog_script = ARGV.shift
+  prog_script = whence_file(prog_script) unless File.exist?(prog_script)
+  Debugger::PROG_SCRIPT = File.expand_path prog_script
+  
+  # install interruption handler
+  trap('INT') { Debugger.interrupt_last }
+  
+  # set options
+  Debugger.wait_connection = options.wait
+  Debugger.keep_frame_binding = options.frame_bind
+  
+  if options.server
+    # start remote mode
+    Debugger.start_remote(options.host, [options.port, options.cport], 
+                          options.post_mortem) do
+      # load initrc script
+      Debugger.run_init_script(StringIO.new) unless options.nx
+    end
+    debug_program(options)
+  else
+    # Set up trace hook for debugger
+    Debugger.start
+    # start control thread
+    Debugger.start_control(options.host, options.cport) if options.control
+
+    # load initrc script (e.g. .rdebugrc)
+    Debugger.run_init_script(StringIO.new) unless options.nx
+    
+    # run restore-settings startup script if specified
+    if options.restart_script
+      require 'fileutils'
+      Debugger.run_script(options.restart_script)
+      FileUtils.rm(options.restart_script)
+    end
+
+    # run startup script if specified
+    if options.script
+      Debugger.run_script(options.script)
+    end
+
+    # activate post-mortem
+    Debugger.post_mortem if options.post_mortem
+    options.stop = false if options.tracing
+    Debugger.tracing = options.tracing
+
+    if !options.quit
+      if Debugger.started?
+        until Debugger.stop do end
+      end
+      begin
+        debug_program(options)
+      rescue SyntaxError
+        puts $!.backtrace.map{|l| "\t#{l}"}.join("\n")
+        puts "Uncaught Syntax Error\n"
+      rescue
+        print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+        print "Uncaught exception: #{$!}\n"
+      end
+      print "The program finished.\n" unless 
+        Debugger.annotate.to_i > 1 # annotate has its own way
+      interface = Debugger::LocalInterface.new
+      # Not sure if ControlCommandProcessor is really the right
+      # thing to use. CommandProcessor requires a state.
+      processor = Debugger::ControlCommandProcessor.new(interface)
+      processor.process_commands
+    else
+      debug_program(options)
+    end
+  end
+end

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

@@ -0,0 +1,267 @@
+require 'rubygems'
+require 'columnize'
+require 'ruby-debug/helper'
+
+module Debugger
+  RUBY_DEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
+    defined?(RUBY_DEBUG_DIR)
+
+  # A Debugger::Command object is is the base class for commands that
+  # implement a single debugger command. Individual debugger commands
+  # will be a subclass of this. The singleton class object is the
+  # command manager for all commands.
+  # 
+  # Each debugger command is expected to implement the following methods:
+  # _regexp_::   A regular expression which input strings are matched
+  #              against. If we have a match, run this command. 
+  #              It is the ruby-debug programmer's responsibility
+  #              to make sure that these regular expressions match disjoint
+  #              sets of strings. Otherwise one is arbitrarily used.
+  # _execute_::  Ruby code that implements the command.
+  # _help_::     Should return a String containing descriptive help for
+  #              the commmand. Used by the 'help' command Debugger::HelpCommand
+  # _help_command_:: The name of the command listed via help.
+  # 
+  # _help_ and _help_command_ methods are singleton methods, not 
+  # instance methods like _regexp_ and _execute_.
+  class Command
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    include Columnize
+
+    # Find _param_ in _subcmds_. The _param_ id downcased and can be
+    # abbreviated to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
+    class << self
+      # An Array containing Debugger::Command classes that implment each
+      # of the debugger commands.
+      def commands
+        @commands ||= []
+      end
+      
+      DEF_OPTIONS = {
+        :allow_in_control     => false, 
+        :allow_in_post_mortem => true,
+        :event => true, 
+        :always_run => 0,
+        :unknown => false,
+        :need_context => false,
+      } unless defined?(DEF_OPTIONS)
+      
+      def inherited(klass)
+        DEF_OPTIONS.each do |o, v|
+          klass.options[o] = v if klass.options[o].nil?
+        end
+        commands << klass
+      end 
+
+      # Read in and "include" all the subclasses of the
+      # Debugger::Command class. For example
+      # Debugger::QuitCommand is one of them. The list of Ruby
+      # files to read are all the files that end .rb in directory
+      # Debugger::RUBY_DEBUG_DIR
+      def load_commands
+        Dir[File.join(Debugger.const_get(:RUBY_DEBUG_DIR), 'commands', '*')].each do |file|
+          require file if file =~ /\.rb$/
+        end
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        end
+      end
+      
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^(.+?)=$/
+          @options[$1.intern] = args.first
+        else
+          if @options.has_key?(meth)
+            @options[meth]
+          else
+            super
+          end
+        end
+      end
+      
+      def options
+        @options ||= {}
+      end
+
+      def settings_map
+        @@settings_map ||= {}
+      end
+      private :settings_map
+
+      # Returns a Hash of Debugger settings, @settings. If doesn't exist
+      # we create a @settings hash with [] setter and getter and return that.
+      def settings
+        unless true and defined? @settings and @settings
+          @settings = Object.new
+          map = settings_map
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          else
+            c.send(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          end
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          else
+            c.send(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          end
+        end
+        @settings
+      end
+
+      def register_setting_var(name, default)
+        var_name = "@@#{name}"
+        class_variable_set(var_name, default)
+        register_setting_get(name) { class_variable_get(var_name) }
+        register_setting_set(name) { |value| class_variable_set(var_name, value) }
+      end
+
+      def register_setting_get(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:getter] = block
+      end
+
+      def register_setting_set(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:setter] = block
+      end
+    end
+
+    register_setting_var(:basename, false)  # use basename in showing files? 
+    register_setting_var(:callstyle, :last)
+    register_setting_var(:debuggertesting, false)
+    register_setting_var(:force_stepping, false)
+    register_setting_var(:full_path, true)
+    register_setting_var(:listsize, 10)    # number of lines in list command
+    register_setting_var(:stack_trace_on_error, false)
+    register_setting_var(:tracing_plus, false) # different linetrace lines?
+    
+    # width of line output. Use COLUMNS value if it exists and is 
+    # not too rediculously large.
+    width = ENV['COLUMNS'].to_i 
+    width = 80 unless width > 10
+    register_setting_var(:width, width)  
+
+    if not defined? Debugger::ARGV
+      Debugger::ARGV = ARGV.clone
+    end
+    register_setting_var(:argv, Debugger::ARGV)
+    
+    def initialize(state)
+      @state = state
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    # FIXME: use delegate? 
+    def errmsg(*args)
+      @state.errmsg(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    # Called when we are about to do a dangerous operation. _msg_
+    # contains a prompt message. Return _true_ if confirmed or _false_
+    # if not confirmed.
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    # debug_eval like Kernel.eval or Object.instance_eval but using
+    # the bindings for the debugged program. If there is a
+    # syntax-error like exception in running eval, print an
+    # appropriate message and throw :debug_error
+    def debug_eval(str, b = get_binding)
+      begin
+        val = eval(str, b)
+      rescue StandardError, ScriptError => e
+        if Command.settings[:stack_trace_on_error]
+          at = eval("caller(1)", b)
+          print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
+          for i in at
+            print "\tfrom %s\n", i
+          end
+        else
+          print "#{e.class} Exception: #{e.message}\n"
+        end
+        throw :debug_error
+      end
+    end
+
+    # debug_eval like Kernel.eval or Object.instance_eval but using
+    # the bindings for the debugged program. If there is a syntax
+    # error kind of exception in running eval, no warning is given and
+    # nil is returned.
+    def debug_silent_eval(str)
+      begin
+        eval(str, get_binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+
+    # Return a binding object for the debugged program.
+    def get_binding
+      @state.context.frame_binding(@state.frame_pos)
+    end
+
+    def line_at(file, line)
+      Debugger.line_at(file, line)
+    end
+
+    def get_context(thnum)
+      Debugger.contexts.find{|c| c.thnum == thnum}
+    end  
+  end
+  
+  Command.load_commands
+
+  # Returns setting object.
+  # Use Debugger.settings[] and Debugger.settings[]= methods to query and set
+  # debugger settings. These settings are available:
+  # 
+  # - :autolist - automatically calls 'list' command on breakpoint
+  # - :autoeval - evaluates input in the current binding if it's not recognized as a debugger command
+  # - :autoirb - automatically calls 'irb' command on breakpoint
+  # - :stack_trace_on_error - shows full stack trace if eval command results with an exception
+  # - :frame_full_path - displays full paths when showing frame stack
+  # - :frame_class_names - displays method's class name when showing frame stack
+  # - :reload_source_on_change - makes 'list' command to always display up-to-date source code
+  # - :force_stepping - stepping command asways move to the new line
+  # 
+  def self.settings
+    Command.settings
+  end
+end