pry 0.10.4-java → 0.11.0-java

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/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