pry 0.9.7.4 → 0.9.8pre2

data/lib/pry/history.rb

@@ -1,61 +1,99 @@
 class Pry
   # The History class is responsible for maintaining the user's input history, both
-  # internally and within Readline::HISTORY.
+  # internally and within Readline.
   class History
+    attr_accessor :loader, :saver, :pusher, :clearer
+
     def initialize
       @history = []
       @saved_lines = 0
+      restore_default_behavior
+    end
+
+    # Assign the default methods for loading, saving, pushing, and clearing.
+    def restore_default_behavior
+      @loader  = method(:read_from_file)
+      @saver   = method(:write_to_file)
+      @pusher  = method(:push_to_readline)
+      @clearer = method(:clear_readline)
     end
 
-    # Loads a file's contents into the input history.
-    # @param [String] filename
+    # Load the input history using `History.loader`.
     # @return [Integer] The number of lines loaded
-    def load(filename)
-      File.foreach(filename) do |line|
-        Readline::HISTORY << line.chomp
+    def load
+      @loader.call do |line|
+        @pusher.call(line.chomp)
         @history << line.chomp
       end
       @saved_lines = @history.length
     end
 
-    # Appends input history from this session to a file.
-    # @param [String] filename
+    # Write this session's history using `History.saver`.
     # @return [Integer] The number of lines saved
-    def save(filename)
+    def save
       history_to_save = @history[@saved_lines..-1]
-      File.open(filename, 'a') do |f|
-        history_to_save.each { |ln| f.puts ln }
-      end
+      @saver.call(history_to_save)
       @saved_lines = @history.length
       history_to_save.length
     end
 
-    # Adds a line to the input history, ignoring blank and duplicate lines.
+    # Add a line to the input history, ignoring blank and duplicate lines.
     # @param [String] line
     # @return [String] The same line that was passed in
     def push(line)
       unless line.empty? || (@history.last && line == @history.last)
-        Readline::HISTORY << line
+        @pusher.call(line)
         @history << line
       end
       line
     end
     alias << push
 
-    # Clears all history. Anything the user entered before this point won't be
+    # Clear all history. Anything the user entered before this point won't be
     # saved, but anything they put in afterwards will still be appended to the
     # history file on exit.
     def clear
-      Readline::HISTORY.shift until Readline::HISTORY.empty?
+      @clearer.call
       @history = []
       @saved_lines = 0
     end
 
-    # Returns an Array containing all stored history.
+    # Return an Array containing all stored history.
     # @return [Array<String>] An Array containing all lines of history loaded
     #   or entered by the user in the current session.
     def to_a
       @history.dup
     end
+
+    private
+    # The default loader. Yields lines from `Pry.history.config.file`.
+    def read_from_file
+      history_file = File.expand_path(Pry.config.history.file)
+
+      if File.exists?(history_file)
+        File.foreach(history_file) { |line| yield(line) }
+      end
+    end
+
+    # The default saver. Appends the given lines to `Pry.history.config.file`.
+    # @param [Array<String>] lines
+    def write_to_file(lines)
+      history_file = File.expand_path(Pry.config.history.file)
+
+      File.open(history_file, 'a') do |f|
+        lines.each { |ln| f.puts ln }
+      end
+    end
+
+    # The default pusher. Appends the given line to Readline::HISTORY.
+    # @param [String] line
+    def push_to_readline(line)
+      Readline::HISTORY << line
+    end
+
+    # The default clearer. Clears Readline::HISTORY.
+    def clear_readline
+      Readline::HISTORY.shift until Readline::HISTORY.empty?
+    end
   end
 end

data/lib/pry/history_array.rb

@@ -72,6 +72,8 @@ class Pry
     def size
       @count
     end
+    alias count size
+    alias length size
 
     def empty?
       size == 0

data/lib/pry/hooks.rb

