pry 0.9.0pre3-java → 0.9.4pre2-java

data/lib/pry/default_commands/easter_eggs.rb

@@ -3,6 +3,11 @@ class Pry
 
     EasterEggs = Pry::CommandSet.new do
 
+      command(/!s\/(.*?)\/(.*?)/, "") do |source, dest|
+        eval_string.gsub!(/#{source}/) { dest }
+        run "show-input"
+      end
+
       command "east-coker", "" do
         text = %{
 --

data/lib/pry/default_commands/input.rb

@@ -3,33 +3,110 @@ class Pry
 
     Input = Pry::CommandSet.new do
 
-      command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop." do
+      command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop.", :use_prefix => false do
         output.puts "Input buffer cleared!"
         eval_string.replace("")
       end
 
-      command "show-input", "Show the current eval_string" do
-        render_output(false, 0, Pry.color ? CodeRay.scan(eval_string, :ruby).term : eval_string)
+      command "show-input", "Show the contents of the input buffer for the current multi-line expression." do
+        render_output(false, 1, Pry.color ? CodeRay.scan(eval_string, :ruby).term : eval_string)
       end
 
-      command(/amend-line-?(\d+)?/, "Experimental amend-line, where the N in amend-line-N represents line to replace. Aliases: %N",
-      :interpolate => false, :listing => "amend-line-N")  do |line_number, replacement_line|
+      command(/amend-line.?(-?\d+)?(?:\.\.(-?\d+))?/, "Amend a line of input in multi-line mode. Type `amend-line --help` for more information. Aliases %",
+              :interpolate => false, :listing => "amend-line")  do |*args|
+        start_line_number, end_line_number, replacement_line = *args
+
+        opts = Slop.parse!(args.compact) do |opt|
+          opt.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. Aliases: %N
+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
+}
+          opt.on :h, :help, "This message." do
+            output.puts opt
+          end
+        end
+
+        next if opts.h?
+        next output.puts "No input to amend." if eval_string.empty?
+
         replacement_line = "" if !replacement_line
         input_array = eval_string.each_line.to_a
-        line_num = line_number ? line_number.to_i : input_array.size - 1
-        input_array[line_num] = arg_string + "\n"
+
+        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
+
+      alias_command(/%.?(-?\d+)?(?:\.\.(-?\d+))?/, /amend-line.?(-?\d+)?(?:\.\.(-?\d+))?/, "")
+
+      command "play", "Play back a string variable or a method or a file as input. Type `play --help` for more information." do |*args|
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: play [OPTIONS] [--help]\nDefault action (no options) is to play the provided string variable\ne.g `play _in_[20] --lines 1..3`\ne.g `play -m Pry#repl --lines 1..-1`\ne.g `play -f Rakefile --lines 5`"
+
+          opt.on :l, :lines, 'The line (or range of lines) to replay.', true, :as => Range
+          opt.on :m, :method, 'Play a method.', true
+          opt.on :f, "file", 'The file to replay in context.', true
+          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.'
+          opt.on :h, :help, "This message." do
+            output.puts opt
+          end
+        end
+
+        if opts.m?
+          meth_name = opts[:m]
+          if (meth = get_method_object(meth_name, target, {})).nil?
+            output.puts "Invalid method name: #{meth_name}."
+            next
+          end
+          code, _ = code_and_code_type_for(meth)
+          next if !code
+
+          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
+          range = (0..-2) if opts.o?
+
+          _pry_.input = StringIO.new(Array(code.each_line.to_a[range]).join)
+        elsif opts.f?
+          file_name = File.expand_path(opts[:f])
+          next output.puts "No such file: #{opts[:f]}" if !File.exists?(file_name)
+          text_array = File.readlines(file_name)
+          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
+          range = (0..-2) if opts.o?
+
+          _pry_.input = StringIO.new(Array(text_array[range]).join)
+        else
+          code = target.eval(args.first)
+
+          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
+          range = (0..-2) if opts.o?
+
+          eval_string << Array(code.each_line.to_a[range]).join
+        end
       end
 
-      alias_command(/%(\d+)?/, /amend-line-?(\d+)?/, "")
+      command "hist", "Show and replay Readline history. Type `hist --help` for more info. Aliases: history" do |*args|
+        # exclude the current command from history.
+        history = Pry.history.to_a[0..-2]
 
-      command "hist", "Show and replay Readline history. Type `hist --help` for more info." do |*args|
-        Slop.parse(args) do |opt|
-          history = Readline::HISTORY.to_a
-          opt.banner "Usage: hist [--replay START..END] [--clear] [--grep PATTERN] [--head N] [--tail N] [--help]\n"
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: hist [--replay START..END] [--clear] [--grep PATTERN] [--head N] [--tail N] [--help] [--save [START..END] file.txt]\n"
 
           opt.on :g, :grep, 'A pattern to match against the history.', true do |pattern|
-            pattern = Regexp.new arg_string.split(/ /)[1]
+            pattern = Regexp.new arg_string.strip.split(/ /, 2).last.strip
             history.pop
 
             history.map!.with_index do |element, index|
@@ -41,64 +118,67 @@ class Pry
             stagger_output history.compact.join "\n"
           end
 
-          opt.on :head, 'Display the first N items of history', :optional => true, :as => Integer do |limit|
-            unless opt.grep?
-              limit ||= 10
-              list  = history.first limit
-              lines = text.with_line_numbers list.join("\n"), 0
-              stagger_output lines
-            end
+          opt.on :head, 'Display the first N items of history',
+                 :optional => true,
+                 :as       => Integer,
+                 :unless   => :grep do |limit|
+
+            limit ||= 10
+            list  = history.first limit
+            lines = text.with_line_numbers list.join("\n"), 0
+            stagger_output lines
           end
 
-          opt.on :t, :tail, 'Display the last N items of history', :optional => true, :as => Integer do |limit|
-            unless opt.grep?
-              limit ||= 10
-              offset = history.size-limit
-              offset = offset < 0 ? 0 : offset
+          opt.on :t, :tail, 'Display the last N items of history',
+                     :optional => true,
+                     :as       => Integer,
+                     :unless   => :grep do |limit|
 
-              list  = history.last limit
-              lines = text.with_line_numbers list.join("\n"), offset
-              stagger_output lines
-            end
+            limit ||= 10
+            offset = history.size - limit
+            offset = offset < 0 ? 0 : offset
+
+            list  = history.last limit
+            lines = text.with_line_numbers list.join("\n"), offset
+            stagger_output lines
           end
 
-          opt.on :s, :show, 'Show the history corresponding to the history line (or range of lines).', true, :as => Range do |range|
-            unless opt.grep?
-              start_line = range.is_a?(Range) ? range.first : range
-              lines = text.with_line_numbers Array(history[range]).join("\n"), start_line
-              stagger_output lines
-            end
+          opt.on :s, :show, 'Show the history corresponding to the history line (or range of lines).',
+                 true,
+                 :as     => Range,
+                 :unless => :grep do |range|
+
+            start_line = range.is_a?(Range) ? range.first : range
+            lines = text.with_line_numbers Array(history[range]).join("\n"), start_line
+            stagger_output lines
           end
 
-          opt.on :e, :exclude, 'Exclude pry commands from the history.' do
-            unless opt.grep?
-              history.map!.with_index do |element, index|
-                unless command_processor.valid_command? element
-                  "#{text.blue index}: #{element}"
-                end
+          opt.on :e, :exclude, 'Exclude pry commands from the history.', :unless => :grep do
+            history.map!.with_index do |element, index|
+              unless command_processor.valid_command? element
+                "#{text.blue index}: #{element}"
               end
-              stagger_output history.compact.join "\n"
             end
+            stagger_output history.compact.join "\n"
           end
 
-          opt.on :r, :replay, 'The line (or range of lines) to replay.', true, :as => Range do |range|
-            unless opt.grep?
-              actions = Array(history[range]).join("\n") + "\n"
-              Pry.active_instance.input = StringIO.new(actions)
-            end
+          opt.on :r, :replay, 'The line (or range of lines) to replay.',
+                 true,
+                 :as     => Range,
+                 :unless => :grep do |range|
+            actions = Array(history[range]).join("\n") + "\n"
+            _pry_.input = StringIO.new(actions)
           end
 
-          opt.on :c, :clear, 'Clear the history' do
-            unless opt.grep?
-              Readline::HISTORY.shift until Readline::HISTORY.empty?
-              output.puts 'History cleared.'
-            end
+          opt.on "save", "Save history to a file. --save [start..end] output.txt. Pry commands are excluded from saved history.", true, :as => Range
+
+          opt.on :c, :clear, 'Clear the history', :unless => :grep do
+            Pry.history.clear
+            output.puts 'History cleared.'
           end
 
-          opt.on :h, :help, 'Show this message.', :tail => true do
-            unless opt.grep?
-              output.puts opt.help
-            end
+          opt.on :h, :help, 'Show this message.', :tail => true, :unless => :grep do
+            output.puts opt.help
           end
 
           opt.on_empty do
@@ -106,6 +186,63 @@ class Pry
             stagger_output lines
           end
         end
+
+        # FIXME: hack to save history (this must be refactored)
+        if opts["save"]
+          file_name = nil
+          hist_array = nil
+
+          case opts["save"]
+          when Range
+            hist_array = Array(history[opts["save"]])
+            next output.puts "Must provide a file name." if !args.first
+            file_name = File.expand_path(args.first)
+          when String
+            hist_array = history
+            file_name =  File.expand_path(opts["save"])
+          end
+
+          output.puts "Saving history in #{file_name} ..."
+          # exclude pry commands
+          hist_array.reject! do |element|
+            command_processor.valid_command?(element)
+          end
+
+          File.open(file_name, 'w') do |f|
+            f.write hist_array.join("\n")
+          end
+
+          output.puts "... history saved."
+        end
+
+      end
+
+      alias_command "history", "hist", ""
+
+      helpers do
+        def one_index_number(line_number)
+          if line_number > 0
+            line_number - 1
+          elsif line_number < 0
+            line_number
+          else
+            line_number
+          end
+        end
+
+        def one_index_range(range)
+          Range.new(one_index_number(range.begin), one_index_number(range.end))
+        end
+
+        def one_index_range_or_number(range_or_number)
+          case range_or_number
+          when Range
+            one_index_range(range_or_number)
+          else
+            one_index_number(range_or_number)
+          end
+        end
+
       end
 
     end

data/lib/pry/default_commands/introspection.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+
 class Pry
   module DefaultCommands
 
@@ -7,11 +9,13 @@ class Pry
         target = target()
 
         opts = Slop.parse!(args) do |opt|
-          opt.banner "Usage: show-method [OPTIONS] [METH]\n" \
+          opt.banner "Usage: show-method [OPTIONS] [METH 1] [METH 2] [METH N]\n" \
                      "Show the source for method METH. Tries instance methods first and then methods by default.\n" \
                      "e.g: show-method hello_method"
 
           opt.on :l, "line-numbers", "Show line numbers."
+          opt.on :b, "base-one", "Show line numbers but start numbering at 1 (useful for `amend-line` and `play` commands)."
+
           opt.on :M, "instance-methods", "Operate on instance methods."
           opt.on :m, :methods, "Operate on methods."
           opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
@@ -25,27 +29,33 @@ class Pry
 
         next if opts.help?
 
-        meth_name = args.shift
-        if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
-          output.puts "Invalid method name: #{meth_name}. Type `show-method --help` for help"
-          next
-        end
+        args = [nil] if args.empty?
+        args.each do |method_name|
+          meth_name = method_name
+          if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+            output.puts "Invalid method name: #{meth_name}. Type `show-method --help` for help"
+            next
+          end
 
-        code, code_type = code_and_code_type_for(meth)
-        next if !code
+          code, code_type = code_and_code_type_for(meth)
+          next if !code
 
-        output.puts make_header(meth, code_type, code)
-        if Pry.color
-          code = CodeRay.scan(code, code_type).term
-        end
+          output.puts make_header(meth, code_type, code)
+          if Pry.color
+            code = CodeRay.scan(code, code_type).term
+          end
 
-        start_line = false
-        if opts.l?
-          start_line = meth.source_location ? meth.source_location.last : 1
-        end
+          start_line = false
+          if opts.l?
+            start_line = meth.source_location ? meth.source_location.last : 1
+          end
+
+          start_line = opts.b? ? 1 : start_line
 
-        render_output(opts.flood?, start_line, code)
-        code
+
+          render_output(opts.flood?, start_line, code)
+          code
+        end
       end
 
       alias_command "show-source", "show-method", ""
@@ -98,18 +108,83 @@ class Pry
         end
       end
 
+      command "edit", "Invoke the default editor on a file. Type `edit --help` for more info" do |*args|
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: edit [OPTIONS] [FILE]\n" \
+                      "Edit the method FILE in an editor.\nWhen no file given, opens editor with contents of input buffer and evals after closing." \
+                      "\nEnsure #{text.bold("Pry.config.editor")} is set to your editor of choice.\n" \
+                      "e.g: edit sample.rb"
+
+          opt.on :r, "reload", "Eval file content after editing (evals at top level)"
+          opt.on :n, "no-reload", "Do not automatically reload the file after editing (only applies to --ex and -t)."
+          opt.on :ex, "Open an editor at the line and file that generated the most recent Exception, reloads file after editing."
+          opt.on :t, "temp", "Open a temporary file in an editor with contents of input buffer and eval it in current context after closing (same as `edit` with no args)"
+          opt.on :p, "play", "Use the pry `play` command to eval the file content after editing."
+          opt.on :l, "line", "Specify line number to jump to in file", true, :as => Integer
+          opt.on :h, :help, "This message." do
+            output.puts opt
+          end
+        end
+        next if opts.h?
+
+        should_reload_at_top_level = opts[:r]
+        should_reload_locally      = false
+
+        if opts.ex?
+          next output.puts "No Exception found." if _pry_.last_exception.nil?
+
+          if is_core_rbx_path?(_pry_.last_exception.file)
+            file_name = rbx_convert_path_to_full(_pry_.last_exception.file)
+          else
+            file_name = _pry_.last_exception.file
+          end
+
+          line = _pry_.last_exception.line
+          next output.puts "Exception has no associated file." if file_name.nil?
+          next output.puts "Cannot edit exceptions raised in REPL." if Pry.eval_path == file_name
+
+          should_reload_at_top_level = opts[:n] ? false : true
+
+        elsif opts.t? || args.first.nil?
+          file_name = Tempfile.new(["tmp", ".rb"]).tap(&:close).path
+          File.open(file_name, "w") { |f| f.puts eval_string } if !eval_string.empty?
+          line = eval_string.lines.count + 1
+          should_reload_locally = opts[:n] ? false : true
+        else
+          file_name, line = File.expand_path(args.first).split(/:/)
+          line = line ? line.to_i : opts[:l].to_i
+        end
+
+        invoke_editor(file_name, line)
+        set_file_and_dir_locals(file_name)
+
+        if opts[:p]
+          silence_warnings do
+            _pry_.input = StringIO.new(File.readlines(file_name).join)
+          end
+        elsif should_reload_locally
+          silence_warnings do
+            eval_string.replace(File.read(file_name))
+          end
+        elsif should_reload_at_top_level
+          silence_warnings do
+            TOPLEVEL_BINDING.eval(File.read(file_name), file_name)
+          end
+        end
+      end
+
       command "edit-method", "Edit a method. Type `edit-method --help` for more info." do |*args|
         target = target()
 
         opts = Slop.parse!(args) do |opt|
           opt.banner "Usage: edit-method [OPTIONS] [METH]\n" \
                       "Edit the method METH in an editor.\n" \
-                      "Ensure #{text.bold("Pry.editor")} is set to your editor of choice.\n" \
+                      "Ensure #{text.bold("Pry.config.editor")} is set to your editor of choice.\n" \
                       "e.g: edit-method hello_method"
 
           opt.on :M, "instance-methods", "Operate on instance methods."
           opt.on :m, :methods, "Operate on methods."
-          opt.on :n, "no-reload", "Do not automatically reload the method's file after editting."
+          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 :c, :context, "Select object context to run under.", true do |context|
             target = Pry.binding_for(target.eval(context))
@@ -127,7 +202,7 @@ class Pry
           next
         end
 
-        next output.puts "Error: No editor set!\nEnsure that #{text.bold("Pry.editor")} is set to your editor of choice." if !Pry.editor
+        next output.puts "Error: No editor set!\nEnsure that #{text.bold("Pry.config.editor")} is set to your editor of choice." if !Pry.config.editor
 
         if is_a_c_method?(meth)
           output.puts "Error: Can't edit a C method."
@@ -139,40 +214,13 @@ class Pry
           file, line = path_line_for(meth)
           set_file_and_dir_locals(file)
 
-          if Pry.editor.respond_to?(:call)
-            editor_invocation = Pry.editor.call(file, line)
-          else
-            # only use start line if -n option is not used
-            start_line_syntax = opts["no-jump"] ? "" : start_line_for_editor(line)
-            editor_invocation = "#{Pry.editor} #{start_line_syntax} #{file}"
-          end
-
-          run ".#{editor_invocation}"
+          invoke_editor(file, opts["no-jump"] ? 0 : line)
           silence_warnings do
-            load file if !opts.n?
+            load file if !opts.n? && !Pry.config.disable_auto_reload
           end
         end
       end
 
-      helpers do
-
-        def start_line_for_editor(line_number)
-          case Pry.editor
-          when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-            "+#{line_number}"
-          when /^mate/, /^geany/
-            "-l #{line_number}"
-          else
-            if RUBY_PLATFORM =~ /mswin|mingw/
-              ""
-            else
-              "+#{line_number}"
-            end
-          end
-        end
-
-      end
-
     end
   end
 end