pry 0.9.8.2 → 0.9.8.3

data/lib/pry/default_commands/help.rb

@@ -0,0 +1,127 @@
+class Pry
+  module DefaultCommands
+    Help = Pry::CommandSet.new do
+      create_command "help" do |cmd|
+        description "Show a list of commands. Type `help <foo>` for information about <foo>."
+
+        banner <<-BANNER
+          Usage: help [ COMMAND ]
+
+          With no arguments, help lists all the available commands in the current
+          command-set along with their description.
+
+          When given a command name as an argument, shows the help for that command.
+        BANNER
+
+        # We only want to show commands that have descriptions, so that the
+        # easter eggs don't show up.
+        def visible_commands
+          visible = {}
+          commands.each do |key, command|
+            visible[key] = command if command.description && !command.description.empty?
+          end
+          visible
+        end
+
+        # Get a hash of available commands grouped by the "group" name.
+        def command_groups
+          visible_commands.values.group_by(&:group)
+        end
+
+        def process
+          if args.empty?
+            display_index(command_groups)
+          else
+            display_search(args.first)
+          end
+        end
+
+        # Display the index view, with headings and short descriptions per command.
+        #
+        # @param Hash[String => Array[Commands]]
+        def display_index(groups)
+          help_text = []
+
+          groups.keys.sort_by(&method(:group_sort_key)).each do |key|
+            commands = groups[key].sort_by{ |command| command.options[:listing].to_s }
+
+            unless commands.empty?
+              help_text << "#{text.bold(key)}\n" + commands.map do |command|
+                "  #{command.options[:listing].to_s.ljust(18)} #{command.description}"
+              end.join("\n")
+            end
+          end
+
+          stagger_output(help_text.join("\n\n"))
+        end
+
+        # Display help for an individual command or group.
+        #
+        # @param String  The string to search for.
+        def display_search(search)
+          if command = command_set.find_command_for_help(search)
+            display_command(command)
+          else
+            groups = search_hash(search, command_groups)
+
+            if groups.size > 0
+              display_index(groups)
+              return
+            end
+
+            filtered = search_hash(search, visible_commands)
+            raise CommandError, "No help found for '#{args.first}'" if filtered.empty?
+
+            if filtered.size == 1
+              display_command(filtered.values.first)
+            else
+              display_index({"'#{search}' commands" => filtered.values})
+            end
+          end
+        end
+
+        # Display help for an individual command.
+        #
+        # @param [Pry::Command]
+        def display_command(command)
+          stagger_output command.new.help
+        end
+
+        # Find a subset of a hash that matches the user's search term.
+        #
+        # If there's an exact match a Hash of one element will be returned,
+        # otherwise a sub-Hash with every key that matches the search will
+        # be returned.
+        #
+        # @param [String]  the search term
+        # @param [Hash]  the hash to search
+        def search_hash(search, hash)
+          matching = {}
+
+          hash.each_pair do |key, value|
+            next unless key.is_a?(String)
+            if normalize(key) == normalize(search)
+              return {key => value}
+            elsif normalize(key).start_with?(normalize(search))
+              matching[key] = value
+            end
+          end
+
+          matching
+        end
+
+        # Clean search terms to make it easier to search group names
+        #
+        # @param String
+        # @return String
+        def normalize(key)
+          key.downcase.gsub(/pry\W+/, '')
+        end
+
+        def group_sort_key(group_name)
+          [%w(Help Context Editing Introspection Input_and_output Navigating_pry Gems Basic Commands).index(group_name.gsub(' ', '_')) || 99, group_name]
+        end
+      end
+    end
+  end
+end

data/lib/pry/default_commands/hist.rb

