pry 0.7.7.2-i386-mingw32 → 0.8.0-i386-mingw32

data/lib/pry/commands.rb

@@ -1,122 +1,207 @@
+direc = File.dirname(__FILE__)
+
 require "optparse"
 require "method_source"
-require "pry/command_base"
-require "pry/pry_instance"
-
-begin
-
-  # YARD crashes on rbx, so do not require it 
-  if !Object.const_defined?(:RUBY_ENGINE) || RUBY_ENGINE !~ /rbx/
-    require "pry-doc"
-  end
-rescue LoadError
-end
+require 'slop'
+require 'rubygems/dependency_installer'
+require "#{direc}/command_base"
+require "#{direc}/pry_instance"
+require "#{direc}/command_helpers"
 
 class Pry
 
   # Default commands used by Pry.
   class Commands < CommandBase
+    extend CommandHelpers
 
-    # We make this a lambda to avoid documenting it
-    meth_name_from_binding = lambda do |b|
-      meth_name = b.eval('__method__')
+    try_to_load_pry_doc
 
-      # :__script__ for rubinius
-      if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
-        nil
-      else
-        meth_name
-      end
+    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
     end
 
-    check_for_dynamically_defined_method = lambda do |meth|
-      file, _ = meth.source_location
-      if file =~ /(\(.*\))|<.*>/
-        raise "Cannot retrieve source for dynamically defined method."
-      end
+    command "!pry", "Start a Pry session on current self; this even works mid-expression." do
+      Pry.start(target)
     end
 
-    remove_first_word = lambda do |text|
-      text.split.drop(1).join(' ')
+    # this cannot be accessed, it's just for help purposes.
+    command ".<shell command>", "All text following a '.' is forwarded to the shell." do
     end
 
-    get_method_object = lambda do |meth_name, target, options|
-      if !meth_name
-        return nil
+    command "hist", "Show and replay Readline history. Type `hist --help` for more info." do |*args|
+      hist_array = Readline::HISTORY.to_a
+
+      if args.empty?
+        text = add_line_numbers(hist_array.join("\n"), 0)
+        stagger_output(text)
+        next
       end
 
-      if options[:M]
-        target.eval("instance_method(:#{meth_name})")
-      elsif options[:m]
-        target.eval("method(:#{meth_name})")
-      else
-        begin
-          target.eval("instance_method(:#{meth_name})")
-        rescue
-          begin
-            target.eval("method(:#{meth_name})")
-          rescue
-            return nil
-          end
+      opts = Slop.parse(args) do |opt|
+        opt.banner "Usage: hist [--replay START..END]\nView and replay history\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
         end
       end
-    end
 
-    make_header = lambda do |meth, code_type|
-      file, line = meth.source_location
-      header = case code_type
-               when :ruby
-                 "--\nFrom #{file} @ line #{line}:\n--"
-               else
-                 "--\nFrom Ruby Core (C Method):\n--"
-               end
-    end
+      next if opts.h?
 
-    is_a_c_method = lambda do |meth|
-      meth.source_location.nil?
+      actions = Array(hist_array[opts[:replay]]).join("\n") + "\n"
+      Pry.active_instance.input = StringIO.new(actions)
     end
 
-    should_use_pry_doc = lambda do |meth|
-      Pry.has_pry_doc && is_a_c_method.call(meth)
+    command "exit-program", "End the current program. Aliases: quit-program, !!!" do
+      exit
     end
-    
-    code_type_for = lambda do |meth|
-      # only C methods
-      if should_use_pry_doc.call(meth)
-        info = Pry::MethodInfo.info_for(meth) 
-        if info && info.source
-          code_type = :c
-        else
-          output.puts "Cannot find C method: #{meth.name}"
-          code_type = nil
-        end
-      else
-        if is_a_c_method.call(meth)
-          output.puts "Cannot locate this method: #{meth.name}. Try `gem install pry-doc` to get access to Ruby Core documentation."
-          code_type = nil
+
+    alias_command "quit-program", "exit-program", ""
+    alias_command "!!!", "exit-program", ""
+
+    command "gem-install", "Install a gem" do |gem_name|
+      gem_home = Gem.instance_variable_get(:@gem_home)
+      output.puts "Attempting to install gem: #{bold(gem_name)}"
+
+      begin
+        if File.writable?(gem_home)
+          Gem::DependencyInstaller.new.install(gem_name)
+          output.puts "Gem #{bold(gem_name)} successfully installed."
         else
