pry 0.12.0 → 0.14.0

data/lib/pry/config/attributable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pry
+  class Config
+    # Attributable provides the ability to create "attribute"
+    # accessors. Attribute accessors create a standard "attr_writer" and a
+    # customised "attr_reader". This reader is Proc-aware (lazy).
+    #
+    # @since v0.13.0
+    # @api private
+    module Attributable
+      def attribute(attr_name)
+        define_method(attr_name) do
+          value = Config::Value.new(instance_variable_get("@#{attr_name}"))
+          value.call
+        end
+
+        attr_writer(attr_name)
+      end
+    end
+  end
+end

data/lib/pry/config/lazy_value.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Pry
+  class Config
+    # LazyValue is a Proc (block) wrapper. It is meant to be used as a
+    # configuration value. Subsequent `#call` calls always evaluate the given
+    # block.
+    #
+    # @example
+    #   num = 19
+    #   value = Pry::Config::LazyValue.new { num += 1 }
+    #   value.foo # => 20
+    #   value.foo # => 21
+    #   value.foo # => 22
+    #
+    # @api private
+    # @since v0.13.0
+    # @see Pry::Config::MemoizedValue
+    class LazyValue
+      def initialize(&block)
+        @block = block
+      end
+
+      def call
+        @block.call
+      end
+    end
+  end
+end

data/lib/pry/config/memoized_value.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Pry
+  class Config
+    # MemoizedValue is a Proc (block) wrapper. It is meant to be used as a
+    # configuration value. Subsequent `#call` calls return the same memoized
+    # result.
+    #
+    # @example
+    #   num = 19
+    #   value = Pry::Config::MemoizedValue.new { num += 1 }
+    #   value.call # => 20
+    #   value.call # => 20
+    #   value.call # => 20
+    #
+    # @api private
+    # @since v0.13.0
+    # @see Pry::Config::LazyValue
+    class MemoizedValue
+      def initialize(&block)
+        @block = block
+        @called = false
+        @call = nil
+      end
+
+      def call
+        return @call if @called
+
+        @called = true
+        @call = @block.call
+      end
+    end
+  end
+end

data/lib/pry/config/value.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Pry
+  class Config
+    # Value holds a value for the given attribute and decides how it should
+    # be read. Procs get called, other values are returned as is.
+    #
+    # @since v0.13.0
+    # @api private
+    class Value
+      def initialize(value)
+        @value = value
+      end
+
+      def call
+        unless [Config::MemoizedValue, Config::LazyValue].include?(@value.class)
+          return @value
+        end
+
+        @value.call
+      end
+    end
+  end
+end

data/lib/pry/control_d_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module ControlDHandler
+    # Deal with the ^D key being pressed. Different behaviour in different
+    # cases:
+    #   1. In an expression behave like `!` command.
+    #   2. At top-level session behave like `exit` command.
+    #   3. In a nested session behave like `cd ..`.
+    def self.default(pry_instance)
+      if !pry_instance.eval_string.empty?
+        # Clear input buffer.
+        pry_instance.eval_string = ''
+      elsif pry_instance.binding_stack.one?
+        pry_instance.binding_stack.clear
+        throw(:breakout)
+      else
+        # Otherwise, saves current binding stack as old stack and pops last
+        # binding out of binding stack (the old stack still has that binding).
+        cd_state = Pry::CommandState.default.state_for('cd')
+        cd_state.old_stack = pry_instance.binding_stack.dup
+        pry_instance.binding_stack.pop
+      end
+    end
+  end
+end

data/lib/pry/core_extensions.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class Pry
   # @return [Array] Code of the method used when implementing Pry's
   #   __binding__, along with line indication to be used with instance_eval (and
   #   friends).
   #
   # @see Object#__binding__
-  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1]
+  BINDING_METHOD_IMPL = [<<-METHOD, __FILE__, __LINE__ + 1].freeze
     # Get a binding with 'self' set to self, and no locals.
     #
     # The default definee is determined by the context in which the
@@ -39,7 +41,7 @@ class Object
   #   my_method()
   # @see Pry.start
   def pry(object = nil, hash = {})
-    if object.nil? || Hash === object
+    if object.nil? || Hash === object # rubocop:disable Style/CaseEquality
       Pry.start(self, object || {})
     else
       Pry.start(object, hash)