@@ -0,0 +1,116 @@
+class Pry
+  module DefaultCommands
+    Hist = Pry::CommandSet.new do
+
+      create_command "hist", "Show and replay Readline history. Aliases: history" do
+        group "Editing"
+        banner <<-USAGE
+          Usage: hist
+                 hist --head N
+                 hist --tail N
+                 hist --show START..END
+                 hist --grep PATTERN
+                 hist --clear
+                 hist --replay START..END
+                 hist --save [START..END] FILE
+        USAGE
+
+        def options(opt)
+          opt.on :H, :head, "Display the first N items.", :optional => true, :as => Integer
+          opt.on :T, :tail, "Display the last N items.", :optional => true, :as => Integer
+          opt.on :s, :show, "Show the given range of lines.", :optional => true, :as => Range
+          opt.on :G, :grep, "Show lines matching the given pattern.", true, :as => String
+          opt.on :c, :clear, "Clear the current session's history."
+          opt.on :r, :replay, "Replay a line or range of lines.", true, :as => Range
+          opt.on     :save, "Save history to a file.", true, :as => Range
+
+          opt.on :e, :'exclude-pry', "Exclude Pry commands from the history."
+          opt.on :n, :'no-numbers', "Omit line numbers."
+          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+        end
+
+        def process
+          @history = Pry::Code(Pry.history.to_a)
+
+          @history = case
+            when opts.present?(:head)
+              @history.between(1, opts[:head] || 10)
+            when opts.present?(:tail)
+              @history.between(-(opts[:tail] || 10), -1)
+            when opts.present?(:show)
+              @history.between(opts[:show])
+            else
+              @history
+            end
+
+          if opts.present?(:grep)
+            @history = @history.grep(opts[:grep])
+          end
+
+          if opts.present?(:'exclude-pry')
+            @history = @history.select { |l, ln| !command_set.valid_command?(l) }
+          end
+
+          if opts.present?(:save)
+            process_save
+          elsif opts.present?(:clear)
+            process_clear
+          elsif opts.present?(:replay)
+            process_replay
+          else
+            process_display
+          end
+        end
+
+        def process_display
+          unless opts.present?(:'no-numbers')
+            @history = @history.with_line_numbers
+          end
+
+          render_output(@history, opts)
+        end
+
+        def process_save
+          case opts[:save]
+          when Range
+            @history = @history.between(opts[:save])
+
+            unless args.first
+              raise CommandError, "Must provide a file name."
+            end
+
+            file_name = File.expand_path(args.first)
+          when String
+            file_name = File.expand_path(opts[:save])
+          end
+
+          output.puts "Saving history in #{file_name}..."
+
+          File.open(file_name, 'w') { |f| f.write(@history.to_s) }
+
+          output.puts "History saved."
+        end
+
+        def process_clear
+          Pry.history.clear
+          output.puts "History cleared."
+        end
+
+        def process_replay
+          @history = @history.between(opts[:r])
+
+          _pry_.input_stack.push _pry_.input
+          _pry_.input = StringIO.new(@history.raw)
+          # eval_string << "#{@history.raw}\n"
+          # run "show-input" unless _pry_.complete_expression?(eval_string)
+        end
+      end
+
+      alias_command "history", "hist"
+
+
+
+
+    end
+  end
+end

data/lib/pry/default_commands/{shell.rb → input_and_output.rb}

@@ -1,9 +1,10 @@
+require 'tempfile'
+
 class Pry
   module DefaultCommands
 
-    Shell = Pry::CommandSet.new do
-
-      command(/\.(.*)/, "All text following a '.' is forwarded to the shell.", :listing => ".<shell command>", :use_prefix => false) do |cmd|
+    InputAndOutput = Pry::CommandSet.new do
+      command(/\.(.*)/, "All text following a '.' is forwarded to the shell.", :listing => ".<shell command>", :use_prefix => false, :takes_block => true) do |cmd|
         if cmd =~ /^cd\s+(.+)/i
           dest = $1
           begin
@@ -12,7 +13,13 @@ class Pry
             raise CommandError, "No such directory: #{dest}"
           end
         else
