pry 0.9.7.4-i386-mingw32 → 0.9.8-i386-mingw32

data/lib/pry/commands.rb

@@ -7,7 +7,6 @@ require "pry/default_commands/shell"
 require "pry/default_commands/introspection"
 require "pry/default_commands/easter_eggs"
 
-require "pry/extended_commands/user_command_api"
 require "pry/extended_commands/experimental"
 
 class Pry

data/lib/pry/config.rb

@@ -33,8 +33,8 @@ class Pry
     attr_accessor :exception_whitelist
 
     # @return [Fixnum] The number of lines of context to show before and after
-    # the exception when using cat --ex.
-    attr_accessor :exception_window_size
+    #   exceptions, etc.
+    attr_accessor :default_window_size
 
     # Get/Set the Hash that defines Pry hooks used by default by all Pry
     # instances.
@@ -42,7 +42,19 @@ class Pry
     # @example
     #   Pry.hooks :before_session => proc { puts "hello" },
     #     :after_session => proc { puts "goodbye" }
-    attr_accessor :hooks
+    attr_reader :hooks
+
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    # @param [Pry::Hooks] v Only accept `Pry::Hooks` now!
+    def hooks=(v)
+      if v.is_a?(Hash)
+        warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+        @hooks = Pry::Hooks.from_hash(v)
+      else
+        @hooks = v
+      end
+    end
 
     # Get/Set the stack of input objects that a Pry instance switches
     # to when its current input object encounters EOF.
@@ -98,14 +110,20 @@ class Pry
     # @return [Boolean]
     attr_accessor :disable_auto_reload
 
+    # Determines whether Pry should trap SIGINT and cause it to raise an
+    # Interrupt exception. This is only useful on jruby, MRI does this
+    # for us.
+    # @return [Boolean]
+    attr_accessor :should_trap_interrupts
+
     # Config option for history.
-    # sub-options include hist.file, hist.load, and hist.save
-    # hist.file is the file to save/load history too, e.g
+    # sub-options include history.file, history.load, and history.save
+    # history.file is the file to save/load history to, e.g
     # Pry.config.history.file = "~/.pry_history".
-    # hist.should_load is a boolean that determines whether history will be
-    # loaded from hist.file at session start.
-    # hist.should_save is a boolean that determines whether history will be
-    # saved to hist.file at session end.
+    # history.should_load is a boolean that determines whether history will be
+    # loaded from history.file at session start.
+    # history.should_save is a boolean that determines whether history will be
+    # saved to history.file at session end.
     # @return [OpenStruct]
     attr_accessor :history
 
@@ -138,6 +156,22 @@ class Pry
     # @return [Boolean] Whether or not indentation should be corrected
     #   after hitting enter. This feature is not supported by all terminals.
     attr_accessor :correct_indent
+
+    # @return [Boolean] Whether or not a warning will be displayed when
+    #   a command name collides with a method/local in the current context.
+    attr_accessor :collision_warning
+
+
+    # Config option for gist.
+    # sub-options include `gist.inspecter`,
+    # `gist.inspecter` is a callable that defines how the expression output
+    # will be displayed when using the `gist -i` command.
+    # @example Pretty inspect output
+    #   Pry.config.gist.inspecter = proc { |v| v.pretty_inspect }
+    # @example Regular inspect
+    #   Pry.config.gist.inspecter = proc &:inspect
+    # @return [OpenStruct]
+    attr_accessor :gist
   end
 end
 

data/lib/pry/default_commands/context.rb

@@ -6,45 +6,56 @@ class Pry
     Context = Pry::CommandSet.new do
       import Ls
 
