pry 0.8.4pre1-i386-mingw32 → 0.9.0-i386-mingw32

data/lib/pry/default_commands/easter_eggs.rb

@@ -1,26 +1,7 @@
 class Pry
   module DefaultCommands
 
-    EasterEggs = Pry::CommandSet.new :easter_eggs do
-
-      command "game", "" do |highest|
-        highest = highest ? highest.to_i : 100
-        num = rand(highest)
-        output.puts "Guess the number between 0-#{highest}: ('.' to quit)"
-        count = 0
-        while(true)
-          count += 1
-          str = Readline.readline("game > ", true)
-          break if str == "." || !str
-          val = str.to_i
-          output.puts "Too large!" if val > num
-          output.puts "Too small!" if val < num
-          if val == num
-            output.puts "Well done! You guessed right! It took you #{count} guesses."
-            break
-          end
-        end
-      end
+    EasterEggs = Pry::CommandSet.new do
 
       command "east-coker", "" do
         text = %{

data/lib/pry/default_commands/gems.rb

@@ -1,56 +1,47 @@
 class Pry
   module DefaultCommands
 
-    Gems = Pry::CommandSet.new :gems do
-
-      command "gem-install", "Install a gem and refresh the gem cache." do |gem_name|
-        gem_home = Gem.instance_variable_get(:@gem_home)
-        output.puts "Attempting to install gem: #{bold(gem_name)}"
+    Gems = Pry::CommandSet.new do
 
+      command "gem-install", "Install a gem and refresh the gem cache.", :argument_required => true do |gem|
         begin
-          if File.writable?(gem_home)
-            Gem::DependencyInstaller.new.install(gem_name)
-            output.puts "Gem #{bold(gem_name)} successfully installed."
-          else
-            if system("sudo gem install #{gem_name}")
-              output.puts "Gem #{bold(gem_name)} successfully installed."
-            else
-              output.puts "Gem #{bold(gem_name)} could not be installed."
-              next
-            end
-          end
+          destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
+          installer = Gem::DependencyInstaller.new :install_dir => destination
+          installer.install gem
+        rescue Errno::EACCES
+          output.puts "Insufficient permissions to install `#{text.green gem}`"
         rescue Gem::GemNotFoundException
-          output.puts "Required Gem: #{bold(gem_name)} not found."
-          next
+          output.puts "Gem `#{text.green gem}` not found."
+        else
+          Gem.refresh
+          output.puts "Gem `#{text.green gem}` installed."
         end
-
-        Gem.refresh
-        output.puts "Refreshed gem cache."
       end
 
-      command "gem-cd", "Change working directory to specified gem's directory." do |gem_name|
-        require 'rubygems'
-        gem_spec = Gem.source_index.find_name(gem_name).first
-        next output.puts("Gem `#{gem_name}` not found.") if !gem_spec
-        Dir.chdir(File.expand_path(gem_spec.full_gem_path))
+      command "gem-cd", "Change working directory to specified gem's directory.", :argument_required => true do |gem|
+        specs = Gem::Specification.respond_to?(:each) ? Gem::Specification.find_all_by_name(gem) : Gem.source_index.find_name(gem)
+        spec  = specs.sort { |a,b| Gem::Version.new(b.version) <=> Gem::Version.new(a.version) }.first
+        spec ? Dir.chdir(spec.full_gem_path) : output.puts("Gem `#{gem}` not found.")
       end
 
+      command "gem-list", "List/search installed gems. (Optional parameter: a regexp to limit the search)" do |pattern|
+        pattern = Regexp.new pattern.to_s, Regexp::IGNORECASE
+        gems    = if Gem::Specification.respond_to?(:each)
+                    Gem::Specification.select{|spec| spec.name =~ pattern }.group_by(&:name)
+                  else
+                    Gem.source_index.gems.values.group_by(&:name).select { |gemname, specs| gemname =~ pattern }
+                  end
+
+        gems.each do |gem, specs|
+          specs.sort! do |a,b|
+            Gem::Version.new(b.version) <=> Gem::Version.new(a.version)
+          end
 
-      command "gem-list", "List/search installed gems. (Optional parameter: a regexp to limit the search)" do |arg|
-        gems = Gem.source_index.gems.values.group_by(&:name)
-        if arg
-          query = Regexp.new(arg, Regexp::IGNORECASE)
-          gems = gems.select { |gemname, specs| gemname =~ query }
-        end
-
-        gems.each do |gemname, specs|
-          versions = specs.map(&:version).sort.reverse.map(&:to_s)
-          versions = ["<bright_green>#{versions.first}</bright_green>"] +
-            versions[1..-1].map{|v| "<green>#{v}</green>" }
+          versions = specs.each_with_index.map do |spec, index|
+            index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s)
+          end
 
-          gemname = highlight(gemname, query) if query
-          result = "<white>#{gemname} <grey>(#{versions.join ', '})</grey>"
-          output.puts colorize(result)
+          output.puts "#{text.white gem} (#{versions.join ', '})"
         end
       end
 

data/lib/pry/default_commands/input.rb