-          check_for_dynamically_defined_method.call(meth)
-          code_type = :ruby
+          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
+      rescue Gem::GemNotFoundException
+        output.puts "Required Gem: #{bold(gem_name)} not found."
+        next
       end
-      code_type
+
+      Gem.refresh
+      output.puts "Refreshed gem cache."
     end
 
-    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
+    command "ri", "View ri documentation. e.g `ri Array#each`" do |*args|
+      run ".ri", *args
     end
 
-    command "!pry", "Start a Pry session on current self; this even works mid-expression." do
-      Pry.start(target)
+    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|
+          target = Pry.binding_for(target.eval(context))
+        end
+        opts.on :h, :help, "This message" do
+          output.puts opts
+        end
+      end
+
+      next if opts.help?
+
+      meth_name = args.shift
+      if meth_name
+        if meth_name =~ /\A([^\.\#]+)[\.\#](.+)\z/ && !opts.context?
+          context, meth_name = $1, $2
+          target = Pry.binding_for(target.eval(context))
+        end
+      else
+        meth_name = meth_name_from_binding(target)
+      end
+      
+      if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+        output.puts "Invalid method name: #{meth_name}. Type `stat --help` for help"
+        next
+      end
+
+      code, code_type = code_and_code_type_for(meth)
+      next if !code
+      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
+
+      name_map = { :req => "Required:", :opt => "Optional:", :rest => "Rest:" }
+      if meth.respond_to?(:parameters)
+        output.puts 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.'))
     end
 
-    command "exit-program", "End the current program. Aliases: quit-program, !!!" do
-      exit
+    command "gist-method", "Gist a method to github. Type `gist-method --help` for more info.", :requires_gem => "gist" do |*args|
+      target = target()
+      
+      opts = Slop.parse!(args) do |opts|
+        opts.banner = %{Usage: gist-method [OPTIONS] [METH]
+Gist the method (doc or source) to github.
+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
+        end
+      end
+
+      next if opts.help?
+
+      # This needs to be extracted into its own method as it's shared
+      # by show-method and show-doc and stat commands 
+      meth_name = args.shift
+      if meth_name
+        if meth_name =~ /\A([^\.\#]+)[\.\#](.+)\z/ 
+          context, meth_name = $1, $2
+          target = Pry.binding_for(target.eval(context))
+        end
+      else
+        meth_name = meth_name_from_binding(target)
+      end
+      
+      if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+        output.puts "Invalid method name: #{meth_name}. Type `gist-method --help` for help"
+        next
+      end
+
+      type_map = { :ruby => "rb", :c => "c", :plain => "plain" }
+      if !opts.doc?
+        content, code_type = code_and_code_type_for(meth)
+      else
+        content, code_type = doc_and_code_type_for(meth)
+        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
     end
 
-    alias_command "quit-program", "exit-program", ""
-    alias_command "!!!", "exit-program", ""
+    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))
+    end
 
     command "toggle-color", "Toggle syntax highlighting." do
       Pry.color = !Pry.color
@@ -132,9 +217,24 @@ class Pry
       end
     end
 
-    command "nesting", "Show nesting information." do 
+    command "shell-mode", "Toggle shell mode. Bring in pwd prompt and file completion." do
+      case Pry.active_instance.prompt
+      when Pry::SHELL_PROMPT
+        Pry.active_instance.prompt = Pry::DEFAULT_PROMPT
+        Pry.active_instance.custom_completions = Pry::DEFAULT_CUSTOM_COMPLETIONS
+      else
+        Pry.active_instance.prompt = Pry::SHELL_PROMPT
+        Pry.active_instance.custom_completions = Pry::FILE_COMPLETIONS
+        Readline.completion_proc = Pry::InputCompleter.build_completion_proc target,
+        Pry.active_instance.instance_eval(&Pry::FILE_COMPLETIONS)
+      end
+    end
+
+    alias_command "file-mode", "shell-mode", ""
+
+    command "nesting", "Show nesting information." do
       nesting = opts[:nesting]
-      
+
       output.puts "Nesting status:"
       output.puts "--"
       nesting.each do |level, obj|
@@ -148,7 +248,7 @@ class Pry
 
     command "status", "Show status information." do
       nesting = opts[:nesting]
-      
+
       output.puts "Status:"
       output.puts "--"
       output.puts "Receiver: #{Pry.view_clip(target.eval('self'))}"
@@ -156,13 +256,59 @@ class Pry
       output.puts "Pry version: #{Pry::VERSION}"
       output.puts "Ruby version: #{RUBY_VERSION}"
 
-      mn = meth_name_from_binding.call(target)
+      mn = meth_name_from_binding(target)
       output.puts "Current method: #{mn ? mn : "N/A"}"
       output.puts "Pry instance: #{Pry.active_instance}"
       output.puts "Last result: #{Pry.view(Pry.last_result)}"
     end
 
-    command "whereami", "Show the code context for the session. Shows AROUND lines around the invocation line. AROUND defaults to 5 lines. " do |num|
+
+    command "req", "Requires gem(s). No need for quotes! (If the gem isn't installed, it will ask if you want to install it.)" do |*gems|
+      gems = gems.join(' ').gsub(',', '').split(/\s+/)
+      gems.each do |gem|
+        begin
+          if require gem
+            output.puts "#{bright_yellow(gem)} loaded"
+          else
+            output.puts "#{bright_white(gem)} already loaded"
+          end
+
+        rescue LoadError => e
+
+          if gem_installed? gem
+            output.puts e.inspect
+          else
+            output.puts "#{bright_red(gem)} not found"
+            if prompt("Install the gem?") == "y"
+              run "gem-install", gem
+            end
+          end
+
+        end # rescue
+      end # gems.each
+    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)
+      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__')
       klass = target.eval('self.class')
@@ -172,17 +318,18 @@ class Pry
       else
         i_num = 5
       end
-      
-      meth_name = meth_name_from_binding.call(target)
+
+      meth_name = meth_name_from_binding(target)
       meth_name = "N/A" if !meth_name
 
-      if file =~ /(\(.*\))|<.*>/ || file == ""
+      if file =~ /(\(.*\))|<.*>/ || file == "" || file == "-e"
         output.puts "Cannot find local context. Did you use `binding.pry` ?"
         next
       end
-     
-      output.puts "--\nFrom #{file} @ line #{line_num} in #{klass}##{meth_name}:\n--"
-      
+
+      set_file_and_dir_locals(file)
+      output.puts "\n#{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|
         line_n = index + 1
@@ -205,25 +352,24 @@ class Pry
         end
       end
     end
-    
+
     command "version", "Show Pry version." do
       output.puts "Pry version: #{Pry::VERSION} on Ruby #{RUBY_VERSION}."
     end
-    
-    command "exit-all", "End all nested Pry sessions. Accepts optional return value. Aliases: !@" do 
-      str = remove_first_word.call(opts[:val])
+
+    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)])
     end
 
