pry 0.9.8.2-i386-mingw32 → 0.9.8.3-i386-mingw32

data/lib/pry/default_commands/commands.rb

@@ -0,0 +1,62 @@
+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,167 +1,30 @@
 require "pry/default_commands/ls"
+require "pry/default_commands/cd"
 
 class Pry
   module DefaultCommands
 
     Context = Pry::CommandSet.new do
       import Ls
+      import Cd
 
-      create_command "cd" do
-        description "Move into a new context (object or scope). Type `cd --help` for more information."
-
-        banner <<-BANNER
-          Usage: cd [OPTIONS] [--help]
-
-          Move into new context (object or scope). As in unix shells use
-          `cd ..` to go back and `cd /` to return to Pry top-level).
-          Complex syntax (e.g cd ../@x/y) also supported.
-
-          e.g: `cd @x`
-          e.g: `cd ..
-          e.g: `cd /`
-
-          https://github.com/pry/pry/wiki/State-navigation#wiki-Changing_scope
-        BANNER
-
-        def process
-          path   = arg_string.split(/\//)
-          stack  = _pry_.binding_stack.dup
-
-          # special case when we only get a single "/", return to root
-          stack  = [stack.first] if path.empty?
-
-          path.each do |context|
-            begin
-              case context.chomp
-              when ""
-                stack = [stack.first]
-              when "::"
-                stack.push(TOPLEVEL_BINDING)
-              when "."
-                next
-              when ".."
-                unless stack.size == 1
-                  stack.pop
-                end
-              else
-                stack.push(Pry.binding_for(stack.last.eval(context)))
-              end
-
-            rescue RescuableException => e
-              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
-
-      command "switch-to", "Start a new sub-session on a binding in the current stack (numbered by nesting)." do |selection|
-        selection = selection.to_i
-
-        if selection < 0 || selection > _pry_.binding_stack.size - 1
-          raise CommandError, "Invalid binding index #{selection} - use `nesting` command to view valid indices."
-        else
-          Pry.start(_pry_.binding_stack[selection])
-        end
-      end
-
-      command "nesting", "Show nesting information." do
-        output.puts "Nesting status:"
-        output.puts "--"
-        _pry_.binding_stack.each_with_index do |obj, level|
-          if level == 0
-            output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))} (Pry top level)"
-          else
-            output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))}"
-          end
-        end
-      end
-
-      command "jump-to", "Jump to a binding further up the stack, popping all bindings below." do |break_level|
-        break_level = break_level.to_i
-        nesting_level = _pry_.binding_stack.size - 1
-
-        case break_level
-        when nesting_level
-          output.puts "Already at nesting level #{nesting_level}"
-        when (0...nesting_level)
-          _pry_.binding_stack.slice!(break_level + 1, _pry_.binding_stack.size)
-
-        else
-          max_nest_level = nesting_level - 1
-          output.puts "Invalid nest level. Must be between 0 and #{max_nest_level}. Got #{break_level}."
-        end
-      end
-
-      command "exit-all", "End the current Pry session (popping all bindings) and returning to caller. Accepts optional return value. Aliases: !!@" do
-        # clear the binding stack
-        _pry_.binding_stack.clear
-
-        # break out of the repl loop
-        throw(:breakout, target.eval(arg_string))
-      end
-
-      alias_command "!!@", "exit-all"
-
-      create_command "exit" do
-        description "Pop the previous binding (does NOT exit program). Type `exit --help` for more information. Aliases: quit"
-
-        banner <<-BANNER
-          Usage:   exit [OPTIONS] [--help]
-          Aliases: quit
-
-          It can be useful to exit a context with a user-provided value. For
-          instance an exit value can be used to determine program flow.
-
-          e.g: `exit "pry this"`
-          e.g: `exit`
-
-          https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
-        BANNER
-
-        command_options(
-                        :keep_retval => true
-                        )
-
-        def process
-          if _pry_.binding_stack.one?
-            # when breaking out of top-level then behave like `exit-all`
-            process_exit_all
-          else
-            # otherwise just pop a binding and return user supplied value
-            process_pop_and_return
-          end
-        end
-
-        def process_exit_all
-          _pry_.binding_stack.clear
-          throw(:breakout, target.eval(arg_string))
-        end
-
-        def process_pop_and_return
-          popped_object = _pry_.binding_stack.pop.eval('self')
+      command "whereami", "Show the code context for the session. (whereami <n> shows <n> extra lines of code around the invocation line. Default: 5)" do |num|
+        file, line_num = file_and_line_from_binding(target)
+        i_num = num ? num.to_i : 5
 
-          # return a user-specified value if given otherwise return the object
-          return target.eval(arg_string) unless arg_string.empty?
-          popped_object
+        if file != Pry.eval_path && (file =~ /(\(.*\))|<.*>/ || file == "" || file == "-e")
+          raise CommandError, "Cannot find local context. Did you use binding.pry?"
         end
-      end
-
-      alias_command "quit", "exit"
 
-      command "exit-program", "End the current program. Aliases: quit-program, !!!" do
-        Pry.save_history if Pry.config.history.should_save
-        Kernel.exit target.eval(arg_string).to_i
-      end
+        set_file_and_dir_locals(file)
 
-      alias_command "quit-program", "exit-program"
-      alias_command "!!!", "exit-program"
+        method = Pry::Method.from_binding(target)
+        method_description = method ? " in #{method.name_with_owner}" : ""
+        output.puts "\n#{text.bold('From:')} #{file} @ line #{line_num}#{method_description}:\n\n"
 
-      command "!pry", "Start a Pry session on current self; this even works mid multi-line expression." do
-        target.pry
+        code = Pry::Code.from_file(file).around(line_num, i_num)
+        output.puts code.with_line_numbers.with_marker(line_num)
+        output.puts
       end
 
       create_command "pry-backtrace", "Show the backtrace for the Pry session." do
@@ -184,24 +47,44 @@ class Pry
         end
       end
 
-      command "whereami", "Show the code context for the session. (whereami <n> shows <n> extra lines of code around the invocation line. Default: 5)" do |num|
-        file = target.eval('__FILE__')
-        line_num = target.eval('__LINE__')
-        i_num = num ? num.to_i : 5
+      command "reset", "Reset the REPL to a clean state." do
+        output.puts "Pry reset."
+        exec "pry"
+      end
 
-        if file != Pry.eval_path && (file =~ /(\(.*\))|<.*>/ || file == "" || file == "-e")
-          raise CommandError, "Cannot find local context. Did you use `binding.pry`?"
-        end
+      create_command /wtf([?!]*)/, "Show the backtrace of the most recent exception" do
+        options :listing => 'wtf?'
 
-        set_file_and_dir_locals(file)
+        banner <<-BANNER
+          Show's a few lines of the backtrace of the most recent exception (also available
+          as _ex_.backtrace).
 
-        method = Pry::Method.from_binding(target)
-        method_description = method ? " in #{method.name_with_owner}" : ""
-        output.puts "\n#{text.bold('From:')} #{file} @ line #{line_num}#{method_description}:\n\n"
+          If you want to see more lines, add more question marks or exclamation marks:
 
-        code = Pry::Code.from_file(file).around(line_num, i_num)
-        output.puts code.with_line_numbers.with_marker(line_num)
-        output.puts
+          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
 
     end

data/lib/pry/default_commands/editing.rb

@@ -0,0 +1,385 @@
+require 'tempfile'
+require 'pry/default_commands/hist'
+
+class Pry
+  module DefaultCommands
+
+    Editing = Pry::CommandSet.new do
+      import Hist
+
+      create_command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop.", :use_prefix => false do
+        def process
+          output.puts "Input buffer cleared!"
+          eval_string.replace("")
+        end
+      end
+
+      create_command "show-input", "Show the contents of the input buffer for the current multi-line expression." do
+        def process
+          output.puts Code.new(eval_string).with_line_numbers
+        end
+      end
+
+      create_command "edit" do
+        description "Invoke the default editor on a file."
+
+        banner <<-BANNER
+          Usage: edit [--no-reload|--reload] [--line LINE] [--temp|--ex|FILE[:LINE]|--in N]
+
+          Open a text editor. When no FILE is given, edits the pry input buffer.
+          Ensure Pry.config.editor is set to your editor of choice.
+
+          e.g: `edit sample.rb`
+          e.g: `edit sample.rb --line 105`
+          e.g: `edit --ex`
+
+          https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_command
+        BANNER
+
+        def options(opt)
+          opt.on :e, :ex, "Open the file that raised the most recent exception (_ex_.file)", :optional => true, :as => Integer
+          opt.on :i, :in, "Open a temporary file containing the Nth line of _in_. N may be a range.", :optional => true, :as => Range, :default => -1..-1
+          opt.on :t, :temp, "Open an empty temporary file"
+          opt.on :l, :line, "Jump to this line in the opened file", true, :as => Integer
+          opt.on :n, :"no-reload", "Don't automatically reload the edited code"
+          opt.on :c, :"current", "Open the current __FILE__ and at __LINE__ (as returned by `whereami`)."
+          opt.on :r, :reload, "Reload the edited code immediately (default for ruby files)"
+        end
+
+        def process
+          if [opts.present?(:ex), opts.present?(:temp), opts.present?(:in), !args.empty?].count(true) > 1
+            raise CommandError, "Only one of --ex, --temp, --in and FILE may be specified."
+          end
+
+          if !opts.present?(:ex) && !opts.present?(:current) && args.empty?
+            # edit of local code, eval'd within pry.
+            process_local_edit
+          else
+            # edit of remote code, eval'd at top-level
+            process_remote_edit
+          end
+        end
+
+        def process_i
+          case opts[:i]
+          when Range
+            (_pry_.input_array[opts[:i]] || []).join
+          when Fixnum
+            _pry_.input_array[opts[:i]] || ""
+          else
+            return output.puts "Not a valid range: #{opts[:i]}"
+          end
+        end
+
+        def process_local_edit
+          content = case
+            when opts.present?(:temp)
+              ""
+            when opts.present?(:in)
+              process_i
+            when eval_string.strip != ""
+              eval_string
+            else
+              _pry_.input_array.reverse_each.find{ |x| x && x.strip != "" } || ""
+          end
+
+          line = content.lines.count
+
+          temp_file do |f|
+            f.puts(content)
+            f.flush
+            invoke_editor(f.path, line)
+            if !opts.present?(:'no-reload') && !Pry.config.disable_auto_reload
+              silence_warnings do
+                eval_string.replace(File.read(f.path))
+              end
+            end
+          end
+        end
+
+        def process_remote_edit
+          if opts.present?(:ex)
+            if _pry_.last_exception.nil?
+              raise CommandError, "No exception found."
+            end
+
+            ex = _pry_.last_exception
+            bt_index = opts[:ex].to_i
+
+            ex_file, ex_line = ex.bt_source_location_for(bt_index)
+            if ex_file && RbxPath.is_core_path?(ex_file)
+              file_name = RbxPath.convert_path_to_full(ex_file)
+            else
+              file_name = ex_file
+            end
+
+            line = ex_line
+
+            if file_name.nil?
+              raise CommandError, "Exception has no associated file."
+            end
+
+            if Pry.eval_path == file_name
+              raise CommandError, "Cannot edit exceptions raised in REPL."
+            end
+          elsif opts.present?(:current)
+            file_name = target.eval("__FILE__")
+            line = target.eval("__LINE__")
+          else
+
+            # break up into file:line
+            file_name = File.expand_path(args.first)
+            line = file_name.sub!(/:(\d+)$/, "") ? $1.to_i : 1
+          end
+
+          if not_a_real_file?(file_name)
+            raise CommandError, "#{file_name} is not a valid file name, cannot edit!"
+          end
+
+          line = opts[:l].to_i if opts.present?(:line)
+
+          invoke_editor(file_name, line)
+          set_file_and_dir_locals(file_name)
+
+          if opts.present?(:reload) || ((opts.present?(:ex) || file_name.end_with?(".rb")) && !opts.present?(:'no-reload')) && !Pry.config.disable_auto_reload
+            silence_warnings do
+              TOPLEVEL_BINDING.eval(File.read(file_name), file_name)
+            end
+          end
+        end
+      end
+
+      create_command "edit-method" do
+        description "Edit the source code for a method."
+
+        banner <<-BANNER
+          Usage: edit-method [OPTIONS] [METH]
+
+          Edit the method METH in an editor.
+          Ensure Pry.config.editor is set to your editor of choice.
+
+          e.g: `edit-method hello_method`
+          e.g: `edit-method Pry#rep`
+          e.g: `edit-method`
+
+          https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_method
+        BANNER
+
+        command_options :shellwords => false
+
+        def options(opt)
+          method_options(opt)
+          opt.on :n, "no-reload", "Do not automatically reload the method's file after editing."
+          opt.on "no-jump", "Do not fast forward editor to first line of method."
+          opt.on :p, :patch, "Instead of editing the method's file, try to edit in a tempfile and apply as a monkey patch."
+        end
+
+        def process
+          if !Pry.config.editor
+            raise CommandError, "No editor set!\nEnsure that #{text.bold("Pry.config.editor")} is set to your editor of choice."
+          end
+
+          begin
+            @method = method_object
+          rescue NonMethodContextError => err
+          end
+
+          if opts.present?(:patch) || (@method && @method.dynamically_defined?)
+            if err
+              raise err # can't patch a non-method
+            end
+
+            process_patch
+          else
+            if err && !File.exist?(target.eval('__FILE__'))
+              raise err # can't edit a non-file
+            end
+
+            process_file
+          end
+        end
+
+        def process_patch
+          lines = @method.source.lines.to_a
+
+          if ((original_name = @method.original_name) &&
+              lines[0] =~ /^def (?:.*?\.)?#{original_name}(?=[\(\s;]|$)/)
+            lines[0] = "def #{original_name}#{$'}"
+          else
+            raise CommandError, "Pry can only patch methods created with the `def` keyword."
+          end
+
+          temp_file do |f|
+            f.puts lines.join
+            f.flush
+            invoke_editor(f.path, 0)
+
+            if @method.alias?
+              with_method_transaction(original_name, @method.owner) do
+                Pry.new(:input => StringIO.new(File.read(f.path))).rep(@method.owner)
+                Pry.binding_for(@method.owner).eval("alias #{@method.name} #{original_name}")
+              end
+            else
+              Pry.new(:input => StringIO.new(File.read(f.path))).rep(@method.owner)
+            end
+          end
+        end
+
+        def process_file
+          file, line = extract_file_and_line
+
+          invoke_editor(file, opts["no-jump"] ? 0 : line)
+          silence_warnings do
+            load file unless opts.present?(:'no-reload') || Pry.config.disable_auto_reload
+          end
+        end
+
+        protected
+          def extract_file_and_line
+            if @method
+              if @method.source_type == :c
+                raise CommandError, "Can't edit a C method."
+              else
+                [@method.source_file, @method.source_line]
+              end
+            else
+              [target.eval('__FILE__'), target.eval('__LINE__')]
+            end
+          end
+
+          def with_method_transaction(meth_name, target=TOPLEVEL_BINDING)
+            target = Pry.binding_for(target)
+            temp_name = "__pry_#{meth_name}__"
+
+            target.eval("alias #{temp_name} #{meth_name}")
+            yield
+            target.eval("alias #{meth_name} #{temp_name}")
+          ensure
+            target.eval("undef #{temp_name}") rescue nil
+          end
+      end
+
+      create_command(/amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/) do
+        description "Amend a line of input in multi-line mode."
+        command_options :interpolate => false, :listing => "amend-line"
+
+        banner <<-'BANNER'
+          Amend a line of input in multi-line mode. `amend-line N`, where the N in `amend-line N` represents line to replace.
+
+          Can also specify a range of lines using `amend-line N..M` syntax. Passing '!' as replacement content deletes the line(s) instead.
+          e.g amend-line 1 puts 'hello world! # replace line 1'
+          e.g amend-line 1..4 !               # delete lines 1..4
+          e.g amend-line 3 >puts 'goodbye'    # insert before line 3
+          e.g amend-line puts 'hello again'   # no line number modifies immediately preceding line
+        BANNER
+
+        def process
+          start_line_number, end_line_number, replacement_line = *args
+
+          if eval_string.empty?
+            raise CommandError, "No input to amend."
+          end
+
+          replacement_line = "" if !replacement_line
+          input_array = eval_string.each_line.to_a
+
+          end_line_number = start_line_number.to_i if !end_line_number
+          line_range = start_line_number ? (one_index_number(start_line_number.to_i)..one_index_number(end_line_number.to_i))  : input_array.size - 1
+
+          # delete selected lines if replacement line is '!'
+          if arg_string == "!"
+            input_array.slice!(line_range)
+          elsif arg_string.start_with?(">")
+            insert_slot = Array(line_range).first
+            input_array.insert(insert_slot, arg_string[1..-1] + "\n")
+          else
+            input_array[line_range] = arg_string + "\n"
+          end
+          eval_string.replace input_array.join
+          run "show-input"
+        end
+      end
+
+      create_command "play" do
+        description "Play back a string variable or a method or a file as input."
+
+        banner <<-BANNER
+          Usage: play [OPTIONS] [--help]
+
+          The play command enables you to replay code from files and methods as
+          if they were entered directly in the Pry REPL. Default action (no
+          options) is to play the provided string variable
+
+          e.g: `play -i 20 --lines 1..3`
+          e.g: `play -m Pry#repl --lines 1..-1`
+          e.g: `play -f Rakefile --lines 5`
+
+          https://github.com/pry/pry/wiki/User-Input#wiki-Play
+        BANNER
+
+        attr_accessor :content
+
+        def setup
+          self.content   = ""
+        end
+
+        def options(opt)
+          opt.on :m, :method, "Play a method's source.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            self.content << meth.source
+          end
+          opt.on :d, :doc, "Play a method's documentation.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            text.no_color do
+              self.content << process_comment_markup(meth.doc, :ruby)
+            end
+          end
+          opt.on :c, :command, "Play a command's source.", true do |command_name|
+            command = find_command(command_name)
+            block = Pry::Method.new(find_command(command_name).block)
+            self.content << block.source
+          end
+          opt.on :f, :file, "Play a file.", true do |file|
+            self.content << File.read(File.expand_path(file))
+          end
+          opt.on :l, :lines, "Only play a subset of lines.", :optional => true, :as => Range, :default => 1..-1
+          opt.on :i, :in, "Play entries from Pry's input expression history. Takes an index or range.", :optional => true,
+          :as => Range, :default => -5..-1 do |range|
+            input_expressions = _pry_.input_array[range] || []
+            Array(input_expressions).each { |v| self.content << v }
+          end
+          opt.on :o, "open", 'When used with the -m switch, it plays the entire method except the last line, leaving the method definition "open". `amend-line` can then be used to modify the method.'
+        end
+
+        def process
+          perform_play
+          run "show-input" unless _pry_.complete_expression?(eval_string)
+        end
+
+        def process_non_opt
+          args.each do |arg|
+            begin
+              self.content << target.eval(arg)
+            rescue Pry::RescuableException
+              raise CommandError, "Prblem when evaling #{arg}."
+            end
+          end
+        end
+
+        def perform_play
+          process_non_opt
+
+          if opts.present?(:lines)
+            self.content = restrict_to_lines(self.content, opts[:l])
+          end
+
+          if opts.present?(:open)
+            self.content = restrict_to_lines(self.content, 1..-2)
+          end
+
+          eval_string << self.content
+        end
+      end
+    end
+  end
+end