pry 0.9.12.2 → 0.14.2

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
@@ -38,8 +40,8 @@ class Object
   #   end
   #   my_method()
   # @see Pry.start
-  def pry(object=nil, hash={})
-    if object.nil? || Hash === object
+  def pry(object = nil, hash = {})
+    if object.nil? || Hash === object # rubocop:disable Style/CaseEquality
       Pry.start(self, object || {})
     else
       Pry.start(object, hash)
@@ -68,15 +70,26 @@ 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 variables. 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::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 respond_to?(:__pry__)
+    unless self.class.method_defined?(:__pry__)
       # The easiest way to check whether an object has a working singleton class
       # is to try and define a method on it. (just checking for the presence of
       # the singleton class gives false positives for `true` and `false`).
@@ -84,14 +97,14 @@ class Object
       # it has the nice property that we can memoize this check.
       begin
         # instance_eval sets the default definee to the object's singleton class
-        instance_eval *Pry::BINDING_METHOD_IMPL
+        instance_eval(*Pry::BINDING_METHOD_IMPL)
 
       # If we can't define methods on the Object's singleton_class. Then we fall
       # back to setting the default definee to be the Object's class. That seems
       # nicer than having a REPL in which you can't define methods.
-      rescue TypeError
+      rescue TypeError, Pry::FrozenObjectException
         # class_eval sets the default definee to self.class
-        self.class.class_eval *Pry::BINDING_METHOD_IMPL
+        self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
       end
     end
 
@@ -99,23 +112,33 @@ class Object
   end
 end
 
-# There's a splat bug on jruby in 1.9 emulation mode, which breaks the
-# pp library.
-#
-# * http://jira.codehaus.org/browse/JRUBY-6687
-# * https://github.com/pry/pry/issues/568
-#
-# Until that gets fixed upstream, let's monkey-patch here:
-if [[1, 2]].pretty_inspect == "[1]\n"
-  class Array
-    def pretty_print(q)
-      q.group(1, '[', ']') {
-        i = 0
-        q.seplist(self) { |*|
-          q.pp self[i]
-          i += 1
-        }
-      }
-    end
+class BasicObject
+  # Return a binding object for the receiver.
+  #
+  # The `self` of the binding is set to the current object, and it contains no
+  # local variables.
+  #
+  # The default definee (http://yugui.jp/articles/846) is set such that new
+  # methods defined will be added to the singleton class of the BasicObject.
+  #
+  # @return [Binding]
+  def __binding__
+    # 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(<<-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
+      # definition is eval'd.
+      #
+      # Please don't call this method directly, see {__binding__}.
+      #
+      # @return [Binding]
+      def __pry__
+        ::Kernel.binding
+      end
+    METHOD
+    __pry__
   end
 end

data/lib/pry/editor.rb

@@ -1,129 +1,157 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
 class Pry
   class Editor
-    extend Pry::Helpers::BaseHelpers
-    extend Pry::Helpers::CommandHelpers
-
-    class << self
-      def edit_tempfile_with_content(initial_content, line=1)
-        temp_file do |f|
-          f.puts(initial_content)
-          f.flush
-          f.close(false)
-          invoke_editor(f.path, line, true)
-          File.read(f.path)
-        end
+    def self.default
+      if (visual = Pry::Env['VISUAL'])
+        return visual
       end
 
-      def invoke_editor(file, line, blocking=true)
-        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
+      if (editor = Pry::Env['EDITOR'])
+        return editor
+      end
 
-        editor_invocation = build_editor_invocation_string(file, line, blocking)
-        return nil unless editor_invocation
+      return 'notepad' if Helpers::Platform.windows?
 
-        if jruby?
-          open_editor_on_jruby(editor_invocation)
-        else
-          open_editor(editor_invocation)
-        end
+      %w[editor nano vi].find do |editor_exe|
+        Kernel.system("which #{editor_exe} > /dev/null 2>&1")
       end
+    end
 
-      private
+    include Pry::Helpers::CommandHelpers
 
-      # 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)
+    attr_reader :pry_instance
 