-    alias_command "!@", "exit-all", ""
+    alias_command "!!@", "exit-all", ""
 
-    command "ls", "Show the list of vars in the current scope. Type `ls --help` for more info." do |*args|
+    command "ls", "Show the list of vars and methods in the current scope. Type `ls --help` for more info." do |*args|
       options = {}
-      
       # Set target local to the default -- note that we can set a different target for
       # ls if we like: e.g ls my_var
       target = target()
-      
+
       OptionParser.new do |opts|
         opts.banner = %{Usage: ls [OPTIONS] [VAR]\n\
 List information about VAR (the current context by default).
@@ -233,7 +379,7 @@ Shows local and instance variables by default.
         opts.on("-g", "--globals", "Display global variables.") do
           options[:g] = true
         end
-        
+
         opts.on("-c", "--constants", "Display constants.") do
           options[:c] = true
         end
@@ -242,15 +388,15 @@ Shows local and instance variables by default.
           options[:l] = true
         end
 
-        opts.on("-i", "--ivars", "Display instance variables.") do 
+        opts.on("-i", "--ivars", "Display instance variables.") do
           options[:i] = true
         end
 
-        opts.on("-k", "--class-vars", "Display class variables.") do 
+        opts.on("-k", "--class-vars", "Display class variables.") do
           options[:k] = true
-        end        
+        end
 
-        opts.on("-m", "--methods", "Display methods (public methods by default).") do 
+        opts.on("-m", "--methods", "Display methods (public methods by default).") do
           options[:m] = true
         end
 
@@ -258,34 +404,42 @@ Shows local and instance variables by default.
           options[:M] = true
         end
 
-        opts.on("-P", "--public", "Display public methods (with -m).") do 
+        opts.on("-P", "--public", "Display public methods (with -m).") do
           options[:P] = true
         end
 
-        opts.on("-r", "--protected", "Display protected methods (with -m).") do 
+        opts.on("-r", "--protected", "Display protected methods (with -m).") do
           options[:r] = true
-        end        
+        end
 
-        opts.on("-p", "--private", "Display private methods (with -m).") do 
+        opts.on("-p", "--private", "Display private methods (with -m).") do
           options[:p] = true
         end
 
-        opts.on("-j", "--just-singletons", "Display just the singleton methods (with -m).") do 
+        opts.on("-j", "--just-singletons", "Display just the singleton methods (with -m).") do
           options[:j] = true
-        end        
+        end
 
-        opts.on("-s", "--super", "Include superclass entries (relevant to constant and methods options).") do 
+        opts.on("-s", "--super", "Include superclass entries (relevant to constant and methods options).") do
           options[:s] = true
         end
-        
+
         opts.on("-a", "--all", "Display all types of entries.") do
           options[:a] = true
         end
 
-        opts.on("-v", "--verbose", "Verbose ouput.") do 
+        opts.on("-v", "--verbose", "Verbose ouput.") do
           options[:v] = true
         end
 
+        opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
+          options[:f] = true
+        end
+
+        opts.on("--grep REG", "Regular expression to be used.") do |reg|
+          options[:grep] = Regexp.new(reg)
+        end
+
         opts.on_tail("-h", "--help", "Show this message.") do
           output.puts opts
           options[:h] = true
@@ -303,18 +457,21 @@ Shows local and instance variables by default.
                        :l => true,
                        :i => true,
                        :k => true
-                     }) if options.empty? || (options.size == 1 && options[:v])
+                     }) if options.empty? || (options.size == 1 && options[:v]) || (options.size == 1 && options[:grep])
+
+      options[:grep] = // if !options[:grep]
+
 
       # Display public methods by default if -m or -M switch is used.
       options[:P] = true if (options[:m] || options[:M]) && !(options[:p] || options[:r] || options[:j])