-          Pry.config.system.call(output, cmd, _pry_)
+          pass_block(cmd)
+
+          if command_block
+            command_block.call `#{cmd}`
+          else
+            Pry.config.system.call(output, cmd, _pry_)
+          end
         end
       end
 
@@ -30,6 +37,122 @@ class Pry
       end
       alias_command "file-mode", "shell-mode"
 
+      create_command "gist", "Gist a method or expression history to github.", :requires_gem => "gist", :shellwords => false do
+        banner <<-USAGE
+          Usage: gist [OPTIONS] [METH]
+          Gist method (doc or source) or input expression 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
+          e.g: gist -i 1..10
+          e.g: gist -c show-method
+          e.g: gist -m hello_world --lines 2..-2
+        USAGE
+
+        attr_accessor :content
+        attr_accessor :code_type
+
+        def setup
+          require 'gist'
+          self.content   = ""
+          self.code_type = :ruby
+        end
+
+        def options(opt)
+          opt.on :m, :method, "Gist a method's source.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            self.content << meth.source
+            self.code_type = meth.source_type
+          end
+          opt.on :d, :doc, "Gist a method's documentation.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            text.no_color do
+              self.content << process_comment_markup(meth.doc, self.code_type)
+            end
+            self.code_type = :plain
+          end
+          opt.on :c, :command, "Gist a command's source.", true do |command_name|
+            command = find_command(command_name)
+            block = Pry::Method.new(find_command(command_name).block)
+            self.content << block.source
+          end
+          opt.on :f, :file, "Gist a file.", true do |file|
+            self.content << File.read(File.expand_path(file))
+          end
+          opt.on :p, :public, "Create a public gist (default: false)", :default => false
+          opt.on :l, :lines, "Only gist a subset of lines.", :optional => true, :as => Range, :default => 1..-1
+          opt.on :i, :in, "Gist entries from Pry's input expression history. Takes an index or range.", :optional => true,
+          :as => Range, :default => -5..-1 do |range|
+            range = convert_to_range(range)
+            input_expressions = _pry_.input_array[range] || []
+            Array(input_expressions).each_with_index do |code, index|
+              corrected_index = index + range.first
+              if code && code != ""
+                self.content << code
+                if code !~ /;\Z/
+                  self.content << "#{comment_expression_result_for_gist(Pry.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}"
+                end
+              end
+            end
+          end
+        end
+
+        def process
+          perform_gist
+        end
+
+        def perform_gist
+          type_map = { :ruby => "rb", :c => "c", :plain => "plain" }
+
+          if self.content =~ /\A\s*\z/
+            raise CommandError, "Found no code to gist."
+          end
+
+          # prevent Gist from exiting the session on error
+          begin
+            extname = opts.present?(:file) ? ".#{gist_file_extension(opts[:f])}" : ".#{type_map[self.code_type]}"
+
+            if opts.present?(:lines)
+              self.content = restrict_to_lines(content, opts[:l])
+            end
+
+            link = Gist.write([:extension => extname,
+                               :input => self.content],
+                              !opts[:p])
+          rescue SystemExit
+          end
+
+          if link
+            Gist.copy(link)
+            output.puts "Gist created at #{link} and added to clipboard."
+          end
+        end
+
+        def gist_file_extension(file_name)
+          file_name.split(".").last
+        end
+
+        def convert_to_range(n)
+          if !n.is_a?(Range)
+            (n..n)
+          else
+            n
+          end
+        end
+
+        def comment_expression_result_for_gist(result)
+          content = ""
+          result.lines.each_with_index do |line, index|
+            if index == 0
+              content << "# => #{line}"
+            else
+              content << "#    #{line}"
+            end
+          end
+          content
+        end
+      end
+
       create_command "save-file", "Export to a file using content from the REPL."  do
         banner <<-USAGE
           Usage: save-file [OPTIONS] [FILE]
@@ -130,13 +253,13 @@ class Pry
 
         def process
           handler = case