@@ -0,0 +1,108 @@
+class Pry
+  class Hooks
+
+    def initialize
+      @hooks = {}
+    end
+
+    # Add a new hook to be executed for the `name` even.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    # @param [#call] callable The callable.
+    # @yield The block to use as the callable (if `callable` parameter not provided)
+    def add_hook(event_name, hook_name, callable=nil, &block)
+      @hooks[event_name] ||= []
+
+      # do not allow duplicates
+      raise ArgumentError, "Hook with name '#{hook_name}' already defined!" if hook_exists?(event_name, hook_name)
+
+      if block
+        @hooks[event_name] << [hook_name, block]
+      elsif callable
+        @hooks[event_name] << [hook_name, callable]
+      else
+        raise ArgumentError, "Must provide a block or callable."
+      end
+
+      self
+    end
+
+    # Execute the list of hooks for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Array] args The arguments to pass to each hook function.
+    # @return [Object] The return value of the last executed hook.
+    def exec_hook(event_name, *args, &block)
+      @hooks[event_name] ||= []
+
+      # silence warnings to get rid of 1.8's "warning: multiple values
+      # for a block parameter" warnings
+      Pry::Helpers::BaseHelpers.silence_warnings do
+        @hooks[event_name].map { |hook_name, callable| callable.call(*args, &block) }.last
+      end
+    end
+
+    # Return the number of hook functions registered for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @return [Fixnum] The number of hook functions for `event_name`.
+    def hook_count(event_name)
+      @hooks[event_name] ||= []
+      @hooks[event_name].size
+    end
+
+    # Return a specific hook for a given event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol[ hook_name The name of the hook
+    # @return [#call] The requested hook.
+    def get_hook(event_name, hook_name)
+      @hooks[event_name] ||= []
+      hook = @hooks[event_name].find { |current_hook_name, callable| current_hook_name == hook_name }
+      hook.last if hook
+    end
+
+    # Return the hash of hook names / hook functions for a
+    # given event. (Note that modifying the returned hash does not
+    # alter the hooks, use add_hook/delete_hook for that).
+    # @param [Symbol] event_name The name of the event.
+    # @return [Hash] The hash of hook names / hook functions.
+    def get_hooks(event_name)
+      @hooks[event_name] ||= []
+      Hash[@hooks[event_name]]
+    end
+
+    # Delete a hook for an event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    #   to delete.
+    # @return [#call] The deleted hook.
+    def delete_hook(event_name, hook_name)
+      @hooks[event_name] ||= []
+      deleted_callable = nil
+
+      @hooks[event_name].delete_if do |current_hook_name, callable|
+        if current_hook_name == hook_name
+          deleted_callable = callable
+          true
+        else
+          false
+        end
+      end
+      deleted_callable
+    end
+
+    # Clear all hooks functions for a given event.
+    # @param [String] event_name The name of the event.
+    def clear(event_name)
+      @hooks[event_name] = []
+    end
+
+    # @param [Symbol] event_name Name of the event.
+    # @param [Symbol] hook_name Name of the hook.
+    # @return [Boolean] Whether the hook by the name `hook_name`
+    #   is defined for the event.
+    def hook_exists?(event_name, hook_name)
+      !!@hooks[event_name].find { |name, _| name == hook_name }
+    end
+    private :hook_exists?
+
+  end
+end

data/lib/pry/indent.rb

@@ -43,7 +43,11 @@ class Pry
     # Collection of token types that should be ignored. Without this list
     # keywords such as "class" inside strings would cause the code to be
     # indented incorrectly.
-    IGNORE_TOKENS = [:space, :content, :string, :delimiter, :method, :ident]
+    #
+    # :pre_constant and :preserved_constant are the CodeRay 0.9.8 and 1.0.0
+    # classifications of "true", "false", and "nil".
+    IGNORE_TOKENS = [:space, :content, :string, :delimiter, :method, :ident,
+                     :constant, :pre_constant, :predefined_constant]
 
     # Tokens that indicate the end of a statement (i.e. that, if they appear
     # directly before an "if" indicates that that if applies to the same line,
@@ -199,11 +203,11 @@ class Pry
       end
 
       if defined?(Win32::Console)
-        move_up    = "\e[#{lines}F"
-        move_down  = "\e[#{lines}E"
+        move_up   = "\e[#{lines}F"
+        move_down = "\e[#{lines}E"
       else
-        move_up    = "\e[#{lines}A\e[0G"
-        move_down  = "\e[#{lines}B\e[0G"
+        move_up   = "\e[#{lines}A\e[0G"
+        move_down = "\e[#{lines}B\e[0G"
       end
       whitespace = ' ' * overhang
 

data/lib/pry/method.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 class Pry
   class Method
     include RbxMethod if Helpers::BaseHelpers.rbx?
@@ -48,7 +49,11 @@ class Pry
         if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
           nil
         else
-          new(b.eval("method(:#{meth_name})"))
+          begin
+            new(b.eval("method(#{meth_name.to_s.inspect})"))
+          rescue NameError, NoMethodError
+            Disowned.new(b.eval('self'), meth_name.to_s)
+          end
         end
       end
 
@@ -128,7 +133,7 @@ class Pry
       end
 
       # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance heirarchy.
+      # inheritance hierarchy.
       # This is required to introspect methods on objects like Net::HTTP::Get that
       # have overridden the `method` method.
       def safe_send(obj, method, *args, &block)
@@ -166,6 +171,27 @@ class Pry
       @method.name.to_s
     end
 
+    # Get the owner of the method as a Pry::Module
+    # @return [Pry::Module]
+    def wrapped_owner
+      @wrapped_owner ||= Pry::WrappedModule.new(owner)
+    end
+
+    # Is the method undefined? (aka `Disowned`)
+    # @return [Boolean] false
+    def undefined?
+      false
+    end
+
+    # Get the name of the method including the class on which it was defined.
+    # @example
+    #   method(:puts).method_name
+    #   => "Kernel.puts"
+    # @return [String]
+    def name_with_owner
+      "#{wrapped_owner.method_prefix}#{name}"
+    end
+
     # @return [String, nil] The source code of the method, or `nil` if it's unavailable.
     def source
       @source ||= case source_type
