pry 0.10.pre.1-java → 0.10.0.pre2-java

data/examples/example_output.rb

@@ -1,11 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-# Create a StringIO to contain the output data
-str_output = StringIO.new
-
-# Start a Pry session on the Fixnum 5 using str_output to store the
-# output (not writing to $stdout)
-Pry.start(5, :output => str_output)
-
-# Display all the output accumulated during the session
-puts str_output.string

data/examples/example_print.rb

@@ -1,6 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-my_print = proc { |out, value| out.puts "Output is: #{value.inspect}" }
-
-# Start a Pry session using the print object defined in my_print
-Pry.start(TOPLEVEL_BINDING, :print => my_print)

data/examples/example_prompt.rb

@@ -1,9 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-
-# Remember, first prompt in array is the main prompt, second is the wait
-# prompt (used for multiline input when more input is required)
-my_prompt = [ proc { |obj, *| "inside #{obj}> " },
-           proc { |obj, *| "inside #{obj}* "} ]
-
-# Start a Pry session using the prompt defined in my_prompt
-Pry.start(TOPLEVEL_BINDING, :prompt => my_prompt)

data/examples/helper.rb

@@ -1,6 +0,0 @@
-require 'rubygems'
-unless Object.const_defined? 'Pry'
-  $:.unshift File.expand_path '../../lib', __FILE__
-  require 'pry'
-end
-

data/lib/pry/completion.rb