@@ -81,10 +83,10 @@ class Object
       # 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::Platform.jruby? and self.name == nil
+      return class_eval { binding } if Pry::Helpers::Platform.jruby? && name.nil?
 
       # class_eval sets both self and the default definee to this class.
-      return class_eval("binding")
+      return class_eval("binding", __FILE__, __LINE__)
     end
 
     unless self.class.method_defined?(:__pry__)
@@ -124,7 +126,7 @@ class BasicObject
     # BasicObjects don't have respond_to?, so we just define the method
     # every time. As they also don't have `.freeze`, this call won't
     # fail as it can for normal Objects.
-    (class << self; self; end).class_eval <<-EOF, __FILE__, __LINE__ + 1
+    (class << self; self; end).class_eval(<<-METHOD, __FILE__, __LINE__ + 1)
       # Get a binding with 'self' set to self, and no locals.
       #
       # The default definee is determined by the context in which the
@@ -136,7 +138,7 @@ class BasicObject
       def __pry__
         ::Kernel.binding
       end
-    EOF
-    self.__pry__
+    METHOD
+    __pry__
   end
 end

data/lib/pry/editor.rb

@@ -1,11 +1,31 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
 class Pry
   class Editor
+    def self.default
+      if (visual = Pry::Env['VISUAL'])
+        return visual
+      end
+
+      if (editor = Pry::Env['EDITOR'])
+        return editor
+      end
+
+      return 'notepad' if Helpers::Platform.windows?
+
+      %w[editor nano vi].find do |editor_exe|
+        Kernel.system("which #{editor_exe} > /dev/null 2>&1")
+      end
+    end
+
     include Pry::Helpers::CommandHelpers
 
-    attr_reader :_pry_
+    attr_reader :pry_instance
 
-    def initialize(_pry_)
-      @_pry_ = _pry_
+    def initialize(pry_instance)
+      @pry_instance = pry_instance
     end
 
     def edit_tempfile_with_content(initial_content, line = 1)
@@ -19,7 +39,10 @@ class Pry
     end
 
     def invoke_editor(file, line, blocking = true)
-      raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless _pry_.config.editor
+      unless pry_instance.config.editor
+        raise CommandError,
+              "Please set Pry.config.editor or export $VISUAL or $EDITOR"
+      end
 
       editor_invocation = build_editor_invocation_string(file, line, blocking)
       return nil unless editor_invocation
@@ -31,40 +54,44 @@ class Pry
       end
     end
 
-    private
-
     # Generate the string that's used to start the editor. This includes
     # all the flags we want as well as the file and line number we
     # want to open at.
     def build_editor_invocation_string(file, line, blocking)
-
-      if _pry_.config.editor.respond_to?(:call)
-        args = [file, line, blocking][0...(_pry_.config.editor.arity)]
-        _pry_.config.editor.call(*args)
+      if pry_instance.config.editor.respond_to?(:call)
+        args = [file, line, blocking][0...(pry_instance.config.editor.arity)]
+        pry_instance.config.editor.call(*args)
       else
         sanitized_file = Helpers::Platform.windows? ? file : Shellwords.escape(file)
-        "#{_pry_.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
+        editor = pry_instance.config.editor
+        flag = blocking_flag_for_editor(blocking)
+        start_line = start_line_syntax_for_editor(sanitized_file, line)
+        "#{editor} #{flag} #{start_line}"
       end
     end
 
+    private
+
     # Start the editor running, using the calculated invocation string
     def open_editor(editor_invocation)
       # Note we dont want to use Pry.config.system here as that
       # may be invoked non-interactively (i.e via Open4), whereas we want to
       # ensure the editor is always interactive
-      system(*Shellwords.split(editor_invocation)) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
+      system(*Shellwords.split(editor_invocation)) ||
+        raise(
+          CommandError,
+          "`#{editor_invocation}` gave exit status: #{$CHILD_STATUS.exitstatus}"
+        )
     end
 
     # We need JRuby specific code here cos just shelling out using
     # system() appears to be pretty broken :/
     def open_editor_on_jruby(editor_invocation)