@@ -174,11 +200,11 @@ class Pry
           if info and info.source
             code = strip_comments_from_c_code(info.source)
           end
-        when :rbx
-          strip_leading_whitespace(core_code)
         when :ruby
-          if pry_method?
-            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => {}).r
+          if Helpers::BaseHelpers.rbx? && core?
+            code = core_code
+          elsif pry_method?
+            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => Pry::Hooks.new).r
           else
             code = @method.source
           end
@@ -194,10 +220,10 @@ class Pry
         when :c
           info = pry_doc_info
           info.docstring if info
-        when :rbx
-          strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
         when :ruby
-          if pry_method?
+          if Helpers::BaseHelpers.rbx? && core?
+            strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
+          elsif pry_method?
             raise CommandError, "Can't view doc for a REPL-defined method."
           else
             strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
@@ -206,14 +232,9 @@ class Pry
     end
 
     # @return [Symbol] The source type of the method. The options are
-    #   `:ruby` for ordinary Ruby methods, `:c` for methods written in
-    #   C, or `:rbx` for Rubinius core methods written in Ruby.
+    #   `:ruby` for Ruby methods or `:c` for methods written in C.
     def source_type
-      if Helpers::BaseHelpers.rbx?
-        if core? then :rbx else :ruby end
-      else
-        if source_location.nil? then :c else :ruby end
-      end
+      source_location.nil? ? :c : :ruby
     end
 
     # @return [String, nil] The name of the file the method is defined in, or
@@ -286,43 +307,11 @@ class Pry
       Pry::Method.new(sup) if sup
     end
 
-    # @return [Symbol, nil] The original name the method was defined under,
+    # @return [String, nil] The original name the method was defined under,
     #   before any aliasing, or `nil` if it can't be determined.
     def original_name
       return nil if source_type != :ruby
-
-      first_line = source.lines.first
-      return nil if first_line.strip !~ /^def /
-
-      if RUBY_VERSION =~ /^1\.9/ && RUBY_ENGINE == "ruby"
-        require 'ripper'
-
-        # Ripper is ok with an extraneous end, so we don't need to worry about
-        # whether it's a one-liner.
-        tree = Ripper::SexpBuilder.new(first_line + ";end").parse
-
-        name = tree.flatten(2).each do |lst|
-          break lst[1] if lst[0] == :@ident
-        end
-
-        name.is_a?(String) ? name : nil
-      else
-        require 'ruby_parser'
-
-        # RubyParser breaks if there's an extra end, so we'll just rescue
-        # and try again.
-        tree = begin
-          RubyParser.new.parse(first_line + ";end")
-        rescue Racc::ParseError
-          RubyParser.new.parse(first_line)
-        end
-
-        name = tree.each_cons(2) do |a, b|
-          break a if b.is_a?(Array) && b.first == :args
-        end
-
-        name.is_a?(Symbol) ? name.to_s : nil
-      end
+      method_name_from_first_line(source.lines.first)
     end
 
     # @return [Boolean] Was the method defined outside a source file?
@@ -409,5 +398,65 @@ class Pry
         end
         next_owner.instance_method(name) rescue nil
       end
+
+      # @param [String] first_ln The first line of a method definition.
+      # @return [String, nil]
+      def method_name_from_first_line(first_ln)
+        return nil if first_ln.strip !~ /^def /
+
+        tokens = CodeRay.scan(first_ln, :ruby)
+        tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
+        tokens.each_cons(2) do |t1, t2|
+          if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
+            return t2.first
+          end
+        end
+
+        nil
+      end
+
+    # A Disowned Method is one that's been removed from the class on which it was defined.
+    #
+    # e.g.
+    # class C
+    #   def foo
+    #     C.send(:undefine_method, :foo)
+    #     Pry::Method.from_binding(binding)
+    #   end
+    # end
+    #
+    # In this case we assume that the "owner" is the singleton class of the receiver.
+    #
+    # This occurs mainly in Sinatra applications.
+    class Disowned < Method
+      attr_reader :receiver, :name
+
+      # Create a new Disowned method.
+      #
+      # @param [Object] receiver
+      # @param [String] method_name
+      def initialize(*args)
+        @receiver, @name = *args
+      end
+
+      # Is the method undefined? (aka `Disowned`)
+      # @return [Boolean] true
+      def undefined?
+        true
+      end
+
+      # Get the hypothesized owner of the method.
+      #
+      # @return [Object]
+      def owner
+        class << receiver; self; end
+      end
+
+      # Raise a more useful error message instead of trying to forward to nil.
+      def method_missing(meth_name, *args, &block)
+        raise "Cannot call '#{meth_name}' on an undef'd method." if method(:name).respond_to?(meth_name)
+        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
+      end
+    end
   end
 end