pry 0.10.4 → 0.11.0

data/lib/pry/commands/shell_command.rb

@@ -4,7 +4,7 @@ class Pry
     group 'Input and Output'
     description "All text following a '.' is forwarded to the shell."
     command_options :listing => '.<shell command>', :use_prefix => false,
-      :takes_block => true
+                    :takes_block => true
 
     banner <<-'BANNER'
       Usage: .COMMAND_NAME
@@ -30,18 +30,44 @@ class Pry
 
     private
 
-      def parse_destination(dest)
-        return "~" if dest.empty?
-        return dest unless dest == "-"
-        state.old_pwd || raise(CommandError, "No prior directory available")
-      end
+    def parse_destination(dest)
+      return "~" if dest.empty?
+      return dest unless dest == "-"
+      state.old_pwd || raise(CommandError, "No prior directory available")
+    end
 
-      def process_cd(dest)
+    def process_cd(dest)
+      begin
         state.old_pwd = Dir.pwd
-        Dir.chdir File.expand_path(dest)
+        Dir.chdir(File.expand_path(path_from_cd_path(dest) || dest))
       rescue Errno::ENOENT
         raise CommandError, "No such directory: #{dest}"
       end
+    end
+
+    def cd_path_env
+      ENV['CDPATH']
+    end
+
+    def cd_path_exists?
+      cd_path_env && cd_path_env.length.nonzero?
+    end
+
+    def path_from_cd_path(dest)
+      return if !(dest && cd_path_exists?) || special_case_path?(dest)
+
+      cd_path_env.split(File::PATH_SEPARATOR).each do |path|
+        if File.directory?(path) && path.split(File::SEPARATOR).last == dest
+          return path
+        end
+      end
+
+      return nil
+    end
+
+    def special_case_path?(dest)
+      ['.', '..', '-'].include?(dest) || dest =~ /\A[#{File::PATH_SEPARATOR}~]/
+    end
   end
 
   Pry::Commands.add_command(Pry::Command::ShellCommand)

data/lib/pry/commands/show_info.rb

@@ -22,7 +22,15 @@ class Pry
       raise CommandError, no_definition_message if !code_object
       @original_code_object = code_object
 
-      if show_all_modules?(code_object)
+      if !obj_name && code_object.c_module? && !opts[:all]
+        result = "Warning: You're inside an object, whose class is defined by means\n" +
+                 "         of the C Ruby API. Pry cannot display the information for\n" +
+                 "         this class."
+        if code_object.candidates.any?
+          result += "\n         However, you can view monkey-patches applied to this class.\n" +
+                    "         Just execute the same command with the '--all' switch."
+        end
+      elsif show_all_modules?(code_object)
         # show all monkey patches for a module
 
         result = content_and_headers_for_all_module_candidates(code_object)
@@ -85,7 +93,7 @@ class Pry
     end
 
     def no_definition_message
-      "Couldn't locate a definition for #{obj_name}!"
+      "Couldn't locate a definition for #{obj_name}"
     end
 
     # Generate a header (meta-data information) for all the code

data/lib/pry/commands/watch_expression/expression.rb

@@ -10,7 +10,7 @@ class Pry
       end
 
       def eval!
-        @previous_value = @value
+        @previous_value = value
         @value = Pry::ColorPrinter.pp(target_eval(target, source), "")
       end
 

data/lib/pry/commands/whereami.rb

@@ -159,12 +159,12 @@ class Pry
     end
 
     def class_code
-      return @class_code if @class_code
-
-      mod = @method ? Pry::WrappedModule(@method.owner) : target_class
-
-      idx = mod.candidates.find_index { |v| expand_path(v.source_file) == @file }
-      @class_code = idx && Pry::Code.from_module(mod, idx)
+      @class_code ||=
+        begin
+          mod = @method ? Pry::WrappedModule(@method.owner) : target_class
+          idx = mod.candidates.find_index { |v| expand_path(v.source_file) == @file }
+          idx && Pry::Code.from_module(mod, idx)
+        end
     end
 
     def valid_method?
@@ -193,4 +193,5 @@ class Pry
 
   Pry::Commands.add_command(Pry::Command::Whereami)
   Pry::Commands.alias_command '@', 'whereami'
+  Pry::Commands.alias_command /whereami[!?]+/, 'whereami'
 end

data/lib/pry/config/behavior.rb

@@ -2,130 +2,201 @@ module Pry::Config::Behavior
   ASSIGNMENT     = "=".freeze
   NODUP          = [TrueClass, FalseClass, NilClass, Symbol, Numeric, Module, Proc].freeze
   INSPECT_REGEXP = /#{Regexp.escape "default=#<"}/
+  ReservedKeyError = Class.new(RuntimeError)
 
   module Builder
-    def from_hash(hash, default = nil)
+    #
+    # @param [Hash] attributes
+    #   a hash to initialize an instance of self with.
+    #
+    # @param [Pry::Config, nil] default
+    #   a default, or nil for none.
+    #
+    # @return [Pry::Config]
+    #   returns an instance of self.
+    #
+    def from_hash(attributes, default = nil)
       new(default).tap do |config|
-        config.merge!(hash)
+        attributes.each do |key,value|
+          config[key] = Hash === value ? from_hash(value, nil) : value
+        end
       end
     end
   end
 
   def self.included(klass)
-    unless defined?(RESERVED_KEYS)
-      const_set :RESERVED_KEYS, instance_methods(false).map(&:to_s).freeze
-    end
     klass.extend(Builder)
   end
 
   def initialize(default = Pry.config)
     @default = default
     @lookup = {}
+    @reserved_keys = methods.map(&:to_s).freeze
   end
 
   #
   # @return [Pry::Config::Behavior]
-  #   returns the default used if a matching value for a key isn't found in self
+  #   returns the default used incase a key isn't found in self.
   #
   def default
     @default
   end
 
+  #
+  # @param [String] key
+  #   a key (as a String)
+  #
+  # @return [Object, BasicObject]
+  #   returns an object from self or one of its defaults.
+  #
   def [](key)
-    @lookup[key.to_s]
+    key = key.to_s
+    key?(key) ? @lookup[key] : (@default and @default[key])
   end
 
+  #
+  # Add a key and value pair to self.
+  #
+  # @param [String] key
+  #   a key (as a String).
+  #
+  # @param [Object,BasicObject] value
+  #   a value.
+  #
+  # @raise [Pry::Config::ReservedKeyError]
+  #   when 'key' is a reserved key name.
+  #
   def []=(key, value)
     key = key.to_s
-    if RESERVED_KEYS.include?(key)
-      raise ArgumentError, "few things are reserved by pry, but using '#{key}' as a configuration key is."
+    if @reserved_keys.include?(key)
+      raise ReservedKeyError, "It is not possible to use '#{key}' as a key name, please choose a different key name."
     end
-    @lookup[key] = value
+    __push(key,value)
   end
 
-  def method_missing(name, *args, &block)
-    key = name.to_s
-    if key[-1] == ASSIGNMENT
-      short_key = key[0..-2]
-      self[short_key] = args[0]
-    elsif key?(key)
-      self[key]
-    elsif @default.respond_to?(name)
-      value = @default.public_send(name, *args, &block)
-      # FIXME: refactor Pry::Hook so that it stores config on the config object,
-      # so that we can use the normal strategy.
-      self[key] = value = value.dup if key == 'hooks'
-      value
-    else
-      nil
-    end
+  #
+  # Removes a key from self.
+  #
+  # @param [String] key
+  #  a key (as a String)
+  #
+  # @return [void]
+  #
+  def forget(key)
+    key = key.to_s
+    __remove(key)
   end
 
+  #
+  # @param [Hash, #to_h, #to_hash] other
+  #   a hash to merge into self.
+  #
+  # @return [void]
+  #
   def merge!(other)
-    other = try_convert_to_hash(other)
+    other = __try_convert_to_hash(other)
     raise TypeError, "unable to convert argument into a Hash" unless other
     other.each do |key, value|
       self[key] = value
     end
   end
 
+  #
+  # @param [Hash, #to_h, #to_hash] other
+  #   a hash to compare against the lookup table of self.
+  #
   def ==(other)
-    @lookup == try_convert_to_hash(other)
+    @lookup == __try_convert_to_hash(other)
   end
   alias_method :eql?, :==
 
-  def respond_to_missing?(key, include_private=false)
-    key?(key) or @default.respond_to?(key) or super(key, include_private)
-  end
-
+  #
+  # @param [String] key
+  #   a key (as a String)
+  #
+  # @return [Boolean]
+  #   returns true when "key" is a member of self.
+  #
   def key?(key)
     key = key.to_s
     @lookup.key?(key)
   end
 
+  #
+  # Clear the lookup table of self.
+  #
+  # @return [void]
+  #
   def clear
     @lookup.clear
     true
   end
-  alias_method :refresh, :clear
-
-  def forget(key)
-    @lookup.delete(key.to_s)
-  end
 
+  #
+  # @return [Array<String>]
+  #   returns an array of keys in self.
+  #
   def keys
     @lookup.keys
   end
 
+  def eager_load!
+    default = @default
+    while default
+      default.memoized_methods.each {|method| self[key] = default.public_send(key)} if default.respond_to?(:memoized_methods)
+      default = @default.default
+    end
+  end
+
+  def last_default
+    last = @default
+    last = last.default while last and last.default
+    last
+  end
+
+  #
+  # @return [Hash]
+  #   returns a duplicate copy of the lookup table used by self.
+  #
   def to_hash
     @lookup.dup
   end
   alias_method :to_h, :to_hash
 
-
   def inspect
     key_str = keys.map { |key| "'#{key}'" }.join(",")
-    "#<#{_clip_inspect(self)} local_keys=[#{key_str}] default=#{@default.inspect}>"
+    "#<#{__clip_inspect(self)} keys=[#{key_str}] default=#{@default.inspect}>"
   end
 
   def pretty_print(q)
     q.text inspect[1..-1].gsub(INSPECT_REGEXP, "default=<")
   end
 
-private
-  def _clip_inspect(obj)
-    "#{obj.class}:0x%x" % obj.object_id << 1
-  end
-
-  def _dup(value)
-    if NODUP.any? { |klass| klass === value }
-      value
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    if key[-1] == ASSIGNMENT
+      short_key = key[0..-2]
+      self[short_key] = args[0]
+    elsif key?(key)
+      self[key]
+    elsif @default.respond_to?(name)
+      value = @default.public_send(name, *args, &block)
+      self[key] = __dup(value)
     else
-      value.dup
+      nil
     end
   end
 
-  def try_convert_to_hash(obj)
+  def respond_to_missing?(key, include_all=false)
+    key?(key) or @default.respond_to?(key) or super(key, include_all)
+  end
+
+private
+  def __clip_inspect(obj)
+    "#{obj.class}:0x%x" % obj.object_id
+  end
+
+  def __try_convert_to_hash(obj)
     if Hash === obj
       obj
     elsif obj.respond_to?(:to_h)
@@ -136,4 +207,24 @@ private
       nil
     end
   end
+
+  def __dup(value)
+    if NODUP.any? { |klass| klass === value }
+      value
+    else
+      value.dup
+    end
+  end
+
+  def __push(key,value)
+    unless singleton_class.method_defined? key
+      define_singleton_method(key) { self[key] }
+      define_singleton_method("#{key}=") { |val| @lookup[key] = val }
+    end
+    @lookup[key] = value
+  end
+
+  def __remove(key)
+    @lookup.delete(key)
+  end
 end

data/lib/pry/config/default.rb

@@ -1,12 +1,13 @@
 class Pry::Config::Default
   include Pry::Config::Behavior
+  include Pry::Config::Memoization
 
-  default = {
+  def_memoized({
     input: proc {
       lazy_readline
     },
     output: proc {
-      $stdout
+      $stdout.tap { |out| out.sync = true }
     },
     commands: proc {
       Pry::Commands
@@ -110,43 +111,30 @@ class Pry::Config::Default
     completer: proc {
       require "pry/input_completer"
       Pry::InputCompleter
+    },
+    gist: proc {
+      Pry::Config.from_hash({inspecter: proc(&:pretty_inspect)}, nil)
+    },
+    history: proc {
+      Pry::Config.from_hash({should_save: true, should_load: true}, nil).tap do |history|
+        history.file = File.expand_path("~/.pry_history") rescue nil
+        if history.file.nil?
+          self.should_load_rc = false
+          history.should_save = false
+          history.should_load = false
+        end
+      end
+    },
+    exec_string: proc {
+      ""
     }
-  }
+  })
 
   def initialize
     super(nil)
-    configure_gist
-    configure_history
-  end
-
-  default.each do |key, value|
-    define_method(key) do
-      if default[key].equal?(value)
-        default[key] = instance_eval(&value)
-      end
-      default[key]
-    end
-  end
-
-private
-  # TODO:
-  # all of this configure_* stuff is a relic of old code.
-  # we should try move this code to being command-local.
-  def configure_gist
-    self["gist"] = Pry::Config.from_hash(inspecter: proc(&:pretty_inspect))
-  end
-
-  def configure_history
-    self["history"] = Pry::Config.from_hash "should_save" => true,
-      "should_load" => true
-    history.file = File.expand_path("~/.pry_history") rescue nil
-    if history.file.nil?
-      self.should_load_rc = false
-      history.should_save = false
-      history.should_load = false
-    end
   end
 
+  private
   def lazy_readline
     require 'readline'
     Readline

data/lib/pry/config/memoization.rb

@@ -0,0 +1,44 @@
+module Pry::Config::Memoization
+  MEMOIZED_METHODS = Hash.new {|h,k| h[k] = [] }
+
+  module ClassMethods
+    #
+    # Defines one or more methods who return a constant value after being
+    # called once.
+    #
+    # @example
+    #   class Foo
+    #     include Pry::Config::Memoization
+    #     def_memoized({
+    #       foo: proc {1+10},
+    #       bar: proc{"aaa"<<"a"}
+    #     })
+    #   end
+    #
+    # @param [{String => Proc}] method_table
+    #
+    # @return [void]
+    #
+    def def_memoized(method_table)
+      method_table.each do |method_name, method|
+        define_method(method_name) do
+          method_table[method_name] = instance_eval(&method) if method_table[method_name].equal? method
+          method_table[method_name]
+        end
+      end
+      MEMOIZED_METHODS[self] |= method_table.keys
+    end
+  end
+
+  def self.included(mod)
+    mod.extend(ClassMethods)
+  end
+
+  #
+  # @return [Array<Symbol>]
+  #   Returns the names of methods that have been defined by {ClassMethods#def_memoized}.
+  #
+  def memoized_methods
+    MEMOIZED_METHODS[self.class]
+  end
+end

data/lib/pry/config.rb

@@ -1,24 +1,11 @@
-class Pry::Config
+require_relative 'basic_object'
+class Pry::Config < Pry::BasicObject
   require_relative 'config/behavior'
+  require_relative 'config/memoization'
   require_relative 'config/default'
   require_relative 'config/convenience'
   include Pry::Config::Behavior
-
   def self.shortcuts
     Convenience::SHORTCUTS
   end
-
-  #
-  # FIXME
-  # @param [Pry::Hooks] hooks
-  #
-  def hooks=(hooks)
-    if hooks.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"
-      self["hooks"] = Pry::Hooks.from_hash(hooks)
-    else
-      self["hooks"] = hooks
-    end
-  end
 end

data/lib/pry/core_extensions.rb

@@ -68,12 +68,22 @@ class Object
   def __binding__
     # If you ever feel like changing this method, be careful about variables
     # that you use. They shouldn't be inserted into the binding that will
-    # eventually be returning.
+    # eventually be returned.
 
     # When you're cd'd into a class, methods you define should be added to it.
     if is_a?(Module)
+      # A special case, for JRuby.
+      # Module.new.class_eval("binding") has different behaviour than CRuby,
+      # where this is not needed: class_eval("binding") vs class_eval{binding}.
+      # Using a block works around the difference of behaviour on JRuby.
+      # The scope is clear of local variabless. Don't add any.
+      #
+      # This fixes the following two spec failures, at https://travis-ci.org/pry/pry/jobs/274470002
+      # 1) ./spec/pry_spec.rb:360:in `block in (root)'
+      # 2) ./spec/pry_spec.rb:366:in `block in (root)'
+      return class_eval {binding} if Pry::Helpers::BaseHelpers.jruby? and self.name == nil
       # class_eval sets both self and the default definee to this class.
-      return class_eval "binding"
+      return class_eval("binding")
     end
 
     unless respond_to?(:__pry__)

data/lib/pry/editor.rb

@@ -44,7 +44,7 @@ class Pry
         _pry_.config.editor.call(*args)
       else
         sanitized_file = if windows?
-                            file.gsub(/\//, '\\')
+                            file
                           else
                             Shellwords.escape(file)
                           end

data/lib/pry/exceptions.rb

@@ -52,7 +52,7 @@ class Pry
     def self.===(exception)
       ["can't modify frozen class/module",
        "can't modify frozen Class",
-       "can't modify frozen object"
+       "can't modify frozen object",
       ].include?(exception.message)
     end
   end

data/lib/pry/forwardable.rb

@@ -0,0 +1,23 @@
+class Pry
+  module Forwardable
+    require 'forwardable'
+    include ::Forwardable
+
+    #
+    # Since Ruby 2.4, Forwardable will print a warning when
+    # calling a method that is private on a delegate, and
+    # in the future it could be an error: https://bugs.ruby-lang.org/issues/12782#note-3
+    #
+    # That's why we revert to a custom implementation for delegating one
+    # private method to another.
+    #
+    def def_private_delegators(target, *private_delegates)
+      private_delegates.each do |private_delegate|
+        define_method(private_delegate) do |*a, &b|
+          instance_variable_get(target).__send__(private_delegate, *a, &b)
+        end
+      end
+      class_eval { private(*private_delegates) }
+    end
+  end
+end

data/lib/pry/helpers/base_helpers.rb

@@ -32,7 +32,7 @@ class Pry
       end
 
       def not_a_real_file?(file)
-        file =~ /(\(.*\))|<.*>/ || file =~ /__unknown__/ || file == "" || file == "-e"
+        file =~ /^(\(.*\))$|^<.*>$/ || file =~ /__unknown__/ || file == "" || file == "-e"
       end
 
       def command_dependencies_met?(options)
@@ -94,19 +94,15 @@ class Pry
         mri? && RUBY_VERSION =~ /^2/
       end
 
-      def mri_20?
-        mri? && RUBY_VERSION =~ /^2\.0/
-      end
-
-      def mri_21?
-        mri? && RUBY_VERSION =~ /^2\.1/
-      end
-
       # Send the given text through the best available pager (if Pry.config.pager is
       # enabled). Infers where to send the output if used as a mixin.
       # DEPRECATED.
       def stagger_output(text, out = nil)
-        Pry.new.pager.page text
+        if _pry_
+          _pry_.pager.page text
+        else
+          Pry.new.pager.page text
+        end
       end
     end
   end

data/lib/pry/helpers/documentation_helpers.rb

@@ -12,6 +12,7 @@ class Pry
         comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
           gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
           gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/<tt>(?:\s*\n)?(.*?)\s*<\/tt>/m) { CodeRay.scan($1, :ruby).term }.
           gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
           gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
           gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }

data/lib/pry/helpers/options_helpers.rb

@@ -3,7 +3,7 @@ class Pry
     module OptionsHelpers
       module_function
 
-      # Add method options to the Slop instance
+      # Add method options to the Pry::Slop instance
       def method_options(opt)
         @method_target = target
         opt.on :M, "instance-methods", "Operate on instance methods."