pry 0.8.4pre1-java → 0.9.0pre1-java

data/lib/pry/default_commands/basic.rb

@@ -0,0 +1,37 @@
+class Pry
+  module DefaultCommands
+
+    Basic = Pry::CommandSet.new do
+      command "toggle-color", "Toggle syntax highlighting." do
+        Pry.color = !Pry.color
+        output.puts "Syntax highlighting #{Pry.color ? "on" : "off"}"
+      end
+
+      command "simple-prompt", "Toggle the simple prompt." do
+        case Pry.active_instance.prompt
+        when Pry::SIMPLE_PROMPT
+          Pry.active_instance.pop_prompt
+        else
+          Pry.active_instance.push_prompt Pry::SIMPLE_PROMPT
+        end
+      end
+
+      command "version", "Show Pry version." do
+        output.puts "Pry version: #{Pry::VERSION} on Ruby #{RUBY_VERSION}."
+      end
+
+      command "import", "Import a command set" do |command_set_name|
+        next output.puts "Provide a command set name" if command_set.nil?
+
+        set = target.eval(arg_string)
+        Pry.active_instance.commands.import set
+      end
+
+      command "reset", "Reset the REPL to a clean state." do
+        output.puts "Pry reset."
+        exec "pry"
+      end
+    end
+
+  end
+end

data/lib/pry/default_commands/context.rb

@@ -3,23 +3,25 @@ require "pry/default_commands/ls"
 class Pry
   module DefaultCommands
 
-    Context = Pry::CommandSet.new :context do
+    Context = Pry::CommandSet.new do
       import Ls
 
       command "cd", "Start a Pry session on VAR (use `cd ..` to go back and `cd /` to return to Pry top-level)",  :keep_retval => true do |obj|
-        if !obj
+        case obj
+        when nil
           output.puts "Must provide an object."
           next
-        end
-
-        throw(:breakout, opts[:nesting].level) if obj == ".."
-
-        if obj == "/"
+        when ".."
+          throw(:breakout, opts[:nesting].level)
+        when "/"
           throw(:breakout, 1) if opts[:nesting].level > 0
           next
+        when "::"
+          TOPLEVEL_BINDING.pry
+          next
+        else
+          Pry.start target.eval(arg_string)
         end
-
-        Pry.start target.eval("#{obj}")
       end
 
       command "nesting", "Show nesting information." do
@@ -52,16 +54,14 @@ class Pry
       end
 
       command "exit", "End the current Pry session. Accepts optional return value. Aliases: quit, back" do
-        str = remove_first_word(opts[:val])
-        throw(:breakout, [opts[:nesting].level, target.eval(str)])
+        throw(:breakout, [opts[:nesting].level, target.eval(arg_string)])
       end
 
       alias_command "quit", "exit", ""
       alias_command "back", "exit", ""
 
       command "exit-all", "End all nested Pry sessions. Accepts optional return value. Aliases: !!@" do
-        str = remove_first_word(opts[:val])
-        throw(:breakout, [0, target.eval(str)])
+        throw(:breakout, [0, target.eval(arg_string)])
       end
 
       alias_command "!!@", "exit-all", ""
@@ -74,7 +74,7 @@ class Pry
       alias_command "!!!", "exit-program", ""
 
       command "!pry", "Start a Pry session on current self; this even works mid-expression." do
-        Pry.start(target)
+        target.pry
       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|
@@ -97,7 +97,7 @@ class Pry
         end
 
         set_file_and_dir_locals(file)
-        output.puts "\n#{bold('From:')} #{file} @ line #{line_num} in #{klass}##{meth_name}:\n\n"
+        output.puts "\n#{text.bold('From:')} #{file} @ line #{line_num} in #{klass}##{meth_name}:\n\n"
 
         # This method inspired by http://rubygems.org/gems/ir_b
         File.open(file).each_with_index do |line, index|

data/lib/pry/default_commands/documentation.rb

@@ -1,7 +1,7 @@
 class Pry
   module DefaultCommands
 