@@ -1,221 +0,0 @@
-# taken from irb
-
-require "readline"
-
-class Pry
-
-  # Implements tab completion for Readline in Pry
-  module InputCompleter
-
-    if Readline.respond_to?("basic_word_break_characters=")
-      Readline.basic_word_break_characters = " \t\n\"\\'`><=;|&{("
-    end
-
-    Readline.completion_append_character = nil
-
-    ReservedWords = [
-      "BEGIN", "END",
-      "alias", "and",
-      "begin", "break",
-      "case", "class",
-      "def", "defined", "do",
-      "else", "elsif", "end", "ensure",
-      "false", "for",
-      "if", "in",
-      "module",
-      "next", "nil", "not",
-      "or",
-      "redo", "rescue", "retry", "return",
-      "self", "super",
-      "then", "true",
-      "undef", "unless", "until",
-      "when", "while",
-      "yield" ]
-
-    Operators = [
-      "%", "&", "*", "**", "+",  "-",  "/",
-      "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
-      "[]", "[]=", "^", "!", "!=", "!~"
-    ]
-
-    # Return a new completion proc for use by Readline.
-    # @param [Binding] target The current binding context.
-    # @param [Array<String>] commands The array of Pry commands.
-    def self.build_completion_proc(target, commands=[""])
-      proc do |input|
-        begin
-          bind = target
-
-          case input
-          when /^(\/[^\/]*\/)\.([^.]*)$/
-            # Regexp
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Regexp.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
-
-          when /^([^\]]*\])\.([^.]*)$/
-            # Array
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Array.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
-
-          when /^([^\}]*\})\.([^.]*)$/
-            # Proc or Hash
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Proc.instance_methods.collect{|m| m.to_s}
-            candidates |= Hash.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
-
-          when /^(:[^:.]*)$/
-            # Symbol
-            if Symbol.respond_to?(:all_symbols)
-              sym        = Regexp.quote($1)
-              candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
-
-              candidates.grep(/^#{sym}/)
-            else
-              []
-            end
-
-          when /^::([A-Z][^:\.\(]*)$/
-            # Absolute Constant or class methods
-            receiver = $1
-            candidates = Object.constants.collect{|m| m.to_s}
-            candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
-
-          when /^([A-Z].*)::([^:.]*)$/
-            # Constant or class methods
-            receiver = $1
-            message = Regexp.quote($2)
-            begin
-              candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
-              candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
-            rescue RescuableException
-              candidates = []
-            end
-            candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-
-          when /^(:[^:.]+)\.([^.]*)$/
-            # Symbol
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Symbol.instance_methods.collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
-
-          when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-            # Numeric
-            receiver = $1
-            message = Regexp.quote($5)
-
-            begin
-              candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-            rescue RescuableException
-              candidates = []
-            end
-            select_message(receiver, message, candidates)
-
-          when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
-            # Numeric(0xFFFF)
-            receiver = $1
-            message = Regexp.quote($2)
-
-            begin
-              candidates = eval(receiver, bind).methods.collect{|m| m.to_s}
-            rescue RescuableException
-              candidates = []
-            end
-            select_message(receiver, message, candidates)
-
-          when /^(\$[^.]*)$/
-            regmessage = Regexp.new(Regexp.quote($1))
-            candidates = global_variables.collect{|m| m.to_s}.grep(regmessage)
-
-          when /^([^."].*)\.([^.]*)$/
-            # variable
-            receiver = $1
-            message = Regexp.quote($2)
-
-            gv = eval("global_variables", bind).collect{|m| m.to_s}
-            lv = eval("local_variables", bind).collect{|m| m.to_s}
-            cv = eval("self.class.constants", bind).collect{|m| m.to_s}
-
-            if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
-              # foo.func and foo is local var. OR
-              # Foo::Bar.func
-              begin
-                candidates = eval("#{receiver}.methods", bind).collect{|m| m.to_s}
-              rescue RescuableException
-                candidates = []
-              end
-            else
-              # func1.func2
-              candidates = []
-              ObjectSpace.each_object(Module){|m|
-                begin
-                  name = m.name.to_s
-                rescue RescuableException
-                  name = ""
-                end
-                next if name != "IRB::Context" and
-                /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
-
-                # jruby doesn't always provide #instance_methods() on each
-                # object.
-                if m.respond_to?(:instance_methods)
-                  candidates.concat m.instance_methods(false).collect{|x| x.to_s}
-                end
-              }
-              candidates.sort!
-              candidates.uniq!
-            end
-            select_message(receiver, message, candidates)
-
-          when /^\.([^.]*)$/
-            # unknown(maybe String)
-
-            receiver = ""
-            message = Regexp.quote($1)
-
-            candidates = String.instance_methods(true).collect{|m| m.to_s}
-            select_message(receiver, message, candidates)
-
-          else
-            candidates = eval(
-              "methods | private_methods | local_variables | " \
-                "self.class.constants | instance_variables",
-              bind
-            ).collect{|m| m.to_s}
-
-            if eval("respond_to?(:class_variables)", bind)
-              candidates += eval("class_variables", bind).collect { |m| m.to_s }
-            end
-
-            (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
-          end
-        rescue RescuableException
-          []
-        end
-      end
-    end
-
-    def self.select_message(receiver, message, candidates)
-      candidates.grep(/^#{message}/).collect do |e|
-      	case e
-      	when /^[a-zA-Z_]/
-      	  receiver + "." + e
-      	when /^[0-9]/
-      	when *Operators
-      	  #receiver + " " + e
-      	end
-      end
-    end
-  end
-end
-

data/lib/pry/custom_completions.rb

@@ -1,6 +0,0 @@
-class Pry
-
-  # This proc will be instance_eval's against the active Pry instance
-  DEFAULT_CUSTOM_COMPLETIONS = proc { commands.commands.keys }
-  FILE_COMPLETIONS = proc { commands.commands.keys + Dir.entries('.') }
-end

data/lib/pry/default_commands/cd.rb

@@ -1,81 +0,0 @@
-class Pry
-  module DefaultCommands
-    Cd = Pry::CommandSet.new do
-      create_command "cd" do
-        group "Context"
-        description "Move into a new context (object or scope)."
-
-        banner <<-BANNER
-          Usage: cd [OPTIONS] [--help]
-
-          Move into new context (object or scope). As in unix shells use
-          `cd ..` to go back, `cd /` to return to Pry top-level and `cd -`
-          to toggle between last two scopes).
-          Complex syntax (e.g `cd ../@x/y`) also supported.
-
-          e.g: `cd @x`
-          e.g: `cd ..`
-          e.g: `cd /`
-          e.g: `cd -`
-
-          https://github.com/pry/pry/wiki/State-navigation#wiki-Changing_scope
-        BANNER
-
-        def process
-          # Extract command arguments. Delete blank arguments like " ", but
-          # don't delete empty strings like "".
-          path      = arg_string.split(/\//).delete_if { |a| a =~ /\A\s+\z/ }
-          stack     = _pry_.binding_stack.dup
-          old_stack = state.old_stack || []
-
-          # Special case when we only get a single "/", return to root.
-          if path.empty?
-            state.old_stack = stack.dup unless old_stack.empty?
-            stack = [stack.first]
-          end
-
-          path.each_with_index do |context, i|
-            begin
-              case context.chomp
-              when ""
-                state.old_stack = stack.dup
-                stack = [stack.first]
-              when "::"
-                state.old_stack = stack.dup
-                stack.push(TOPLEVEL_BINDING)
-              when "."
-                next
-              when ".."
-                unless stack.size == 1
-                  # Don't rewrite old_stack if we're in complex expression
-                  # (e.g.: `cd 1/2/3/../4).
-                  state.old_stack = stack.dup if path.first == ".."
-                  stack.pop
-                end
-              when "-"
-                unless old_stack.empty?
-                  # Interchange current stack and old stack with each other.
-                  stack, state.old_stack = state.old_stack, stack
-                end
-              else
-                state.old_stack = stack.dup if i == 0
-                stack.push(Pry.binding_for(stack.last.eval(context)))
-              end
-
-            rescue RescuableException => e
-              # Restore old stack to its initial values.
-              state.old_stack = old_stack
-
-              output.puts "Bad object path: #{arg_string.chomp}. Failed trying to resolve: #{context}"
-              output.puts e.inspect
-              return
-            end
-          end
-
-          _pry_.binding_stack = stack
-        end
-
-      end
-    end
-  end
-end

data/lib/pry/default_commands/commands.rb

@@ -1,62 +0,0 @@
-class Pry
-  module DefaultCommands
-    Commands = Pry::CommandSet.new do
-      create_command "import-set", "Import a command set" do
-        group "Commands"
-        def process(command_set_name)
-          raise CommandError, "Provide a command set name" if command_set.nil?
-
-          set = target.eval(arg_string)
-          _pry_.commands.import set
-        end
-      end
-
-      create_command "install-command", "Install a disabled command." do |name|
-        group 'Commands'
-
-        banner <<-BANNER
-          Usage: install-command COMMAND
-
-          Installs the gems necessary to run the given COMMAND. You will generally not
-          need to run this unless told to by an error message.
-        BANNER
-
-        def process(name)
-          require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
-          command = find_command(name)
-
-          if command_dependencies_met?(command.options)
-            output.puts "Dependencies for #{command.name} are met. Nothing to do."
-            return
-          end
-
-          output.puts "Attempting to install `#{name}` command..."
-          gems_to_install = Array(command.options[:requires_gem])
-
-          gems_to_install.each do |g|
-            next if gem_installed?(g)
-            output.puts "Installing `#{g}` gem..."
-
-            begin
-              Gem::DependencyInstaller.new.install(g)
-            rescue Gem::GemNotFoundException
-              raise CommandError, "Required Gem: `#{g}` not found. Aborting command installation."
-            end
-          end
-
-          Gem.refresh
-          gems_to_install.each do |g|
-            begin
-              require g
-            rescue LoadError
-              raise CommandError, "Required Gem: `#{g}` installed but not found?!. Aborting command installation."
-            end
-          end
-
-          output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
-        end
-      end
-    end
-  end
-end
-

data/lib/pry/default_commands/context.rb

@@ -1,98 +0,0 @@
-require "pry/default_commands/ls"
-require "pry/default_commands/cd"
-require "pry/default_commands/find_method"
-require "pry/default_commands/whereami"
-
-class Pry
-  module DefaultCommands
-
-    Context = Pry::CommandSet.new do
-      import Ls
-      import Cd
-      import FindMethod
-      import Whereami
-
-      create_command "pry-backtrace", "Show the backtrace for the Pry session." do
-        banner <<-BANNER
-          Usage:   pry-backtrace [OPTIONS] [--help]
-
-          Show the backtrace for the position in the code where Pry was started. This can be used to
-          infer the behavior of the program immediately before it entered Pry, just like the backtrace
-          property of an exception.
-
-          (NOTE: if you are looking for the backtrace of the most recent exception raised,
-          just type: `_ex_.backtrace` instead, see https://github.com/pry/pry/wiki/Special-Locals)
-
-          e.g: pry-backtrace
-        BANNER
-
-        def process
-          output.puts "\n#{text.bold('Backtrace:')}\n--\n"
-          stagger_output _pry_.backtrace.join("\n")
-        end
-      end
-
-      command "reset", "Reset the REPL to a clean state." do
-        output.puts "Pry reset."
-        exec "pry"
-      end
-
-      create_command(/wtf([?!]*)/, "Show the backtrace of the most recent exception") do
-        options :listing => 'wtf?'
-
-        banner <<-BANNER
-          Show's a few lines of the backtrace of the most recent exception (also available
-          as _ex_.backtrace).
-
-          If you want to see more lines, add more question marks or exclamation marks:
-
-          e.g.
-          pry(main)> wtf?
-          pry(main)> wtf?!???!?!?
-
-          To see the entire backtrace, pass the -v/--verbose flag:
-
-          e.g.
-          pry(main)> wtf -v
-        BANNER
-
-        def options(opt)
-          opt.on(:v, :verbose, "Show the full backtrace.")
-        end
-
-        def process
-          raise Pry::CommandError, "No most-recent exception" unless _pry_.last_exception
-
-          output.puts "#{text.bold('Exception:')} #{_pry_.last_exception.class}: #{_pry_.last_exception}\n--"
-          if opts.verbose?
-            output.puts Code.new(_pry_.last_exception.backtrace, 0, :text).with_line_numbers.to_s
-          else
-            output.puts Code.new(_pry_.last_exception.backtrace.first([captures[0].size, 0.5].max * 10), 0, :text).with_line_numbers.to_s
-          end
-        end
-      end
-
-      # N.B. using a regular expresion here so that "raise-up 'foo'" does the right thing.
-      create_command(/raise-up(!?\b.*)/, :listing => 'raise-up') do
-        description "Raise an exception out of the current pry instance."
-        banner <<-BANNER
-          Raise up, like exit, allows you to quit pry. Instead of returning a value however, it raises an exception.
-          If you don't provide the exception to be raised, it will use the most recent exception (in pry _ex_).
-
-          e.g. `raise-up "get-me-out-of-here"` is equivalent to:
-               `raise "get-me-out-of-here"
-                raise-up`
-
-          When called as raise-up! (with an exclamation mark), this command raises the exception through
-          any nested prys you have created by "cd"ing into objects.
-        BANNER
-
-        def process
-          return stagger_output help if captures[0] =~ /(-h|--help)\b/
-          # Handle 'raise-up', 'raise-up "foo"', 'raise-up RuntimeError, 'farble' in a rubyesque manner
-          target.eval("_pry_.raise_up#{captures[0]}")
-        end
-      end
-    end
-  end
-end