-            when opts.present?(:ex)
-              method :process_ex
-            when opts.present?(:in)
-              method :process_in
-            else
-              method :process_file
-            end
+                    when opts.present?(:ex)
+                      method :process_ex
+                    when opts.present?(:in)
+                      method :process_in
+                    else
+                      method :process_file
+                    end
 
           output = handler.call do |code|
             code.code_type = opts[:type] || :ruby
@@ -183,8 +306,8 @@ class Pry
           HEADER
 
           code = yield(Pry::Code.from_file(ex_file).
-                         between(start_line, end_line).
-                         with_marker(ex_line))
+                       between(start_line, end_line).
+                       with_marker(ex_line))
 
           "#{header}#{code}"
         end
@@ -233,8 +356,7 @@ class Pry
           code
         end
       end
-    end
 
+    end
   end
 end
-

data/lib/pry/default_commands/introspection.rb

@@ -5,8 +5,80 @@ class Pry
 
     Introspection = Pry::CommandSet.new do
 
+      create_command "show-doc", "Show the comments above METH. Aliases: \?", :shellwords => false do |*args|
+        banner <<-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
+        BANNER
+
+        def options(opt)
+          method_options(opt)
+          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 :f, :flood, "Do not use a pager to view text longer than one screen."
+        end
+
+        def process
+          meth = method_object
+          raise Pry::CommandError, "No documentation found." if meth.doc.nil? || meth.doc.empty?
+
+          doc = process_comment_markup(meth.doc, meth.source_type)
+          output.puts make_header(meth, doc)
+          output.puts "#{text.bold("Owner:")} #{meth.owner || "N/A"}"
+          output.puts "#{text.bold("Visibility:")} #{meth.visibility}"
+          output.puts "#{text.bold("Signature:")} #{meth.signature}"
+          output.puts
+
+          if opts.present?(:b) || opts.present?(:l)
+            doc = Code.new(doc, start_line, :text).
+              with_line_numbers(true)
+          end
+
+          render_output(doc, opts)
+        end
+
+        def start_line
+          if opts.present?(:'base-one')
+             1
+          else
+            (method_object.source_line - method_object.doc.lines.count) || 1
+          end
+        end
+
+      end
+
+      alias_command "?", "show-doc"
+
+      create_command "stat", "View method information and set _file_ and _dir_ locals.", :shellwords => false do |*args|
+        banner <<-BANNER
+            Usage: stat [OPTIONS] [METH]
+            Show method information for method METH and set _file_ and _dir_ locals.
+            e.g: stat hello_method
+        BANNER
+
+        def options(opt)
+          method_options(opt)
+        end
+
+        def process
+          meth = method_object
+          output.puts unindent <<-EOS
+            Method Information:
+            --
+            Name: #{meth.name}
+            Owner: #{meth.owner ? meth.owner : "Unknown"}
+            Visibility: #{meth.visibility}
+            Type: #{meth.is_a?(::Method) ? "Bound" : "Unbound"}
+            Arity: #{meth.arity}
+            Method Signature: #{meth.signature}
+            Source Location: #{meth.source_location ? meth.source_location.join(":") : "Not found."}
+          EOS
+        end
+      end
+
       create_command "show-method" do
-        description "Show the source for METH. Type `show-method --help` for more info. Aliases: $, show-source"
+        description "Show the source for METH. Aliases: $, show-source"
 
         banner <<-BANNER
           Usage: show-method [OPTIONS] [METH]
@@ -62,7 +134,7 @@ class Pry
       alias_command "show-source", "show-method"
       alias_command "$", "show-method"
 
-      command "show-command", "Show the source for CMD. Type `show-command --help` for more info." do |*args|
+      command "show-command", "Show the source for CMD." do |*args|
         target = target()
 
         opts = Slop.parse!(args) do |opt|
@@ -103,244 +175,19 @@ class Pry
         end
       end
 
-      create_command "edit" do
-        description "Invoke the default editor on a file. Type `edit --help` for more info"
-
+      create_command "ri", "View ri documentation. e.g `ri Array#each`" do
         banner <<-BANNER