@@ -1,37 +1,245 @@
 class Pry
   module DefaultCommands
 
-    Input = Pry::CommandSet.new :input do
+    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
         output.puts "Input buffer cleared!"
-        opts[:eval_string].clear
+        eval_string.replace("")
       end
 
-      command "hist", "Show and replay Readline history. When given no args history is displayed.\nType `hist --help` for more info." do |*args|
-        hist_array = Readline::HISTORY.to_a
+      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+)?(?:\.\.(-?\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
 
-        if args.empty?
-          text = add_line_numbers(hist_array.join("\n"), 0)
-          stagger_output(text)
-          next
+        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 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\ne.g `play puts 'hello world'` #=> \"hello world\"\ne.g `play -m Pry#repl --lines 1..-1`\ne.g `play -f Rakefile --lines 5`\n"
+
+          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 line (or range of lines) to replay.', 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
+
+          opt.on_noopts { Pry.active_instance.input = StringIO.new(arg_string)  }
+        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_type = 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.active_instance.input = StringIO.new(Array(code.each_line.to_a[range]).join)
+        end
+
+        if 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.active_instance.input = StringIO.new(Array(text_array[range]).join)
+        end
+      end
+
+      command "hist", "Show and replay Readline history. Type `hist --help` for more info." do |*args|
+        history = Readline::HISTORY.to_a
+
+        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.strip.split(/ /, 2).last.strip
+            history.pop
+
+            history.map!.with_index do |element, index|
+              if element =~ pattern
+                "#{text.blue index}: #{element}"
+              end
+            end
+
+            stagger_output history.compact.join "\n"
+          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
 
-        opts = Slop.parse(args) do |opt|
-          opt.banner "Usage: hist [--replay START..END]\nView and replay history\nWhen given no args, history is displayed.\ne.g hist --replay 2..8"
-          opt.on :r, :replay, 'The line (or range of lines) to replay.', true, :as => Range
-          opt.on :h, :help, 'Show this message.', :tail => true do
+          opt.on :t, :tail, 'Display the last N items of history',
+                     :optional => true,
+                     :as       => Integer,
+                     :unless   => :grep do |limit|
+
+            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,
+                 :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.', :unless => :grep do
+            history.map!.with_index do |element, index|
+              unless command_processor.valid_command? element
+                "#{text.blue index}: #{element}"
+              end
+            end
+            stagger_output history.compact.join "\n"
+          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.active_instance.input = StringIO.new(actions)
+          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
+            Readline::HISTORY.shift until Readline::HISTORY.empty?
+            output.puts 'History cleared.'
+          end
+
+          opt.on :h, :help, 'Show this message.', :tail => true, :unless => :grep do
             output.puts opt.help
           end
+
+          opt.on_empty do
+            lines = text.with_line_numbers history.join("\n"), 0
+            stagger_output lines
+          end
         end
 
-        next if opts.h?
+        # 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
 
-        actions = Array(hist_array[opts[:replay]]).join("\n") + "\n"
-        Pry.active_instance.input = StringIO.new(actions)
       end
 
 
+      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
 
   end

data/lib/pry/default_commands/introspection.rb

@@ -1,26 +1,27 @@
 class Pry
   module DefaultCommands
 
-    Introspection = Pry::CommandSet.new :introspection do
+    Introspection = Pry::CommandSet.new do
 
       command "show-method", "Show the source for METH. Type `show-method --help` for more info. Aliases: $, show-source" do |*args|
         target = target()
 
-        opts = Slop.parse!(args) do |opts|
-          opts.banner %{Usage: show-method [OPTIONS] [METH]
-Show the source for method METH. Tries instance methods first and then methods by default.
-e.g: show-method hello_method
---
-}
-          opts.on :l, "line-numbers", "Show line numbers."
-          opts.on :M, "instance-methods", "Operate on instance methods."
-          opts.on :m, :methods, "Operate on methods."
-          opts.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opts.on :c, :context, "Select object context to run under.", true do |context|
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: show-method [OPTIONS] [METH]\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."
+          opt.on :c, :context, "Select object context to run under.", true do |context|
             target = Pry.binding_for(target.eval(context))
           end
-          opts.on :h, :help, "This message." do
-            output.puts opts
+          opt.on :h, :help, "This message." do
+            output.puts opt
           end
         end
 
@@ -45,6 +46,9 @@ e.g: show-method hello_method
           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
       end
@@ -53,79 +57,103 @@ e.g: show-method hello_method
       alias_command "$", "show-method", ""
 
       command "show-command", "Show the source for CMD. Type `show-command --help` for more info." do |*args|
-        options = {}
         target = target()
-        command_name = nil
-
-        OptionParser.new do |opts|
-          opts.banner = %{Usage: show-command [OPTIONS] [CMD]
-Show the source for command CMD.
-e.g: show-command show-method
---
-}
-          opts.on("-l", "--line-numbers", "Show line numbers.") do |line|
-            options[:l] = true
-          end
 
-          opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
-            options[:f] = true
-          end
+        opts = Slop.parse!(args) do |opt|
+          opt.banner = "Usage: show-command [OPTIONS] [CMD]\n" \
+                       "Show the source for command CMD.\n" \
+                       "e.g: show-command show-method"
 
-          opts.on_tail("-h", "--help", "This message.") do
-            output.puts opts
-            options[:h] = true
+          opt.on :l, "line-numbers", "Show line numbers."
+          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+          opt.on :h, :help, "This message." do
+            output.puts opt
           end
-        end.order(args) do |v|
-          command_name = v
         end
 
-        next if options[:h]
+        next if opts.help?
 
+        command_name = args.shift
         if !command_name
           output.puts "You must provide a command name."
           next
         end
 
-        if commands[command_name]
-          meth = commands[command_name].block
+        if find_command(command_name)
+          block = find_command(command_name).block
 
-          code = strip_leading_whitespace(meth.source)
-          file, line = meth.source_location
-          set_file_and_dir_locals(file)
-          check_for_dynamically_defined_method(meth)
+          code, _ = code_and_code_type_for(block)
+          next if !code
 
-          output.puts make_header(meth, :ruby, code)
+          output.puts make_header(block, :ruby, code)
 
           if Pry.color
             code = CodeRay.scan(code, :ruby).term
           end
 
-          render_output(options[:f], options[:l] ? meth.source_location.last : false, code)
+          start_line = false
+          if opts.l?
+            start_line = block.source_location ? block.source_location.last : 1
+          end
+
+          render_output(opts.flood?, opts.l? ? block.source_location.last : false, code)
           code
         else
           output.puts "No such command: #{command_name}."
         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.\n" \
+                      "Ensure #{text.bold("Pry.editor")} is set to your editor of choice.\n" \
+                      "e.g: edit sample.rb"
+
+          opt.on :r, "reload", "Eval file content after editing (using `load`)"
+          opt.on :p, "play", "Use the pry `play` command to eval the file content after editing (instead of the `load` method)."
+          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?
+
+        next output.puts("Need to specify a file.") if !args.first
+        file_name = File.expand_path(args.first)
+
+        invoke_editor(file_name, opts[:l].to_i)
+        set_file_and_dir_locals(file_name)
+
+        if opts[:r]
+          silence_warnings do
+            load file_name
+          end
+        elsif opts[:p]
+          silence_warnings do
+            Pry.active_instance.input = StringIO.new(File.readlines(file_name).join)
+          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 |opts|
-          opts.banner %{Usage: edit-method [OPTIONS] [METH]
-Edit the method METH in an editor.
-Ensure #{bold("Pry.editor")} is set to your editor of choice.
-e.g: edit-method hello_method
---
-}
-          opts.on :M, "instance-methods", "Operate on instance methods."
-          opts.on :m, :methods, "Operate on methods."
-          opts.on "no-reload", "Do not automatically reload the method's file after editting."
-          opts.on :n, "no-jump", "Do not fast forward editor to first line of method."
-          opts.on :c, :context, "Select object context to run under.", true do |context|
+        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" \
+                      "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 "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))
           end
-          opts.on :h, :help, "This message." do
-            output.puts opts
+          opt.on :h, :help, "This message." do
+            output.puts opt
           end
         end
 
@@ -137,7 +165,7 @@ e.g: edit-method hello_method
           next
         end
 
-        next output.puts "Error: No editor set!\nEnsure that #{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.editor")} is set to your editor of choice." if !Pry.editor
 
         if is_a_c_method?(meth)
           output.puts "Error: Can't edit a C method."