-      command "cd", "Move into a new context (use `cd ..` to go back and `cd /` to return to Pry top-level). Complex syntax (e.g cd ../@x/y) also supported."  do |obj|
-        path   = arg_string.split(/\//)
-        stack  = _pry_.binding_stack.dup
-
-        # special case when we only get a single "/", return to root
-        stack  = [stack.first] if path.empty?
-
-        resolve_failure = false
-        path.each do |context|
-          begin
-            case context.chomp
-            when ""
-              stack = [stack.first]
-            when "::"
-              stack.push(TOPLEVEL_BINDING)
-            when "."
-              next
-            when ".."
-              if stack.one?
-                _pry_.binding_stack.clear
-                throw(:breakout)
+      create_command "cd" do
+        description "Move into a new context (object or scope). Type `cd --help` for more information."
+
+        banner <<-BANNER
+          Usage: cd [OPTIONS] [--help]
+
+          Move into new context (object or scope). As in unix shells use
+          `cd ..` to go back and `cd /` to return to Pry top-level).
+          Complex syntax (e.g cd ../@x/y) also supported.
+
+          e.g: `cd @x`
+          e.g: `cd ..
+          e.g: `cd /`
+
+          https://github.com/pry/pry/wiki/State-navigation#wiki-Changing_scope
+        BANNER
+
+        def process
+          path   = arg_string.split(/\//)
+          stack  = _pry_.binding_stack.dup
+
+          # special case when we only get a single "/", return to root
+          stack  = [stack.first] if path.empty?
+
+          path.each do |context|
+            begin
+              case context.chomp
+              when ""
+                stack = [stack.first]
+              when "::"
+                stack.push(TOPLEVEL_BINDING)
+              when "."
+                next
+              when ".."
+                unless stack.size == 1
+                  stack.pop
+                end
               else
-                stack.pop
+                stack.push(Pry.binding_for(stack.last.eval(context)))
               end
-            else
-              stack.push(Pry.binding_for(stack.last.eval(context)))
-            end
 
-          rescue RescuableException => e
-            output.puts "Bad object path: #{arg_string.chomp}. Failed trying to resolve: #{context}"
-            output.puts e.inspect
-            resolve_failure = true
-            break
+            rescue RescuableException => e
+              output.puts "Bad object path: #{arg_string.chomp}. Failed trying to resolve: #{context}"
+              output.puts e.inspect
+              return
+            end
           end
-        end
 
-        next if resolve_failure
-
-        _pry_.binding_stack = stack
+          _pry_.binding_stack = stack
+        end
       end
 
       command "switch-to", "Start a new sub-session on a binding in the current stack (numbered by nesting)." do |selection|
@@ -95,21 +106,47 @@ class Pry
 
       alias_command "!!@", "exit-all"
 
-      command "exit", "Pop the current binding and return to the one immediately prior. Note this does NOT exit the program. Aliases: quit", :keep_retval => true do
-        if _pry_.binding_stack.one?
-          # when breaking out of top-level then behave like `exit-all`
+      create_command "exit" do
+        description "Pop the previous binding (does NOT exit program). Type `exit --help` for more information. Aliases: quit"
+
+        banner <<-BANNER
+          Usage:   exit [OPTIONS] [--help]
+          Aliases: quit
+
+          It can be useful to exit a context with a user-provided value. For
+          instance an exit value can be used to determine program flow.
+
+          e.g: `exit "pry this"`
+          e.g: `exit`
+
+          https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
+        BANNER
+
+        command_options(
+                        :keep_retval => true
+                        )
+
+        def process
+          if _pry_.binding_stack.one?
+            # when breaking out of top-level then behave like `exit-all`
+            process_exit_all
+          else
+            # otherwise just pop a binding and return user supplied value
+            process_pop_and_return
+          end
+        end
+
+        def process_exit_all
           _pry_.binding_stack.clear
           throw(:breakout, target.eval(arg_string))
-        else
-          # otherwise just pop a binding
+        end
+
+        def process_pop_and_return
           popped_object = _pry_.binding_stack.pop.eval('self')
 
-          # return a user-specified value if given
-          if !arg_string.empty?
-            target.eval(arg_string)
-          else
-            popped_object
-          end
+          # return a user-specified value if given otherwise return the object
+          return target.eval(arg_string) unless arg_string.empty?
+          popped_object
         end
       end
 
@@ -127,64 +164,44 @@ class Pry
         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|
-        file = target.eval('__FILE__')
-        line_num = target.eval('__LINE__')
-        klass = target.eval('self.class')
+      create_command "pry-backtrace", "Show the backtrace for the Pry session." do
+        banner <<-BANNER
+          Usage:   pry-backtrace [OPTIONS] [--help]
 
-        if num
-          i_num = num.to_i
-        else
-          i_num = 5
-        end
+          Show the backtrace for the position in the code where Pry was started. This can be used to
+          infer the behavior of the program immediately before it entered Pry, just like the backtrace
+          property of an exception.
 
-        if (meth = Pry::Method.from_binding(target))
-          meth_name = meth.name
-        else
-          meth_name = "N/A"
+          (NOTE: if you are looking for the backtrace of the most recent exception raised,
+          just type: `_ex_.backtrace` instead, see https://github.com/pry/pry/wiki/Special-Locals)
+
+          e.g: pry-backtrace
+        BANNER
+
+        def process
+          output.puts "\n#{text.bold('Backtrace:')}\n--\n"
+          stagger_output _pry_.backtrace.join("\n")
         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__')
+        i_num = num ? num.to_i : 5
 
         if file != Pry.eval_path && (file =~ /(\(.*\))|<.*>/ || file == "" || file == "-e")
           raise CommandError, "Cannot find local context. Did you use `binding.pry`?"
         end
 
         set_file_and_dir_locals(file)
-        output.puts "\n#{text.bold('From:')} #{file} @ line #{line_num} in #{klass}##{meth_name}:\n\n"
 
-        if file == Pry.eval_path
-          f = Pry.line_buffer[1..-1]
-        else
-          unless File.readable?(file)
-            raise CommandError, "Cannot open #{file.inspect} for reading."
-          end
-          f = File.open(file)
-        end
+        method = Pry::Method.from_binding(target)
+        method_description = method ? " in #{method.name_with_owner}" : ""
+        output.puts "\n#{text.bold('From:')} #{file} @ line #{line_num}#{method_description}:\n\n"
 
-        # This method inspired by http://rubygems.org/gems/ir_b
-        begin
-          f.each_with_index do |line, index|
-            line_n = index + 1
-            next unless line_n > (line_num - i_num - 1)
-            break if line_n > (line_num + i_num)
-            if line_n == line_num
-              code =" =>#{line_n.to_s.rjust(3)}: #{line.chomp}"
-              if Pry.color
-                code = CodeRay.scan(code, :ruby).term
-              end
-              output.puts code
-              code
-            else
-              code = "#{line_n.to_s.rjust(6)}: #{line.chomp}"
-              if Pry.color
-                code = CodeRay.scan(code, :ruby).term
-              end
-              output.puts code
-              code
-            end
-          end
-        ensure
-          f.close if f.respond_to?(:close)
-        end
+        code = Pry::Code.from_file(file).around(line_num, i_num)
+        output.puts code.with_line_numbers.with_marker(line_num)
+        output.puts
       end
 
     end

data/lib/pry/default_commands/documentation.rb

@@ -3,96 +3,207 @@ class Pry
 
     Documentation = Pry::CommandSet.new do
 
-      command "ri", "View ri documentation. e.g `ri Array#each`" do |*args|
-        run ".ri", *args
-      end
+      create_command "ri", "View ri documentation. e.g `ri Array#each`" do
+        banner <<-BANNER
+          Usage: ri [spec]
+          e.g. ri Array#each
 