-      begin
-        require 'spoon'
-        pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
-        Process.waitpid(pid)
-      rescue FFI::NotFoundError
-        system(editor_invocation)
-      end
+      require 'spoon'
+      pid = Spoon.spawnp(*Shellwords.split(editor_invocation))
+      Process.waitpid(pid)
+    rescue FFI::NotFoundError
+      system(editor_invocation)
     end
 
     # Some editors that run outside the terminal allow you to control whether or
@@ -104,7 +131,7 @@ class Pry
         "-l#{line_number} #{file_name}"
       else
         if Helpers::Platform.windows?
-          "#{file_name}"
+          file_name.to_s
         else
           "+#{line_number} #{file_name}"
         end
@@ -122,7 +149,7 @@ class Pry
     #   # => textmate
     #
     def editor_name
-      File.basename(_pry_.config.editor).split(" ").first
+      File.basename(pry_instance.config.editor).split(" ").first
     end
   end
 end

data/lib/pry/env.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Pry
+  # Env is a helper module to work with environment variables.
+  #
+  # @since v0.13.0
+  # @api private
+  module Env
+    def self.[](key)
+      return unless ENV.key?(key)
+
+      value = ENV[key]
+      return if value == ''
+
+      value
+    end
+  end
+end

data/lib/pry/exception_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module ExceptionHandler
+    class << self
+      # Will only show the first line of the backtrace.
+      def handle_exception(output, exception, _pry_instance)
+        if exception.is_a?(UserError) && exception.is_a?(SyntaxError)
+          output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+        else
+          output.puts standard_error_text_for(exception)
+        end
+      end
+
+      private
+
+      def standard_error_text_for(exception)
+        text = exception_text(exception)
+        return text unless exception.respond_to?(:cause)
+
+        cause = exception.cause
+        while cause
+          text += cause_text(cause)
+          cause = cause.cause
+        end
+
+        text
+      end
+
+      def exception_text(exception)
+        "#{exception.class}: #{exception.message}\n" \
+        "from #{exception.backtrace.first}\n"
+      end
+
+      def cause_text(cause)
+        "Caused by #{cause.class}: #{cause}\n" \
+        "from #{cause.backtrace.first}\n"
+      end
+    end
+  end
+end

data/lib/pry/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   # As a REPL, we often want to catch any unexpected exceptions that may have
   # been raised; however we don't want to go overboard and prevent the user
@@ -13,7 +15,7 @@ class Pry
         # Don't catch signals (particularly not SIGTERM) as these are unlikely
         # to be intended for pry itself. We should also make sure that
         # Kernel#exit works.
-      when *Pry.config.exception_whitelist
+      when *Pry.config.unrescued_exceptions
         false
         # All other exceptions will be caught.
       else
@@ -23,9 +25,13 @@ class Pry
   end
 
   # Catches SecurityErrors if $SAFE is set
-  module Pry::TooSafeException
+  module TooSafeException
     def self.===(exception)
-      $SAFE > 0 && SecurityError === exception
+      if Pry::HAS_SAFE_LEVEL
+        $SAFE > 0 && exception.is_a?(SecurityError)
+      else
+        exception.is_a?(SecurityError)
+      end
     end
   end
 
@@ -49,18 +55,14 @@ class Pry
   # the exception is just a vanilla RuntimeError.
   module FrozenObjectException
     def self.===(exception)
-      ["can't modify frozen class/module",
-       "can't modify frozen Class",
-       "can't modify frozen object",
+      [
+        "can't modify frozen class/module",
+        "can't modify frozen Class",
+        "can't modify frozen object"
       ].include?(exception.message)
     end
   end
 
-  # Don't catch these exceptions
-  DEFAULT_EXCEPTION_WHITELIST = [SystemExit,
-                                 SignalException,
-                                 Pry::TooSafeException]
-
   # CommandErrors are caught by the REPL loop and displayed to the user. They
   # indicate an exceptional condition that's fatal to the current command.
   class CommandError < StandardError; end
@@ -68,9 +70,4 @@ class Pry
 
   # indicates obsolete API
   class ObsoleteError < StandardError; end
-
-  # This is to keep from breaking under Rails 3.2 for people who are doing that
-  # IRB = Pry thing.
-  module ExtendCommandBundle
-  end
 end