-    Documentation = Pry::CommandSet.new :gems do
+    Documentation = Pry::CommandSet.new do
 
       command "ri", "View ri documentation. e.g `ri Array#each`" do |*args|
         run ".ri", *args
@@ -10,20 +10,19 @@ class Pry
       command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. Aliases: \?" do |*args|
         target = target()
 
-        opts = Slop.parse!(args) do |opts|
-          opts.banner %{Usage: show-doc [OPTIONS] [METH]
-Show the comments above method METH. Tries instance methods first and then methods by default.
-e.g show-doc hello_method
---
-}
-          opts.on :M, "instance-methods", "Operate on instance methods."
-          opts.on :m, :methods, "Operate on methods."
-          opts.on :c, :context, "Select object context to run under.", true do |context|
+        opts = Slop.parse!(args) do |opt|
+          opt.banner = "Usage: show-doc [OPTIONS] [METH]\n" \
+                       "Show the comments above method METH. Tries instance methods first and then methods by default.\n" \
+                       "e.g show-doc hello_method"
+
+          opt.on :M, "instance-methods", "Operate on instance methods."
+          opt.on :m, :methods, "Operate on methods."
+          opt.on :c, :context, "Select object context to run under.", true do |context|
             target = Pry.binding_for(target.eval(context))
           end
-          opts.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opts.on :h, :help, "This message." do
-            output.puts opts
+          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
 
@@ -51,19 +50,18 @@ e.g show-doc hello_method
       command "stat", "View method information and set _file_ and _dir_ locals. Type `stat --help` for more info." do |*args|
         target = target()
 
-        opts = Slop.parse!(args) do |opts|
-          opts.banner %{Usage: stat [OPTIONS] [METH]
-Show method information for method METH and set _file_ and _dir_ locals.
-e.g: stat hello_method
---
-}
-          opts.on :M, "instance-methods", "Operate on instance methods."
-          opts.on :m, :methods, "Operate on methods."
-          opts.on :c, :context, "Select object context to run under.", true do |context|
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: stat [OPTIONS] [METH]\n" \
+                     "Show method information for method METH and set _file_ and _dir_ locals." \
+                     "e.g: stat hello_method"
+
+          opt.on :M, "instance-methods", "Operate on instance methods."
+          opt.on :m, :methods, "Operate on methods."
+          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
 
@@ -80,36 +78,37 @@ e.g: stat hello_method
         doc, code_type = doc_and_code_type_for(meth)
 
         output.puts make_header(meth, code_type, code)
-        output.puts bold("Method Name: ") + meth_name
-        output.puts bold("Method Owner: ") + (meth.owner.to_s ? meth.owner.to_s : "Unknown")
-        output.puts bold("Method Language: ") + code_type.to_s.capitalize
-        output.puts bold("Method Type: ") + (meth.is_a?(Method) ? "Bound" : "Unbound")
-        output.puts bold("Method Arity: ") + meth.arity.to_s
+        output.puts text.bold("Method Name: ") + meth_name
+        output.puts text.bold("Method Owner: ") + (meth.owner.to_s ? meth.owner.to_s : "Unknown")
+        output.puts text.bold("Method Language: ") + code_type.to_s.capitalize
+        output.puts text.bold("Method Type: ") + (meth.is_a?(Method) ? "Bound" : "Unbound")
+        output.puts text.bold("Method Arity: ") + meth.arity.to_s
 
         name_map = { :req => "Required:", :opt => "Optional:", :rest => "Rest:" }
         if meth.respond_to?(:parameters)
-          output.puts bold("Method Parameters: ") + meth.parameters.group_by(&:first).
+          output.puts text.bold("Method Parameters: ") + meth.parameters.group_by(&:first).
             map { |k, v| "#{name_map[k]} #{v.map { |kk, vv| vv ? vv.to_s : "noname" }.join(", ")}" }.join(". ")
         end