@@ -146,38 +174,45 @@ e.g: edit-method hello_method
 
           # editor is invoked here
         else
-          file, line = meth.source_location
+          file, line = path_line_for(meth)
           set_file_and_dir_locals(file)
 
+          invoke_editor(file, opts["no-jump"] ? 0 : line)
+          silence_warnings do
+            load file if !opts.n?
+          end
+        end
+      end
+
+      helpers do
+
+        def invoke_editor(file, line)
           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.n? ? "" : start_line_for_editor(line)
-            editor_invocation = "#{Pry.editor} #{start_line_syntax} #{file}"
+            editor_invocation = "#{Pry.editor} #{start_line_syntax_for_editor(file, line)}"
           end
 
           run ".#{editor_invocation}"
-          silence_warnings do
-            load file if !opts["no-reload"]
-          end
         end
-      end
 
+        def start_line_syntax_for_editor(file_name, line_number)
+          file_name.gsub!(/\//, '\\') if RUBY_PLATFORM =~ /mswin|mingw/
 
-      helpers do
-
-        def start_line_for_editor(line_number)
           case Pry.editor
           when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-            "+#{line_number}"
+            "+#{line_number} #{file_name}"
           when /^mate/, /^geany/
-            "-l #{line_number}"
+            "-l #{line_number} #{file_name}"
+          when /^uedit32/
+            "#{file_name}/#{line_number}"
+          when /^jedit/
+            "#{file_name} +#{line_number}"
           else
             if RUBY_PLATFORM =~ /mswin|mingw/
-              ""
+              "#{file_name}"
             else
-              "+#{line_number}"
+              "+#{line_number} #{file_name}"
             end
           end
         end