-      command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. Aliases: \?", :shellwords => false do |*args|
-        opts, meth = parse_options!(args, :method_object) do |opt|
-          opt.banner unindent <<-USAGE
-            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
-          USAGE
+          Relies on the ri executable being available. See also: show-doc.
+        BANNER
 
+        def process
+          run ".ri", *args
+        end
+      end
+
+      create_command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. 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
 
-        raise Pry::CommandError, "No documentation found." if meth.doc.nil? || meth.doc.empty?
+        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
 
-        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
-        render_output(opts.flood?, false, doc)
       end
 
       alias_command "?", "show-doc"
 
-      command "stat", "View method information and set _file_ and _dir_ locals. Type `stat --help` for more info.", :shellwords => false do |*args|
-        target = target()
-
-        opts, meth = parse_options!(args, :method_object) do |opt|
-          opt.banner unindent <<-USAGE
+      create_command "stat", "View method information and set _file_ and _dir_ locals. Type `stat --help` for more info.", :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
-          USAGE
+        BANNER
+
+        def options(opt)
+          method_options(opt)
         end
 
-        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
+        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
 
-      command "gist-method", "Gist a method to github. Type `gist-method --help` for more info.", :requires_gem => "gist", :shellwords => false do |*args|
-        require 'gist'
-
-        target = target()
+      create_command "gist", "Gist a method or expression history to github. Type `gist --help` for more info.", :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
 
-        opts, meth = parse_options!(args, :method_object) do |opt|
-          opt.banner unindent <<-USAGE
-            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
-          USAGE
+        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
 
-          opt.on :d, :doc, "Gist a method's documentation."
-          opt.on :p, :private, "Create a private gist (default: true)", :default => true
+        def process
+          perform_gist
         end
 
-        type_map = { :ruby => "rb", :c => "c", :plain => "plain" }
-        if !opts.doc?
-          content = meth.source
-          code_type = meth.source_type
-        else
-          content = meth.doc
-          code_type = meth.source_type
+        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
 
-          text.no_color do
-            content = process_comment_markup(content, code_type)
+            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
-          code_type = :plain
         end
 
-        link = Gist.write([:extension => ".#{type_map[code_type]}",
-                           :input => content],
-                          opts.p?)
+        def gist_file_extension(file_name)
+          file_name.split(".").last
+        end
 
-        output.puts "Gist created at #{link}"
+        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
     end
   end
 end
+