-          Usage: edit [--no-reload|--reload] [--line LINE] [--temp|--ex|FILE[:LINE]|--in N]
-
-          Open a text editor. When no FILE is given, edits the pry input buffer.
-          Ensure Pry.config.editor is set to your editor of choice.
-
-          e.g: `edit sample.rb`
-          e.g: `edit sample.rb --line 105`
-          e.g: `edit --ex`
+          Usage: ri [spec]
+          e.g. ri Array#each
 
-          https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_command
+          Relies on the ri executable being available. See also: show-doc.
         BANNER
 
-        def options(opt)
-          opt.on :e, :ex, "Open the file that raised the most recent exception (_ex_.file)", :optional => true, :as => Integer
-          opt.on :i, :in, "Open a temporary file containing the Nth line of _in_. N may be a range.", :optional => true, :as => Range, :default => -1..-1
-          opt.on :t, :temp, "Open an empty temporary file"
-          opt.on :l, :line, "Jump to this line in the opened file", true, :as => Integer
-          opt.on :n, :"no-reload", "Don't automatically reload the edited code"
-          opt.on :c, :"current", "Open the current __FILE__ and at __LINE__ (as returned by `whereami`)."
-          opt.on :r, :reload, "Reload the edited code immediately (default for ruby files)"
-        end
-
         def process
-          if [opts.present?(:ex), opts.present?(:temp), opts.present?(:in), !args.empty?].count(true) > 1
-            raise CommandError, "Only one of --ex, --temp, --in and FILE may be specified."
-          end
-
-          if !opts.present?(:ex) && !opts.present?(:current) && args.empty?
-            # edit of local code, eval'd within pry.
-            process_local_edit
-          else
-            # edit of remote code, eval'd at top-level
-            process_remote_edit
-          end
-        end
-
-        def process_i
-          case opts[:i]
-          when Range
-            (_pry_.input_array[opts[:i]] || []).join
-          when Fixnum
-            _pry_.input_array[opts[:i]] || ""
-          else
-            return output.puts "Not a valid range: #{opts[:i]}"
-          end
-        end
-
-        def process_local_edit
-          content = case
-            when opts.present?(:temp)
-              ""
-            when opts.present?(:in)
-              process_i
-            when eval_string.strip != ""
-              eval_string
-            else
-              _pry_.input_array.reverse_each.find{ |x| x && x.strip != "" } || ""
-          end
-
-          line = content.lines.count
-
-          temp_file do |f|
-            f.puts(content)
-            f.flush
-            invoke_editor(f.path, line)
-            if !opts.present?(:'no-reload') && !Pry.config.disable_auto_reload
-              silence_warnings do
-                eval_string.replace(File.read(f.path))
-              end
-            end
-          end
-        end
-
-        def process_remote_edit
-          if opts.present?(:ex)
-            if _pry_.last_exception.nil?
-              raise CommandError, "No exception found."
-            end
-
-            ex = _pry_.last_exception
-            bt_index = opts[:ex].to_i
-
-            ex_file, ex_line = ex.bt_source_location_for(bt_index)
-            if ex_file && RbxPath.is_core_path?(ex_file)
-              file_name = RbxPath.convert_path_to_full(ex_file)
-            else
-              file_name = ex_file
-            end
-
-            line = ex_line
-
-            if file_name.nil?
-              raise CommandError, "Exception has no associated file."
-            end
-
-            if Pry.eval_path == file_name
-              raise CommandError, "Cannot edit exceptions raised in REPL."
-            end
-          elsif opts.present?(:current)
-            file_name = target.eval("__FILE__")
-            line = target.eval("__LINE__")
-          else
-
-            # break up into file:line
-            file_name = File.expand_path(args.first)
-            line = file_name.sub!(/:(\d+)$/, "") ? $1.to_i : 1
-          end
-
-          if not_a_real_file?(file_name)
-            raise CommandError, "#{file_name} is not a valid file name, cannot edit!"
-          end
-
-          line = opts[:l].to_i if opts.present?(:line)
-
-          invoke_editor(file_name, line)
-          set_file_and_dir_locals(file_name)
-
-          if opts.present?(:reload) || ((opts.present?(:ex) || file_name.end_with?(".rb")) && !opts.present?(:'no-reload')) && !Pry.config.disable_auto_reload
-            silence_warnings do
-              TOPLEVEL_BINDING.eval(File.read(file_name), file_name)
-            end
-          end
+          run ".ri", *args
         end
       end
 