-        output.puts bold("Comment length: ") + (doc.empty? ? 'No comment.' : (doc.lines.count.to_s + ' lines.'))
+        output.puts text.bold("Comment length: ") + (doc.empty? ? 'No comment.' : (doc.lines.count.to_s + ' lines.'))
       end
 
       command "gist-method", "Gist a method to github. Type `gist-method --help` for more info.", :requires_gem => "gist" do |*args|
+        require 'gist'
+
         target = target()
 
-        opts = Slop.parse!(args) do |opts|
-          opts.banner = %{Usage: gist-method [OPTIONS] [METH]
-Gist the method (doc or source) to github.
-Ensure the `gist` gem is properly working before use. http://github.com/defunkt/gist for instructions.
-e.g: gist -m my_method
-e.g: gist -d my_method
---
-}
-          opts.on :m, :method, "Gist a method's source."
-          opts.on :d, :doc, "Gist a method's documentation."
-          opts.on :p, :private, "Create a private gist (default: true)", :default => true
-          opts.on :h, :help, "This message" do
-            output.puts opts
+        opts = Slop.parse!(args) do |opt|
+          opt.banner "Usage: gist-method [OPTIONS] [METH]\n" \
+                     "Gist the method (doc or source) to github.\n" \
+                     "Ensure the `gist` gem is properly working before use. http://github.com/defunkt/gist for instructions.\n" \
+                     "e.g: gist -m my_method\n" \
+                     "e.g: gist -d my_method\n"
+
+          opt.on :m, :method, "Gist a method's source."
+          opt.on :d, :doc, "Gist a method's documentation."
+          opt.on :p, :private, "Create a private gist (default: true)", :default => true
+          opt.on :h, :help, "This message" do
+            output.puts opt
           end
         end
 
@@ -128,15 +127,17 @@ e.g: gist -d my_method
           content, code_type = code_and_code_type_for(meth)
         else
           content, code_type = doc_and_code_type_for(meth)
-          no_color do
+          text.no_color do
             content = process_comment_markup(content, code_type)
           end
           code_type = :plain
         end
 
-        IO.popen("gist#{' -p' if opts.p?} -t #{type_map[code_type]} -", "w") do |gist|
-          gist.puts content
-        end
+        link = Gist.write([:extension => ".#{type_map[code_type]}",
+                           :input => content],
+                          opts.p?)
+
+        output.puts "Gist created at #{link}"
       end
 
     end

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
+          
+          versions = specs.map.with_index do |spec, index|
+            index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s) 
+          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>" }
-
-          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,36 +1,112 @@
 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 current eval_string" do
+        render_output(false, 0, Pry.color ? CodeRay.scan(eval_string, :ruby).term : eval_string)
+      end
 
-        if args.empty?
-          text = add_line_numbers(hist_array.join("\n"), 0)
-          stagger_output(text)
-          next
-        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|
+        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"
+        eval_string.replace input_array.join
+      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
-            output.puts opt.help
+      alias_command /%(\d+)?/, /amend-line-?(\d+)?/, ""
+
+      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"
+
+          opt.on :g, :grep, 'A pattern to match against the history.', true do |pattern|
+            pattern = Regexp.new arg_string.split(/ /)[1]
+            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
-        end
 
-        next if opts.h?
+          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
+          end
 
-        actions = Array(hist_array[opts[:replay]]).join("\n") + "\n"
-        Pry.active_instance.input = StringIO.new(actions)
-      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
 
+              list  = history.last limit
+              lines = text.with_line_numbers list.join("\n"), offset
+              stagger_output lines
+            end
+          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
+          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
+              end
+              stagger_output history.compact.join "\n"
+            end
+          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
+          end
+
+          opt.on :c, :clear, 'Clear the history' do
+            unless opt.grep?
+              Readline::HISTORY.shift until Readline::HISTORY.empty?
+              output.puts 'History cleared.'
+            end
+          end
+
+          opt.on :h, :help, 'Show this message.', :tail => true do
+            unless opt.grep?
+              output.puts opt.help
+            end
+          end
+
+          opt.on_empty do
+            lines = text.with_line_numbers history.join("\n"), 0
+            stagger_output lines
+          end
+        end
+      end
 
     end