-      
+
       info = {}
       target_self = target.eval('self')
 
       # ensure we have a real boolean and not a `nil` (important when
       # interpolating in the string)
       options[:s] = !!options[:s]
-      
+
       # Numbers (e.g 0, 1, 2) are for ordering the hash values in Ruby 1.8
       i = -1
 
@@ -329,7 +486,7 @@ Shows local and instance variables by default.
                                  end, i += 1] if options[:k] || options[:a]
 
       info["global variables"] = [Array(target.eval("global_variables")).sort, i += 1] if options[:g] || options[:a]
-      
+
       info["public methods"] = [Array(target.eval("public_methods(#{options[:s]})")).uniq.sort, i += 1] if (options[:m] && options[:P]) || options[:a]
 
       info["protected methods"] = [Array(target.eval("protected_methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:r]) || options[:a]
@@ -337,59 +494,132 @@ Shows local and instance variables by default.
       info["private methods"] = [Array(target.eval("private_methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:p]) || options[:a]
 
       info["just singleton methods"] = [Array(target.eval("methods(#{options[:s]})")).sort, i += 1] if (options[:m] && options[:j]) || options[:a]
-      
+
       info["public instance methods"] = [Array(target.eval("public_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:P]) || options[:a])
 
       info["protected instance methods"] = [Array(target.eval("protected_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:r]) || options[:a])
 
       info["private instance methods"] = [Array(target.eval("private_instance_methods(#{options[:s]})")).uniq.sort, i += 1] if target_self.is_a?(Module) && ((options[:M] && options[:p]) || options[:a])
-      
+
       # dealing with 1.8/1.9 compatibility issues :/
       csuper = options[:s]
       if Module.method(:constants).arity == 0
         csuper = nil
       end
-      
+
       info["constants"] = [Array(target_self.is_a?(Module) ? target.eval("constants(#{csuper})") :
                                  target.eval("self.class.constants(#{csuper})")).uniq.sort, i += 1] if options[:c] || options[:a]
 
+      text = ""
+
       # verbose output?
       if options[:v]
-
         # verbose
+
         info.sort_by { |k, v| v.last }.each do |k, v|
           if !v.first.empty?
-            output.puts "#{k}:\n--"
+            text <<  "#{k}:\n--\n"
+            filtered_list = v.first.grep options[:grep]
             if Pry.color
-              output.puts CodeRay.scan(Pry.view(v.first), :ruby).term
+              text << CodeRay.scan(Pry.view(filtered_list), :ruby).term + "\n"
             else
-              output.puts Pry.view(v.first)
+              text << Pry.view(filtered_list) + "\n"
             end
-            output.puts
+            text << "\n\n"
           end
         end
 
+        if !options[:f]
+          stagger_output(text)
+        else
+          output.puts text
+        end
+
       # plain
       else
         list = info.values.sort_by(&:last).map(&:first).inject(&:+)
+        list = list.grep(options[:grep]) if list
         list.uniq! if list
         if Pry.color
-          output.puts CodeRay.scan(Pry.view(list), :ruby).term
+          text << CodeRay.scan(Pry.view(list), :ruby).term + "\n"
+        else
+          text <<  Pry.view(list) + "\n"
+        end
+        if !options[:f]
+          stagger_output(text)
         else
-          output.puts Pry.view(list)
+          output.puts text
         end
         list
       end
     end
 
-    command "cat-file", "Show output of file FILE" do |file_name|
+    command "lls", "List local files using 'ls'" do |*args|
+      cmd = ".ls"
+      cmd << " --color=always" if Pry.color
+      run cmd, *args
+    end
+
+    command "lcd", "Change the current (working) directory" do |*args|
+      run ".cd", *args
+    end
+
+    command "cat", "Show output of file FILE. Type `cat --help` for more information." do |*args|
+      options= {}
+      file_name = nil
+      start_line = 0
+      end_line = -1
+      file_type = nil
+
+      OptionParser.new do |opts|
+        opts.banner = %{Usage: cat [OPTIONS] FILE
+Cat a file. Defaults to displaying whole file. Syntax highlights file if type is recognized.
+e.g: cat hello.rb
+--
+}
+        opts.on("-l", "--line-numbers", "Show line numbers.") do |line|
+          options[:l] = true
+        end
+
+        opts.on("-s", "--start LINE", "Start line (defaults to start of file). Line 1 is the first line.") do |line|
+          start_line = line.to_i - 1
+        end
+
+        opts.on("-e", "--end LINE", "End line (defaults to end of file). Line -1 is the last line.") do |line|
+          end_line = line.to_i - 1
+        end
+
+        opts.on("-t", "--type TYPE", "The specific file type for syntax higlighting (e.g ruby, python, cpp, java)") do |type|
+          file_type = type.to_sym
+        end
+
+        opts.on("-f", "--flood", "Do not use a pager to view text longer than one screen.") do
+          options[:f] = true
+        end
+
+        opts.on_tail("-h", "--help", "This message.") do
+          output.puts opts
+          options[:h] = true
+        end
+      end.order(args) do |v|
+        file_name = v
+      end
+
+      next if options[:h]
+
       if !file_name
         output.puts "Must provide a file name."
         next
       end
 
-      contents = File.read(File.expand_path(file_name))
-      output.puts contents
+      contents, normalized_start_line, _ = read_between_the_lines(file_name, start_line, end_line)
+
+      if Pry.color
+        contents = syntax_highlight_by_file_type_or_specified(contents, file_name, file_type)
+      end
+
+      set_file_and_dir_locals(file_name)
+      render_output(options[:f], options[:l] ? normalized_start_line + 1 : false, contents)
       contents
     end
 
@@ -397,7 +627,7 @@ Shows local and instance variables by default.
       options = {}
       target = target()
       file_name = nil
-      
+
       OptionParser.new do |opts|
         opts.banner = %{Usage: eval-file [OPTIONS] FILE
 Eval a Ruby script at top-level or in the specified context. Defaults to top-level.
@@ -409,7 +639,7 @@ e.g: eval-file -c self "hello.rb"
           target = Pry.binding_for(target.eval(context))
         end
 
-        opts.on_tail("-h", "--help", "This message.") do 
+        opts.on_tail("-h", "--help", "This message.") do
           output.puts opts
           options[:h] = true
         end
@@ -433,204 +663,193 @@ e.g: eval-file -c self "hello.rb"
         TOPLEVEL_BINDING.eval(File.read(File.expand_path(file_name)))
         output.puts "--\nEval'd '#{file_name}' at top-level."
       end
+      set_file_and_dir_locals(file_name)
+
       new_constants = Object.constants - old_constants
       output.puts "Brought in the following top-level constants: #{new_constants.inspect}" if !new_constants.empty?
-    end      
-
-    command "cat", "Show output of VAR.inspect. Aliases: inspect" do |obj|
-      if !obj
-        output.puts "Must provide an object to inspect."
-        next
-      end
-      
-      output.puts Pry.view(target.eval("#{obj}"))
     end
 
-    alias_command "inspect", "cat", ""
-    
     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
         output.puts "Must provide an object."
         next
       end
-      
+
       throw(:breakout, opts[:nesting].level) if obj == ".."
 
-      if obj == "/" 
+      if obj == "/"
         throw(:breakout, 1) if opts[:nesting].level > 0
         next
-      end    
-
-      target.eval("#{obj}").pry
-    end
-
-    process_comment_markup = lambda do |comment, code_type|
-      comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
-        gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { Pry.color ? "\e[32m#{$1}\e[0m": $1 }.
-        gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { Pry.color ? "\e[34m#{$1}\e[0m" : $1 }.
-        gsub(/\B\+(\w*?)\+\B/)  { Pry.color ? "\e[32m#{$1}\e[0m": $1 }.
-        gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
-        gsub(/`(?:\s*\n)?(.*?)\s*`/) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
-        gsub(/^@(param|return|example|option|yield|attr|attr_reader|attr_writer)/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
-    end
-
-    # strip leading whitespace but preserve indentation
-    strip_leading_whitespace = lambda do |text|
-      leading_spaces = text.lines.first[/^(\s+)/, 1]
-      text.gsub(/^#{leading_spaces}/, '')
-    end
+      end
 
-    strip_leading_hash_and_whitespace_from_ruby_comments = lambda do |comment|
-      comment = comment.dup
-      comment.gsub!(/^\s*#/, '')
-      strip_leading_whitespace.call(comment)
+      Pry.start target.eval("#{obj}")
     end
 
-    command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info." do |*args|
-      options = {}
+    command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. Aliases: \?" do |*args|
       target = target()
-      meth_name = nil
-      
-      OptionParser.new do |opts|
-        opts.banner = %{Usage: show-doc [OPTIONS] [METH]
+
+      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.") do 
-          options[:M] = true
-        end
-
-        opts.on("-m", "--methods", "Operate on methods.") do 
-          options[:m] = true
-        end
-
-        opts.on("-c", "--context CONTEXT", "Select object context to run under.") do |context|
+        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|
           target = Pry.binding_for(target.eval(context))
         end
-
-        opts.on_tail("-h", "--help", "This message.") do 
+        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
-          options[:h] = true
         end
-      end.order(args) do |v|
-        meth_name = v
       end
 
-      next if options[:h]
+      next if opts.help?
 
-      if (meth = get_method_object.call(meth_name, target, options)).nil?
-        output.puts "Invalid method name: #{meth_name}. Type `show-doc --help` for help"
-        next
+      meth_name = args.shift
+      if meth_name
+        if meth_name =~ /\A([^\.\#]+)[\.\#](.+)\z/ && !opts.context?
+          context, meth_name = $1, $2
+          target = Pry.binding_for(target.eval(context))
+        end
+      else
+        meth_name = meth_name_from_binding(target)
       end
 
-      case code_type = code_type_for.call(meth)
-      when nil
+      if (meth = get_method_object(meth_name, target, opts.to_hash(true))).nil?
+        output.puts "Invalid method name: #{meth_name}. Type `show-doc --help` for help"
         next
-      when :c
-        doc = Pry::MethodInfo.info_for(meth).docstring
-      when :ruby
-        doc = meth.comment
-        doc = strip_leading_hash_and_whitespace_from_ruby_comments.call(doc)
       end
 
-      doc = process_comment_markup.call(doc, code_type)
-      output.puts make_header.call(meth, code_type)
-      output.puts doc
+      doc, code_type = doc_and_code_type_for(meth)
+      next if !doc
+
+      next output.puts("No documentation found.") if doc.empty?
+
+      doc = process_comment_markup(doc, code_type)
+
+      output.puts make_header(meth, code_type, doc)
+
+      render_output(opts.flood?, false, doc)
       doc
     end
 
-    strip_comments_from_c_code = lambda do |code|
-      code.sub /\A\s*\/\*.*?\*\/\s*/m, ''
-    end
-    
-    command "show-method", "Show the source for METH. Type `show-method --help` for more info. Aliases: show-source" do |*args|
-      options = {}
+    alias_command "?", "show-doc", ""
+
+    command "show-method", "Show the source for METH. Type `show-method --help` for more info. Aliases: $, show-source" do |*args|
       target = target()
-      meth_name = nil
-      
-      OptionParser.new do |opts|
-        opts.banner = %{Usage: show-method [OPTIONS] [METH]
+
+      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("-M", "--instance-methods", "Operate on instance methods.") do 
-          options[:M] = true
-        end
-
-        opts.on("-m", "--methods", "Operate on methods.") do 
-          options[:m] = true
-        end
-
-        opts.on("-c", "--context CONTEXT", "Select object context to run under.") do |context|
+        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|
           target = Pry.binding_for(target.eval(context))
         end
-
-        opts.on_tail("-h", "--help", "This message.") do 
+        opts.on :h, :help, "This message." do
           output.puts opts
-          options[:h] = true
         end
-      end.order(args) do |v|
-        meth_name = v
       end
 
-      next if options[:h]
+      next if opts.help?
 
-      meth_name = meth_name_from_binding.call(target) if !meth_name
+      meth_name = args.shift
+      if meth_name
+        if meth_name =~ /\A([^\.\#]+)[\.\#](.+)\z/ && !opts.context?
+          context, meth_name = $1, $2
+          target = Pry.binding_for(target.eval(context))
+        end
+      else
+        meth_name = meth_name_from_binding(target)
+      end
 
-      if (meth = get_method_object.call(meth_name, target, options)).nil?
+      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
-    
-      case code_type = code_type_for.call(meth)
-      when nil
-        next
-      when :c
-        code = Pry::MethodInfo.info_for(meth).source
-        code = strip_comments_from_c_code.call(code)
-      when :ruby
-        code = strip_leading_whitespace.call(meth.source)
-      end
 
-      output.puts make_header.call(meth, code_type)
+      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 code
+
+      start_line = false
+      if opts.l?
+        start_line = meth.source_location ? meth.source_location.last : 1
+      end
+
+      render_output(opts.flood?, start_line, code)
       code
     end
 
     alias_command "show-source", "show-method", ""
-    
-    command "show-command", "Show sourcecode for a Pry command, e.g: show-command cd" do |command_name|
+    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.on_tail("-h", "--help", "This message.") do
+          output.puts opts
+          options[:h] = true
+        end
+      end.order(args) do |v|
+        command_name = v
+      end
+
+      next if options[:h]
+
       if !command_name
         output.puts "You must provide a command name."
         next
       end
-      
+
       if commands[command_name]
         meth = commands[command_name][:action]
 
-        code = strip_leading_whitespace.call(meth.source)
+        code = strip_leading_whitespace(meth.source)
         file, line = meth.source_location
-        check_for_dynamically_defined_method.call(meth)
+        set_file_and_dir_locals(file)
+        check_for_dynamically_defined_method(meth)
 
-        output.puts "--\nFrom #{file} @ line #{line}:\n--"
+        output.puts make_header(meth, :ruby, code)
 
         if Pry.color
           code = CodeRay.scan(code, :ruby).term
         end
 
-        output.puts code
+        render_output(options[:f], options[:l] ? meth.source_location.last : false, code)
         code
       else
         output.puts "No such command: #{command_name}."
       end
     end
-    
+
     command "jump-to", "Jump to a Pry session further up the stack, exiting all sessions below." do |break_level|
       break_level = break_level.to_i
       nesting = opts[:nesting]
@@ -646,8 +865,8 @@ e.g: show-method hello_method
       end
     end
 
-    command "exit", "End the current Pry session. Accepts optional return value. Aliases: quit, back" do 
-      str = remove_first_word.call(opts[:val])
+    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)])
     end
 
@@ -687,11 +906,11 @@ Is absorbed, not refracted, by grey stone.
 The dahlias sleep in the empty silence.
 Wait for the early owl.
 -- T.S Eliot
-}
+            }
       output.puts text
       text
     end
-    
+
     command "cohen-poem", "" do
       text = %{
 --
@@ -709,7 +928,7 @@ and so small between the thin pines
 on these enormous landscapes,
 that if you turn your head
 they are lost for hours.
--- Leonard Cohen                    
+-- Leonard Cohen
                 }
   output.puts text
   text