-      create_command "edit-method" do
-        description "Edit a method. Type `edit-method --help` for more info."
-
-        banner <<-BANNER
-          Usage: edit-method [OPTIONS] [METH]
-
-          Edit the method METH in an editor.
-          Ensure Pry.config.editor is set to your editor of choice.
-
-          e.g: `edit-method hello_method`
-          e.g: `edit-method Pry#rep`
-          e.g: `edit-method`
-
-          https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_method
-        BANNER
-
-        command_options :shellwords => false
-
-        def options(opt)
-          method_options(opt)
-          opt.on :n, "no-reload", "Do not automatically reload the method's file after editing."
-          opt.on "no-jump", "Do not fast forward editor to first line of method."
-          opt.on :p, :patch, "Instead of editing the method's file, try to edit in a tempfile and apply as a monkey patch."
-        end
-
-        def process
-          if !Pry.config.editor
-            raise CommandError, "No editor set!\nEnsure that #{text.bold("Pry.config.editor")} is set to your editor of choice."
-          end
-
-          begin
-            @method = method_object
-          rescue NonMethodContextError => err
-          end
-
-          if opts.present?(:patch) || (@method && @method.dynamically_defined?)
-            if err
-              raise err # can't patch a non-method
-            end
-
-            process_patch
-          else
-            if err && !File.exist?(target.eval('__FILE__'))
-              raise err # can't edit a non-file
-            end
-
-            process_file
-          end
-        end
-
-        def process_patch
-          lines = @method.source.lines.to_a
-
-          if ((original_name = @method.original_name) &&
-              lines[0] =~ /^def (?:.*?\.)?#{original_name}(?=[\(\s;]|$)/)
-            lines[0] = "def #{original_name}#{$'}"
-          else
-            raise CommandError, "Pry can only patch methods created with the `def` keyword."
-          end
-
-          temp_file do |f|
-            f.puts lines.join
-            f.flush
-            invoke_editor(f.path, 0)
-
-            if @method.alias?
-              with_method_transaction(original_name, @method.owner) do
-                Pry.new(:input => StringIO.new(File.read(f.path))).rep(@method.owner)
-                Pry.binding_for(@method.owner).eval("alias #{@method.name} #{original_name}")
-              end
-            else
-              Pry.new(:input => StringIO.new(File.read(f.path))).rep(@method.owner)
-            end
-          end
-        end
-
-        def process_file
-          file, line = extract_file_and_line
-
-          invoke_editor(file, opts["no-jump"] ? 0 : line)
-          silence_warnings do
-            load file unless opts.present?(:'no-reload') || Pry.config.disable_auto_reload
-          end
-        end
-
-        protected
-          def extract_file_and_line
-            if @method
-              if @method.source_type == :c
-                raise CommandError, "Can't edit a C method."
-              else
-                [@method.source_file, @method.source_line]
-              end
-            else
-              [target.eval('__FILE__'), target.eval('__LINE__')]
-            end
-          end
-
-          def with_method_transaction(meth_name, target=TOPLEVEL_BINDING)
-            target = Pry.binding_for(target)
-            temp_name = "__pry_#{meth_name}__"
-
-            target.eval("alias #{temp_name} #{meth_name}")
-            yield
-            target.eval("alias #{meth_name} #{temp_name}")
-          ensure
-            target.eval("undef #{temp_name}") rescue nil
-          end
-      end
     end
   end
 end