-        if Pry.config.editor.respond_to?(:call)
-          args = [file, line, blocking][0...(Pry.config.editor.arity)]
-          Pry.config.editor.call(*args)
-        else
-          sanitized_file = if windows?
-                             file.gsub(/\//, '\\')
-                           else
-                             Shellwords.escape(file)
-                           end
+    def initialize(pry_instance)
+      @pry_instance = pry_instance
+    end
 
-          "#{Pry.config.editor} #{blocking_flag_for_editor(blocking)} #{start_line_syntax_for_editor(sanitized_file, line)}"
-        end
+    def edit_tempfile_with_content(initial_content, line = 1)
+      temp_file do |f|
+        f.puts(initial_content)
+        f.flush
+        f.close(false)
+        invoke_editor(f.path, line, true)
+        File.read(f.path)
       end
+    end
 
-      # 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(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
+    def invoke_editor(file, line, blocking = true)
+      unless pry_instance.config.editor
+        raise CommandError,
+              "Please set Pry.config.editor or export $VISUAL or $EDITOR"
       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(*editor_invocation.split)
-          Process.waitpid(pid)
-        rescue FFI::NotFoundError
-          system(editor_invocation)
-        end
+      editor_invocation = build_editor_invocation_string(file, line, blocking)
+      return nil unless editor_invocation
+
+      if Helpers::Platform.jruby?
+        open_editor_on_jruby(editor_invocation)
+      else
+        open_editor(editor_invocation)
       end
+    end
 
-      # Some editors that run outside the terminal allow you to control whether or
-      # not to block the process from which they were launched (in this case, Pry).
-      # For those editors, return the flag that produces the desired behavior.
-      def blocking_flag_for_editor(blocking)
-        case editor_name
-        when /^emacsclient/
-          '--no-wait' unless blocking
-        when /^[gm]vim/
-          '--nofork' if blocking
-        when /^jedit/
-          '-wait' if blocking
-        when /^mate/, /^subl/
-          '-w' if blocking
-        end
+    # 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_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)
+        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
 
-      # Return the syntax for a given editor for starting the editor
-      # and moving to a particular line within that file
-      def start_line_syntax_for_editor(file_name, line_number)
-        # special case for 1st line
-        return file_name if line_number <= 1
+    private
 
-        case editor_name
-        when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
-          "+#{line_number} #{file_name}"
-        when /^mate/, /^geany/
-          "-l #{line_number} #{file_name}"
-        when /^subl/
-          "#{file_name}:#{line_number}"
-        when /^uedit32/
-          "#{file_name}/#{line_number}"
-        when /^jedit/
-          "#{file_name} +line:#{line_number}"
-        else
-          if windows?
-            "#{file_name}"
-          else
-            "+#{line_number} #{file_name}"
-          end
-        end
+    # 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)) ||
+        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)
+      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
+    # not to block the process from which they were launched (in this case, Pry).
+    # For those editors, return the flag that produces the desired behavior.
+    def blocking_flag_for_editor(blocking)
+      case editor_name
+      when /^emacsclient/
+        '--no-wait' unless blocking
+      when /^[gm]vim/
+        '--nofork' if blocking
+      when /^jedit/
+        '-wait' if blocking
+      when /^mate/, /^subl/, /^redcar/, /^code/
+        '-w' if blocking
       end
+    end
 
-      # Get the name of the binary that Pry.config.editor points to.
-      #
-      # This is useful for deciding which flags we pass to the editor as
-      # we can just use the program's name and ignore any absolute paths.
-      #
-      # @example
-      #   Pry.config.editor="/home/conrad/bin/textmate -w"
-      #   editor_name
-      #   # => textmate
-      #
-      def editor_name
-        File.basename(Pry.config.editor).split(" ").first
+    # Return the syntax for a given editor for starting the editor
+    # and moving to a particular line within that file
+    def start_line_syntax_for_editor(file_name, line_number)
+      # special case for 1st line
+      return file_name if line_number <= 1
+
+      case editor_name
+      when /^[gm]?vi/, /^emacs/, /^nano/, /^pico/, /^gedit/, /^kate/
+        "+#{line_number} #{file_name}"
+      when /^mate/, /^geany/
+        "-l #{line_number} #{file_name}"
+      when /^code/
+        "-g #{file_name}:#{line_number}"
+      when /^subl/
+        "#{file_name}:#{line_number}"
+      when /^uedit32/
+        "#{file_name}/#{line_number}"
+      when /^jedit/
+        "#{file_name} +line:#{line_number}"
+      when /^redcar/
+        "-l#{line_number} #{file_name}"
+      else
+        if Helpers::Platform.windows?
+          file_name.to_s
+        else
+          "+#{line_number} #{file_name}"
+        end
       end
+    end
 
+    # Get the name of the binary that Pry.config.editor points to.
+    #
+    # This is useful for deciding which flags we pass to the editor as
+    # we can just use the program's name and ignore any absolute paths.
+    #
+    # @example
+    #   Pry.config.editor="/home/conrad/bin/textmate -w"
+    #   editor_name
+    #   # => textmate
+    #
+    def editor_name
+      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

@@ -0,0 +1,73 @@
+# 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
+  # from exiting Pry when they want to.
+  module RescuableException
+    def self.===(exception)
+      case exception
+        # Catch when the user hits ^C (Interrupt < SignalException), and assume
+        # that they just wanted to stop the in-progress command (just like bash
+        # etc.)
+      when Interrupt
+        true
+        # 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.unrescued_exceptions
+        false
+        # All other exceptions will be caught.
+      else
+        true
+      end
+    end
+  end
+
+  # Catches SecurityErrors if $SAFE is set
+  module TooSafeException
+    def self.===(exception)
+      if Pry::HAS_SAFE_LEVEL
+        $SAFE > 0 && exception.is_a?(SecurityError)
+      else
+        exception.is_a?(SecurityError)
+      end
+    end
+  end
+
+  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
+  # in a more user-friendly manner. This should be used when the exception
+  # happens within Pry itself as a direct consequence of the user typing
+  # something wrong.
+  #
+  # This allows us to distinguish between the user typing:
+  #
+  # pry(main)> def )
+  # SyntaxError: unexpected )
+  #
+  # pry(main)> method_that_evals("def )")
+  # SyntaxError: (eval):1: syntax error, unexpected ')'
+  # from ./a.rb:2 in `eval'
+  module UserError; end
+
+  # When we try to get a binding for an object, we try to define a method on
+  # that Object's singleton class. This doesn't work for "frozen" Object's, and
+  # 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"
+      ].include?(exception.message)
+    end
+  end
+
+  # 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
+  class MethodNotFound < CommandError; end
+
+  # indicates obsolete API
+  class ObsoleteError < StandardError; end
+end

data/lib/pry/forwardable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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 do
+        private(*private_delegates) # rubocop:disable Style/AccessModifierDeclarations
+      end
+    end
+  end
+end